@toolproof-core/schema 1.0.4 → 1.0.5

package/src/scripts/_lib/config.ts

@@ -26,8 +26,8 @@ export class SchemaConfig {
   private readonly schemasDir: string;
   private readonly resourcesDir: string;
   private readonly dependencyMapPath: string;
-  private readonly typesTsSrcDir: string;
-  private readonly typesTsDistDir: string;
+  private readonly typesSrcDir: string;
+  private readonly typesDistDir: string;
 
   // Schema metadata
   private readonly baseUrl: string;
@@ -38,14 +38,12 @@ export class SchemaConfig {
     this.root = getEnv('TP_SCHEMA_ROOT', process.cwd());
     this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/');
     this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
-    // Intermediate, generated artifact produced by normalizeAnchorsToPointers.
-    // This should NOT live next to the source-of-truth schemas.
     this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/generated/normalized');
     this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'src/generated/schemas');
     this.resourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
     this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencies/dependencyMap.json');
-    this.typesTsSrcDir = getEnv('TP_SCHEMA_TYPES_TS_SRC_DIR', 'src/generated/typesTS');
-    this.typesTsDistDir = getEnv('TP_SCHEMA_TYPES_TS_DIST_DIR', 'dist/generated/typesTS');
+    this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/generated/types');
+    this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/generated/types');
     this.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
     this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
   }
@@ -96,48 +94,48 @@ export class SchemaConfig {
     return path.join(this.getSchemasDir(), filename);
   }
 
-  getSchemasStandaloneDir(): string {
+  getStandaloneSchemaDir(): string {
     return path.join(this.getSchemasDir(), 'standalone');
   }
 
-  getSchemaStandalonePath(filename: string): string {
-    return path.join(this.getSchemasStandaloneDir(), filename);
+  getStandaloneSchemaPath(filename: string): string {
+    return path.join(this.getStandaloneSchemaDir(), filename);
   }
 
-  getTypesTsSrcDir(): string {
-    return path.isAbsolute(this.typesTsSrcDir)
-      ? this.typesTsSrcDir
-      : path.join(this.root, this.typesTsSrcDir);
+  getTypesSrcDir(): string {
+    return path.isAbsolute(this.typesSrcDir)
+      ? this.typesSrcDir
+      : path.join(this.root, this.typesSrcDir);
   }
 
-  getTypesTsDistDir(): string {
-    return path.isAbsolute(this.typesTsDistDir)
-      ? this.typesTsDistDir
-      : path.join(this.root, this.typesTsDistDir);
+  getTypesDistDir(): string {
+    return path.isAbsolute(this.typesDistDir)
+      ? this.typesDistDir
+      : path.join(this.root, this.typesDistDir);
   }
 
-  getTypesTsSrcPath(filename: string): string {
-    return path.join(this.getTypesTsSrcDir(), filename);
+  getTypesSrcPath(filename: string): string {
+    return path.join(this.getTypesSrcDir(), filename);
   }
 
-  getTypesTsDistPath(filename: string): string {
-    return path.join(this.getTypesTsDistDir(), filename);
+  getTypesDistPath(filename: string): string {
+    return path.join(this.getTypesDistDir(), filename);
   }
 
-  getStandaloneTypeTsSrcDir(): string {
-    return path.join(this.getTypesTsSrcDir(), 'standalone');
+  getStandaloneTypeSrcDir(): string {
+    return path.join(this.getTypesSrcDir(), 'standalone');
   }
 
-  getStandaloneTypeTsDistDir(): string {
-    return path.join(this.getTypesTsDistDir(), 'standalone');
+  getStandaloneTypeDistDir(): string {
+    return path.join(this.getTypesDistDir(), 'standalone');
   }
 
-  getStandaloneTypeTsSrcPath(filename: string): string {
-    return path.join(this.getStandaloneTypeTsSrcDir(), filename);
+  getStandaloneTypeSrcPath(filename: string): string {
+    return path.join(this.getStandaloneTypeSrcDir(), filename);
   }
 
-  getStandaloneTypeTsDistPath(filename: string): string {
-    return path.join(this.getStandaloneTypeTsDistDir(), filename);
+  getStandaloneTypeDistPath(filename: string): string {
+    return path.join(this.getStandaloneTypeDistDir(), filename);
   }
 
   getResourcesDir(): string {

package/src/scripts/generateSchemaShims.ts

@@ -11,7 +11,7 @@ import { getConfig } from './_lib/config.js';
  * 
  * Generates shims for:
  * - schemas dir: config.getSchemasDir() (schema files)
- * - standalone schemas dir: config.getSchemasStandaloneDir() (standalone schema files)
+ * - standalone schemas dir: config.getStandaloneSchemaDir() (standalone schema files)
  * - resources dir: config.getResourcesDir() (resource envelope files)
  * 
  * Usage: node ./dist/scripts/generateSchemaShims.js
@@ -38,7 +38,7 @@ function main() {
     try {
         const config = getConfig();
         const schemasDir = config.getSchemasDir();
-        const standaloneSchemasDir = config.getSchemasStandaloneDir();
+        const standaloneSchemasDir = config.getStandaloneSchemaDir();
         const resourcesDir = config.getResourcesDir();
         const generatedResourceTypesDir = config.getNormalizedDir();
 

package/src/scripts/generateStandaloneSchema.ts

@@ -161,7 +161,7 @@ async function main() {
 
     const schemasDir = config.getSchemasDir();
     const genesisPath = path.join(schemasDir, config.getSourceFile());
-    const outPath = config.getSchemaStandalonePath(`${name}.json`);
+    const outPath = config.getStandaloneSchemaPath(`${name}.json`);
 
     if (!fs.existsSync(genesisPath)) {
       throw new Error(`Genesis.json not found at ${genesisPath}. Run extractSchemasFromResourceTypeShells first.`);

package/src/scripts/{generateStandaloneTypeTS.ts → generateStandaloneType.ts}

@@ -5,14 +5,14 @@ import { getConfig } from "./_lib/config.js";
  * Generate a typed Resource variant where `nucleus` is typed to a specific schema
  * extracted under the configured output directory.
  *
- * Usage: node ./dist/scripts/generateStandaloneType.js --name Job
+ * Usage: node ./dist/scripts/generateStandaloneTypes.js --name Job
  */
 
 // PURE: Generate the content of a standalone Resource type definition file for a given schema name.
 function generateStandaloneTypeLogic(name: string): string {
     const header = "// Auto-generated strict composite type. Do not edit.\n";
     const ts =
-        `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../typesTS.js";\n` +
+        `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../types.js";\n` +
         `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }
@@ -70,7 +70,7 @@ function main() {
         const inPath =
             name === "Genesis"
                 ? config.getSchemaPath("Genesis.json")
-                : config.getSchemaStandalonePath(`${name}.json`);
+                : config.getStandaloneSchemaPath(`${name}.json`);
 
         if (!fs.existsSync(inPath)) {
             if (name === "Genesis") {
@@ -95,13 +95,13 @@ function main() {
         // Output setup
         const outName = `Resource_${name}.d.ts`;
         const outJsName = `Resource_${name}.js`;
-        const outDir = config.getStandaloneTypeTsSrcDir();
-        const distLibDir = config.getStandaloneTypeTsDistDir();
+        const outDir = config.getStandaloneTypeSrcDir();
+        const distLibDir = config.getStandaloneTypeDistDir();
 
         // Process src output
         fs.mkdirSync(outDir, { recursive: true });
-        const outPath = config.getStandaloneTypeTsSrcPath(outName);
-        const outJsPath = config.getStandaloneTypeTsSrcPath(outJsName);
+        const outPath = config.getStandaloneTypeSrcPath(outName);
+        const outJsPath = config.getStandaloneTypeSrcPath(outJsName);
         fs.writeFileSync(outPath, tsContent, "utf8");
         console.log(`Wrote ${outPath}`);
 
@@ -112,8 +112,8 @@ function main() {
 
         // Process dist output
         fs.mkdirSync(distLibDir, { recursive: true });
-        const distDtsPath = config.getStandaloneTypeTsDistPath(outName);
-        const distJsPath = config.getStandaloneTypeTsDistPath(outJsName);
+        const distDtsPath = config.getStandaloneTypeDistPath(outName);
+        const distJsPath = config.getStandaloneTypeDistPath(outJsName);
         fs.writeFileSync(distDtsPath, tsContent, "utf8");
         fs.writeFileSync(distJsPath, jsContent, "utf8");
         console.log(`Wrote ${distDtsPath}`);

package/src/scripts/{generateTypesTS.ts → generateTypes.ts}

@@ -407,10 +407,10 @@ function postProcessEmittedTypes(ts: string, parsedSchema: any): string {
 }
 
 // PURE: Add banner + formatting/guards to build the final .d.ts content.
-function finalizeOutputDts(emittedTypesTs: string): string {
+function finalizeOutputDts(emittedType: string): string {
     const banner = '// Auto-generated from JSON schemas. Do not edit.\n';
 
-    let output = banner + '\n' + emittedTypesTs + '\n';
+    let output = banner + '\n' + emittedType + '\n';
 
     // Final guard: strip any lingering `[k: string]: unknown;` that might have been
     // reintroduced by later transforms.
@@ -438,8 +438,8 @@ async function main() {
     try {
         const config = getConfig();
         const inputDir = config.getSchemasDir();
-        const srcLibTypesDir = config.getTypesTsSrcDir();
-        const srcLibOutputPath = config.getTypesTsSrcPath('typesTS.d.ts');
+        const srcLibTypesDir = config.getTypesSrcDir();
+        const srcLibOutputPath = config.getTypesSrcPath('types.d.ts');
 
         fs.mkdirSync(srcLibTypesDir, { recursive: true });
 
@@ -493,8 +493,8 @@ async function main() {
         }
 
         // Also write a copy into dist so consumers get the generated declarations
-        const distLibTypesDir = config.getTypesTsDistDir();
-        const distLibOutputPath = config.getTypesTsDistPath('typesTS.d.ts');
+        const distLibTypesDir = config.getTypesDistDir();
+        const distLibOutputPath = config.getTypesDistPath('types.d.ts');
         try {
             fs.mkdirSync(distLibTypesDir, { recursive: true });
             fs.writeFileSync(distLibOutputPath, output, 'utf8');
@@ -504,24 +504,24 @@ async function main() {
             console.warn('Failed to write types to dist:', e);
         }
 
-        // Ensure there is a runtime-resolvable module next to `typesTS.d.ts`
+        // Ensure there is a runtime-resolvable module next to `types.d.ts`
         // Some consumers and TS NodeNext resolution expect a concrete .js next to .d.ts
         // The file is intentionally empty as all exports are types-only.
         try {
-            const srcLibTypesJsPath = config.getTypesTsSrcPath('typesTS.js');
+            const srcLibTypesJsPath = config.getTypesSrcPath('types.js');
             if (!fs.existsSync(srcLibTypesJsPath)) {
                 fs.writeFileSync(srcLibTypesJsPath, 'export {}\n', 'utf8');
                 console.log('Wrote', srcLibTypesJsPath);
             }
         } catch (e) {
-            console.warn('Failed to write typesTS.js to src/_lib:', e);
+            console.warn('Failed to write types.js to src/_lib:', e);
         }
         try {
-            const distLibTypesJsPath = config.getTypesTsDistPath('typesTS.js');
+            const distLibTypesJsPath = config.getTypesDistPath('types.js');
             fs.writeFileSync(distLibTypesJsPath, 'export {}\n', 'utf8');
             console.log('Wrote', distLibTypesJsPath);
         } catch (e) {
-            console.warn('Failed to write typesTS.js to dist/_lib:', e);
+            console.warn('Failed to write types.js to dist/_lib:', e);
         }
     } catch (err) {
         console.error(err);

package/src/scripts/normalizeAnchorsToPointers.ts

@@ -2,18 +2,41 @@ 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/normalizeAnchorsToPointers.js
- */
+/*
+    * Rewrite anchor-style references to JSON Pointer references in Genesis.json.
+    * We also strip all $anchor fields from the output since they are no longer needed after rewriting refs.
+*/
+
+// PURE: Remove all `$anchor` keys from a schema tree without rewriting refs.
+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;
+}
 
 // PURE: Rewrite anchor-style `$ref` strings (`#Anchor`) into JSON Pointer refs (`#/$defs/DefName`).
 function normalizeAnchorsToPointers(input: any): any {
@@ -102,6 +125,9 @@ function main() {
         // Rewrite anchors in the nucleusSchema (pure function call)
         genesis.nucleusSchema = normalizeAnchorsToPointers(genesis.nucleusSchema);
 
+        // Strip $anchor fields from the schemas (pure function call)
+        genesis.nucleusSchema = stripAnchors(genesis.nucleusSchema);
+
         // Write normalized version
         fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
         fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');