@toolproof-core/schema 1.0.0 → 1.0.2

package/src/scripts/{extractSubSchemaWithDefs.ts → generateStandaloneSchema.ts}

@@ -1,196 +1,175 @@
-import fs from 'fs';
-import path from 'path';
-import { getConfig } from './_lib/config.js';
-
-/**
- * Generic extractor: given a subschema name that exists under Genesis.json $defs,
- * produce a standalone JSON Schema file that contains that subschema plus an inner $defs
- * object holding all direct & transitive local $defs dependencies (by #/$defs/... $ref).
- *
- * Genesis.json itself is left unchanged.
- *
- * Usage:
- *   node ./dist/scripts/extractSubschemaWithDefs.js --name <DefName>
- *
- * Writes: src/genesis/generated/schemas/<DefName>.json
- */
-/**
- * Pure function to extract a subschema and its dependencies from a genesis object.
- * Performs no I/O operations.
- * 
- * @param genesis The root Genesis schema object
- * @param name The name of the definition to extract
- * @returns The standalone subschema
- */
-function extractSubSchemaLogic(genesis: any, name: string): any {
-  const rootDefs: Record<string, any> | undefined = genesis.$defs;
-  if (!rootDefs || typeof rootDefs !== 'object') {
-    throw new Error('No $defs object found in Genesis.json');
-  }
-
-  const target = rootDefs[name];
-  if (!target) {
-    throw new Error(`Subschema named '${name}' not found under $defs in Genesis.json`);
-  }
-
-  // Collect transitive local $defs names referenced by target
-  const needed = collectLocalDefClosure(target, rootDefs);
-
-  // Build output schema: clone target and attach collected subset as $defs
-  const targetClone = deepClone(target);
-  const defsOut: Record<string, any> = {};
-  for (const defName of needed) {
-    // Avoid including the target itself inside its own $defs (mirrors previous pattern)
-    if (defName === name) continue;
-    const defSchema = rootDefs[defName];
-    if (defSchema === undefined) {
-      console.warn(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
-      continue;
-    }
-    defsOut[defName] = deepClone(defSchema);
-  }
-
-  // Merge any pre-existing inner $defs of targetClone (if present) giving precedence to collected ones
-  const existingInner = isObject(targetClone.$defs) ? targetClone.$defs : {};
-  targetClone.$defs = { ...existingInner, ...defsOut };
-
-  return targetClone;
-}
-
-async function main() {
-  const config = getConfig();
-  const { name } = parseArgs(process.argv.slice(2));
-  if (!name) {
-    console.error('Missing --name <DefName> argument');
-    process.exit(1);
-  }
-
-  const schemasDir = config.getOutputDir();
-  const genesisPath = path.join(schemasDir, config.getSourceFile());
-  const outPath = config.getOutputPath(`${name}.json`);
-
-  if (!fs.existsSync(genesisPath)) {
-    console.error(`Genesis.json not found at ${genesisPath}`);
-    process.exit(1);
-  }
-
-  const raw = fs.readFileSync(genesisPath, 'utf-8');
-  const genesis = JSON.parse(raw);
-
-  try {
-    // Call the pure logic function
-    const result = extractSubSchemaLogic(genesis, name);
-
-    // I/O: Write the result
-    fs.mkdirSync(path.dirname(outPath), { recursive: true });
-    fs.writeFileSync(outPath, JSON.stringify(result, null, 2) + '\n');
-    console.log(`Extracted subschema '${name}' -> ${outPath}`);
-  } catch (error: any) {
-    console.error(error.message);
-    process.exit(1);
-  }
-}
-
-// ---- Helpers ----
-function parseArgs(args: string[]): { name?: string } {
-  let name: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a === '--name') {
-      name = args[i + 1];
-      i++;
-    } else if (a.startsWith('--name=')) {
-      name = a.split('=')[1];
-    }
-  }
-  return { name };
-}
-
-function isObject(v: any): v is Record<string, any> {
-  return v !== null && typeof v === 'object' && !Array.isArray(v);
-}
-
-function deepClone<T>(v: T): T {
-  if (Array.isArray(v)) return v.map((x) => deepClone(x)) as any;
-  if (isObject(v)) {
-    const out: Record<string, any> = {};
-    for (const k of Object.keys(v)) out[k] = deepClone((v as any)[k]);
-    return out as any;
-  }
-  return v;
-}
-
-function extractPointerDefName(ref: string): string | null {
-  // Accept refs like '#/$defs/Name' only (single-level under $defs)
-  if (!ref || !ref.startsWith('#/')) return null;
-  const parts = ref.slice(2).split('/'); // remove '#/'
-  if (parts.length !== 2) return null;
-  if (parts[0] !== '$defs') return null;
-  // Decode JSON Pointer tokens for the def name
-  const name = parts[1].replace(/~1/g, '/').replace(/~0/g, '~');
-  return name;
-}
-
-function resolveRefToDefName(ref: string, rootDefs: Record<string, any>): string | null {
-  if (!ref) return null;
-  // Case 1: JSON Pointer into $defs: '#/$defs/Name'
-  const byPointer = extractPointerDefName(ref);
-  if (byPointer) return byPointer;
-
-  // Case 2: Anchor ref: '#Name' -> find a def whose nucleusSchema.$anchor equals 'Name'
-  if (ref.startsWith('#') && !ref.startsWith('#/')) {
-    const anchor = ref.slice(1);
-    if (!anchor) return null;
-    for (const [defName, defSchema] of Object.entries(rootDefs)) {
-      if (!defSchema || typeof defSchema !== 'object') continue;
-      // Flattened Genesis has defs as the extraction schema itself (with $anchor at the top level).
-      // Unflattened may have { nucleusSchema: { $anchor } } envelopes. Support both.
-      const topLevelAnchor = (defSchema as any).$anchor;
-      const nested = (defSchema as any).nucleusSchema;
-      const nestedAnchor = nested && typeof nested === 'object' ? nested.$anchor : undefined;
-      const defAnchor = typeof topLevelAnchor === 'string' ? topLevelAnchor : (typeof nestedAnchor === 'string' ? nestedAnchor : undefined);
-      if (defAnchor === anchor) {
-        return defName;
-      }
-    }
-  }
-
-  return null;
-}
-
-function collectLocalDefClosure(node: any, rootDefs: Record<string, any>): Set<string> {
-  const needed = new Set<string>();
-  const queue: string[] = [];
-
-  function visit(n: any) {
-    if (Array.isArray(n)) {
-      for (const item of n) visit(item);
-      return;
-    }
-    if (!isObject(n)) return;
-    if (typeof n.$ref === 'string') {
-      const name = resolveRefToDefName(n.$ref, rootDefs);
-      if (name && !needed.has(name)) {
-        needed.add(name);
-        queue.push(name);
-      }
-    }
-    for (const val of Object.values(n)) visit(val);
-  }
-
-  visit(node);
-
-  while (queue.length > 0) {
-    const name = queue.shift()!;
-    const def = rootDefs[name];
-    if (!def) continue; // Missing def handled earlier
-    visit(def);
-  }
-
-  return needed;
-}
-
-main().catch((e) => {
-  console.error(e);
-  process.exit(1);
-});
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+/**
+ * Create a standalone JSON Schema for a single $defs entry under Genesis.json,
+ * embedding all direct & transitive local $defs dependencies.
+ *
+ * Usage:
+ *   node ./dist/scripts/generateStandaloneSchema.js --name <DefName>
+ */
+
+/**
+ * Pure function to extract a subschema and its dependencies from a flattened genesis schema.
+ * Performs no I/O operations.
+ */
+function extractStandaloneSubschemaLogic(genesis: any, name: string): any {
+  const rootDefs: Record<string, any> | undefined = genesis.$defs;
+  if (!rootDefs || typeof rootDefs !== 'object') {
+    throw new Error('No $defs object found in Genesis.json');
+  }
+
+  const target = rootDefs[name];
+  if (!target) {
+    throw new Error(`Subschema named '${name}' not found under $defs in Genesis.json`);
+  }
+
+  const needed = collectLocalDefClosure(target, rootDefs);
+
+  const targetClone = deepClone(target);
+  const defsOut: Record<string, any> = {};
+  for (const defName of needed) {
+    if (defName === name) continue;
+    const defSchema = rootDefs[defName];
+    if (defSchema === undefined) {
+      console.warn(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
+      continue;
+    }
+    defsOut[defName] = deepClone(defSchema);
+  }
+
+  const existingInner = isObject(targetClone.$defs) ? targetClone.$defs : {};
+  targetClone.$defs = { ...existingInner, ...defsOut };
+
+  return targetClone;
+}
+
+async function main() {
+  const config = getConfig();
+  const { name } = parseArgs(process.argv.slice(2));
+  if (!name) {
+    console.error('Missing --name <DefName> argument');
+    process.exit(1);
+  }
+
+  const schemasDir = config.getSchemasDir();
+  const genesisPath = path.join(schemasDir, config.getSourceFile());
+  const outPath = config.getSchemaStandalonePath(`${name}.json`);
+
+  if (!fs.existsSync(genesisPath)) {
+    console.error(`Genesis.json not found at ${genesisPath}. Run extractSchemasFromResourceTypeShells first.`);
+    process.exit(1);
+  }
+
+  const raw = fs.readFileSync(genesisPath, 'utf-8');
+  const genesis = JSON.parse(raw);
+
+  try {
+    const result = extractStandaloneSubschemaLogic(genesis, name);
+
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(result, null, 2) + '\n');
+    console.log(`Created standalone subschema '${name}' -> ${outPath}`);
+  } catch (error: any) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+function parseArgs(args: string[]): { name?: string } {
+  let name: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--name') {
+      name = args[i + 1];
+      i++;
+    } else if (a.startsWith('--name=')) {
+      name = a.split('=')[1];
+    }
+  }
+  return { name };
+}
+
+function isObject(v: any): v is Record<string, any> {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function deepClone<T>(v: T): T {
+  if (Array.isArray(v)) return v.map((x) => deepClone(x)) as any;
+  if (isObject(v)) {
+    const out: Record<string, any> = {};
+    for (const k of Object.keys(v)) out[k] = deepClone((v as any)[k]);
+    return out as any;
+  }
+  return v;
+}
+
+function extractPointerDefName(ref: string): string | null {
+  if (!ref || !ref.startsWith('#/')) return null;
+  const parts = ref.slice(2).split('/');
+  if (parts.length !== 2) return null;
+  if (parts[0] !== '$defs') return null;
+  const name = parts[1].replace(/~1/g, '/').replace(/~0/g, '~');
+  return name;
+}
+
+function resolveRefToDefName(ref: string, rootDefs: Record<string, any>): string | null {
+  if (!ref) return null;
+  const byPointer = extractPointerDefName(ref);
+  if (byPointer) return byPointer;
+
+  if (ref.startsWith('#') && !ref.startsWith('#/')) {
+    const anchor = ref.slice(1);
+    if (!anchor) return null;
+    for (const [defName, defSchema] of Object.entries(rootDefs)) {
+      if (!defSchema || typeof defSchema !== 'object') continue;
+      const topLevelAnchor = (defSchema as any).$anchor;
+      const nested = (defSchema as any).nucleusSchema;
+      const nestedAnchor = nested && typeof nested === 'object' ? nested.$anchor : undefined;
+      const defAnchor = typeof topLevelAnchor === 'string' ? topLevelAnchor : (typeof nestedAnchor === 'string' ? nestedAnchor : undefined);
+      if (defAnchor === anchor) {
+        return defName;
+      }
+    }
+  }
+
+  return null;
+}
+
+function collectLocalDefClosure(node: any, rootDefs: Record<string, any>): Set<string> {
+  const needed = new Set<string>();
+  const queue: string[] = [];
+
+  function visit(n: any) {
+    if (Array.isArray(n)) {
+      for (const item of n) visit(item);
+      return;
+    }
+    if (!isObject(n)) return;
+    if (typeof n.$ref === 'string') {
+      const name = resolveRefToDefName(n.$ref, rootDefs);
+      if (name && !needed.has(name)) {
+        needed.add(name);
+        queue.push(name);
+      }
+    }
+    for (const val of Object.values(n)) visit(val);
+  }
+
+  visit(node);
+
+  while (queue.length > 0) {
+    const name = queue.shift()!;
+    const def = rootDefs[name];
+    if (!def) continue;
+    visit(def);
+  }
+
+  return needed;
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

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

@@ -1,110 +1,119 @@
-import fs from 'fs';
-import path from 'path';
-import { getConfig } from './_lib/config.js';
-
-/**
- * Generate a typed Resource variant where `extractedData` is typed to a specific schema
- * extracted under the configured output directory.
- *
- * Usage: node ./dist/scripts/generateResourceTypeType.js --name Job
- */
-/**
- * Pure function to generate the typed Resource D.TS content.
- * 
- * @param name The name of the schema
- * @returns The TypeScript D.TS file content
- */
-function generateResourceTypeTypeLogic(name: string): string {
-    const header = '// Auto-generated strict composite type. Do not edit.\n';
-    const ts =
-        `import type { ResourceMetaBase, ${name} as ExtractedData } from './types.js';\n` +
-        `export type Resource_${name} = ResourceMetaBase & { extractedData: ExtractedData };\n`;
-    return header + ts;
-}
-
-async function main() {
-    const config = getConfig();
-    const { name } = parseArgs(process.argv.slice(2));
-    if (!name) {
-        console.error('Missing --name <SchemaBasename> argument');
-        process.exit(1);
-    }
-
-    const inPath = config.getOutputPath(`${name}.json`);
-
-    if (!fs.existsSync(inPath)) {
-        console.error(`Schema file not found: ${inPath}`);
-        process.exit(1);
-    }
-
-    // Basic validation against the expected shape of nucleusSchema.
-    const raw = fs.readFileSync(inPath, 'utf8');
-    let parsed: any = null;
-    try {
-        parsed = JSON.parse(raw);
-    } catch (e) {
-        console.error(`Failed to parse JSON schema ${inPath}:`, e);
-        process.exit(1);
-    }
-
-    // Minimal checks that roughly match the nucleusSchema constraints used elsewhere.
-    if (parsed.$schema && parsed.$schema !== 'https://json-schema.org/draft/2020-12/schema') {
-        console.warn(`Warning: schema $schema is '${parsed.$schema}', expected draft 2020-12. Proceeding anyway.`);
-    }
-    if (parsed.type && parsed.type !== 'object') {
-        console.warn(`Warning: nucleusSchema usually has type: 'object' but this schema has type: '${parsed.type}'. Proceeding.`);
-    }
-
-    const tsContent = generateResourceTypeTypeLogic(name);
-    const jsContent = 'export {}\n';
-
-    // Output setup
-    const outName = `Resource_${name}.d.ts`;
-    const outJsName = `Resource_${name}.js`;
-
-    // Process src output
-    const outDir = config.getTypesSrcDir();
-    fs.mkdirSync(outDir, { recursive: true });
-
-    const outPath = config.getTypesSrcPath(outName);
-    const outJsPath = config.getTypesSrcPath(outJsName);
-
-    fs.writeFileSync(outPath, tsContent, 'utf8');
-    console.log(`Wrote ${outPath}`);
-
-    if (!fs.existsSync(outJsPath)) {
-        fs.writeFileSync(outJsPath, jsContent, 'utf8');
-        console.log(`Wrote ${outJsPath}`);
-    }
-
-    // Process dist output
-    const distLibDir = config.getTypesDistDir();
-    fs.mkdirSync(distLibDir, { recursive: true });
-
-    const distDtsPath = config.getTypesDistPath(outName);
-    const distJsPath = config.getTypesDistPath(outJsName);
-
-    fs.writeFileSync(distDtsPath, tsContent, 'utf8');
-    fs.writeFileSync(distJsPath, jsContent, 'utf8');
-    console.log(`Wrote ${distDtsPath}`);
-    console.log(`Wrote ${distJsPath}`);
-}
-
-function parseArgs(args: string[]): { name?: string } {
-    let name: string | undefined;
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if (a === '--name') {
-            name = args[i + 1];
-            i++;
-        } else if (a.startsWith('--name=')) {
-            name = a.split('=')[1];
-        }
-    }
-    return { name };
-}
-
-main().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
+import fs from 'fs';
+import path from 'path';
+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
+ */
+/**
+ * Pure function to generate the typed Resource D.TS content.
+ * 
+ * @param name The name of the schema
+ * @returns The TypeScript D.TS file content
+ */
+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 '../types.js';\n` +
+        `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
+    return header + ts;
+}
+
+async function main() {
+    const config = getConfig();
+    const { name } = parseArgs(process.argv.slice(2));
+    if (!name) {
+        console.error('Missing --name <SchemaBasename> argument');
+        process.exit(1);
+    }
+
+    const inPath =
+        name === 'Genesis'
+            ? config.getSchemaPath('Genesis.json')
+            : config.getSchemaStandalonePath(`${name}.json`);
+
+    if (!fs.existsSync(inPath)) {
+        if (name === 'Genesis') {
+            console.error(`Schema file not found: ${inPath}`);
+            console.error('Run extractSchemasFromResourceTypeShells first.');
+        } else {
+            console.error(`Standalone schema file not found: ${inPath}`);
+            console.error(`Run generateStandaloneSchema -- --name ${name} first.`);
+        }
+        process.exit(1);
+    }
+
+    // Basic validation against the expected shape of nucleusSchema.
+    const raw = fs.readFileSync(inPath, 'utf8');
+    let parsed: any = null;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (e) {
+        console.error(`Failed to parse JSON schema ${inPath}:`, e);
+        process.exit(1);
+    }
+
+    // Minimal checks that roughly match the nucleusSchema constraints used elsewhere.
+    if (parsed.$schema && parsed.$schema !== 'https://json-schema.org/draft/2020-12/schema') {
+        console.warn(`Warning: schema $schema is '${parsed.$schema}', expected draft 2020-12. Proceeding anyway.`);
+    }
+    if (parsed.type && parsed.type !== 'object') {
+        console.warn(`Warning: nucleusSchema usually has type: 'object' but this schema has type: '${parsed.type}'. Proceeding.`);
+    }
+
+    const tsContent = generateStandaloneTypeLogic(name);
+    const jsContent = 'export {}\n';
+
+    // Output setup
+    const outName = `Resource_${name}.d.ts`;
+    const outJsName = `Resource_${name}.js`;
+
+    // Process src output
+    const outDir = config.getTypesStandaloneSrcDir();
+    fs.mkdirSync(outDir, { recursive: true });
+
+    const outPath = config.getTypesStandaloneSrcPath(outName);
+    const outJsPath = config.getTypesStandaloneSrcPath(outJsName);
+
+    fs.writeFileSync(outPath, tsContent, 'utf8');
+    console.log(`Wrote ${outPath}`);
+
+    if (!fs.existsSync(outJsPath)) {
+        fs.writeFileSync(outJsPath, jsContent, 'utf8');
+        console.log(`Wrote ${outJsPath}`);
+    }
+
+    // Process dist output
+    const distLibDir = config.getTypesStandaloneDistDir();
+    fs.mkdirSync(distLibDir, { recursive: true });
+
+    const distDtsPath = config.getTypesStandaloneDistPath(outName);
+    const distJsPath = config.getTypesStandaloneDistPath(outJsName);
+
+    fs.writeFileSync(distDtsPath, tsContent, 'utf8');
+    fs.writeFileSync(distJsPath, jsContent, 'utf8');
+    console.log(`Wrote ${distDtsPath}`);
+    console.log(`Wrote ${distJsPath}`);
+}
+
+function parseArgs(args: string[]): { name?: string } {
+    let name: string | undefined;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--name') {
+            name = args[i + 1];
+            i++;
+        } else if (a.startsWith('--name=')) {
+            name = a.split('=')[1];
+        }
+    }
+    return { name };
+}
+
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});