@toolproof-npm/schema 0.1.46 → 0.1.47

package/dist/genesis/generated/types/types.d.ts

@@ -82,13 +82,11 @@ export type ExtractionSchema =
  {
 } & {
   $schema: "https://json-schema.org/draft/2020-12/schema";
-  $defs?: {
-};
+  $defs?: Record<string, unknown>;
   type: "object";
-  allOf?: [{type: "array"; items: {type: "object"}}];
-  properties?: {
-};
-  required?: [{type: "array"; items: {type: "string"}; uniqueItems: true}];
+  allOf?: Array<{[k: string]: unknown}>;
+  properties?: Record<string, unknown>;
+  required?: string[];
   additionalProperties?: false;
   unevaluatedProperties?: false;
   $anchor: string;
@@ -123,7 +121,10 @@ export type IdentitySchema =
   type: "string" | "number" | "integer" | "boolean";
   $anchor?: string;
   $comment?: string;
-  enum?: [{type: "array"; minItems: 1; uniqueItems: true}];
+  /**
+   * @minItems 1
+   */
+  enum?: [unknown, ...unknown[]];
   format?: string;
   maxLength?: number;
   minLength?: number;
@@ -180,7 +181,10 @@ export type MeritSchema =
   type?: "number" | "integer";
   $anchor?: string;
   $comment?: string;
-  enum?: [{type: "array"; items: {type: "number"}; minItems: 1; uniqueItems: true}];
+  /**
+   * @minItems 1
+   */
+  enum?: [number, ...number[]];
   exclusiveMaximum?: number;
   exclusiveMinimum?: number;
   maximum?: number;
@@ -192,7 +196,10 @@ export type MeritSchema1 =
       type: "number" | "integer";
 }
   | {
-      enum: [{type: "array"; items: {type: "number"}; minItems: 1}];
+      /**
+       * @minItems 1
+       */
+      enum: [number, ...number[]];
 };
 /**
  * This interface was referenced by `GenesisJson`'s JSON-Schema
@@ -416,12 +423,11 @@ export interface ExtractionSchemaWrapper {
  * via the `definition` "IdentityProp".
  */
 export interface IdentityProp {
-  $defs: {
-};
+  $defs: Record<string, unknown>;
   properties: {
     identity: IdentitySchemaRef;
 };
-  required?: string[];
+  required: string[];
   additionalProperties?: unknown;
 }
 /**
@@ -456,12 +462,11 @@ export type RoleMap = Record<ResourceRoleIdentity, ResourceRoleValue>;
  * via the `definition` "MeritProp".
  */
 export interface MeritProp {
-  $defs: {
-};
+  $defs: Record<string, unknown>;
   properties: {
     merit: MeritSchemaRef;
 };
-  required: [{type: "array"; items: {type: "string"}; uniqueItems: true}];
+  required: string[];
   additionalProperties?: unknown;
 }
 /**
@@ -577,13 +582,11 @@ export type ExtractionSchema =
  {
 } & {
   $schema: "https://json-schema.org/draft/2020-12/schema";
-  $defs?: {
-};
+  $defs?: Record<string, unknown>;
   type: "object";
-  allOf?: [{type: "array"; items: {type: "object"}}];
-  properties?: {
-};
-  required?: [{type: "array"; items: {type: "string"}; uniqueItems: true}];
+  allOf?: Array<{[k: string]: unknown}>;
+  properties?: Record<string, unknown>;
+  required?: string[];
   additionalProperties?: false;
   unevaluatedProperties?: false;
   $anchor: string;

package/dist/scripts/generateTypes.js

@@ -187,24 +187,38 @@ async function main() {
             try {
                 const rawSchema = fs.readFileSync(schemaPath, 'utf8');
                 const parsedSchema = JSON.parse(rawSchema);
-                function normalizeArrays(node) {
+                function normalizeArrays(node, parentKey) {
                     if (Array.isArray(node)) {
                         for (let i = 0; i < node.length; i++)
-                            normalizeArrays(node[i]);
+                            normalizeArrays(node[i], parentKey);
                         return;
                     }
                     if (!node || typeof node !== 'object')
                         return;
-                    const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
-                    for (const k of arrayKeys) {
-                        if (k in node) {
-                            const v = node[k];
-                            if (!Array.isArray(v))
-                                node[k] = [v];
+                    // IMPORTANT:
+                    // In meta-schemas we often have `properties: { required: { ...schema... } }`.
+                    // Here, the key "required" is a *property name*, not the JSON-Schema keyword
+                    // "required". Blindly normalizing would wrap that schema object into an array,
+                    // causing json-schema-to-typescript to emit the schema-shape instead of `string[]`.
+                    //
+                    // So: only coerce array-keywords when we're not inside a map of property names.
+                    const isPropertyNameMap = parentKey === 'properties'
+                        || parentKey === 'patternProperties'
+                        || parentKey === '$defs'
+                        || parentKey === 'definitions'
+                        || parentKey === 'dependentSchemas';
+                    if (!isPropertyNameMap) {
+                        const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
+                        for (const k of arrayKeys) {
+                            if (k in node) {
+                                const v = node[k];
+                                if (!Array.isArray(v))
+                                    node[k] = [v];
+                            }
                         }
                     }
-                    for (const val of Object.values(node))
-                        normalizeArrays(val);
+                    for (const [k, v] of Object.entries(node))
+                        normalizeArrays(v, k);
                 }
                 // Normalize expected arrays to prevent traversal crashes
                 normalizeArrays(parsedSchema);
@@ -245,15 +259,24 @@ async function main() {
         // Robust single-pass: delete the entire line (with optional trailing newline) where the signature appears.
         // This avoids introducing extra blank lines while handling CRLF/LF and varying indentation.
         ts = ts.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*(?:\r?\n)?/gm, '');
-        // Fix meta-schema types where json-schema-to-typescript incorrectly interprets
-        // schema definitions as literal values. ExtractionSchemaValue describes what
-        // an extraction schema looks like, not what the schema meta-properties should be.
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(\$defs\?:\s*\{[\s\S]*?};)/gm, '$1$defs?: {\n    [k: string]: unknown;\n  };');
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(properties\?:\s*\{[\s\S]*?};)/gm, '$1properties?: {\n    [k: string]: unknown;\n  };');
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(allOf\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"object"\}\}\];)/gm, '$1allOf?: Array<{[k: string]: unknown}>;');
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(required\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
-        // Similarly fix IdentityProp which has the same issue
+        // Fix meta-schema types where json-schema-to-typescript can still incorrectly interpret
+        // schema definitions as literal values (or emit overly-restrictive `{}` objects).
+        // We do this as a broad post-pass on the emitted TS because the generator output varies
+        // (e.g. `allOf?: { }[];` vs `allOf?: [{type:"array"; ...}]`).
+        // `$defs?: { }` or `$defs: { }` -> map type (preserve required/optional marker)
+        // NOTE: We emit `Record<...>` instead of an index signature because later cleanup
+        // strips standalone `[k: string]: unknown;` lines.
+        ts = ts.replace(/^(\s*)(\$defs\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+        // `properties?: { }` or `properties: { }` -> map type
+        ts = ts.replace(/^(\s*)(properties\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+        // `allOf?: { }[];` (and similar for anyOf/oneOf) -> array of schema-ish objects
+        ts = ts.replace(/^(\s*)((?:allOf|anyOf|oneOf)\??:\s*)\{\s*\r?\n\s*\}\[\];/gm, (_m, indent, head) => `${indent}${head}Array<{[k: string]: unknown}>;`);
+        // Older broken shapes from earlier normalization (keep for backwards compatibility)
+        ts = ts.replace(/((?:allOf|anyOf|oneOf)\??:\s*)\[\{type:\s*"array";\s*items:\s*\{type:\s*"object"\}\}\];/g, '$1Array<{[k: string]: unknown}>;');
+        ts = ts.replace(/required\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];/g, 'required?: string[];');
+        // Similarly fix IdentityProp/MeritProp which have the same issue
         ts = ts.replace(/^(export interface IdentityProp[\s\S]*?)(required:\s*\[\{type:\s*"array";\s*contains:\s*\{const:\s*"identity"\};\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
+        ts = ts.replace(/^(export interface MeritProp[\s\S]*?)(required:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
         // Prune verbose type/interface names produced from absolute $id URLs.
         // Deterministic pruning based on original $id -> baseName map
         // This avoids heuristic truncation that dropped prefixes.

package/package.json

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