@modelprofile.com/flexharness 13.0.0 → 13.1.0

package/ts_typedrequest/references.ts

@@ -0,0 +1,68 @@
+import * as plugins from './plugins.js';
+import type { IFlexCatalogType } from '@modelprofile.com/flexharness';
+import type { IFlexTypedRequestMethod, TFlexTypedRequestSchema } from './interfaces.js';
+
+export const definitionsPrefix = '#/$defs/';
+
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+/** The type a `#/$defs/<type>` reference names. */
+export const referencedType = (schema: TFlexTypedRequestSchema): string | undefined =>
+  typeof schema.$ref === 'string' && schema.$ref.startsWith(definitionsPrefix)
+    ? schema.$ref.slice(definitionsPrefix.length)
+    : undefined;
+
+/** The named types a schema refers to. */
+export const referencesIn = (value: unknown, found: Set<string>): Set<string> => {
+  if (Array.isArray(value)) {
+    for (const entry of value) referencesIn(entry, found);
+  } else if (isRecord(value)) {
+    const target = referencedType(value);
+    if (target !== undefined) found.add(target);
+    for (const child of Object.values(value)) referencesIn(child, found);
+  }
+  return found;
+};
+
+/**
+ * The types of `types` that `methods` reach, in their order: the ones the methods' schemas refer
+ * to and their declarations' code names, and the ones those types reach the same way. A type only
+ * other methods use is left out. A declaration names a type by the identifier the catalog of all of
+ * `types` declares it under (`FlexToolCatalog.identifiersOf()`); as that depends on the other
+ * types, a reached type keeps the ones that took the lower identifiers of its name along, so it is
+ * declared under the same identifier.
+ */
+export const typesReachedBy = (
+  methods: readonly IFlexTypedRequestMethod[],
+  types: readonly IFlexCatalogType[],
+): IFlexCatalogType[] => {
+  const identifiers = plugins.FlexToolCatalog.identifiersOf(types.map((type) => type.name));
+  const byName = new Map(types.map((type) => [type.name, type]));
+  const byIdentifier = new Map(types.map((type) => [identifiers.get(type.name)!, type]));
+  const pending: IFlexCatalogType[] = [];
+  const reach = (schemas: unknown, declaration: string | undefined) => {
+    for (const name of referencesIn(schemas, new Set())) {
+      const type = byName.get(name);
+      if (type !== undefined) pending.push(type);
+    }
+    for (const identifier of declaration === undefined ? [] : plugins.FlexToolCatalog.identifiersIn(declaration)) {
+      const type = byIdentifier.get(identifier);
+      if (type !== undefined) pending.push(type);
+    }
+  };
+  for (const method of methods) reach([method.inputSchema, method.outputSchema], method.declaration);
+  const reached = new Set<IFlexCatalogType>();
+  while (pending.length) {
+    const type = pending.pop()!;
+    if (reached.has(type)) continue;
+    reached.add(type);
+    reach(type.schema, type.declaration);
+    const identifier = identifiers.get(type.name)!;
+    const base = plugins.FlexToolCatalog.identifierOf(type.name);
+    for (let suffix = 1, lower = base; lower !== identifier; lower = `${base}_${++suffix}`) {
+      pending.push(byIdentifier.get(lower)!);
+    }
+  }
+  return types.filter((type) => reached.has(type));
+};