@toolproof-core/schema 1.0.9 → 1.0.11

package/src/scripts/generateConstantsAndMappings.ts

@@ -0,0 +1,309 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+export type GeneratedConstants = {
+    Names: Record<string, string>;
+    Enums: Record<string, Record<string, string>>;
+};
+
+export type GeneratedMappings = {
+    IdentityNameToIdentityPrefix: Record<string, string>;
+    StepKindToStepIdentityPrefix: Record<string, string>;
+};
+
+export type DeriveStepKindToStepIdentityPrefixResult = {
+    mapping: Record<string, string>;
+    missing: Array<{ stepKind: string; identityName: string }>;
+};
+
+// PURE: Convert a string enum member into PascalCase.
+// Examples: 'job' -> 'Job', 'graph_start' -> 'GraphStart'
+function toPascalCase(value: string): string {
+    return value
+        .split(/[^A-Za-z0-9]+/g)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+
+// PURE: Attempt to derive a canonical identity prefix from a canonical identity regex pattern.
+function deriveIdentityPrefixFromPattern(pattern: string): string | undefined {
+    // Canonical (currently used across schemas): ^PREFIX-.+$
+    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
+    if (!match) return undefined;
+
+    const prefix = match[1];
+    if (!prefix || /[`\n\r]/.test(prefix)) return undefined;
+
+    return prefix;
+}
+
+// PURE: Extract all identity prefixes from `$defs/*Identity` string-pattern definitions.
+export function extractIdentityPrefixes(schema: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as any).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, string> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/Identity$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const v: any = defVal;
+        if (v.type !== 'string') continue;
+        if (typeof v.pattern !== 'string') continue;
+
+        const prefix = deriveIdentityPrefixFromPattern(v.pattern);
+        if (!prefix) continue;
+
+        out[defName] = prefix;
+    }
+
+    return out;
+}
+
+// PURE: Extract all subschema names from `$defs/*`.
+// Shape: { JobStep: 'JobStep', StepKind: 'StepKind', ... }
+export function extractSubschemaNames(schema: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as any).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, string> = {};
+    for (const [defName] of defEntries) {
+        if (!defName || /[\n\r`]/.test(defName)) continue;
+        out[defName] = defName;
+    }
+
+    return out;
+}
+
+// PURE: Extract all string enums from `$defs/*Kind|*Status` definitions.
+// Shape: { StepKind: { job: 'job', ... }, ResourceShellKind: { inputPotential': 'inputPotential', ... } }
+export function extractEnums(schema: unknown): Record<string, Record<string, string>> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as any).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, Record<string, string>> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Kind|Status)$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const v: any = defVal;
+        if (v.type !== 'string') continue;
+        if (!Array.isArray(v.enum) || v.enum.length === 0) continue;
+        if (v.enum.some((x: unknown) => typeof x !== 'string')) continue;
+
+        const members: Record<string, string> = {};
+        for (const member of v.enum as readonly string[]) {
+            members[member] = member;
+        }
+
+        out[defName] = members;
+    }
+
+    return out;
+}
+
+// PURE: Derive a StepKind -> StepIdentityPrefix mapping.
+// Example: { job: 'job' } + IdentityNameToIdentityPrefix['JobStepIdentity']='JOB_STEP-' => { job: 'JOB_STEP-' }
+export function deriveStepKindToStepIdentityPrefix(
+    enums: Record<string, Record<string, string>>,
+    identityNameToIdentityPrefix: Record<string, string>
+): DeriveStepKindToStepIdentityPrefixResult {
+    const stepKindEnum = enums.StepKind;
+    if (!stepKindEnum || typeof stepKindEnum !== 'object') return { mapping: {}, missing: [] };
+
+    const stepKinds = Object.keys(stepKindEnum).sort((a, b) => a.localeCompare(b));
+    const mapping: Record<string, string> = {};
+    const missing: Array<{ stepKind: string; identityName: string }> = [];
+
+    for (const stepKind of stepKinds) {
+        const identityName = `${toPascalCase(stepKind)}StepIdentity`;
+        const prefix = identityNameToIdentityPrefix[identityName];
+        if (!prefix) {
+            missing.push({ stepKind, identityName });
+            continue;
+        }
+        mapping[stepKind] = prefix;
+    }
+
+    return { mapping, missing };
+}
+
+// PURE: Extract generated CONSTANTS + MAPPINGS from a parsed schema.
+export function extractGeneratedConstantsAndMappings(schema: unknown): {
+    CONSTANTS: GeneratedConstants;
+    MAPPINGS: GeneratedMappings;
+    DIAGNOSTICS: {
+        missingStepKindIdentityPrefixes: Array<{ stepKind: string; identityName: string }>;
+    };
+} {
+    const names = extractSubschemaNames(schema);
+    const enums = extractEnums(schema);
+    const identityPrefixes = extractIdentityPrefixes(schema);
+    const derivedStepKind = deriveStepKindToStepIdentityPrefix(enums, identityPrefixes);
+
+    return {
+        CONSTANTS: {
+            Names: names,
+            Enums: enums,
+        },
+        MAPPINGS: {
+            IdentityNameToIdentityPrefix: identityPrefixes,
+            StepKindToStepIdentityPrefix: derivedStepKind.mapping,
+        },
+        DIAGNOSTICS: {
+            missingStepKindIdentityPrefixes: derivedStepKind.missing,
+        },
+    };
+}
+
+// PURE: Render helpers for TS keys/strings.
+function escapeTsString(value: string): string {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/'/g, "\\'");
+}
+
+function renderTsStringLiteral(value: string): string {
+    return `'${escapeTsString(value)}'`;
+}
+
+function isValidTsIdentifier(key: string): boolean {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+
+function renderTsKey(key: string): string {
+    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
+}
+
+// PURE: Render constants TypeScript source.
+export function renderConstantsTs(constants: GeneratedConstants): string {
+    const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
+    const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
+
+    const lines: string[] = [];
+    lines.push('const CONSTANTS = {');
+    lines.push('    Names: {');
+
+    for (const key of nameKeys) {
+        const value = constants.Names[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('    },');
+    lines.push('    Enums: {');
+
+    for (const key of enumKeys) {
+        const members = constants.Enums[key] ?? {};
+        lines.push(`        ${renderTsKey(key)}: {`);
+
+        for (const memberKey of Object.keys(members)) {
+            const value = members[memberKey] ?? '';
+            lines.push(`            ${renderTsKey(memberKey)}: ${renderTsStringLiteral(value)},`);
+        }
+
+        lines.push('        },');
+    }
+
+    lines.push('    }');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default CONSTANTS;');
+    lines.push('');
+
+    return lines.join('\n');
+}
+
+// PURE: Render mappings TypeScript source.
+export function renderMappingsTs(mappings: GeneratedMappings): string {
+    const identityKeys = Object.keys(mappings.IdentityNameToIdentityPrefix).sort((a, b) => a.localeCompare(b));
+    const stepKindKeys = Object.keys(mappings.StepKindToStepIdentityPrefix).sort((a, b) => a.localeCompare(b));
+
+    const lines: string[] = [];
+    lines.push('const MAPPINGS = {');
+    lines.push('    IdentityNameToIdentityPrefix: {');
+
+    for (const key of identityKeys) {
+        const value = mappings.IdentityNameToIdentityPrefix[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('    },');
+    lines.push('    StepKindToStepIdentityPrefix: {');
+
+    for (const key of stepKindKeys) {
+        const value = mappings.StepKindToStepIdentityPrefix[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('    },');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default MAPPINGS;');
+    lines.push('');
+
+    return lines.join('\n');
+}
+
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+
+        const inPath = config.getSchemaPath('Genesis.json');
+        const outConstantsPath = config.getArtifactsPath('constants.ts');
+        const outMappingsPath = config.getArtifactsPath('mappings.ts');
+
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
+        }
+
+        const raw = fs.readFileSync(inPath, 'utf8');
+        const doc: JSONValue = JSON.parse(raw);
+
+        const { CONSTANTS, MAPPINGS, DIAGNOSTICS } = extractGeneratedConstantsAndMappings(doc);
+        if (DIAGNOSTICS.missingStepKindIdentityPrefixes.length) {
+            const rows = DIAGNOSTICS.missingStepKindIdentityPrefixes
+                .map(({ stepKind, identityName }) => `${stepKind} -> ${identityName}`)
+                .join(', ');
+            throw new Error(`Missing IdentityNameToIdentityPrefix entries required for StepKindToStepIdentityPrefix: ${rows}`);
+        }
+
+        const constantsTs = renderConstantsTs(CONSTANTS);
+        const mappingsTs = renderMappingsTs(MAPPINGS);
+
+        fs.mkdirSync(path.dirname(outConstantsPath), { recursive: true });
+        fs.writeFileSync(outConstantsPath, constantsTs, 'utf8');
+        fs.writeFileSync(outMappingsPath, mappingsTs, 'utf8');
+        console.log(`Wrote constants to ${outConstantsPath}`);
+        console.log(`Wrote mappings to ${outMappingsPath}`);
+    } catch (error: any) {
+        console.error(`Error generating constants/mappings: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+
+main();

package/src/scripts/generateDependencies.ts

@@ -1,121 +1,121 @@
-import fs from "fs";
-import path from "path";
-import { getConfig } from "./_lib/config.js";
-
-type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
-
-// PURE: Decode a single JSON Pointer segment.
-function decodeJsonPointerSegment(segment: string): string {
-  // JSON Pointer decoding: ~1 => / and ~0 => ~
-  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-
-// PURE: Collect all `$ref` strings from a JSON-ish tree.
-function collectRefs(node: unknown, out: Set<string>): void {
-  if (Array.isArray(node)) {
-    for (const item of node) collectRefs(item, out);
-    return;
-  }
-  if (!node || typeof node !== "object") return;
-
-  const obj = node as Record<string, unknown>;
-  const ref = obj["$ref"];
-  if (typeof ref === "string") out.add(ref);
-
-  for (const value of Object.values(obj)) {
-    collectRefs(value, out);
-  }
-}
-
-// PURE: Resolve an internal ref (pointer or anchor) to a root $defs key, if possible.
-function resolveInternalRefToDefKey(ref: string, defKeys: Set<string>, anchorToDef: Record<string, string>): string | null {
-  if (!ref.startsWith("#")) return null;
-
-  // JSON Pointer: #/$defs/<Name>(/...)
-  const defsPrefix = "#/$defs/";
-  if (ref.startsWith(defsPrefix)) {
-    const rest = ref.slice(defsPrefix.length);
-    const firstSegment = rest.split("/")[0] ?? "";
-    const defKey = decodeJsonPointerSegment(firstSegment);
-    return defKeys.has(defKey) ? defKey : null;
-  }
-
-  // Anchor ref: #AnchorName
-  if (!ref.startsWith("#/")) {
-    const anchor = ref.slice(1);
-    const mapped = anchorToDef[anchor];
-    if (mapped && defKeys.has(mapped)) return mapped;
-    if (defKeys.has(anchor)) return anchor;
-  }
-
-  return null;
-}
-
-/**
- * Pure function that generates a dependency map from a JSON Schema document.
- * 
- * @param doc The source JSON Schema document
- * @returns A record mapping definition names to their dependency lists
- */
-// PURE: Generate a $defs dependency map from a JSON Schema document (no I/O).
-function generateDependencyMapLogic(doc: any): Record<string, string[]> {
-  const defs: Record<string, JSONValue> = doc?.$defs && typeof doc.$defs === "object" ? doc.$defs : {};
-  const defKeys = new Set(Object.keys(defs));
-
-  // Map anchors to $defs keys (useful if any anchor-style refs remain)
-  const anchorToDef: Record<string, string> = {};
-  for (const [defKey, defSchema] of Object.entries(defs)) {
-    if (!defSchema || typeof defSchema !== "object" || Array.isArray(defSchema)) continue;
-    const anchor = (defSchema as any).$anchor;
-    if (typeof anchor === "string" && !(anchor in anchorToDef)) {
-      anchorToDef[anchor] = defKey;
-    }
-  }
-
-  const dependencyMap: Record<string, string[]> = {};
-
-  for (const [defKey, defSchema] of Object.entries(defs)) {
-    const refs = new Set<string>();
-    collectRefs(defSchema, refs);
-
-    const deps = new Set<string>();
-    for (const ref of refs) {
-      const depKey = resolveInternalRefToDefKey(ref, defKeys, anchorToDef);
-      if (!depKey) continue;
-      if (depKey === defKey) continue;
-      deps.add(depKey);
-    }
-
-    dependencyMap[defKey] = Array.from(deps);
-  }
-
-  return dependencyMap;
-}
-
-// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
-function main() {
-  try {
-    const config = getConfig();
-
-    const inPath = config.getSchemaPath("Genesis.json");
-    const outPath = config.getDependencyMapPath();
-
-    if (!fs.existsSync(inPath)) {
-      throw new Error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
-    }
-
-    const raw = fs.readFileSync(inPath, "utf8");
-    const doc = JSON.parse(raw);
-
-    const dependencyMap = generateDependencyMapLogic(doc);
-
-    fs.mkdirSync(path.dirname(outPath), { recursive: true });
-    fs.writeFileSync(outPath, JSON.stringify(dependencyMap, null, 4), "utf8");
-    console.log(`Wrote dependency map to ${outPath}`);
-  } catch (error: any) {
-    console.error(`Error generating dependency map: ${error?.message ?? error}`);
-    process.exitCode = 1;
-  }
-}
-
-main();
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./_lib/config.js";
+
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+// PURE: Decode a single JSON Pointer segment.
+function decodeJsonPointerSegment(segment: string): string {
+  // JSON Pointer decoding: ~1 => / and ~0 => ~
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+// PURE: Collect all `$ref` strings from a JSON-ish tree.
+function collectRefs(node: unknown, out: Set<string>): void {
+  if (Array.isArray(node)) {
+    for (const item of node) collectRefs(item, out);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+
+  const obj = node as Record<string, unknown>;
+  const ref = obj["$ref"];
+  if (typeof ref === "string") out.add(ref);
+
+  for (const value of Object.values(obj)) {
+    collectRefs(value, out);
+  }
+}
+
+// PURE: Resolve an internal ref (pointer or anchor) to a root $defs key, if possible.
+function resolveInternalRefToDefKey(ref: string, defKeys: Set<string>, anchorToDef: Record<string, string>): string | null {
+  if (!ref.startsWith("#")) return null;
+
+  // JSON Pointer: #/$defs/<Name>(/...)
+  const defsPrefix = "#/$defs/";
+  if (ref.startsWith(defsPrefix)) {
+    const rest = ref.slice(defsPrefix.length);
+    const firstSegment = rest.split("/")[0] ?? "";
+    const defKey = decodeJsonPointerSegment(firstSegment);
+    return defKeys.has(defKey) ? defKey : null;
+  }
+
+  // Anchor ref: #AnchorName
+  if (!ref.startsWith("#/")) {
+    const anchor = ref.slice(1);
+    const mapped = anchorToDef[anchor];
+    if (mapped && defKeys.has(mapped)) return mapped;
+    if (defKeys.has(anchor)) return anchor;
+  }
+
+  return null;
+}
+
+/**
+ * Pure function that generates a dependency map from a JSON Schema document.
+ * 
+ * @param doc The source JSON Schema document
+ * @returns A record mapping definition names to their dependency lists
+ */
+// PURE: Generate a $defs dependency map from a JSON Schema document (no I/O).
+function generateDependencyMapLogic(doc: any): Record<string, string[]> {
+  const defs: Record<string, JSONValue> = doc?.$defs && typeof doc.$defs === "object" ? doc.$defs : {};
+  const defKeys = new Set(Object.keys(defs));
+
+  // Map anchors to $defs keys (useful if any anchor-style refs remain)
+  const anchorToDef: Record<string, string> = {};
+  for (const [defKey, defSchema] of Object.entries(defs)) {
+    if (!defSchema || typeof defSchema !== "object" || Array.isArray(defSchema)) continue;
+    const anchor = (defSchema as any).$anchor;
+    if (typeof anchor === "string" && !(anchor in anchorToDef)) {
+      anchorToDef[anchor] = defKey;
+    }
+  }
+
+  const dependencyMap: Record<string, string[]> = {};
+
+  for (const [defKey, defSchema] of Object.entries(defs)) {
+    const refs = new Set<string>();
+    collectRefs(defSchema, refs);
+
+    const deps = new Set<string>();
+    for (const ref of refs) {
+      const depKey = resolveInternalRefToDefKey(ref, defKeys, anchorToDef);
+      if (!depKey) continue;
+      if (depKey === defKey) continue;
+      deps.add(depKey);
+    }
+
+    dependencyMap[defKey] = Array.from(deps);
+  }
+
+  return dependencyMap;
+}
+
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+  try {
+    const config = getConfig();
+
+    const inPath = config.getSchemaPath("Genesis.json");
+    const outPath = config.getArtifactsPath("dependencyMap.json");
+
+    if (!fs.existsSync(inPath)) {
+      throw new Error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
+    }
+
+    const raw = fs.readFileSync(inPath, "utf8");
+    const doc = JSON.parse(raw);
+
+    const dependencyMap = generateDependencyMapLogic(doc);
+
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(dependencyMap, null, 4), "utf8");
+    console.log(`Wrote dependency map to ${outPath}`);
+  } catch (error: any) {
+    console.error(`Error generating dependency map: ${error?.message ?? error}`);
+    process.exitCode = 1;
+  }
+}
+
+main();