@toolproof-core/genesis 1.0.49 → 1.0.50

package/src/utils/constantsAndMappings.ts

@@ -1,195 +1,195 @@
-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 = {
-    HandleNameToPrefix: Record<string, string>;
-};
-
-function deriveIdPrefixFromPattern(pattern: string): string | undefined {
-    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
-    if (!match) return undefined;
-
-    const prefix = match[1];
-    if (!prefix || /[`\n\r]/.test(prefix)) return undefined;
-
-    return prefix;
-}
-
-export function extractHandlePrefixes(schema: unknown): Record<string, string> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$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 (!/(Id|Handle)$/.test(defName)) continue;
-        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
-
-        const value = defVal as { type?: unknown; pattern?: unknown };
-        if (value.type !== 'string') continue;
-        if (typeof value.pattern !== 'string') continue;
-
-        const prefix = deriveIdPrefixFromPattern(value.pattern);
-        if (!prefix) continue;
-
-        out[defName] = prefix;
-    }
-
-    return out;
-}
-
-export function extractSubschemaNames(schema: unknown): Record<string, string> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$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;
-}
-
-export function extractEnums(schema: unknown): Record<string, Record<string, string>> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$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 value = defVal as { type?: unknown; enum?: unknown };
-        if (value.type !== 'string') continue;
-        if (!Array.isArray(value.enum) || value.enum.length === 0) continue;
-        if (value.enum.some((item) => typeof item !== 'string')) continue;
-
-        const members: Record<string, string> = {};
-        for (const member of value.enum as readonly string[]) {
-            members[member] = member;
-        }
-
-        out[defName] = members;
-    }
-
-    return out;
-}
-
-export function extractGeneratedConstantsAndMappings(schema: JSONValue): {
-    CONSTANTS: GeneratedConstants;
-    MAPPINGS: GeneratedMappings;
-} {
-    const names = extractSubschemaNames(schema);
-    const enums = extractEnums(schema);
-    const handlePrefixes = extractHandlePrefixes(schema);
-
-    return {
-        CONSTANTS: {
-            Names: names,
-            Enums: enums,
-        },
-        MAPPINGS: {
-            HandleNameToPrefix: handlePrefixes,
-        },
-    };
-}
-
-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);
-}
-
-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');
-}
-
-export function renderMappingsTs(mappings: GeneratedMappings): string {
-    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
-
-    const lines: string[] = [];
-    lines.push('const MAPPINGS = {');
-    lines.push('    HandleNameToPrefix: {');
-
-    for (const key of handleKeys) {
-        const value = mappings.HandleNameToPrefix[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');
+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 = {
+    HandleNameToPrefix: Record<string, string>;
+};
+
+function deriveIdPrefixFromPattern(pattern: string): string | undefined {
+    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
+    if (!match) return undefined;
+
+    const prefix = match[1];
+    if (!prefix || /[`\n\r]/.test(prefix)) return undefined;
+
+    return prefix;
+}
+
+export function extractHandlePrefixes(schema: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as { $defs?: unknown }).$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 (!/(Id|Handle)$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const value = defVal as { type?: unknown; pattern?: unknown };
+        if (value.type !== 'string') continue;
+        if (typeof value.pattern !== 'string') continue;
+
+        const prefix = deriveIdPrefixFromPattern(value.pattern);
+        if (!prefix) continue;
+
+        out[defName] = prefix;
+    }
+
+    return out;
+}
+
+export function extractSubschemaNames(schema: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as { $defs?: unknown }).$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;
+}
+
+export function extractEnums(schema: unknown): Record<string, Record<string, string>> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as { $defs?: unknown }).$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 value = defVal as { type?: unknown; enum?: unknown };
+        if (value.type !== 'string') continue;
+        if (!Array.isArray(value.enum) || value.enum.length === 0) continue;
+        if (value.enum.some((item) => typeof item !== 'string')) continue;
+
+        const members: Record<string, string> = {};
+        for (const member of value.enum as readonly string[]) {
+            members[member] = member;
+        }
+
+        out[defName] = members;
+    }
+
+    return out;
+}
+
+export function extractGeneratedConstantsAndMappings(schema: JSONValue): {
+    CONSTANTS: GeneratedConstants;
+    MAPPINGS: GeneratedMappings;
+} {
+    const names = extractSubschemaNames(schema);
+    const enums = extractEnums(schema);
+    const handlePrefixes = extractHandlePrefixes(schema);
+
+    return {
+        CONSTANTS: {
+            Names: names,
+            Enums: enums,
+        },
+        MAPPINGS: {
+            HandleNameToPrefix: handlePrefixes,
+        },
+    };
+}
+
+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);
+}
+
+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');
+}
+
+export function renderMappingsTs(mappings: GeneratedMappings): string {
+    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
+
+    const lines: string[] = [];
+    lines.push('const MAPPINGS = {');
+    lines.push('    HandleNameToPrefix: {');
+
+    for (const key of handleKeys) {
+        const value = mappings.HandleNameToPrefix[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');
 }

package/src/utils/coreProjection.ts

@@ -1,53 +1,53 @@
-import * as path from 'node:path';
-
-export type CoreProjectionNode = CoreProjectionDirectoryNode | CoreProjectionFileNode;
-
-export interface CoreProjectionBaseNode {
-    kind: 'directory' | 'file';
-    name: string;
-    path: string;
-}
-
-export interface CoreProjectionDirectoryNode extends CoreProjectionBaseNode {
-    kind: 'directory';
-    children: CoreProjectionNode[];
-}
-
-export interface CoreProjectionFileNode extends CoreProjectionBaseNode {
-    kind: 'file';
-}
-
-const EXCLUDED_DIRECTORY_NAMES = new Set([
-    '.git',
-    '.next',
-    'dist',
-    'node_modules',
-]);
-
-export function toPosixPath(value: string): string {
-    return value.split(path.sep).join('/');
-}
-
-export function shouldExclude(relativePath: string, isDirectory: boolean, excludedRelativePathPrefixes: string[]): boolean {
-    if (!relativePath || relativePath === '.') {
-        return false;
-    }
-
-    const normalizedPath = toPosixPath(relativePath);
-    const baseName = path.posix.basename(normalizedPath);
-
-    if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(baseName)) {
-        return true;
-    }
-
-    return excludedRelativePathPrefixes.some((prefix) => {
-        return normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`);
-    });
-}
-
-export function compareNodes(a: CoreProjectionNode, b: CoreProjectionNode): number {
-    if (a.kind !== b.kind) {
-        return a.kind === 'directory' ? -1 : 1;
-    }
-    return a.name.localeCompare(b.name);
+import * as path from 'node:path';
+
+export type CoreProjectionNode = CoreProjectionDirectoryNode | CoreProjectionFileNode;
+
+export interface CoreProjectionBaseNode {
+    kind: 'directory' | 'file';
+    name: string;
+    path: string;
+}
+
+export interface CoreProjectionDirectoryNode extends CoreProjectionBaseNode {
+    kind: 'directory';
+    children: CoreProjectionNode[];
+}
+
+export interface CoreProjectionFileNode extends CoreProjectionBaseNode {
+    kind: 'file';
+}
+
+const EXCLUDED_DIRECTORY_NAMES = new Set([
+    '.git',
+    '.next',
+    'dist',
+    'node_modules',
+]);
+
+export function toPosixPath(value: string): string {
+    return value.split(path.sep).join('/');
+}
+
+export function shouldExclude(relativePath: string, isDirectory: boolean, excludedRelativePathPrefixes: string[]): boolean {
+    if (!relativePath || relativePath === '.') {
+        return false;
+    }
+
+    const normalizedPath = toPosixPath(relativePath);
+    const baseName = path.posix.basename(normalizedPath);
+
+    if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(baseName)) {
+        return true;
+    }
+
+    return excludedRelativePathPrefixes.some((prefix) => {
+        return normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`);
+    });
+}
+
+export function compareNodes(a: CoreProjectionNode, b: CoreProjectionNode): number {
+    if (a.kind !== b.kind) {
+        return a.kind === 'directory' ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
 }

package/src/utils/resourceTypes.ts

@@ -1,39 +1,71 @@
-type JsonObject = Record<string, unknown>;
-
-type SchemasDocument = {
-    $defs?: Record<string, JsonObject>;
-};
-
-type ResourceTypeShell = JsonObject & {
-    handle?: unknown;
-    name?: unknown;
-    description?: unknown;
-};
-
-type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
-
-export function generateResourceTypes(
-    schemasDocument: SchemasDocument,
-    resourceTypeShells: ResourceTypeShellByName,
-): ResourceTypeShellByName {
-    if (!schemasDocument.$defs || typeof schemasDocument.$defs !== 'object') {
-        throw new Error('Schema document must have root $defs');
-    }
-
-    const resourceTypes: ResourceTypeShellByName = {};
-
-    for (const [resourceTypeName, resourceTypeShell] of Object.entries(resourceTypeShells)) {
-        const valueSchema = schemasDocument.$defs[resourceTypeName];
-
-        if (!valueSchema || typeof valueSchema !== 'object' || Array.isArray(valueSchema)) {
-            throw new Error(`Missing matching schema for resource type record ${resourceTypeName}`);
-        }
-
-        resourceTypes[resourceTypeName] = {
-            ...resourceTypeShell,
-            valueSchema,
-        };
-    }
-
-    return resourceTypes;
+type JsonObject = Record<string, unknown>;
+
+type SchemasDocument = {
+    $defs?: Record<string, JsonObject>;
+};
+
+type ResourceTypeShell = JsonObject & {
+    handle?: unknown;
+    name?: unknown;
+    description?: unknown;
+    ingestorToolInputSchema?: unknown;
+};
+
+type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
+
+export function generateResourceTypes(
+    schemasDocument: SchemasDocument,
+    resourceTypeShells: ResourceTypeShellByName,
+): ResourceTypeShell[] {
+    if (!schemasDocument.$defs || typeof schemasDocument.$defs !== 'object') {
+        throw new Error('Schema document must have root $defs');
+    }
+
+    const resourceTypes: ResourceTypeShell[] = [];
+
+    for (const [resourceTypeName, resourceTypeShell] of Object.entries(resourceTypeShells)) {
+        const projectionSchema = schemasDocument.$defs[resourceTypeName];
+        const ingestorToolInputSchemaDefName = resourceTypeShell.ingestorToolInputSchema;
+
+        if (!projectionSchema || typeof projectionSchema !== 'object' || Array.isArray(projectionSchema)) {
+            throw new Error(`Missing matching schema for resource type record ${resourceTypeName}`);
+        }
+
+        if (
+            ingestorToolInputSchemaDefName !== undefined &&
+            typeof ingestorToolInputSchemaDefName !== 'string'
+        ) {
+            throw new Error(
+                `ingestorToolInputSchema for resource type record ${resourceTypeName} must be a schema definition name when present`,
+            );
+        }
+
+        const ingestorToolInputSchema =
+            typeof ingestorToolInputSchemaDefName === 'string'
+                ? schemasDocument.$defs[ingestorToolInputSchemaDefName]
+                : undefined;
+
+        if (typeof ingestorToolInputSchemaDefName === 'string' && !ingestorToolInputSchema) {
+            throw new Error(
+                `Missing ingestor input schema ${ingestorToolInputSchemaDefName} for resource type record ${resourceTypeName}`,
+            );
+        }
+
+        if (
+            ingestorToolInputSchema !== undefined &&
+            (typeof ingestorToolInputSchema !== 'object' || Array.isArray(ingestorToolInputSchema))
+        ) {
+            throw new Error(
+                `Ingestor input schema ${ingestorToolInputSchemaDefName} for resource type record ${resourceTypeName} must be an object`,
+            );
+        }
+
+        resourceTypes.push({
+            ...resourceTypeShell,
+            projectionSchema,
+            ...(ingestorToolInputSchema ? { ingestorToolInputSchema } : {}),
+        });
+    }
+
+    return resourceTypes;
 }