refactor: stricter domain: server-directory

toju-app/src/app/domains/server-directory/domain/logic/server-endpoint-defaults.logic.ts

@@ -0,0 +1,187 @@
+import type {
+  ConfiguredDefaultServerDefinition,
+  DefaultEndpointTemplate,
+  DefaultServerDefinition,
+  ServerEndpoint
+} from '../models/server-directory.model';
+
+export function sanitiseServerBaseUrl(rawUrl: string): string {
+  let cleaned = rawUrl.trim().replace(/\/+$/, '');
+
+  if (cleaned.toLowerCase().endsWith('/api')) {
+    cleaned = cleaned.slice(0, -4);
+  }
+
+  return cleaned;
+}
+
+export function normaliseConfiguredServerUrl(
+  rawUrl: string,
+  defaultProtocol: 'http' | 'https'
+): string {
+  let cleaned = rawUrl.trim();
+
+  if (!cleaned) {
+    return '';
+  }
+
+  if (cleaned.toLowerCase().startsWith('ws://')) {
+    cleaned = `http://${cleaned.slice(5)}`;
+  } else if (cleaned.toLowerCase().startsWith('wss://')) {
+    cleaned = `https://${cleaned.slice(6)}`;
+  } else if (cleaned.startsWith('//')) {
+    cleaned = `${defaultProtocol}:${cleaned}`;
+  } else if (!/^[a-z][a-z\d+.-]*:\/\//i.test(cleaned)) {
+    cleaned = `${defaultProtocol}://${cleaned}`;
+  }
+
+  return sanitiseServerBaseUrl(cleaned);
+}
+
+export function buildFallbackDefaultServerUrl(
+  configuredUrl: string | undefined,
+  defaultProtocol: 'http' | 'https'
+): string {
+  if (configuredUrl?.trim()) {
+    return normaliseConfiguredServerUrl(configuredUrl, defaultProtocol);
+  }
+
+  return `${defaultProtocol}://localhost:3001`;
+}
+
+export function buildDefaultServerDefinitions(
+  configuredDefaults: ConfiguredDefaultServerDefinition[] | undefined,
+  configuredUrl: string | undefined,
+  defaultProtocol: 'http' | 'https'
+): DefaultServerDefinition[] {
+  const seenKeys = new Set<string>();
+  const seenUrls = new Set<string>();
+  const definitions = (configuredDefaults ?? [])
+    .map((server, index) => {
+      const key = server.key?.trim() || `default-${index + 1}`;
+      const url = normaliseConfiguredServerUrl(server.url ?? '', defaultProtocol);
+
+      if (!key || !url || seenKeys.has(key) || seenUrls.has(url)) {
+        return null;
+      }
+
+      seenKeys.add(key);
+      seenUrls.add(url);
+
+      return {
+        key,
+        name: server.name?.trim() || (index === 0 ? 'Default Server' : `Default Server ${index + 1}`),
+        url
+      } satisfies DefaultServerDefinition;
+    })
+    .filter((definition): definition is DefaultServerDefinition => definition !== null);
+
+  if (definitions.length > 0) {
+    return definitions;
+  }
+
+  return [
+    {
+      key: 'default',
+      name: 'Default Server',
+      url: buildFallbackDefaultServerUrl(configuredUrl, defaultProtocol)
+    }
+  ];
+}
+
+export function buildDefaultEndpointTemplates(
+  definitions: DefaultServerDefinition[]
+): DefaultEndpointTemplate[] {
+  return definitions.map((definition) => ({
+    name: definition.name,
+    url: definition.url,
+    isActive: true,
+    isDefault: true,
+    defaultKey: definition.key,
+    status: 'unknown'
+  }));
+}
+
+export function hasEndpointForDefault(
+  endpoints: ServerEndpoint[],
+  defaultEndpoint: DefaultEndpointTemplate
+): boolean {
+  return endpoints.some((endpoint) =>
+    endpoint.defaultKey === defaultEndpoint.defaultKey
+    || sanitiseServerBaseUrl(endpoint.url) === defaultEndpoint.url
+  );
+}
+
+export function matchDefaultEndpointTemplate(
+  defaultEndpoints: DefaultEndpointTemplate[],
+  endpoint: ServerEndpoint,
+  sanitisedUrl: string,
+  claimedDefaultKeys: Set<string>
+): DefaultEndpointTemplate | null {
+  if (endpoint.defaultKey) {
+    return defaultEndpoints.find(
+      (candidate) => candidate.defaultKey === endpoint.defaultKey && !claimedDefaultKeys.has(candidate.defaultKey)
+    ) ?? null;
+  }
+
+  if (!endpoint.isDefault) {
+    return null;
+  }
+
+  const matchingCurrentDefault = defaultEndpoints.find(
+    (candidate) => candidate.url === sanitisedUrl && !claimedDefaultKeys.has(candidate.defaultKey)
+  );
+
+  if (matchingCurrentDefault) {
+    return matchingCurrentDefault;
+  }
+
+  return defaultEndpoints.find(
+    (candidate) => !claimedDefaultKeys.has(candidate.defaultKey)
+  ) ?? null;
+}
+
+export function findDefaultEndpointKeyByUrl(
+  defaultEndpoints: DefaultEndpointTemplate[],
+  url: string
+): string | null {
+  const sanitisedUrl = sanitiseServerBaseUrl(url);
+
+  return defaultEndpoints.find((endpoint) => endpoint.url === sanitisedUrl)?.defaultKey ?? null;
+}
+
+export function ensureAnyActiveEndpoint(endpoints: ServerEndpoint[]): ServerEndpoint[] {
+  if (endpoints.length === 0 || endpoints.some((endpoint) => endpoint.isActive)) {
+    return endpoints;
+  }
+
+  const nextEndpoints = [...endpoints];
+
+  nextEndpoints[0] = {
+    ...nextEndpoints[0],
+    isActive: true
+  };
+
+  return nextEndpoints;
+}
+
+export function ensureCompatibleActiveEndpoint(endpoints: ServerEndpoint[]): ServerEndpoint[] {
+  if (endpoints.length === 0 || endpoints.some((endpoint) => endpoint.isActive)) {
+    return endpoints;
+  }
+
+  const fallbackIndex = endpoints.findIndex((endpoint) => endpoint.status !== 'incompatible');
+
+  if (fallbackIndex < 0) {
+    return endpoints;
+  }
+
+  const nextEndpoints = [...endpoints];
+
+  nextEndpoints[fallbackIndex] = {
+    ...nextEndpoints[fallbackIndex],
+    isActive: true
+  };
+
+  return nextEndpoints;
+}