@toolproof-core/genesis 1.0.48 → 1.0.50

package/src/utils/standaloneSchemas.ts

@@ -1,114 +1,114 @@
-export function isObject(value: unknown): value is Record<string, unknown> {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-export function deepClone<T>(value: T): T {
-    if (Array.isArray(value)) return value.map((item) => deepClone(item)) as T;
-    if (isObject(value)) {
-        const out: Record<string, unknown> = {};
-        for (const key of Object.keys(value)) out[key] = deepClone(value[key]);
-        return out as T;
-    }
-    return value;
-}
-
-export function extractPointerDefName(ref: string): string | null {
-    if (!ref || !ref.startsWith('#/')) return null;
-    const parts = ref.slice(2).split('/');
-    if (parts.length !== 2) return null;
-    if (parts[0] !== '$defs') return null;
-    const defName = parts[1];
-    if (defName === undefined) return null;
-    return defName.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-
-export function collectLocalDefClosure(node: unknown, rootDefs: Record<string, unknown>): Set<string> {
-    const needed = new Set<string>();
-    const queue: string[] = [];
-
-    function visit(value: unknown) {
-        if (Array.isArray(value)) {
-            for (const item of value) visit(item);
-            return;
-        }
-        if (!isObject(value)) return;
-
-        if (typeof value.$ref === 'string') {
-            const name = extractPointerDefName(value.$ref);
-            if (name && !needed.has(name)) {
-                needed.add(name);
-                queue.push(name);
-            }
-        }
-
-        for (const nested of Object.values(value)) visit(nested);
-    }
-
-    visit(node);
-
-    while (queue.length > 0) {
-        const name = queue.shift();
-        if (!name) continue;
-        const def = rootDefs[name];
-        if (def === undefined) continue;
-        visit(def);
-    }
-
-    return needed;
-}
-
-export function extractStandaloneSchema(
-    schemasDocument: { $defs?: Record<string, unknown> },
-    name: string,
-): { schema: unknown; warnings: string[] } {
-    const rootDefs = schemasDocument.$defs;
-    if (!rootDefs || typeof rootDefs !== 'object') {
-        throw new Error('No $defs object found in schema document');
-    }
-
-    const target = rootDefs[name];
-    if (target === undefined) {
-        throw new Error(`Subschema named '${name}' not found under $defs in schema document`);
-    }
-
-    const needed = collectLocalDefClosure(target, rootDefs);
-    const targetClone = deepClone(target);
-    const defsOut: Record<string, unknown> = {};
-    const warnings: string[] = [];
-
-    for (const defName of needed) {
-        if (defName === name) continue;
-        const defSchema = rootDefs[defName];
-        if (defSchema === undefined) {
-            warnings.push(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
-            continue;
-        }
-        defsOut[defName] = deepClone(defSchema);
-    }
-
-    const existingInner = isObject(targetClone) && isObject(targetClone.$defs)
-        ? targetClone.$defs
-        : {};
-
-    if (isObject(targetClone)) {
-        targetClone.$defs = { ...existingInner, ...defsOut };
-    }
-
-    return { schema: targetClone, warnings };
-}
-
-export function generateStandaloneSchemas(
-    schemasDocument: { $defs?: Record<string, unknown> },
-    names: string[],
-): { standaloneSchemas: Record<string, unknown>; warnings: string[] } {
-    const standaloneSchemas: Record<string, unknown> = {};
-    const warnings: string[] = [];
-
-    for (const name of names) {
-        const result = extractStandaloneSchema(schemasDocument, name);
-        standaloneSchemas[name] = result.schema;
-        warnings.push(...result.warnings);
-    }
-
-    return { standaloneSchemas, warnings };
+export function isObject(value: unknown): value is Record<string, unknown> {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function deepClone<T>(value: T): T {
+    if (Array.isArray(value)) return value.map((item) => deepClone(item)) as T;
+    if (isObject(value)) {
+        const out: Record<string, unknown> = {};
+        for (const key of Object.keys(value)) out[key] = deepClone(value[key]);
+        return out as T;
+    }
+    return value;
+}
+
+export function extractPointerDefName(ref: string): string | null {
+    if (!ref || !ref.startsWith('#/')) return null;
+    const parts = ref.slice(2).split('/');
+    if (parts.length !== 2) return null;
+    if (parts[0] !== '$defs') return null;
+    const defName = parts[1];
+    if (defName === undefined) return null;
+    return defName.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+
+export function collectLocalDefClosure(node: unknown, rootDefs: Record<string, unknown>): Set<string> {
+    const needed = new Set<string>();
+    const queue: string[] = [];
+
+    function visit(value: unknown) {
+        if (Array.isArray(value)) {
+            for (const item of value) visit(item);
+            return;
+        }
+        if (!isObject(value)) return;
+
+        if (typeof value.$ref === 'string') {
+            const name = extractPointerDefName(value.$ref);
+            if (name && !needed.has(name)) {
+                needed.add(name);
+                queue.push(name);
+            }
+        }
+
+        for (const nested of Object.values(value)) visit(nested);
+    }
+
+    visit(node);
+
+    while (queue.length > 0) {
+        const name = queue.shift();
+        if (!name) continue;
+        const def = rootDefs[name];
+        if (def === undefined) continue;
+        visit(def);
+    }
+
+    return needed;
+}
+
+export function extractStandaloneSchema(
+    schemasDocument: { $defs?: Record<string, unknown> },
+    name: string,
+): { schema: unknown; warnings: string[] } {
+    const rootDefs = schemasDocument.$defs;
+    if (!rootDefs || typeof rootDefs !== 'object') {
+        throw new Error('No $defs object found in schema document');
+    }
+
+    const target = rootDefs[name];
+    if (target === undefined) {
+        throw new Error(`Subschema named '${name}' not found under $defs in schema document`);
+    }
+
+    const needed = collectLocalDefClosure(target, rootDefs);
+    const targetClone = deepClone(target);
+    const defsOut: Record<string, unknown> = {};
+    const warnings: string[] = [];
+
+    for (const defName of needed) {
+        if (defName === name) continue;
+        const defSchema = rootDefs[defName];
+        if (defSchema === undefined) {
+            warnings.push(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
+            continue;
+        }
+        defsOut[defName] = deepClone(defSchema);
+    }
+
+    const existingInner = isObject(targetClone) && isObject(targetClone.$defs)
+        ? targetClone.$defs
+        : {};
+
+    if (isObject(targetClone)) {
+        targetClone.$defs = { ...existingInner, ...defsOut };
+    }
+
+    return { schema: targetClone, warnings };
+}
+
+export function generateStandaloneSchemas(
+    schemasDocument: { $defs?: Record<string, unknown> },
+    names: string[],
+): { standaloneSchemas: Record<string, unknown>; warnings: string[] } {
+    const standaloneSchemas: Record<string, unknown> = {};
+    const warnings: string[] = [];
+
+    for (const name of names) {
+        const result = extractStandaloneSchema(schemasDocument, name);
+        standaloneSchemas[name] = result.schema;
+        warnings.push(...result.warnings);
+    }
+
+    return { standaloneSchemas, warnings };
 }

package/src/utils/standaloneTypes.ts

@@ -1,28 +1,28 @@
-export function generateStandaloneTypeContent(name: string): string {
-    const header = '// Auto-generated strict composite type. Do not edit.\n';
-    const standaloneResourceTypeName = `${name}Resource`;
-
-    const ts =
-        `import type { ResourcePointer, ${name} as ValueSchema } from "../types.js";\n` +
-        `export type ${standaloneResourceTypeName} = ResourcePointer & { value: ValueSchema };\n`;
-    return header + ts;
-}
-
-export function validateStandaloneSchemaForWarnings(schema: any): string[] {
-    const warnings: string[] = [];
-    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.`,
-        );
-    }
-    return warnings;
-}
-
-export function generateStandaloneTypeArtifacts(name: string): { dtsFileName: string; jsFileName: string; dtsContent: string; jsContent: string } {
-    return {
-        dtsFileName: `${name}Resource.d.ts`,
-        jsFileName: `${name}Resource.js`,
-        dtsContent: generateStandaloneTypeContent(name),
-        jsContent: 'export {}\n',
-    };
+export function generateStandaloneTypeContent(name: string): string {
+    const header = '// Auto-generated strict composite type. Do not edit.\n';
+    const standaloneResourceTypeName = `${name}Resource`;
+
+    const ts =
+        `import type { ResourcePointer, ${name} as ProjectionSchema } from "../types.js";\n` +
+        `export type ${standaloneResourceTypeName} = ResourcePointer & { projection: ProjectionSchema };\n`;
+    return header + ts;
+}
+
+export function validateStandaloneSchemaForWarnings(schema: any): string[] {
+    const warnings: string[] = [];
+    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.`,
+        );
+    }
+    return warnings;
+}
+
+export function generateStandaloneTypeArtifacts(name: string): { dtsFileName: string; jsFileName: string; dtsContent: string; jsContent: string } {
+    return {
+        dtsFileName: `${name}Resource.d.ts`,
+        jsFileName: `${name}Resource.js`,
+        dtsContent: generateStandaloneTypeContent(name),
+        jsContent: 'export {}\n',
+    };
 }

package/src/utils/standaloneZodSchemas.ts

@@ -1,72 +1,72 @@
-import { jsonSchemaToZodExpressions, type JsonSchemaToZodWarning } from './zodCodegen.js';
-
-export type GeneratedZodModule = {
-    fileName: string;
-    content: string;
-    warnings: JsonSchemaToZodWarning[];
-};
-
-function isValidIdentifier(name: string): boolean {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
-}
-
-function toIdentifier(name: string): string {
-    let out = name.replace(/[^A-Za-z0-9_]/g, '_');
-    if (!/^[A-Za-z_]/.test(out)) out = `_${out}`;
-    return out;
-}
-
-function emitHeader(name: string): string {
-    return (
-        `// Auto-generated from standalone schema '${name}'. Do not edit.\n` +
-        `import { z } from 'zod/v4';\n\n`
-    );
-}
-
-function emitModule(name: string, expressionsByName: Record<string, string>, warnings: JsonSchemaToZodWarning[]): string {
-    const lines: string[] = [];
-    lines.push(emitHeader(name));
-
-    if (warnings.length > 0) {
-        const warningsName = `${toIdentifier(name)}ZodGenerationWarnings`;
-        lines.push(`export const ${warningsName} = ${JSON.stringify(warnings, null, 2)} as const;\n`);
-    }
-
-    const rootIdent = toIdentifier(name);
-    const defNames = Object.keys(expressionsByName)
-        .filter((schemaName) => schemaName !== name)
-        .sort((a, b) => a.localeCompare(b));
-
-    for (const schemaName of defNames) {
-        const ident = toIdentifier(schemaName);
-        if (!isValidIdentifier(ident)) {
-            throw new Error(`Invalid generated identifier for schema '${schemaName}': '${ident}'`);
-        }
-        const expr = expressionsByName[schemaName];
-        lines.push(`const ${ident}Schema: z.ZodTypeAny = z.lazy(() => ${expr});`);
-    }
-
-    lines.push('');
-
-    const rootExpr = expressionsByName[name];
-    lines.push(`export const ${rootIdent}Schema: z.ZodTypeAny = z.lazy(() => ${rootExpr});`);
-
-    return lines.join('\n') + '\n';
-}
-
-export function generateStandaloneZodModule(name: string, standaloneSchema: unknown): GeneratedZodModule {
-    const { expressionsByName, warnings } = jsonSchemaToZodExpressions(standaloneSchema, name);
-    return {
-        fileName: `${name}.ts`,
-        content: emitModule(name, expressionsByName, warnings),
-        warnings,
-    };
-}
-
-export function generateStandaloneZodBarrel(names: string[]): string {
-    const exports = names
-        .slice()
-        .sort((a, b) => a.localeCompare(b))
-        .map((name) => `export { ${toIdentifier(name)}Schema } from './${name}.js';`);
-    return `// Auto-generated barrel file. Do not edit.\n${exports.join('\n')}\n`;
+import { jsonSchemaToZodExpressions, type JsonSchemaToZodWarning } from './zodCodegen.js';
+
+export type GeneratedZodModule = {
+    fileName: string;
+    content: string;
+    warnings: JsonSchemaToZodWarning[];
+};
+
+function isValidIdentifier(name: string): boolean {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+
+function toIdentifier(name: string): string {
+    let out = name.replace(/[^A-Za-z0-9_]/g, '_');
+    if (!/^[A-Za-z_]/.test(out)) out = `_${out}`;
+    return out;
+}
+
+function emitHeader(name: string): string {
+    return (
+        `// Auto-generated from standalone schema '${name}'. Do not edit.\n` +
+        `import { z } from 'zod/v4';\n\n`
+    );
+}
+
+function emitModule(name: string, expressionsByName: Record<string, string>, warnings: JsonSchemaToZodWarning[]): string {
+    const lines: string[] = [];
+    lines.push(emitHeader(name));
+
+    if (warnings.length > 0) {
+        const warningsName = `${toIdentifier(name)}ZodGenerationWarnings`;
+        lines.push(`export const ${warningsName} = ${JSON.stringify(warnings, null, 2)} as const;\n`);
+    }
+
+    const rootIdent = toIdentifier(name);
+    const defNames = Object.keys(expressionsByName)
+        .filter((schemaName) => schemaName !== name)
+        .sort((a, b) => a.localeCompare(b));
+
+    for (const schemaName of defNames) {
+        const ident = toIdentifier(schemaName);
+        if (!isValidIdentifier(ident)) {
+            throw new Error(`Invalid generated identifier for schema '${schemaName}': '${ident}'`);
+        }
+        const expr = expressionsByName[schemaName];
+        lines.push(`const ${ident}Schema: z.ZodTypeAny = z.lazy(() => ${expr});`);
+    }
+
+    lines.push('');
+
+    const rootExpr = expressionsByName[name];
+    lines.push(`export const ${rootIdent}Schema: z.ZodTypeAny = z.lazy(() => ${rootExpr});`);
+
+    return lines.join('\n') + '\n';
+}
+
+export function generateStandaloneZodModule(name: string, standaloneSchema: unknown): GeneratedZodModule {
+    const { expressionsByName, warnings } = jsonSchemaToZodExpressions(standaloneSchema, name);
+    return {
+        fileName: `${name}.ts`,
+        content: emitModule(name, expressionsByName, warnings),
+        warnings,
+    };
+}
+
+export function generateStandaloneZodBarrel(names: string[]): string {
+    const exports = names
+        .slice()
+        .sort((a, b) => a.localeCompare(b))
+        .map((name) => `export { ${toIdentifier(name)}Schema } from './${name}.js';`);
+    return `// Auto-generated barrel file. Do not edit.\n${exports.join('\n')}\n`;
 }

package/src/utils/timestampedResources.ts

@@ -0,0 +1,42 @@
+type JsonObject = Record<string, unknown>;
+
+type TimestampedResource = JsonObject & {
+    id: string;
+    resourceTypeHandle: string;
+    provenance: {
+        resourceProvenanceKind: 'genesis';
+    };
+    timestamp: string;
+    projection: unknown;
+};
+
+type GenerateTimestampedResourcesOptions = {
+    resourceTypeHandle: string;
+    getResourceId: (projection: unknown) => string;
+};
+
+const GENESIS_TIMESTAMP = '2025-11-30T00:00:00.000Z';
+
+export function generateTimestampedResources(
+    declarations: unknown[],
+    options: GenerateTimestampedResourcesOptions,
+): TimestampedResource[] {
+    return declarations.map((projection) => {
+        return createTimestampedResource(projection, options);
+    });
+}
+
+function createTimestampedResource(
+    projection: unknown,
+    options: GenerateTimestampedResourcesOptions,
+): TimestampedResource {
+    return {
+        id: options.getResourceId(projection),
+        resourceTypeHandle: options.resourceTypeHandle,
+        provenance: {
+            resourceProvenanceKind: 'genesis',
+        },
+        timestamp: GENESIS_TIMESTAMP,
+        projection,
+    };
+}

package/src/utils/typeGeneration.ts

@@ -1,31 +1,31 @@
-import { compile } from 'json-schema-to-typescript';
-import { finalizeOutputDts, postProcessEmittedTypes } from './typeGenerationPostProcess.js';
-import { normalizeSchemaForGenerator, validateSchemaArrayKeywords } from './typeGenerationPreflight.js';
-
-export async function generateTypeDeclarations(parsedSchema: any, rootName: string): Promise<string> {
-    const validationIssues = validateSchemaArrayKeywords(parsedSchema);
-    if (validationIssues.length) {
-        throw new Error(
-            'Schema is not in canonical form for type generation:\n' +
-            validationIssues.map((issue) => `- ${issue}`).join('\n'),
-        );
-    }
-
-    const normalizedSchema = normalizeSchemaForGenerator(parsedSchema);
-
-    let ts = await compile(normalizedSchema, rootName, {
-        bannerComment: '',
-        declareExternallyReferenced: true,
-        unreachableDefinitions: true,
-        $refOptions: {
-            resolve: {
-                file: { order: 2 },
-                http: false,
-                https: false,
-            },
-        } as any,
-    });
-
-    ts = postProcessEmittedTypes(ts, parsedSchema);
-    return finalizeOutputDts(ts);
+import { compile } from 'json-schema-to-typescript';
+import { finalizeOutputDts, postProcessEmittedTypes } from './typeGenerationPostProcess.js';
+import { normalizeSchemaForGenerator, validateSchemaArrayKeywords } from './typeGenerationPreflight.js';
+
+export async function generateTypeDeclarations(parsedSchema: any, rootName: string): Promise<string> {
+    const validationIssues = validateSchemaArrayKeywords(parsedSchema);
+    if (validationIssues.length) {
+        throw new Error(
+            'Schema is not in canonical form for type generation:\n' +
+            validationIssues.map((issue) => `- ${issue}`).join('\n'),
+        );
+    }
+
+    const normalizedSchema = normalizeSchemaForGenerator(parsedSchema);
+
+    let ts = await compile(normalizedSchema, rootName, {
+        bannerComment: '',
+        declareExternallyReferenced: true,
+        unreachableDefinitions: true,
+        $refOptions: {
+            resolve: {
+                file: { order: 2 },
+                http: false,
+                https: false,
+            },
+        } as any,
+    });
+
+    ts = postProcessEmittedTypes(ts, parsedSchema);
+    return finalizeOutputDts(ts);
 }