@shortlink-org/portolan 0.2.4 → 0.4.0

package/src/enrich.ts

@@ -24,6 +24,7 @@ import type {
   Flow,
   FlowNode,
   RpcCall,
+  HTTPDestination,
   Service,
   Status,
   Step,
@@ -60,7 +61,7 @@ export function enrichCatalog(input: Catalog): Enriched {
   // rather than the name.
   const catalog = resolveForeignKeys(
     resolveStoreAccesses(
-      composeExecutionContinuations(resolveWireNames(input)),
+      composeExecutionContinuations(resolveWireNames(resolveHTTPCalls(input))),
     ),
   );
 
@@ -228,6 +229,266 @@ export function enrichCatalog(input: Catalog): Enriched {
   return { catalog: { ...catalog, contexts }, derived };
 }
 
+interface HTTPProvider {
+  service: string;
+  context: string;
+  ref: string;
+  method: string;
+  path: string;
+  /** Set when the manifests, not the route alone, chose this provider. */
+  basis?: "kubernetes-host";
+}
+
+/**
+ * Resolves the protocol-neutral calls emitted by the HTTP client extractor
+ * against HTTP routes contributed by server-side extractors.
+ *
+ * No source fragment can do this on its own: a client repository knows the
+ * verb and path but not which of the estate's services answers it, while an
+ * OpenAPI or framework fragment knows only what its own service provides.
+ * The merged catalog is the first place both facts exist.
+ *
+ * Proven full paths are authoritative and never fall back to a suffix.
+ * Legacy calls can still use a unique suffix because mounted
+ * applications commonly see only their local route (`/get-admin-settings`)
+ * while the server extractor records the mount too
+ * (`/settings/get-admin-settings`). Ambiguous matches and possible self-calls
+ * deliberately remain unresolved.
+ */
+function resolveHTTPCalls(input: Catalog): Catalog {
+  const providers: HTTPProvider[] = [];
+  // What the manifests said, where a tree of them was read: the names each
+  // service answers on, and the names each caller is configured to dial.
+  const hostsByService = new Map<string, Set<string>>();
+  const dialsByService = new Map<string, string[]>();
+  for (const context of input.contexts) {
+    for (const service of context.services) {
+      if (service.hosts?.length) {
+        hostsByService.set(service.id, new Set(service.hosts));
+      }
+      if (service.dials?.length) dialsByService.set(service.id, service.dials);
+      for (const provided of service.provides) {
+        for (const method of provided.methods) {
+          // A route with an empty method is mounted but its verb is unknown
+          // (extract-django's `Planet.fetch`); the path alone never confirms
+          // a link, so it is kept out of the candidates deliberately.
+          if (!method.http || !method.http.method) continue;
+          providers.push({
+            service: service.id,
+            context: context.id,
+            ref: `${provided.id}/${method.name}`,
+            method: method.http.method.toUpperCase(),
+            path: method.http.path,
+          });
+        }
+      }
+    }
+  }
+  if (providers.length === 0) return input;
+
+  const resolvedByCaller = new Map<string, Map<string, HTTPProvider>>();
+  const resolve = (caller: string, call: RpcCall): HTTPProvider | undefined => {
+    if (call.status !== "unresolved") return undefined;
+    const raw = rawHTTPRoute(call.id);
+    const route = call.destination?.fullPath
+      ? { method: call.destination.method, path: call.destination.fullPath }
+      : raw;
+    if (!route) return undefined;
+
+    const candidates = providers.filter(
+      (provider) =>
+        provider.service !== caller &&
+        provider.method === route.method &&
+        (call.destination?.fullPath
+          ? sameHTTPShape(provider.path, route.path)
+          : sameHTTPPath(provider.path, route.path)),
+    );
+    const exact = uniqueHTTPProviders(
+      candidates.filter((provider) => sameHTTPShape(provider.path, route.path)),
+    );
+    const matches = exact.length > 0 ? exact : uniqueHTTPProviders(candidates);
+    if (matches.length === 1) return matches[0];
+    if (matches.length < 2) return undefined;
+    // Ambiguous by route alone. The manifests may say which of them the
+    // caller reaches: the host the call names, or failing that the hosts the
+    // caller's workload is configured to dial. They only ever decide between
+    // providers of the route; a host never conjures a provider that does not
+    // have it.
+    const host = callHost(call);
+    const dials = dialsByService.get(caller) ?? [];
+    const reachable = matches.filter((provider) => {
+      const hosts = hostsByService.get(provider.service);
+      if (!hosts) return false;
+      return host ? hosts.has(host) : dials.some((dial) => hosts.has(dial));
+    });
+    return reachable.length === 1
+      ? { ...reachable[0]!, basis: "kubernetes-host" }
+      : undefined;
+  };
+
+  const evidence = (call: Pick<RpcCall, "id" | "source" | "destination">, provider: HTTPProvider): HTTPDestination => {
+    const raw = rawHTTPRoute(call.id);
+    const destination = call.destination ?? {
+      callSite: call.source, endpointExpression: raw?.path ?? call.id,
+      method: raw?.method ?? provider.method, localPath: raw?.path,
+    };
+    return { ...destination, resolution: {
+      basis: provider.basis ?? (destination.fullPath ? "full-path" : sameHTTPShape(provider.path, raw?.path ?? "") ? "exact-route" : "unique-suffix"),
+      provider: provider.service, route: provider.path,
+    } };
+  };
+  let changed = false;
+  const contexts = input.contexts.map((context) => ({
+    ...context,
+    services: context.services.map((service) => {
+      const resolved = new Map<string, HTTPProvider>();
+      const mapped = service.consumes.map((call) => {
+        const provider = resolve(service.id, call);
+        if (!provider) return call;
+        changed = true;
+        resolved.set(call.id, provider);
+        return {
+          ...call,
+          id: provider.ref,
+          destination: evidence(call, provider),
+          peer: provider.service,
+          status: "declared" as const,
+        };
+      });
+      const consumes = [
+        ...new Map(mapped.map((call) => [call.id, call])).values(),
+      ];
+      if (resolved.size > 0) resolvedByCaller.set(service.id, resolved);
+      return resolved.size > 0 ? { ...service, consumes } : service;
+    }),
+  }));
+
+  if (!changed) return input;
+
+  const flows = input.flows.map((flow) => {
+    let flowChanged = false;
+    const targets = new Map<string, HTTPProvider>();
+    const steps = mapSteps(flow.steps, (step) => {
+      if (step.kind !== "rpc" || !step.ref) return step;
+      const provider = resolvedByCaller.get(step.from)?.get(step.ref);
+      if (!provider) return step;
+      flowChanged = true;
+      targets.set(provider.service, provider);
+      return {
+        ...step,
+        ref: provider.ref,
+        destination: evidence({ id: step.ref, source: step.line ?? "", destination: step.destination }, provider),
+        to: provider.service,
+        status: "declared",
+      };
+    });
+    if (!flowChanged) return flow;
+
+    const participants = [...flow.participants];
+    const seen = new Set(participants.map((participant) => participant.id));
+    for (const target of targets.values()) {
+      if (seen.has(target.service)) continue;
+      seen.add(target.service);
+      participants.push({
+        id: target.service,
+        kind: "service",
+        context: target.context,
+      });
+    }
+    return { ...flow, participants, steps };
+  });
+
+  return { ...input, contexts, flows };
+}
+
+function rawHTTPRoute(
+  id: string,
+): { method: string; path: string } | undefined {
+  // The extractor qualifies a raw call with its destination after " @ "
+  // (`http-client/POST /foo @ payments.internal`) so that the same route to two
+  // hosts stays two calls; the route itself is what resolves against providers.
+  const match = /^http-client\/([A-Z]+)\s+(\/\S*)(?: @ .+)?$/.exec(id);
+  return match ? { method: match[1]!, path: match[2]! } : undefined;
+}
+
+/**
+ * The host a call names, when it names one: the service-discovery alias the
+ * extractor recorded, the hostname of a literal base URL, or the destination
+ * after " @ " in the id when that is a host rather than an expression. A port
+ * is dropped, because a Service's name has none.
+ */
+function callHost(call: RpcCall): string | undefined {
+  const at = /^http-client\/[A-Z]+\s+\/\S*\s@\s(.+)$/.exec(call.id)?.[1];
+  for (const value of [
+    call.destination?.serviceDiscoveryAlias,
+    call.destination?.baseURL?.value,
+    at,
+  ]) {
+    const host = hostOf(value);
+    if (host) return host;
+  }
+  return undefined;
+}
+
+function hostOf(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  if (trimmed.includes("://")) {
+    try {
+      return new URL(trimmed).hostname || undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  // Lower case by the cluster's own rule, so that `Config.SupplierURL` - an
+  // expression the extractor could not evaluate - is not taken for a host.
+  return /^([a-z0-9]([a-z0-9.-]*[a-z0-9])?)(:[0-9]+)?$/.exec(trimmed)?.[1];
+}
+
+function uniqueHTTPProviders(providers: HTTPProvider[]): HTTPProvider[] {
+  const unique = new Map<string, HTTPProvider>();
+  for (const provider of providers) {
+    unique.set(`${provider.service}\u0000${provider.ref}`, provider);
+  }
+  return [...unique.values()];
+}
+
+function sameHTTPPath(provided: string, called: string): boolean {
+  const provider = httpSegments(provided);
+  const call = httpSegments(called);
+  if (call.length === 0) return provider.length === 0;
+  if (call.length > provider.length) return false;
+  const offset = provider.length - call.length;
+  for (let index = 0; index < call.length; index += 1) {
+    if (!sameHTTPSegment(provider[offset + index]!, call[index]!)) return false;
+  }
+  return true;
+}
+
+function sameHTTPShape(left: string, right: string): boolean {
+  const a = httpSegments(left);
+  const b = httpSegments(right);
+  return (
+    a.length === b.length &&
+    a.every((segment, index) => sameHTTPSegment(segment, b[index]!))
+  );
+}
+
+function httpSegments(path: string): string[] {
+  const withoutQuery = path.split("?", 1)[0] ?? path;
+  return withoutQuery.split("/").filter(Boolean);
+}
+
+function sameHTTPSegment(left: string, right: string): boolean {
+  return left === right || (isHTTPParameter(left) && isHTTPParameter(right));
+}
+
+function isHTTPParameter(segment: string): boolean {
+  return (
+    segment === "%s" || /^\{[^{}]+\}$/.test(segment) || /^:[^:]+$/.test(segment)
+  );
+}
+
 /**
  * Joins the use-case-side repository call emitted by extract-go to the
  * concrete Redis client call emitted independently by extract-redis. Method
@@ -273,8 +534,10 @@ function resolveStoreAccesses(input: Catalog): Catalog {
         ) {
           return node;
         }
-        const method = storeAccess.method.split(".").pop() ?? storeAccess.method;
-        const matches = byMethod.get(`${storeAccess.store}\u0000${method}`) ?? [];
+        const method =
+          storeAccess.method.split(".").pop() ?? storeAccess.method;
+        const matches =
+          byMethod.get(`${storeAccess.store}\u0000${method}`) ?? [];
         if (matches.length !== 1) return node;
         changed = true;
         return {
@@ -866,21 +1129,59 @@ function resolveWireNames(catalog: Catalog): Catalog {
  * keeps the raw name, because no extractor sees two schemas. The merge sees
  * all of them, and a name exactly one table in the estate answers to is that
  * table - which is what turns a dangling key into the crossing it is, on the
- * page and on Problems. Two tables of that name resolve to neither.
+ * page and on Problems.
+ *
+ * Two tables of that name are told apart by who the referencing service
+ * talks to: its own store first, then the stores of the services it shares a
+ * context with or calls, or that call it. A shop's delivery service keying
+ * on `orders` means the order service it fetches orders from, not the
+ * `orders` of an unrelated shop that happens to be in the same estate. A
+ * name that is still ambiguous after that resolves to neither.
  */
 function resolveForeignKeys(catalog: Catalog): Catalog {
   const stores = catalog.stores ?? [];
   if (stores.length === 0) return catalog;
 
   const known = new Set<string>();
-  const byName = new Map<string, string | null>();
+  // name → every table id answering to it, in store order.
+  const byName = new Map<string, string[]>();
+  const ownerOfTable = new Map<string, string>();
   for (const store of stores) {
     for (const table of store.tables) {
       known.add(table.id);
-      byName.set(table.name, byName.has(table.name) ? null : table.id);
+      byName.set(table.name, [...(byName.get(table.name) ?? []), table.id]);
+      ownerOfTable.set(table.id, store.owner);
+    }
+  }
+
+  // Who a service is close to: the services of its context, the ones it
+  // calls, and the ones that call it.
+  const peers = new Map<string, Set<string>>();
+  const near = (a: string, b: string) => {
+    if (!peers.has(a)) peers.set(a, new Set());
+    peers.get(a)!.add(b);
+  };
+  for (const ctx of catalog.contexts) {
+    for (const svc of ctx.services) {
+      for (const other of ctx.services) near(svc.id, other.id);
+      for (const call of svc.consumes) {
+        near(svc.id, call.peer);
+        near(call.peer, svc.id);
+      }
     }
   }
 
+  const resolveName = (name: string, from: string, owner: string): string | null => {
+    const candidates = byName.get(name) ?? [];
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0]!;
+    const own = candidates.filter((id) => id.startsWith(`${from}.`));
+    if (own.length === 1) return own[0]!;
+    const close = peers.get(owner) ?? new Set<string>();
+    const nearby = candidates.filter((id) => close.has(ownerOfTable.get(id) ?? ""));
+    return nearby.length === 1 ? nearby[0]! : null;
+  };
+
   let any = false;
   const resolved = stores.map((store) => {
     let touched = false;
@@ -888,7 +1189,7 @@ function resolveForeignKeys(catalog: Catalog): Catalog {
       let changed = false;
       const columns = table.columns.map((column) => {
         if (!column.fk || known.has(column.fk.table)) return column;
-        const found = byName.get(column.fk.table);
+        const found = resolveName(column.fk.table, store.id, store.owner);
         if (!found) return column;
         changed = true;