@toolproof-npm/schema 0.1.43 → 0.1.44

package/dist/genesis/generated/schemas/Genesis.json

@@ -1151,5 +1151,5 @@
             "pattern": "^WORKSTEP-.+$"
         }
     },
-    "$comment": "This schema defines all genesis schemas used throughout the Toolproof ecosystem. The genesis schemas themselves are defined in $defs.<ResourceType>.extractionSchema. The build process (via extractSchemas.js) extracts these schemas and writes them to a separate file (src/schemas/Genesis.json). The reason for this indirection is to have all these schema envelopes validate positively against the schema at $defs/ResourceType, effectively making them ResourceTypes, which are first-class citizens in the Toolproof ecosystem."
+    "$comment": "This schema defines all genesis schemas used throughout the Toolproof ecosystem. The genesis schemas themselves are defined in $defs.<ResourceType>.extractionSchema. The build process (via extractSchemas.js) extracts these schemas and writes them to a separate file (genesis/generated/schemas/Genesis.json). The reason for this indirection is to have all these schema envelopes validate positively against the schema at $defs/ResourceType, effectively making them ResourceTypes, which are first-class citizens in the Toolproof ecosystem."
 }

package/dist/genesis/resourceTypes/Genesis.json

@@ -4,7 +4,7 @@
     "description": "dummy-description",
     "resourceFormatId": "FORMAT-ApplicationJson",
     "extractionSchema": {
-        "$comment": "This schema defines all genesis schemas used throughout the Toolproof ecosystem. The genesis schemas themselves are defined in $defs.<ResourceType>.extractionSchema. The build process (via extractSchemas.js) extracts these schemas and writes them to a separate file (src/schemas/Genesis.json). The reason for this indirection is to have all these schema envelopes validate positively against the schema at $defs/ResourceType, effectively making them ResourceTypes, which are first-class citizens in the Toolproof ecosystem.",
+        "$comment": "This schema defines all genesis schemas used throughout the Toolproof ecosystem. The genesis schemas themselves are defined in $defs.<ResourceType>.extractionSchema. The build process (via extractSchemas.js) extracts these schemas and writes them to a separate file (genesis/generated/schemas/Genesis.json). The reason for this indirection is to have all these schema envelopes validate positively against the schema at $defs/ResourceType, effectively making them ResourceTypes, which are first-class citizens in the Toolproof ecosystem.",
         "$id": "https://schemas.toolproof.com/v0/Genesis.json",
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "$defs": {

package/dist/index.d.ts

@@ -4,6 +4,6 @@ export { default as JobSchema } from './genesis/generated/schemas/Job.js';
 export type { Resource_ResourceFormat as Resource_ResourceFormatJson } from './_lib/types/Resource_ResourceFormat.js';
 export type { Resource_ResourceType as Resource_ResourceTypeJson } from './_lib/types/Resource_ResourceType.js';
 export type { Resource_Job as Resource_JobJson } from './_lib/types/Resource_Job.js';
-export type { Documented as DocumentedJson, ResourceFormatId as ResourceFormatIdJson, ResourceFormat as ResourceFormatJson, ExtractionSchema as ExtractionSchemaJson, ExtractionSchemaValue as ExtractionSchemaValueJson, IdentityProp as IdentityPropJson, MeritProp as MeritPropJson, ResourceTypeId as ResourceTypeIdJson, ResourceType as ResourceTypeJson, ResourceRoleId as ResourceRoleIdJson, ResourceRoleValue as ResourceRoleValueJson, ExecutionId as ExecutionIdJson, Execution as ExecutionJson, ConditionalWrapper as ConditionalWrapperJson, RoleMap as RoleMapJson, RolesOuter as RolesOuterJson, RoleBindingMap as RoleBindingMapJson, RoleBindingsOuter as RoleBindingsOuterJson, ResourceId as ResourceIdJson, WorkStepId as WorkStepIdJson, BranchStepId as BranchStepIdJson, WhileStepId as WhileStepIdJson, ForStepId as ForStepIdJson, WorkStep as WorkStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, Step as StepJson, CreationContextValue as CreationContextValueJson, ResourcePotentialInput as ResourcePotentialInputJson, ResourcePotentialOutput as ResourcePotentialOutputJson, ResourceMetaBase as ResourceMetaJson, // ATTENTION: type not generated for ResourceMeta
+export type { Documented as DocumentedJson, ResourceFormatId as ResourceFormatIdJson, ResourceFormat as ResourceFormatJson, ExtractionSchema as ExtractionSchemaJson, ExtractionSchemaValue as ExtractionSchemaValueJson, IdentityProp as IdentityPropJson, MeritProp as MeritPropJson, ResourceTypeId as ResourceTypeIdJson, ResourceType as ResourceTypeJson, ResourceRoleId as ResourceRoleIdJson, ResourceRoleValue as ResourceRoleValueJson, ExecutionId as ExecutionIdJson, Execution as ExecutionJson, ConditionalWrapper as ConditionalWrapperJson, RoleMap as RoleMapJson, RolesOuter as RolesOuterJson, RoleBindingMap as RoleBindingMapJson, RoleBindingsOuter as RoleBindingsOuterJson, ResourceId as ResourceIdJson, WorkStepId as WorkStepIdJson, BranchStepId as BranchStepIdJson, WhileStepId as WhileStepIdJson, ForStepId as ForStepIdJson, WorkStep as WorkStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, Step as StepJson, CreationContextValue as CreationContextValueJson, ResourceMissing as ResourceMissingJson, ResourcePotentialInput as ResourcePotentialInputJson, ResourcePotentialOutput as ResourcePotentialOutputJson, ResourceMetaBase as ResourceMetaJson, // ATTENTION: type not generated for ResourceMeta
 Resource as ResourceJson, StrategyState as StrategyStateJson, StrategyStateValue as StrategyStateValueJson, StatelessStrategyId as StatelessStrategyIdJson, StatelessStrategy as StatelessStrategyJson, StatefulStrategyId as StatefulStrategyIdJson, StatefulStrategy as StatefulStrategyJson, JobId as JobIdJson, Job as JobJson, JsonValue as JsonValueJson, } from './_lib/types/types.js';
 export { unsafeBrand, asResourceTypeId, asResourceRoleId, asExecutionId, asResourceId, asWorkStepId, asBranchStepId, asForStepId, asResourceFormatId, asWhileStepId, asStatelessStrategyId, asStatefulStrategyId, asResourceTypeIds, asResourceRoleIds, asExecutionIds, asResourceIds, asWorkStepIds, asBranchStepIds, asForStepIds, asResourceFormatIds, asWhileStepIds, asStatelessStrategyIds, asStatefulStrategyIds, } from './scripts/brandFactories.js';

package/dist/scripts/resolveRefsInGenesisStory.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/resolveRefsInGenesisStory.js

@@ -0,0 +1,199 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getConfig } from "./_lib/config.js";
+function stripSurroundingQuotes(v) {
+    if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))) {
+        return v.slice(1, -1);
+    }
+    return v;
+}
+function parseArgs() {
+    const config = getConfig();
+    const argv = process.argv.slice(2);
+    let storyInPath = "";
+    let storyOutPath = "";
+    let schemasPath = "";
+    let resourceTypesPath = "";
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if ((a === "--in" || a === "--storyIn") && i + 1 < argv.length)
+            storyInPath = stripSurroundingQuotes(argv[++i]);
+        else if ((a === "--out" || a === "--storyOut") && i + 1 < argv.length)
+            storyOutPath = stripSurroundingQuotes(argv[++i]);
+        else if ((a === "--schemas" || a === "--schemasPath") && i + 1 < argv.length)
+            schemasPath = stripSurroundingQuotes(argv[++i]);
+        else if ((a === "--resourceTypes" || a === "--resourceTypesPath") && i + 1 < argv.length)
+            resourceTypesPath = stripSurroundingQuotes(argv[++i]);
+    }
+    // Defaults
+    if (!storyInPath)
+        storyInPath = path.join(config.getRoot(), "src/genesis/GenesisStory.json");
+    if (!storyOutPath)
+        storyOutPath = path.join(config.getRoot(), "src/genesis/generated/GenesisStory.json");
+    // Extracted schemas (raw JSON Schemas)
+    if (!schemasPath)
+        schemasPath = config.getOutputPath(config.getSourceFile());
+    // ResourceType envelopes (ToolProof resources)
+    if (!resourceTypesPath)
+        resourceTypesPath = config.getSourcePath();
+    const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+    // Resolve relative paths against config root; then fallback relative to script dir
+    const resolveWithFallback = (p) => {
+        const wasRelative = !path.isAbsolute(p);
+        let candidate = p;
+        if (wasRelative)
+            candidate = path.join(config.getRoot(), p);
+        if (fs.existsSync(candidate))
+            return candidate;
+        if (wasRelative) {
+            const alt = path.resolve(scriptDir, p);
+            if (fs.existsSync(alt))
+                return alt;
+        }
+        return candidate;
+    };
+    storyInPath = resolveWithFallback(storyInPath);
+    storyOutPath = !path.isAbsolute(storyOutPath) ? path.join(config.getRoot(), storyOutPath) : storyOutPath;
+    schemasPath = resolveWithFallback(schemasPath);
+    resourceTypesPath = resolveWithFallback(resourceTypesPath);
+    return { storyInPath, storyOutPath, schemasPath, resourceTypesPath };
+}
+function deepClone(v) {
+    return JSON.parse(JSON.stringify(v));
+}
+function isRefWrapper(node) {
+    return (!!node &&
+        typeof node === "object" &&
+        !Array.isArray(node) &&
+        node.$ref &&
+        typeof node.$ref === "string" &&
+        Object.keys(node).length === 1);
+}
+function refToDefName(ref) {
+    let r = stripSurroundingQuotes(ref.trim());
+    // Support URL#anchor or URL#/$defs/Name
+    const hashIndex = r.indexOf("#");
+    if (hashIndex >= 0)
+        r = r.slice(hashIndex + 1);
+    // r could now be "Name" or "/$defs/Name" or "$defs/Name"
+    if (r.startsWith("/"))
+        r = r.slice(1);
+    if (r.startsWith("$defs/"))
+        r = r.slice("$defs/".length);
+    // If it's still a JSON pointer-like path, support only '$defs/<Name>'
+    if (r.includes("/")) {
+        const parts = r.split("/").filter(Boolean);
+        if (parts.length === 2 && parts[0] === "$defs")
+            return parts[1];
+        throw new Error(`Unsupported $ref format in GenesisStory: '${ref}'`);
+    }
+    return r;
+}
+function applyRefAliases(defName) {
+    // Backwards-compat / naming aliases (story names -> canonical def names)
+    const aliasMap = {
+        ExtractedSchemaValue: "ExtractionSchemaValue",
+        ExtractedSchema: "ExtractionSchema",
+    };
+    return defName in aliasMap ? aliasMap[defName] : defName;
+}
+function resolveRawSchemaDef(extractedSchemas, defName) {
+    defName = applyRefAliases(defName);
+    const defs = extractedSchemas?.$defs;
+    if (!defs || typeof defs !== "object") {
+        throw new Error("Extracted schemas file must contain a top-level $defs object");
+    }
+    if (defName in defs)
+        return defs[defName];
+    for (const v of Object.values(defs)) {
+        if (v && typeof v === "object" && v.$anchor === defName)
+            return v;
+    }
+    const available = Object.keys(defs).slice(0, 25);
+    throw new Error(`Could not resolve raw schema for ref '${defName}' from extracted schemas.$defs. ` +
+        `Example available keys: ${available.join(", ")}${Object.keys(defs).length > 25 ? ", ..." : ""}`);
+}
+function resolveResourceTypeEnvelope(resourceTypesDoc, defName) {
+    defName = applyRefAliases(defName);
+    const defs = resourceTypesDoc?.extractionSchema?.$defs;
+    if (!defs || typeof defs !== "object") {
+        throw new Error("ResourceTypes file must contain extractionSchema.$defs");
+    }
+    if (defName in defs)
+        return defs[defName];
+    // Fallback: match by envelope name or inner extractionSchema $anchor
+    for (const v of Object.values(defs)) {
+        if (!v || typeof v !== "object")
+            continue;
+        if (v.name === defName)
+            return v;
+        const innerAnchor = v.extractionSchema?.$anchor;
+        if (innerAnchor === defName)
+            return v;
+    }
+    const available = Object.keys(defs).slice(0, 25);
+    throw new Error(`Could not resolve ResourceType envelope for ref '${defName}' from resourceTypes.extractionSchema.$defs. ` +
+        `Example available keys: ${available.join(", ")}${Object.keys(defs).length > 25 ? ", ..." : ""}`);
+}
+function inlineRefs(node, resolve) {
+    if (isRefWrapper(node)) {
+        const defName = refToDefName(node.$ref);
+        const resolved = resolve(defName);
+        return deepClone(resolved);
+    }
+    if (Array.isArray(node)) {
+        return node.map((v) => inlineRefs(v, resolve));
+    }
+    if (node && typeof node === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(node)) {
+            out[k] = inlineRefs(v, resolve);
+        }
+        return out;
+    }
+    return node;
+}
+function main() {
+    const { storyInPath, storyOutPath, schemasPath, resourceTypesPath } = parseArgs();
+    if (!fs.existsSync(storyInPath))
+        throw new Error(`Story file not found: ${storyInPath}`);
+    if (!fs.existsSync(schemasPath))
+        throw new Error(`Schemas file not found: ${schemasPath}`);
+    if (!fs.existsSync(resourceTypesPath))
+        throw new Error(`ResourceTypes file not found: ${resourceTypesPath}`);
+    const storyRaw = fs.readFileSync(storyInPath, "utf8");
+    const story = JSON.parse(storyRaw);
+    const schemasRaw = fs.readFileSync(schemasPath, "utf8");
+    const extractedSchemas = JSON.parse(schemasRaw);
+    const resourceTypesRaw = fs.readFileSync(resourceTypesPath, "utf8");
+    const resourceTypesDoc = JSON.parse(resourceTypesRaw);
+    const resolved = resolveStoryDocument(story, extractedSchemas, resourceTypesDoc);
+    fs.mkdirSync(path.dirname(storyOutPath), { recursive: true });
+    fs.writeFileSync(storyOutPath, JSON.stringify(resolved, null, 4) + "\n", "utf8");
+    console.log(`Wrote resolved GenesisStory to ${storyOutPath}`);
+}
+function resolveStoryDocument(storyDoc, extractedSchemas, resourceTypesDoc) {
+    // Special handling: switch ref source after a marker in the GenesisStory array.
+    if (storyDoc &&
+        typeof storyDoc === "object" &&
+        !Array.isArray(storyDoc) &&
+        Array.isArray(storyDoc.GenesisStory)) {
+        const items = storyDoc.GenesisStory;
+        let inResourceTypeSpace = false;
+        const resolvedItems = items.map((item) => {
+            if (typeof item === "string" && item.trim() === "!!!!!") {
+                inResourceTypeSpace = true;
+                return item;
+            }
+            const resolver = inResourceTypeSpace
+                ? (name) => resolveResourceTypeEnvelope(resourceTypesDoc, name)
+                : (name) => resolveRawSchemaDef(extractedSchemas, name);
+            return inlineRefs(item, resolver);
+        });
+        return { ...storyDoc, GenesisStory: resolvedItems };
+    }
+    // Fallback: if it's not a GenesisStory doc, just resolve using raw schemas.
+    return inlineRefs(storyDoc, (name) => resolveRawSchemaDef(extractedSchemas, name));
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/schema",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "keywords": [
     "toolproof",
@@ -47,6 +47,7 @@
     "rewriteAnchors": "node ./dist/scripts/rewriteAnchors.js",
     "extractSchemas": "node ./dist/scripts/extractSchemas.js",
     "extractSubschema": "node ./dist/scripts/extractSubschemaWithDefs.js",
+    "resolveRefsInGenesisStory": "pnpm run build:scripts && node ./dist/scripts/resolveRefsInGenesisStory.js",
     "generateTypes": "node ./dist/scripts/generateTypes.js",
     "generateResourceTypeType": "node ./dist/scripts/generateResourceTypeType.js",
     "generateResourceEnvelopes": "node ./dist/scripts/generateResourceEnvelopes.js",