@toolproof-core/schema 1.0.3 → 1.0.4

package/dist/scripts/generateSchemaShims.js

@@ -15,23 +15,11 @@ import { getConfig } from './_lib/config.js';
  *
  * Usage: node ./dist/scripts/generateSchemaShims.js
  */
-/**
- * Pure function to generate the content of a TypeScript shim file.
- *
- * @param jsonFile The name of the JSON file to import
- * @param variableName The name of the variable to use for the import
- * @returns The TypeScript file content
- */
+// PURE: Generate the .ts shim module content for a given .json filename.
 function generateShimContent(jsonFile, variableName) {
     return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
 }
-/**
- * Pure function to map a list of JSON files to their corresponding TypeScript shim files and contents.
- *
- * @param jsonFiles List of JSON filenames
- * @param variableName The variable name to use in the shim
- * @returns A record mapping TS filenames to their contents
- */
+// PURE: Map JSON filenames to deterministic shim file contents.
 function getShimsForFiles(jsonFiles, variableName) {
     const shims = {};
     for (const jsonFile of jsonFiles) {
@@ -41,83 +29,87 @@ function getShimsForFiles(jsonFiles, variableName) {
     }
     return shims;
 }
-async function main() {
-    const config = getConfig();
-    const schemasDir = config.getSchemasDir();
-    const standaloneSchemasDir = config.getSchemasStandaloneDir();
-    const resourcesDir = config.getResourcesDir();
-    const generatedResourceTypesDir = config.getNormalizedDir();
-    let totalCount = 0;
-    // Process schemas directory
-    if (fs.existsSync(schemasDir)) {
-        const files = fs.readdirSync(schemasDir);
-        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
-        const shims = getShimsForFiles(jsonFiles, 'schema');
-        for (const [tsFile, content] of Object.entries(shims)) {
-            const tsPath = path.join(schemasDir, tsFile);
-            fs.writeFileSync(tsPath, content, 'utf-8');
-            console.log(`Generated ${tsFile} in ${schemasDir}`);
-            totalCount++;
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const schemasDir = config.getSchemasDir();
+        const standaloneSchemasDir = config.getSchemasStandaloneDir();
+        const resourcesDir = config.getResourcesDir();
+        const generatedResourceTypesDir = config.getNormalizedDir();
+        let totalCount = 0;
+        // Process schemas directory
+        if (fs.existsSync(schemasDir)) {
+            const files = fs.readdirSync(schemasDir);
+            const jsonFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
+            const shims = getShimsForFiles(jsonFiles, 'schema');
+            for (const [tsFile, content] of Object.entries(shims)) {
+                const tsPath = path.join(schemasDir, tsFile);
+                fs.writeFileSync(tsPath, content, 'utf-8');
+                console.log('Generated ' + tsFile + ' in ' + schemasDir);
+                totalCount++;
+            }
+            console.log('Generated ' + jsonFiles.length + ' TypeScript schema shims in ' + schemasDir);
         }
-        console.log(`Generated ${jsonFiles.length} TypeScript schema shims in ${schemasDir}`);
-    }
-    else {
-        console.warn(`Schemas directory not found at ${schemasDir}`);
-    }
-    // Process standalone schemas directory
-    if (fs.existsSync(standaloneSchemasDir)) {
-        const files = fs.readdirSync(standaloneSchemasDir);
-        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
-        const shims = getShimsForFiles(jsonFiles, 'schema');
-        for (const [tsFile, content] of Object.entries(shims)) {
-            const tsPath = path.join(standaloneSchemasDir, tsFile);
-            fs.writeFileSync(tsPath, content, 'utf-8');
-            console.log(`Generated ${tsFile} in ${standaloneSchemasDir}`);
-            totalCount++;
+        else {
+            console.warn('Schemas directory not found at ' + schemasDir);
         }
-        console.log(`Generated ${jsonFiles.length} TypeScript standalone schema shims in ${standaloneSchemasDir}`);
-    }
-    else {
-        // Standalone schemas are optional
-    }
-    // Process resources directory
-    if (fs.existsSync(resourcesDir)) {
-        const files = fs.readdirSync(resourcesDir);
-        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
-        const shims = getShimsForFiles(jsonFiles, 'resources');
-        for (const [tsFile, content] of Object.entries(shims)) {
-            const tsPath = path.join(resourcesDir, tsFile);
-            fs.writeFileSync(tsPath, content, 'utf-8');
-            console.log(`Generated ${tsFile} in ${resourcesDir}`);
-            totalCount++;
+        // Process standalone schemas directory
+        if (fs.existsSync(standaloneSchemasDir)) {
+            const files = fs.readdirSync(standaloneSchemasDir);
+            const jsonFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
+            const shims = getShimsForFiles(jsonFiles, 'schema');
+            for (const [tsFile, content] of Object.entries(shims)) {
+                const tsPath = path.join(standaloneSchemasDir, tsFile);
+                fs.writeFileSync(tsPath, content, 'utf-8');
+                console.log('Generated ' + tsFile + ' in ' + standaloneSchemasDir);
+                totalCount++;
+            }
+            console.log('Generated ' + jsonFiles.length + ' TypeScript standalone schema shims in ' + standaloneSchemasDir);
         }
-        console.log(`Generated ${jsonFiles.length} TypeScript resource shims in ${resourcesDir}`);
-    }
-    else {
-        console.warn(`Resources directory not found at ${resourcesDir}`);
-    }
-    // Genesis (normalized) shim
-    try {
-        const genesisJsonPath = config.getNormalizedSourcePath();
-        if (fs.existsSync(genesisJsonPath)) {
-            fs.mkdirSync(generatedResourceTypesDir, { recursive: true });
-            const tsFile = 'Genesis.ts';
-            const content = generateShimContent('Genesis.json', 'schema');
-            const tsPath = path.join(generatedResourceTypesDir, tsFile);
-            fs.writeFileSync(tsPath, content, 'utf-8');
-            console.log(`Generated ${tsFile} in ${generatedResourceTypesDir}`);
-            totalCount++;
+        else {
+            // Standalone schemas are optional
+        }
+        // Process resources directory
+        if (fs.existsSync(resourcesDir)) {
+            const files = fs.readdirSync(resourcesDir);
+            const jsonFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
+            const shims = getShimsForFiles(jsonFiles, 'resources');
+            for (const [tsFile, content] of Object.entries(shims)) {
+                const tsPath = path.join(resourcesDir, tsFile);
+                fs.writeFileSync(tsPath, content, 'utf-8');
+                console.log('Generated ' + tsFile + ' in ' + resourcesDir);
+                totalCount++;
+            }
+            console.log('Generated ' + jsonFiles.length + ' TypeScript resource shims in ' + resourcesDir);
         }
         else {
-            console.warn(`Genesis source JSON not found at ${genesisJsonPath}; skipping Genesis.ts shim`);
+            console.warn('Resources directory not found at ' + resourcesDir);
+        }
+        // Genesis (normalized) shim
+        try {
+            const genesisJsonPath = config.getNormalizedSourcePath();
+            if (fs.existsSync(genesisJsonPath)) {
+                fs.mkdirSync(generatedResourceTypesDir, { recursive: true });
+                const tsFile = 'Genesis.ts';
+                const content = generateShimContent('Genesis.json', 'schema');
+                const tsPath = path.join(generatedResourceTypesDir, tsFile);
+                fs.writeFileSync(tsPath, content, 'utf-8');
+                console.log('Generated ' + tsFile + ' in ' + generatedResourceTypesDir);
+                totalCount++;
+            }
+            else {
+                console.warn('Genesis source JSON not found at ' + genesisJsonPath + '; skipping Genesis.ts shim');
+            }
+        }
+        catch (e) {
+            console.warn('Failed to generate Genesis.ts shim:', e);
         }
+        console.log('Generated ' + totalCount + ' total TypeScript shims');
     }
     catch (e) {
-        console.warn('Failed to generate Genesis.ts shim:', e);
+        console.error(e);
+        process.exitCode = 1;
     }
-    console.log(`Generated ${totalCount} total TypeScript shims`);
 }
-main().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
+main();

package/dist/scripts/generateStandaloneSchema.js

@@ -8,11 +8,8 @@ import { getConfig } from './_lib/config.js';
  * 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, name) {
+// PURE: Extract a standalone subschema from a flattened Genesis schema, returning warnings instead of logging
+function extractStandaloneSchemaLogic(genesis, name) {
     const rootDefs = genesis.$defs;
     if (!rootDefs || typeof rootDefs !== 'object') {
         throw new Error('No $defs object found in Genesis.json');
@@ -24,47 +21,29 @@ function extractStandaloneSubschemaLogic(genesis, name) {
     const needed = collectLocalDefClosure(target, rootDefs);
     const targetClone = deepClone(target);
     const defsOut = {};
+    const warnings = [];
     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).`);
+            warnings.push(`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;
+    return { schema: targetClone, warnings };
 }
-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) {
-        console.error(error.message);
-        process.exit(1);
+// PURE: Strip accidental surrounding quotes from CLI values (PowerShell/cmd).
+function stripSurroundingQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
     }
+    return value;
 }
+// PURE: Parse CLI args (no defaults, no filesystem probing).
 function parseArgs(args) {
     let name;
     for (let i = 0; i < args.length; i++) {
@@ -77,11 +56,14 @@ function parseArgs(args) {
             name = a.split('=')[1];
         }
     }
-    return { name };
+    const normalized = typeof name === 'string' ? stripSurroundingQuotes(name) : undefined;
+    return { name: normalized?.trim() ? normalized : undefined };
 }
+// PURE: Narrow unknown values to plain objects.
 function isObject(v) {
     return v !== null && typeof v === 'object' && !Array.isArray(v);
 }
+// PURE: Deep-clone JSON-ish values (no mutation of input).
 function deepClone(v) {
     if (Array.isArray(v))
         return v.map((x) => deepClone(x));
@@ -93,6 +75,7 @@ function deepClone(v) {
     }
     return v;
 }
+// PURE: Extract a $defs key from a local JSON pointer ref.
 function extractPointerDefName(ref) {
     if (!ref || !ref.startsWith('#/'))
         return null;
@@ -104,6 +87,7 @@ function extractPointerDefName(ref) {
     const name = parts[1].replace(/~1/g, '/').replace(/~0/g, '~');
     return name;
 }
+// PURE: Resolve an internal ref (pointer or anchor) to a root $defs key.
 function resolveRefToDefName(ref, rootDefs) {
     if (!ref)
         return null;
@@ -128,6 +112,7 @@ function resolveRefToDefName(ref, rootDefs) {
     }
     return null;
 }
+// PURE: Compute the transitive closure of local $defs dependencies for a node.
 function collectLocalDefClosure(node, rootDefs) {
     const needed = new Set();
     const queue = [];
@@ -159,7 +144,32 @@ function collectLocalDefClosure(node, rootDefs) {
     }
     return needed;
 }
-main().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+async function main() {
+    try {
+        const config = getConfig();
+        const { name } = parseArgs(process.argv.slice(2));
+        if (!name) {
+            throw new Error('Missing --name <DefName> argument');
+        }
+        const schemasDir = config.getSchemasDir();
+        const genesisPath = path.join(schemasDir, config.getSourceFile());
+        const outPath = config.getSchemaStandalonePath(`${name}.json`);
+        if (!fs.existsSync(genesisPath)) {
+            throw new Error(`Genesis.json not found at ${genesisPath}. Run extractSchemasFromResourceTypeShells first.`);
+        }
+        const raw = fs.readFileSync(genesisPath, 'utf-8');
+        const genesis = JSON.parse(raw);
+        const { schema, warnings } = extractStandaloneSchemaLogic(genesis, name);
+        for (const w of warnings)
+            console.warn(w);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(schema, null, 2) + '\n');
+        console.log(`Created standalone subschema '${name}' -> ${outPath}`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/scripts/generateStandaloneTypeTS.js

@@ -0,0 +1,108 @@
+import fs from "fs";
+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: Generate the content of a standalone Resource type definition file for a given schema name.
+function generateStandaloneTypeLogic(name) {
+    const header = "// Auto-generated strict composite type. Do not edit.\n";
+    const ts = `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../typesTS.js";\n` +
+        `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
+    return header + ts;
+}
+// PURE: Strip accidental surrounding quotes from CLI values (PowerShell/cmd).
+function stripSurroundingQuotes(value) {
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+// PURE: Validate a standalone schema and return warnings (no logging).
+function validateStandaloneSchemaForWarnings(schema) {
+    const warnings = [];
+    if (schema?.$schema && schema.$schema !== "https://json-schema.org/draft/2020-12/schema") {
+        warnings.push(`Warning: schema $schema is '${String(schema.$schema)}', expected draft 2020-12. Proceeding anyway.`);
+    }
+    if (schema?.type && schema.type !== "object") {
+        warnings.push(`Warning: nucleusSchema usually has type: 'object' but this schema has type: '${String(schema.type)}'. Proceeding.`);
+    }
+    return warnings;
+}
+// PURE: Parse CLI args (no defaults, no filesystem probing).
+function parseArgs(args) {
+    let name;
+    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];
+        }
+    }
+    const normalized = typeof name === "string" ? stripSurroundingQuotes(name) : undefined;
+    return { name: normalized?.trim() ? normalized : undefined };
+}
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit).
+function main() {
+    try {
+        const config = getConfig();
+        const { name } = parseArgs(process.argv.slice(2));
+        if (!name) {
+            throw new Error("Missing --name <SchemaBasename> argument");
+        }
+        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.`);
+            }
+            throw new Error("Input schema file not found");
+        }
+        // Basic validation against the expected shape of nucleusSchema.
+        const raw = fs.readFileSync(inPath, "utf8");
+        const parsed = JSON.parse(raw);
+        for (const warning of validateStandaloneSchemaForWarnings(parsed))
+            console.warn(warning);
+        const tsContent = generateStandaloneTypeLogic(name);
+        const jsContent = "export {}\n";
+        // Output setup
+        const outName = `Resource_${name}.d.ts`;
+        const outJsName = `Resource_${name}.js`;
+        const outDir = config.getStandaloneTypeTsSrcDir();
+        const distLibDir = config.getStandaloneTypeTsDistDir();
+        // Process src output
+        fs.mkdirSync(outDir, { recursive: true });
+        const outPath = config.getStandaloneTypeTsSrcPath(outName);
+        const outJsPath = config.getStandaloneTypeTsSrcPath(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
+        fs.mkdirSync(distLibDir, { recursive: true });
+        const distDtsPath = config.getStandaloneTypeTsDistPath(outName);
+        const distJsPath = config.getStandaloneTypeTsDistPath(outJsName);
+        fs.writeFileSync(distDtsPath, tsContent, "utf8");
+        fs.writeFileSync(distJsPath, jsContent, "utf8");
+        console.log(`Wrote ${distDtsPath}`);
+        console.log(`Wrote ${distJsPath}`);
+    }
+    catch (e) {
+        console.error(e);
+        process.exitCode = 1;
+    }
+}
+main();