@toolproof-core/genesis 1.0.53 → 1.0.55

package/src/utils/typeGeneration.ts

@@ -1,31 +0,0 @@
-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);
-}

package/src/utils/typeGenerationPostProcess.ts

@@ -1,246 +0,0 @@
-function deriveTemplateFromPattern(pattern: string): string | undefined {
-    const match = /^\^([^$]+)\.\+\$/.exec(pattern);
-    if (match) {
-        const prefix = match[1];
-        if (prefix === undefined) return undefined;
-        if (!/[`]/.test(prefix)) {
-            return '`' + prefix + '${string}`';
-        }
-    }
-    return undefined;
-}
-
-function loadPatternTemplatesFromSchema(schema: any): Record<string, string> {
-    const map: Record<string, string> = {};
-    const defs = schema?.$defs && typeof schema.$defs === 'object' ? schema.$defs : {};
-    for (const [defName, defVal] of Object.entries(defs)) {
-        if (!/(Id|Handle)$/.test(defName)) continue;
-
-        const value: any = defVal;
-        if (value && value.type === 'string' && typeof value.pattern === 'string') {
-            const tmpl = deriveTemplateFromPattern(value.pattern);
-            if (tmpl) map[defName] = tmpl;
-        }
-    }
-    return map;
-}
-
-function removeDuplicateUnionEntries(ts: string): string {
-    return ts.replace(/export type ([A-Za-z0-9_]+) =([\s\S]*?);/g, (_match, typeName, body) => {
-        const lines = body.split(/\r?\n/);
-        const seen = new Set<string>();
-        const kept: string[] = [];
-        for (const line of lines) {
-            const trimmed = line.trim();
-            const match = /^\|\s*([A-Za-z0-9_]+)\b/.exec(trimmed);
-            if (match) {
-                const name = match[1];
-                if (name === undefined) continue;
-                if (!seen.has(name)) {
-                    seen.add(name);
-                    kept.push('  | ' + name);
-                }
-                continue;
-            }
-            if (trimmed.length) kept.push(line);
-        }
-        return `export type ${typeName} =\n` + kept.join('\n') + ';';
-    });
-}
-
-function escapeRegExpLiteral(value: string): string {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function deriveStrategyStateInputEntryByRoleNameValueType(parsedSchema: any): string {
-    const defs = parsedSchema?.$defs ?? parsedSchema?.projectionSchema?.$defs;
-    const def = defs?.StrategyStateInputEntryByRoleName;
-    const schemaNode = def?.projectionSchema ?? def;
-    const additionalProperties = schemaNode?.additionalProperties;
-
-    if (!additionalProperties || typeof additionalProperties !== 'object' || Array.isArray(additionalProperties)) {
-        return 'StrategyStateInputEntry';
-    }
-
-    const union = (additionalProperties as any).oneOf ?? (additionalProperties as any).anyOf;
-    if (!Array.isArray(union) || union.length === 0) {
-        const ref = (additionalProperties as any).$ref;
-        const match = typeof ref === 'string'
-            ? /^#(?:\/(?:\$defs|definitions)\/)?([A-Za-z_][A-Za-z0-9_]*)$/.exec(ref)
-            : undefined;
-        const typeName = match?.[1];
-        return typeName ?? 'StrategyStateInputEntry';
-    }
-
-    const names: string[] = [];
-    for (const item of union) {
-        const ref = item && typeof item === 'object' ? (item as any).$ref : undefined;
-        if (typeof ref !== 'string') continue;
-
-        const match = /^#(?:\/(?:\$defs|definitions)\/)?([A-Za-z_][A-Za-z0-9_]*)$/.exec(ref);
-        const name = match?.[1];
-        if (name !== undefined) names.push(name);
-    }
-
-    const unique = Array.from(new Set(names));
-    if (!unique.length) return 'StrategyStateInputEntry';
-
-    return unique.join(' | ');
-}
-
-function fixRecursiveArrayAliasSelfReference(ts: string, typeName: string): string {
-    const lines = ts.split(/\r?\n/);
-    const typeNamePattern = escapeRegExpLiteral(typeName);
-    const startIndex = lines.findIndex((line) => new RegExp(`^export\\s+type\\s+${typeNamePattern}\\s*=\\s*$`).test(line.trimEnd()));
-    if (startIndex < 0) return ts;
-
-    let endIndex = -1;
-    for (let i = startIndex + 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (line !== undefined && /^\s*};\s*$/.test(line)) {
-            endIndex = i;
-            break;
-        }
-    }
-    if (endIndex < 0) return ts;
-
-    for (let i = startIndex + 1; i < endIndex; i++) {
-        const line = lines[i];
-        if (line !== undefined && new RegExp(`^\\s*\\|\\s*${typeNamePattern}\\s*$`).test(line)) {
-            lines[i] = line.replace(new RegExp(`\\b${typeNamePattern}\\b`), `${typeName}[]`);
-        }
-    }
-
-    return lines.join('\n');
-}
-
-export function postProcessEmittedTypes(ts: string, parsedSchema: any): string {
-    ts = ts.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*(?:\r?\n)?/gm, '');
-
-    ts = ts.replace(
-        /^(\s*)(\$defs\??:\s*)\{\s*\r?\n\s*\};/gm,
-        (_m, indent, head) => `${indent}${head}Record<string, unknown>;`,
-    );
-
-    ts = ts.replace(
-        /^(\s*)(properties\??:\s*)\{\s*\r?\n\s*\};/gm,
-        (_m, indent, head) => `${indent}${head}Record<string, unknown>;`,
-    );
-
-    ts = ts.replace(
-        /^(\s*)((?:allOf|anyOf|oneOf)\??:\s*)\{\s*\r?\n\s*\}\[\];/gm,
-        (_m, indent, head) => `${indent}${head}Array<{[k: string]: unknown}>;`,
-    );
-
-    ts = removeDuplicateUnionEntries(ts);
-
-    const schemaId = parsedSchema?.$id;
-    if (typeof schemaId === 'string') {
-        const match = /\/([^/]+)\.json$/i.exec(schemaId);
-        const rootBaseName = match?.[1];
-        if (rootBaseName) {
-            const rootTypeNameEsc = escapeRegExpLiteral(rootBaseName);
-            const generatedRootSchemaNamePattern = `Https[A-Za-z0-9_]*${rootTypeNameEsc}(?:Json)?`;
-
-            ts = ts.replace(
-                new RegExp(`^export interface ${generatedRootSchemaNamePattern}\\s*\\{\\s*\\}\\s*(?:\\r?\\n)?`, 'gm'),
-                '',
-            );
-
-            ts = ts.replace(
-                new RegExp(`\\b${generatedRootSchemaNamePattern}\\b`, 'g'),
-                rootBaseName,
-            );
-        }
-    }
-
-    if (!ts || !ts.trim()) {
-        throw new Error('Type generator emitted no output for schema.');
-    }
-
-    const patternTemplates = loadPatternTemplatesFromSchema(parsedSchema);
-    ts = ts.replace(
-        /^(export\s+type\s+)([A-Za-z_][A-Za-z0-9_]*(?:Id|Handle))(\s*=\s*)string\s*;$/gm,
-        (_m, p1, typeName, p3) => {
-            const tmpl = patternTemplates[typeName];
-            return `${p1}${typeName}${p3}${tmpl ?? 'string'};`;
-        },
-    );
-
-    const roleNameKeyType = 'RoleName';
-    const unthreadedToolStepPathKeyType = 'UnthreadedToolStepPath';
-    const threadedToolStepPathKeyType = 'ThreadedToolStepPath';
-    const toolStepPathKeyType = 'ToolStepPath';
-
-    ts = ts.replace(
-        /export interface RoleValueByName\s*\{\s*\[k:\s*string\]:\s*RoleValue;\s*\}/g,
-        `export type RoleValueByName = Record<${roleNameKeyType}, RoleValue>;`,
-    );
-
-    const strategyStateInputEntryByRoleNameValueType = deriveStrategyStateInputEntryByRoleNameValueType(parsedSchema);
-    ts = ts.replace(
-        /export interface StrategyStateInputEntryByRoleName\s*\{\s*\[k:\s*string\]:\s*[^;]+;\s*\}/g,
-        `export type StrategyStateInputEntryByRoleName = Record<${roleNameKeyType}, ${strategyStateInputEntryByRoleNameValueType}>;`,
-    );
-
-    ts = ts.replace(
-        /export\s+type\s+StrategyStateInputEntryByRoleName\s*=\s*Record<\s*RoleName\s*,\s*[^>]+>\s*;/g,
-        `export type StrategyStateInputEntryByRoleName = Record<${roleNameKeyType}, ${strategyStateInputEntryByRoleNameValueType}>;`,
-    );
-
-    ts = ts.replace(
-        /export interface StrategyStateInputEntryByRoleNameByUnthreadedToolStepPath\s*\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\}/g,
-        `export type StrategyStateInputEntryByRoleNameByUnthreadedToolStepPath = Record<${unthreadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`,
-    );
-
-    ts = ts.replace(
-        /export interface StrategyStateInputEntryByRoleNameByThreadedToolStepPath\s*\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\}/g,
-        `export type StrategyStateInputEntryByRoleNameByThreadedToolStepPath = Record<${threadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`,
-    );
-
-    ts = ts.replace(
-        /export\s+type\s+UnthreadedStrategyState\s*=\s*StrategyStateInputEntryByRoleNameByUnthreadedToolStepPath\s*;/g,
-        `export type UnthreadedStrategyState = Record<${unthreadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`,
-    );
-
-    ts = ts.replace(
-        /export\s+type\s+ThreadedStrategyState\s*=\s*StrategyStateInputEntryByRoleNameByThreadedToolStepPath\s*;/g,
-        `export type ThreadedStrategyState = Record<${threadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`,
-    );
-
-    ts = ts.replace(
-        /(strategyState\??:\s*)\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\};/g,
-        `$1Record<${toolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`,
-    );
-
-    ts = ts.replace(
-        /(strategyStateUpdate\??:\s*)\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\};/g,
-        `$1Record<${toolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`,
-    );
-
-    ts = ts.replace(
-        /export interface StepsByThreadIndexFacet\s*\{\s*stepsByThreadIndex:\s*StepArrayArray;\s*\}/g,
-        'export interface StepsByThreadIndexFacet {\n  stepsByThreadIndex: StepArrayArray;\n}',
-    );
-
-    ts = fixRecursiveArrayAliasSelfReference(ts, 'JsonData');
-
-    return ts;
-}
-
-export function finalizeOutputDts(emittedType: string): string {
-    const banner = '// Auto-generated from JSON schemas. Do not edit.\n';
-
-    let output = banner + '\n' + emittedType + '\n';
-    output = output.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*$/gm, '');
-    output = output
-        .replace(/\r?\n\s*\r?\n(\s*};)/g, '\n$1')
-        .replace(/\r?\n\s*\r?\n(\s*})/g, '\n$1')
-        .replace(/(\r?\n){3,}/g, '\n\n');
-
-    if (!/\bexport\b|\bdeclare\s+module\b|\bdeclare\s+namespace\b/.test(output)) {
-        output += '\nexport {}\n';
-    }
-
-    return output;
-}

package/src/utils/typeGenerationPreflight.ts

@@ -1,119 +0,0 @@
-import { normalizeAllOfSiblingObjectKeywords } from './schemaObjectNormalization.js';
-
-function formatPath(pathSegments: Array<string | number>): string {
-    let out = '';
-    for (const seg of pathSegments) {
-        if (typeof seg === 'number') {
-            out += `[${seg}]`;
-            continue;
-        }
-        out = out ? `${out}.${seg}` : seg;
-    }
-    return out || '<root>';
-}
-
-export function validateSchemaArrayKeywords(node: any, parentKey?: string, pathSegments: Array<string | number> = []): string[] {
-    if (Array.isArray(node)) {
-        const issues: string[] = [];
-        for (let i = 0; i < node.length; i++) {
-            issues.push(...validateSchemaArrayKeywords(node[i], parentKey, pathSegments.concat([i])));
-        }
-        return issues;
-    }
-
-    if (!node || typeof node !== 'object') return [];
-
-    const isPropertyNameMap =
-        parentKey === 'properties' ||
-        parentKey === 'patternProperties' ||
-        parentKey === '$defs' ||
-        parentKey === 'dependentSchemas' ||
-        parentKey === 'dependentRequired';
-
-    const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'] as const;
-    const issues: string[] = [];
-
-    for (const [key, value] of Object.entries(node)) {
-        if (key === 'properties' || key === 'patternProperties' || key === '$defs' || key === 'dependentSchemas') {
-            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-                issues.push(
-                    `${formatPath(pathSegments.concat([key]))}: expected \`${key}\` to be an object map, got ${value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value}`,
-                );
-            }
-        }
-
-        if (key === 'dependentRequired') {
-            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-                issues.push(
-                    `${formatPath(pathSegments.concat([key]))}: expected \`dependentRequired\` to be an object map, got ${value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value}`,
-                );
-            } else {
-                for (const [depKey, depVal] of Object.entries(value as any)) {
-                    if (!Array.isArray(depVal)) {
-                        issues.push(
-                            `${formatPath(pathSegments.concat([key, depKey]))}: expected dependentRequired entries to be string arrays, got ${depVal === null ? 'null' : typeof depVal}`,
-                        );
-                        continue;
-                    }
-                    for (let i = 0; i < depVal.length; i++) {
-                        if (typeof depVal[i] !== 'string') {
-                            issues.push(
-                                `${formatPath(pathSegments.concat([key, depKey, i]))}: expected dependentRequired entries to be strings, got ${depVal[i] === null ? 'null' : typeof depVal[i]}`,
-                            );
-                        }
-                    }
-                }
-            }
-        }
-
-        if (!isPropertyNameMap && (arrayKeys as readonly string[]).includes(key) && Object.prototype.hasOwnProperty.call(node, key)) {
-            if (!Array.isArray(value)) {
-                issues.push(
-                    `${formatPath(pathSegments.concat([key]))}: expected \`${key}\` to be an array, got ${value === null ? 'null' : typeof value}`,
-                );
-            } else {
-                if ((key === 'anyOf' || key === 'allOf' || key === 'oneOf') && value.length === 0) {
-                    issues.push(`${formatPath(pathSegments.concat([key]))}: expected \`${key}\` to be a non-empty array`);
-                }
-
-                if (key === 'anyOf' || key === 'allOf' || key === 'oneOf') {
-                    for (let i = 0; i < value.length; i++) {
-                        const item = value[i];
-                        const ok =
-                            typeof item === 'boolean' ||
-                            (item !== null && typeof item === 'object' && !Array.isArray(item));
-                        if (!ok) {
-                            issues.push(
-                                `${formatPath(pathSegments.concat([key, i]))}: expected a schema (object or boolean), got ${item === null ? 'null' : Array.isArray(item) ? 'array' : typeof item}`,
-                            );
-                        }
-                    }
-                }
-
-                if (key === 'required') {
-                    const seen = new Set<string>();
-                    for (let i = 0; i < value.length; i++) {
-                        if (typeof value[i] !== 'string') {
-                            issues.push(
-                                `${formatPath(pathSegments.concat([key, i]))}: expected \`required\` entries to be strings, got ${value[i] === null ? 'null' : typeof value[i]}`,
-                            );
-                            continue;
-                        }
-                        if (seen.has(value[i])) {
-                            issues.push(`${formatPath(pathSegments.concat([key]))}: duplicate required entry \`${value[i]}\``);
-                        }
-                        seen.add(value[i]);
-                    }
-                }
-            }
-        }
-
-        issues.push(...validateSchemaArrayKeywords(value, key, pathSegments.concat([key])));
-    }
-
-    return issues;
-}
-
-export function normalizeSchemaForGenerator(schema: any): any {
-    return normalizeAllOfSiblingObjectKeywords(schema);
-}