@toolproof-core/schema 1.0.0

package/src/scripts/rewriteAnchors.ts

@@ -0,0 +1,123 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+/**
+ * Rewrite anchor-style references to JSON Pointer references in Genesis.json
+ * 
+ * Converts #AnchorName to #/$defs/AnchorName for compatibility with strict
+ * JSON Schema validators and downstream tooling. This normalization step runs
+ * before both schema extraction and resource envelope generation.
+ * 
+ * The rewritten file is saved under src/genesis/generated/resourceTypes/Genesis.json
+ * for use by other scripts.
+ * 
+ * Usage: node ./dist/scripts/rewriteAnchors.js
+ */
+
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+/**
+ * Pure function to rewrite anchor-style references to JSON Pointer references.
+ * Converts #AnchorName to #/$defs/AnchorName for compatibility with strict JSON Schema validators.
+ * 
+ * This function works on a schema object that has $defs at its top level.
+ * @param input The schema object to process
+ * @returns A new schema object with rewritten references
+ */
+function rewriteAnchorsToPointers(input: any): any {
+    if (!input || typeof input !== "object") return input;
+
+    // Deep clone the input to ensure the function is pure (no side effects on input)
+    const root = JSON.parse(JSON.stringify(input));
+
+    // Build a map of anchors to their definition names
+    const defs: Record<string, any> = root.$defs && typeof root.$defs === "object" ? root.$defs : {};
+    const anchorToDef: Record<string, string> = {};
+
+    // For Genesis structure: each def is a Type envelope with nucleusSchema.$anchor
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!defValue || typeof defValue !== "object") continue;
+
+        // Check if this is a Type envelope (has nucleusSchema property)
+        const nucleusSchema = (defValue as any).nucleusSchema;
+        if (nucleusSchema && typeof nucleusSchema === "object") {
+            // Look for $anchor inside the nucleusSchema
+            const anchor = nucleusSchema.$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        } else {
+            // Fallback: check for $anchor at the def level (non-envelope case)
+            const anchor = (defValue as any).$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+
+    // Walk the entire tree and rewrite anchor refs to pointer refs
+    function walk(node: any): void {
+        if (Array.isArray(node)) {
+            for (const item of node) walk(item);
+            return;
+        }
+        if (!node || typeof node !== "object") return;
+
+        // Rewrite $ref if it's an anchor-style reference
+        if (typeof node.$ref === "string") {
+            const ref: string = node.$ref;
+            // Match anchor refs: starts with # but not #/ (JSON Pointer syntax)
+            if (ref.startsWith("#") && !ref.startsWith("#/")) {
+                const anchor = ref.slice(1);
+                const defName = anchorToDef[anchor];
+                if (defName) {
+                    node.$ref = `#/$defs/${defName}`;
+                }
+            }
+        }
+
+        // Recursively walk all properties
+        for (const val of Object.values(node)) {
+            walk(val);
+        }
+    }
+
+    walk(root);
+    return root;
+}
+
+async function main() {
+    const config = getConfig();
+    const genesisSourcePath = config.getSourcePath();
+
+    // Create a generated/normalized version (anchor refs rewritten to pointers)
+    const normalizedPath = config.getNormalizedSourcePath();
+
+    if (!fs.existsSync(genesisSourcePath)) {
+        console.error(`Genesis source file not found at ${genesisSourcePath}`);
+        process.exit(1);
+    }
+
+    const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
+    const genesis = JSON.parse(raw);
+
+    // Validate structure
+    if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
+        console.error('Genesis.json must have nucleusSchema.$defs');
+        process.exit(1);
+    }
+
+    // Rewrite anchors in the nucleusSchema (pure function call)
+    genesis.nucleusSchema = rewriteAnchorsToPointers(genesis.nucleusSchema);
+
+    // Write normalized version
+    fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
+    fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');
+    console.log(`Wrote normalized Genesis with pointer refs to ${normalizedPath}`);
+}
+
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});