Function resolveRef

client/src/utils/schemaUtils.ts:165–230

(
  schema: JsonSchemaType,
  rootSchema: JsonSchemaType,
  visitedRefs: Set<string> = new Set(),
)

 * @returns The resolved schema without $ref
 */
export function resolveRef(
  schema: JsonSchemaType,
  rootSchema: JsonSchemaType,
  visitedRefs: Set<string> = new Set(),
): JsonSchemaType {
  if (!schema) return schema;

  if (!("$ref" in schema) || !schema.$ref) {
    // Recursively resolve $ref in anyOf (and other nested structures)
    if (schema.anyOf && Array.isArray(schema.anyOf)) {
      const resolvedAnyOf = schema.anyOf.map((item) => {
        if (typeof item === "object" && item !== null) {
          return resolveRef(item, rootSchema, visitedRefs);
        }
        return item;
      });
      return {
        ...schema,
        anyOf: resolvedAnyOf,
      };
    }
    return schema;
  }

  const ref = schema.$ref;

  // Handle all #/ formats (#/properties/, #/$defs/, etc.)
  if (ref.startsWith("#/")) {
    // Check for circular reference
    if (visitedRefs.has(ref)) {
      console.warn(`Circular reference detected: ${ref}`);
      return schema;
    }

    // Add current ref to visited set
    visitedRefs.add(ref);

    const path = ref.substring(2).split("/");
    let current: unknown = rootSchema;

    for (const segment of path) {
      if (
        current &&
        typeof current === "object" &&
        current !== null &&
        segment in current
      ) {
        current = (current as Record<string, unknown>)[segment];
      } else {
        // If reference cannot be resolved, return the original schema
        visitedRefs.delete(ref); // Clean up on failure
        console.warn(`Could not resolve $ref: ${ref}`);
        return schema;
      }
    }

    const resolved = current as JsonSchemaType;