@toolproof-core/genesis 1.0.49 → 1.0.50

package/src/utils/schemaDependencies.ts

@@ -1,115 +1,115 @@
-type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
-
-export type DependencyMap = Record<string, string[]>;
-
-export function decodeJsonPointerSegment(segment: string): string {
-    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-
-export function collectRefs(node: unknown, out: Set<string>): void {
-    if (Array.isArray(node)) {
-        for (const item of node) collectRefs(item, out);
-        return;
-    }
-    if (!node || typeof node !== 'object') return;
-
-    const obj = node as Record<string, unknown>;
-    const ref = obj.$ref;
-    if (typeof ref === 'string') out.add(ref);
-
-    for (const value of Object.values(obj)) {
-        collectRefs(value, out);
-    }
-}
-
-export function resolveInternalRefToDefKey(
-    ref: string,
-    defKeys: Set<string>,
-    anchorToDef: Record<string, string>,
-): string | null {
-    if (!ref.startsWith('#')) return null;
-
-    const defsPrefix = '#/$defs/';
-    if (ref.startsWith(defsPrefix)) {
-        const rest = ref.slice(defsPrefix.length);
-        const firstSegment = rest.split('/')[0] ?? '';
-        const defKey = decodeJsonPointerSegment(firstSegment);
-        return defKeys.has(defKey) ? defKey : null;
-    }
-
-    if (!ref.startsWith('#/')) {
-        const anchor = ref.slice(1);
-        const mapped = anchorToDef[anchor];
-        if (mapped && defKeys.has(mapped)) return mapped;
-        if (defKeys.has(anchor)) return anchor;
-    }
-
-    return null;
-}
-
-export function generateDependencyMap(doc: { $defs?: Record<string, JSONValue> } | null | undefined): DependencyMap {
-    const defs: Record<string, JSONValue> = doc?.$defs && typeof doc.$defs === 'object' ? doc.$defs : {};
-    const defKeys = new Set(Object.keys(defs));
-
-    const anchorToDef: Record<string, string> = {};
-    for (const [defKey, defSchema] of Object.entries(defs)) {
-        if (!defSchema || typeof defSchema !== 'object' || Array.isArray(defSchema)) continue;
-        const anchor = (defSchema as { $anchor?: unknown }).$anchor;
-        if (typeof anchor === 'string' && !(anchor in anchorToDef)) {
-            anchorToDef[anchor] = defKey;
-        }
-    }
-
-    const dependencyMap: DependencyMap = {};
-
-    for (const [defKey, defSchema] of Object.entries(defs)) {
-        const refs = new Set<string>();
-        collectRefs(defSchema, refs);
-
-        const deps = new Set<string>();
-        for (const ref of refs) {
-            const depKey = resolveInternalRefToDefKey(ref, defKeys, anchorToDef);
-            if (!depKey || depKey === defKey) continue;
-            deps.add(depKey);
-        }
-
-        dependencyMap[defKey] = Array.from(deps);
-    }
-
-    return dependencyMap;
-}
-
-export function normalizeDependencyMap(value: unknown): DependencyMap {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Invalid dependencyMap.json: expected an object');
-    }
-
-    const input = value as Record<string, unknown>;
-    const out: DependencyMap = {};
-
-    for (const [key, rawDeps] of Object.entries(input)) {
-        if (rawDeps == null) {
-            out[key] = [];
-            continue;
-        }
-        if (!Array.isArray(rawDeps)) {
-            throw new Error(`Invalid dependencyMap.json: value for ${key} must be an array`);
-        }
-        out[key] = rawDeps.filter((dep): dep is string => typeof dep === 'string');
-    }
-
-    return out;
-}
-
-export function computeTerminalsInKeyOrder(dependencyMap: DependencyMap): string[] {
-    const keys = Object.keys(dependencyMap);
-    const dependedUpon = new Set<string>();
-
-    for (const key of keys) {
-        for (const dep of dependencyMap[key] ?? []) {
-            dependedUpon.add(dep);
-        }
-    }
-
-    return keys.filter((key) => !dependedUpon.has(key));
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+export type DependencyMap = Record<string, string[]>;
+
+export function decodeJsonPointerSegment(segment: string): string {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+
+export function collectRefs(node: unknown, out: Set<string>): void {
+    if (Array.isArray(node)) {
+        for (const item of node) collectRefs(item, out);
+        return;
+    }
+    if (!node || typeof node !== 'object') return;
+
+    const obj = node as Record<string, unknown>;
+    const ref = obj.$ref;
+    if (typeof ref === 'string') out.add(ref);
+
+    for (const value of Object.values(obj)) {
+        collectRefs(value, out);
+    }
+}
+
+export function resolveInternalRefToDefKey(
+    ref: string,
+    defKeys: Set<string>,
+    anchorToDef: Record<string, string>,
+): string | null {
+    if (!ref.startsWith('#')) return null;
+
+    const defsPrefix = '#/$defs/';
+    if (ref.startsWith(defsPrefix)) {
+        const rest = ref.slice(defsPrefix.length);
+        const firstSegment = rest.split('/')[0] ?? '';
+        const defKey = decodeJsonPointerSegment(firstSegment);
+        return defKeys.has(defKey) ? defKey : null;
+    }
+
+    if (!ref.startsWith('#/')) {
+        const anchor = ref.slice(1);
+        const mapped = anchorToDef[anchor];
+        if (mapped && defKeys.has(mapped)) return mapped;
+        if (defKeys.has(anchor)) return anchor;
+    }
+
+    return null;
+}
+
+export function generateDependencyMap(doc: { $defs?: Record<string, JSONValue> } | null | undefined): DependencyMap {
+    const defs: Record<string, JSONValue> = doc?.$defs && typeof doc.$defs === 'object' ? doc.$defs : {};
+    const defKeys = new Set(Object.keys(defs));
+
+    const anchorToDef: Record<string, string> = {};
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        if (!defSchema || typeof defSchema !== 'object' || Array.isArray(defSchema)) continue;
+        const anchor = (defSchema as { $anchor?: unknown }).$anchor;
+        if (typeof anchor === 'string' && !(anchor in anchorToDef)) {
+            anchorToDef[anchor] = defKey;
+        }
+    }
+
+    const dependencyMap: DependencyMap = {};
+
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        const refs = new Set<string>();
+        collectRefs(defSchema, refs);
+
+        const deps = new Set<string>();
+        for (const ref of refs) {
+            const depKey = resolveInternalRefToDefKey(ref, defKeys, anchorToDef);
+            if (!depKey || depKey === defKey) continue;
+            deps.add(depKey);
+        }
+
+        dependencyMap[defKey] = Array.from(deps);
+    }
+
+    return dependencyMap;
+}
+
+export function normalizeDependencyMap(value: unknown): DependencyMap {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Invalid dependencyMap.json: expected an object');
+    }
+
+    const input = value as Record<string, unknown>;
+    const out: DependencyMap = {};
+
+    for (const [key, rawDeps] of Object.entries(input)) {
+        if (rawDeps == null) {
+            out[key] = [];
+            continue;
+        }
+        if (!Array.isArray(rawDeps)) {
+            throw new Error(`Invalid dependencyMap.json: value for ${key} must be an array`);
+        }
+        out[key] = rawDeps.filter((dep): dep is string => typeof dep === 'string');
+    }
+
+    return out;
+}
+
+export function computeTerminalsInKeyOrder(dependencyMap: DependencyMap): string[] {
+    const keys = Object.keys(dependencyMap);
+    const dependedUpon = new Set<string>();
+
+    for (const key of keys) {
+        for (const dep of dependencyMap[key] ?? []) {
+            dependedUpon.add(dep);
+        }
+    }
+
+    return keys.filter((key) => !dependedUpon.has(key));
 }

package/src/utils/schemaObjectNormalization.ts

@@ -1,71 +1,71 @@
-export function normalizeAllOfSiblingObjectKeywords(node: any): any {
-    if (Array.isArray(node)) {
-        let changed = false;
-        const out = node.map((item) => {
-            const next = normalizeAllOfSiblingObjectKeywords(item);
-            if (next !== item) changed = true;
-            return next;
-        });
-        return changed ? out : node;
-    }
-    if (!node || typeof node !== 'object') return node;
-
-    const hasAllOf = Array.isArray((node as any).allOf) && (node as any).allOf.length > 0;
-    const looksLikeObjectSchema =
-        (node as any).type === 'object' ||
-        (node as any).properties !== undefined ||
-        (node as any).required !== undefined ||
-        (node as any).unevaluatedProperties !== undefined ||
-        (node as any).additionalProperties !== undefined ||
-        (node as any).propertyNames !== undefined;
-
-    const siblingKeys = [
-        'type',
-        'properties',
-        'required',
-        'additionalProperties',
-        'unevaluatedProperties',
-        'propertyNames',
-        'patternProperties',
-        'dependentRequired',
-        'dependentSchemas',
-        'minProperties',
-        'maxProperties',
-    ] as const;
-
-    let localNode: any = node;
-    if (hasAllOf && looksLikeObjectSchema) {
-        const hasSiblingObjectKeywords = siblingKeys.some((key) => key in localNode);
-        if (hasSiblingObjectKeywords) {
-            const overlay: any = {};
-            const nextNode: any = { ...localNode };
-
-            for (const key of siblingKeys) {
-                if (key in nextNode) {
-                    overlay[key] = nextNode[key];
-                    delete nextNode[key];
-                }
-            }
-
-            nextNode.allOf = [overlay, ...(nextNode.allOf as any[])];
-            localNode = nextNode;
-        }
-    }
-
-    let changed = localNode !== node;
-    const out: Record<string, any> = localNode === node ? ({} as any) : { ...localNode };
-    for (const [key, value] of Object.entries(localNode)) {
-        const next = normalizeAllOfSiblingObjectKeywords(value);
-        if (next !== value) {
-            if (!changed) {
-                changed = true;
-                Object.assign(out, localNode);
-            }
-            out[key] = next;
-        } else if (changed) {
-            out[key] = value;
-        }
-    }
-
-    return changed ? out : node;
+export function normalizeAllOfSiblingObjectKeywords(node: any): any {
+    if (Array.isArray(node)) {
+        let changed = false;
+        const out = node.map((item) => {
+            const next = normalizeAllOfSiblingObjectKeywords(item);
+            if (next !== item) changed = true;
+            return next;
+        });
+        return changed ? out : node;
+    }
+    if (!node || typeof node !== 'object') return node;
+
+    const hasAllOf = Array.isArray((node as any).allOf) && (node as any).allOf.length > 0;
+    const looksLikeObjectSchema =
+        (node as any).type === 'object' ||
+        (node as any).properties !== undefined ||
+        (node as any).required !== undefined ||
+        (node as any).unevaluatedProperties !== undefined ||
+        (node as any).additionalProperties !== undefined ||
+        (node as any).propertyNames !== undefined;
+
+    const siblingKeys = [
+        'type',
+        'properties',
+        'required',
+        'additionalProperties',
+        'unevaluatedProperties',
+        'propertyNames',
+        'patternProperties',
+        'dependentRequired',
+        'dependentSchemas',
+        'minProperties',
+        'maxProperties',
+    ] as const;
+
+    let localNode: any = node;
+    if (hasAllOf && looksLikeObjectSchema) {
+        const hasSiblingObjectKeywords = siblingKeys.some((key) => key in localNode);
+        if (hasSiblingObjectKeywords) {
+            const overlay: any = {};
+            const nextNode: any = { ...localNode };
+
+            for (const key of siblingKeys) {
+                if (key in nextNode) {
+                    overlay[key] = nextNode[key];
+                    delete nextNode[key];
+                }
+            }
+
+            nextNode.allOf = [overlay, ...(nextNode.allOf as any[])];
+            localNode = nextNode;
+        }
+    }
+
+    let changed = localNode !== node;
+    const out: Record<string, any> = localNode === node ? ({} as any) : { ...localNode };
+    for (const [key, value] of Object.entries(localNode)) {
+        const next = normalizeAllOfSiblingObjectKeywords(value);
+        if (next !== value) {
+            if (!changed) {
+                changed = true;
+                Object.assign(out, localNode);
+            }
+            out[key] = next;
+        } else if (changed) {
+            out[key] = value;
+        }
+    }
+
+    return changed ? out : node;
 }

package/src/utils/schemaRefNormalization.ts

@@ -1,83 +1,83 @@
-export function stripAnchors<T>(schema: T): T {
-    const seen = new WeakMap<object, unknown>();
-
-    function walk(node: unknown): unknown {
-        if (!node || typeof node !== 'object') return node;
-
-        const existing = seen.get(node as object);
-        if (existing) return existing;
-
-        if (Array.isArray(node)) {
-            const out: unknown[] = [];
-            seen.set(node, out);
-            for (const item of node) out.push(walk(item));
-            return out;
-        }
-
-        const out: Record<string, unknown> = {};
-        seen.set(node as object, out);
-
-        for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
-            if (key === '$anchor') continue;
-            out[key] = walk(value);
-        }
-
-        return out;
-    }
-
-    return walk(schema) as T;
-}
-
-export function normalizeAnchorsToPointers<T>(input: T): T {
-    if (!input || typeof input !== 'object') return input;
-
-    const root = JSON.parse(JSON.stringify(input)) as { $defs?: Record<string, unknown> };
-    const defs: Record<string, unknown> = root.$defs && typeof root.$defs === 'object' ? root.$defs : {};
-    const anchorToDef: Record<string, string> = {};
-
-    for (const [defName, defValue] of Object.entries(defs)) {
-        if (!anchorToDef[defName]) {
-            anchorToDef[defName] = defName;
-        }
-
-        if (!defValue || typeof defValue !== 'object') continue;
-
-        const envelope = defValue as { valueSchema?: { $anchor?: unknown }; $anchor?: unknown };
-        const valueSchema = envelope.valueSchema;
-        if (valueSchema && typeof valueSchema === 'object') {
-            const anchor = valueSchema.$anchor;
-            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        } else {
-            const anchor = envelope.$anchor;
-            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        }
-    }
-
-    function walk(node: unknown): void {
-        if (Array.isArray(node)) {
-            for (const item of node) walk(item);
-            return;
-        }
-        if (!node || typeof node !== 'object') return;
-
-        const obj = node as { $ref?: unknown } & Record<string, unknown>;
-        if (typeof obj.$ref === 'string' && obj.$ref.startsWith('#') && !obj.$ref.startsWith('#/')) {
-            const anchor = obj.$ref.slice(1);
-            const defName = anchorToDef[anchor];
-            if (defName) {
-                obj.$ref = `#/$defs/${defName}`;
-            }
-        }
-
-        for (const value of Object.values(obj)) {
-            walk(value);
-        }
-    }
-
-    walk(root);
-    return root as T;
+export function stripAnchors<T>(schema: T): T {
+    const seen = new WeakMap<object, unknown>();
+
+    function walk(node: unknown): unknown {
+        if (!node || typeof node !== 'object') return node;
+
+        const existing = seen.get(node as object);
+        if (existing) return existing;
+
+        if (Array.isArray(node)) {
+            const out: unknown[] = [];
+            seen.set(node, out);
+            for (const item of node) out.push(walk(item));
+            return out;
+        }
+
+        const out: Record<string, unknown> = {};
+        seen.set(node as object, out);
+
+        for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
+            if (key === '$anchor') continue;
+            out[key] = walk(value);
+        }
+
+        return out;
+    }
+
+    return walk(schema) as T;
+}
+
+export function normalizeAnchorsToPointers<T>(input: T): T {
+    if (!input || typeof input !== 'object') return input;
+
+    const root = JSON.parse(JSON.stringify(input)) as { $defs?: Record<string, unknown> };
+    const defs: Record<string, unknown> = root.$defs && typeof root.$defs === 'object' ? root.$defs : {};
+    const anchorToDef: Record<string, string> = {};
+
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!anchorToDef[defName]) {
+            anchorToDef[defName] = defName;
+        }
+
+        if (!defValue || typeof defValue !== 'object') continue;
+
+        const envelope = defValue as { projectionSchema?: { $anchor?: unknown }; $anchor?: unknown };
+        const projectionSchema = envelope.projectionSchema;
+        if (projectionSchema && typeof projectionSchema === 'object') {
+            const anchor = projectionSchema.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        } else {
+            const anchor = envelope.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+
+    function walk(node: unknown): void {
+        if (Array.isArray(node)) {
+            for (const item of node) walk(item);
+            return;
+        }
+        if (!node || typeof node !== 'object') return;
+
+        const obj = node as { $ref?: unknown } & Record<string, unknown>;
+        if (typeof obj.$ref === 'string' && obj.$ref.startsWith('#') && !obj.$ref.startsWith('#/')) {
+            const anchor = obj.$ref.slice(1);
+            const defName = anchorToDef[anchor];
+            if (defName) {
+                obj.$ref = `#/$defs/${defName}`;
+            }
+        }
+
+        for (const value of Object.values(obj)) {
+            walk(value);
+        }
+    }
+
+    walk(root);
+    return root as T;
 }

package/src/utils/schemaShims.ts

@@ -1,17 +1,17 @@
-import * as path from 'node:path';
-
-export function generateShimContent(jsonFile: string, variableName: string): string {
-    return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
-}
-
-export function getShimsForFiles(jsonFiles: string[], variableName: string): Record<string, string> {
-    const shims: Record<string, string> = {};
-
-    for (const jsonFile of jsonFiles) {
-        const baseName = path.basename(jsonFile, '.json');
-        const tsFile = `${baseName}.ts`;
-        shims[tsFile] = generateShimContent(jsonFile, variableName);
-    }
-
-    return shims;
+import * as path from 'node:path';
+
+export function generateShimContent(jsonFile: string, variableName: string): string {
+    return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
+}
+
+export function getShimsForFiles(jsonFiles: string[], variableName: string): Record<string, string> {
+    const shims: Record<string, string> = {};
+
+    for (const jsonFile of jsonFiles) {
+        const baseName = path.basename(jsonFile, '.json');
+        const tsFile = `${baseName}.ts`;
+        shims[tsFile] = generateShimContent(jsonFile, variableName);
+    }
+
+    return shims;
 }