@toolproof-npm/schema 0.1.49 → 0.1.52

package/dist/scripts/generateTypes.js

@@ -220,8 +220,66 @@ async function main() {
                     for (const [k, v] of Object.entries(node))
                         normalizeArrays(v, k);
                 }
+                // json-schema-to-typescript has a long-standing quirk:
+                // when a schema uses `allOf`, sibling object keywords like `properties`/`required`
+                // can be ignored in the emitted TS (it treats `allOf` as the whole schema).
+                //
+                // Example (Genesis $defs/Job):
+                //   { type: 'object', allOf: [Documented, RolesWrapper], properties: { identity: ... }, required: [...] }
+                // can become:
+                //   type Job = Documented & RolesWrapper
+                //
+                // To avoid cluttering the source JSON schemas, we normalize to a temp file:
+                // move those sibling object keywords into an extra `allOf` item.
+                function normalizeAllOfSiblingObjectKeywords(node) {
+                    if (Array.isArray(node)) {
+                        for (const item of node)
+                            normalizeAllOfSiblingObjectKeywords(item);
+                        return;
+                    }
+                    if (!node || typeof node !== 'object')
+                        return;
+                    const hasAllOf = Array.isArray(node.allOf) && node.allOf.length > 0;
+                    const looksLikeObjectSchema = node.type === 'object' ||
+                        node.properties !== undefined ||
+                        node.required !== undefined ||
+                        node.unevaluatedProperties !== undefined ||
+                        node.additionalProperties !== undefined;
+                    if (hasAllOf && looksLikeObjectSchema) {
+                        const siblingKeys = [
+                            'properties',
+                            'required',
+                            'additionalProperties',
+                            'unevaluatedProperties',
+                            'propertyNames',
+                            'patternProperties',
+                            'dependentRequired',
+                            'dependentSchemas',
+                            'minProperties',
+                            'maxProperties'
+                        ];
+                        const hasSiblingObjectKeywords = siblingKeys.some((k) => k in node);
+                        if (hasSiblingObjectKeywords) {
+                            const overlay = {};
+                            if (node.type === 'object')
+                                overlay.type = 'object';
+                            for (const k of siblingKeys) {
+                                if (k in node) {
+                                    overlay[k] = node[k];
+                                    delete node[k];
+                                }
+                            }
+                            // Prepend so it participates in the intersection early.
+                            node.allOf = [overlay, ...node.allOf];
+                        }
+                    }
+                    for (const v of Object.values(node))
+                        normalizeAllOfSiblingObjectKeywords(v);
+                }
                 // Normalize expected arrays to prevent traversal crashes
                 normalizeArrays(parsedSchema);
+                // Normalize `allOf` + sibling object keywords so the TS generator doesn't drop them.
+                normalizeAllOfSiblingObjectKeywords(parsedSchema);
                 const tmpPath = path.join(inputDir, `.normalized.${path.basename(fileName)}`);
                 fs.writeFileSync(tmpPath, JSON.stringify(parsedSchema, null, 2), 'utf8');
                 toCompilePath = tmpPath;

package/dist/scripts/rewriteAnchors.js

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import path from 'path';
 import { getConfig } from './_lib/config.js';
 /**
  * Rewrite anchor-style references to JSON Pointer references
@@ -65,8 +66,8 @@ function rewriteAnchorsToPointers(root) {
 async function main() {
     const config = getConfig();
     const genesisSourcePath = config.getSourcePath();
-    // Create a temporary normalized version
-    const normalizedPath = genesisSourcePath.replace('.json', '.normalized.json');
+    // 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);
@@ -81,6 +82,7 @@ async function main() {
     // Rewrite anchors in the extractionSchema (where $defs is at the top level)
     rewriteAnchorsToPointers(genesis.extractionSchema);
     // 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}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/schema",
-  "version": "0.1.49",
+  "version": "0.1.52",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "keywords": [
     "toolproof",