@constructive-io/graphql-codegen 4.24.5 → 4.26.0

package/esm/core/codegen/cli/table-command-generator.js

@@ -1,7 +1,8 @@
 import * as t from '@babel/types';
 import { toKebabCase } from 'komoji';
 import { generateCode } from '../babel-ast';
-import { getGeneratedFileHeader, getPrimaryKeyInfo, getScalarFields, getSelectableScalarFields, getTableNames, getWritableFieldNames, resolveInnerInputType, ucFirst, lcFirst, getCreateInputTypeName, getPatchTypeName, } from '../utils';
+import { getGeneratedFileHeader, getPrimaryKeyInfo, getScalarFields, getSelectableScalarFields, getTableNames, getWritableFieldNames, resolveInnerInputType, ucFirst, lcFirst, toPascalCase, getCreateInputTypeName, getPatchTypeName, } from '../utils';
+import { categorizeSpecialFields } from '../docs-utils';
 function createImportDeclaration(moduleSpecifier, namedImports, typeOnly = false) {
     const specifiers = namedImports.map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
     const decl = t.importDeclaration(specifiers, t.stringLiteral(moduleSpecifier));
@@ -153,7 +154,7 @@ function buildArgvType() {
 }
 function buildSubcommandSwitch(subcommands, handlerPrefix, usageVarName) {
     const cases = subcommands.map((sub) => t.switchCase(t.stringLiteral(sub), [
-        t.returnStatement(t.callExpression(t.identifier(`${handlerPrefix}${ucFirst(sub)}`), [
+        t.returnStatement(t.callExpression(t.identifier(`${handlerPrefix}${toPascalCase(sub)}`), [
             t.identifier('argv'),
             t.identifier('prompter'),
         ])),
@@ -166,17 +167,27 @@ function buildSubcommandSwitch(subcommands, handlerPrefix, usageVarName) {
 }
 function buildListHandler(table, targetName, typeRegistry) {
     const { singularName } = getTableNames(table);
-    const selectObj = buildSelectObject(table, typeRegistry);
-    const tryBody = [
-        buildGetClientStatement(targetName),
-        t.variableDeclaration('const', [
-            t.variableDeclarator(t.identifier('result'), t.awaitExpression(buildOrmCall(singularName, 'findMany', t.objectExpression([
-                t.objectProperty(t.identifier('select'), selectObj),
-            ])))),
-        ]),
-        buildJsonLog(t.identifier('result')),
-    ];
-    const argvParam = t.identifier('_argv');
+    const defaultSelectObj = buildSelectObject(table, typeRegistry);
+    // --- Build the try body ---
+    const tryBody = [];
+    // const defaultSelect = { id: true, name: true, ... };
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('defaultSelect'), defaultSelectObj),
+    ]));
+    // const findManyArgs = parseFindManyArgs(argv, defaultSelect);
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('findManyArgs'), t.callExpression(t.identifier('parseFindManyArgs'), [
+            t.identifier('argv'),
+            t.identifier('defaultSelect'),
+        ])),
+    ]));
+    tryBody.push(buildGetClientStatement(targetName));
+    // const result = await client.<singular>.findMany(findManyArgs).execute();
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('result'), t.awaitExpression(t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.memberExpression(t.identifier('client'), t.identifier(singularName)), t.identifier('findMany')), [t.identifier('findManyArgs')]), t.identifier('execute')), []))),
+    ]));
+    tryBody.push(buildJsonLog(t.identifier('result')));
+    const argvParam = t.identifier('argv');
     argvParam.typeAnnotation = buildArgvType();
     const prompterParam = t.identifier('_prompter');
     prompterParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Inquirerer')));
@@ -184,6 +195,129 @@ function buildListHandler(table, targetName, typeRegistry) {
         t.tryStatement(t.blockStatement(tryBody), buildErrorCatch('Failed to list records.')),
     ]), false, true);
 }
+/**
+ * Build a `handleFindFirst` function — CLI equivalent of the TS SDK's findFirst().
+ * Accepts --fields, --where.<field>.<op>, --condition.<field>.<op> flags.
+ * Internally calls findMany with first:1 and returns a single record (or null).
+ */
+function buildFindFirstHandler(table, targetName, typeRegistry) {
+    const { singularName } = getTableNames(table);
+    const defaultSelectObj = buildSelectObject(table, typeRegistry);
+    const tryBody = [];
+    // const defaultSelect = { ... };
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('defaultSelect'), defaultSelectObj),
+    ]));
+    // const findFirstArgs = parseFindFirstArgs(argv, defaultSelect);
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('findFirstArgs'), t.callExpression(t.identifier('parseFindFirstArgs'), [
+            t.identifier('argv'),
+            t.identifier('defaultSelect'),
+        ])),
+    ]));
+    tryBody.push(buildGetClientStatement(targetName));
+    // const result = await client.<singular>.findFirst(findFirstArgs).execute();
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('result'), t.awaitExpression(t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.memberExpression(t.identifier('client'), t.identifier(singularName)), t.identifier('findFirst')), [t.identifier('findFirstArgs')]), t.identifier('execute')), []))),
+    ]));
+    tryBody.push(buildJsonLog(t.identifier('result')));
+    const argvParam = t.identifier('argv');
+    argvParam.typeAnnotation = buildArgvType();
+    const prompterParam = t.identifier('_prompter');
+    prompterParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Inquirerer')));
+    return t.functionDeclaration(t.identifier('handleFindFirst'), [argvParam, prompterParam], t.blockStatement([
+        t.tryStatement(t.blockStatement(tryBody), buildErrorCatch('Failed to find record.')),
+    ]), false, true);
+}
+/**
+ * Build a `handleSearch` function for tables with search-capable fields.
+ * Extracts the first positional arg as the query string and auto-builds a
+ * `where` clause that targets all detected search fields (tsvector, BM25,
+ * trigram, vector embedding).  Supports --limit, --offset, --fields, --orderBy.
+ */
+function buildSearchHandler(table, specialGroups, targetName, typeRegistry) {
+    const { singularName } = getTableNames(table);
+    const defaultSelectObj = buildSelectObject(table, typeRegistry);
+    const tryBody = [];
+    // const query = Array.isArray(argv._) && argv._.length > 0 ? String(argv._[0]) : undefined;
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('query'), t.conditionalExpression(t.logicalExpression('&&', t.callExpression(t.memberExpression(t.identifier('Array'), t.identifier('isArray')), [t.memberExpression(t.identifier('argv'), t.identifier('_'))]), t.binaryExpression('>', t.memberExpression(t.memberExpression(t.identifier('argv'), t.identifier('_')), t.identifier('length')), t.numericLiteral(0))), t.callExpression(t.identifier('String'), [
+            t.memberExpression(t.memberExpression(t.identifier('argv'), t.identifier('_')), t.numericLiteral(0), true),
+        ]), t.identifier('undefined'))),
+    ]));
+    // if (!query) { console.error('Usage: ... search <query>'); process.exit(1); }
+    tryBody.push(t.ifStatement(t.unaryExpression('!', t.identifier('query')), t.blockStatement([
+        t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('console'), t.identifier('error')), [t.stringLiteral('Error: search requires a <query> argument')])),
+        t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('process'), t.identifier('exit')), [t.numericLiteral(1)])),
+    ])));
+    // Build the where clause properties from detected search fields
+    // e.g. { tsvContent: { query }, bm25Body: { query }, trgmTitle: { value: query, threshold: 0.3 }, vectorEmbedding: { value: query } }
+    const whereProps = [];
+    for (const group of specialGroups) {
+        for (const field of group.fields) {
+            if (field.type.gqlType === 'FullText' && !field.type.isArray) {
+                // tsvector field: { query }
+                whereProps.push(t.objectProperty(t.identifier(field.name), t.objectExpression([
+                    t.objectProperty(t.identifier('query'), t.identifier('query'), false, true),
+                ])));
+            }
+            else if (/Bm25Score$/.test(field.name)) {
+                // BM25 computed score field — derive the input field name:
+                // bodyBm25Score -> bm25Body (strip trailing "Bm25Score", prefix with "bm25")
+                const baseName = field.name.replace(/Bm25Score$/, '');
+                const inputFieldName = `bm25${baseName.charAt(0).toUpperCase()}${baseName.slice(1)}`;
+                whereProps.push(t.objectProperty(t.identifier(inputFieldName), t.objectExpression([
+                    t.objectProperty(t.identifier('query'), t.identifier('query'), false, true),
+                ])));
+            }
+            else if (/TrgmSimilarity$/.test(field.name)) {
+                // Trigram computed score field — derive the input field name:
+                // titleTrgmSimilarity -> trgmTitle
+                const baseName = field.name.replace(/TrgmSimilarity$/, '');
+                const inputFieldName = `trgm${baseName.charAt(0).toUpperCase()}${baseName.slice(1)}`;
+                whereProps.push(t.objectProperty(t.identifier(inputFieldName), t.objectExpression([
+                    t.objectProperty(t.identifier('value'), t.identifier('query')),
+                    t.objectProperty(t.identifier('threshold'), t.numericLiteral(0.3)),
+                ])));
+            }
+            else if (group.category === 'embedding') {
+                // Vector embedding field: { value: query }
+                whereProps.push(t.objectProperty(t.identifier(field.name), t.objectExpression([
+                    t.objectProperty(t.identifier('value'), t.identifier('query')),
+                ])));
+            }
+        }
+    }
+    // const searchWhere = { tsvContent: { query }, ... };
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('searchWhere'), t.objectExpression(whereProps)),
+    ]));
+    // const defaultSelect = { ... };
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('defaultSelect'), defaultSelectObj),
+    ]));
+    // const findManyArgs = parseFindManyArgs(argv, defaultSelect, searchWhere);
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('findManyArgs'), t.callExpression(t.identifier('parseFindManyArgs'), [
+            t.identifier('argv'),
+            t.identifier('defaultSelect'),
+            t.identifier('searchWhere'),
+        ])),
+    ]));
+    tryBody.push(buildGetClientStatement(targetName));
+    // const result = await client.<singular>.findMany(findManyArgs).execute();
+    tryBody.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('result'), t.awaitExpression(t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.memberExpression(t.identifier('client'), t.identifier(singularName)), t.identifier('findMany')), [t.identifier('findManyArgs')]), t.identifier('execute')), []))),
+    ]));
+    tryBody.push(buildJsonLog(t.identifier('result')));
+    const argvParam = t.identifier('argv');
+    argvParam.typeAnnotation = buildArgvType();
+    const prompterParam = t.identifier('_prompter');
+    prompterParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Inquirerer')));
+    return t.functionDeclaration(t.identifier('handleSearch'), [argvParam, prompterParam], t.blockStatement([
+        t.tryStatement(t.blockStatement(tryBody), buildErrorCatch('Failed to search records.')),
+    ]), false, true);
+}
 function buildGetHandler(table, targetName, typeRegistry) {
     const { singularName } = getTableNames(table);
     const pkFields = getPrimaryKeyInfo(table);
@@ -394,7 +528,7 @@ export function generateTableCommand(table, options) {
     ]));
     statements.push(createImportDeclaration(executorPath, ['getClient']));
     const utilsPath = options?.targetName ? '../../utils' : '../utils';
-    statements.push(createImportDeclaration(utilsPath, ['coerceAnswers', 'stripUndefined']));
+    statements.push(createImportDeclaration(utilsPath, ['coerceAnswers', 'parseFindFirstArgs', 'parseFindManyArgs', 'stripUndefined']));
     statements.push(createImportDeclaration(utilsPath, ['FieldSchema'], true));
     // Import ORM input types for proper type assertions in mutation handlers.
     // These types ensure that cleanedData is cast to the correct ORM input type
@@ -426,7 +560,12 @@ export function generateTableCommand(table, options) {
     const hasUpdate = table.query?.update !== undefined && table.query?.update !== null;
     const hasDelete = table.query?.delete !== undefined && table.query?.delete !== null;
     const hasGet = table.query?.one !== null || hasUpdate || hasDelete;
-    const subcommands = ['list'];
+    // Detect whether this table has search-capable fields (tsvector, BM25, trgm, vector embedding)
+    const specialGroups = categorizeSpecialFields(table, options?.typeRegistry);
+    const hasSearchFields = specialGroups.some((g) => g.category === 'search' || g.category === 'embedding');
+    const subcommands = ['list', 'find-first'];
+    if (hasSearchFields)
+        subcommands.push('search');
     if (hasGet)
         subcommands.push('get');
     subcommands.push('create');
@@ -439,8 +578,11 @@ export function generateTableCommand(table, options) {
         `${commandName} <command>`,
         '',
         'Commands:',
-        `  list                  List all ${singularName} records`,
+        `  list                  List ${singularName} records`,
+        `  find-first            Find first matching ${singularName} record`,
     ];
+    if (hasSearchFields)
+        usageLines.push(`  search <query>        Search ${singularName} records`);
     if (hasGet)
         usageLines.push(`  get                   Get a ${singularName} by ID`);
     usageLines.push(`  create                Create a new ${singularName}`);
@@ -448,7 +590,11 @@ export function generateTableCommand(table, options) {
         usageLines.push(`  update                Update an existing ${singularName}`);
     if (hasDelete)
         usageLines.push(`  delete                Delete a ${singularName}`);
-    usageLines.push('', '  --help, -h            Show this help message', '');
+    usageLines.push('', 'List Options:', '  --limit <n>           Max number of records to return (forward pagination)', '  --last <n>            Number of records from the end (backward pagination)', '  --after <cursor>      Cursor for forward pagination', '  --before <cursor>     Cursor for backward pagination', '  --offset <n>          Number of records to skip', '  --fields <fields>     Comma-separated list of fields to return', '  --where.<field>.<op>  Filter (dot-notation, e.g. --where.name.equalTo foo)', '  --condition.<f>.<op>  Condition filter (dot-notation)', '  --orderBy <values>    Comma-separated ordering values (e.g. NAME_ASC,CREATED_AT_DESC)', '', 'Find-First Options:', '  --fields <fields>     Comma-separated list of fields to return', '  --where.<field>.<op>  Filter (dot-notation, e.g. --where.status.equalTo active)', '  --condition.<f>.<op>  Condition filter (dot-notation)', '');
+    if (hasSearchFields) {
+        usageLines.push('Search Options:', '  <query>               Search query string (required)', '  --limit <n>           Max number of records to return', '  --offset <n>          Number of records to skip', '  --fields <fields>     Comma-separated list of fields to return', '  --orderBy <values>    Comma-separated list of ordering values', '');
+    }
+    usageLines.push('  --help, -h            Show this help message', '');
     statements.push(t.variableDeclaration('const', [
         t.variableDeclarator(t.identifier('usage'), t.stringLiteral(usageLines.join('\n'))),
     ]));
@@ -510,6 +656,9 @@ export function generateTableCommand(table, options) {
     const tn = options?.targetName;
     const ormTypes = { createInputTypeName, patchTypeName, innerFieldName };
     statements.push(buildListHandler(table, tn, options?.typeRegistry));
+    statements.push(buildFindFirstHandler(table, tn, options?.typeRegistry));
+    if (hasSearchFields)
+        statements.push(buildSearchHandler(table, specialGroups, tn, options?.typeRegistry));
     if (hasGet)
         statements.push(buildGetHandler(table, tn, options?.typeRegistry));
     statements.push(buildMutationHandler(table, 'create', tn, options?.typeRegistry, ormTypes));

package/esm/core/codegen/docs-utils.d.ts

@@ -4,12 +4,6 @@ export interface GeneratedDocFile {
     fileName: string;
     content: string;
 }
-export interface McpTool {
-    name: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    _meta?: Record<string, unknown>;
-}
 export interface SkillDefinition {
     name: string;
     description: string;

package/esm/core/codegen/docs-utils.js

@@ -29,18 +29,17 @@ export function getReadmeFooter() {
 }
 export function resolveDocsConfig(docs) {
     if (docs === true) {
-        return { readme: true, agents: true, mcp: true, skills: true };
+        return { readme: true, agents: true, skills: true };
     }
     if (docs === false) {
-        return { readme: false, agents: false, mcp: false, skills: false };
+        return { readme: false, agents: false, skills: false };
     }
     if (!docs) {
-        return { readme: true, agents: true, mcp: false, skills: false };
+        return { readme: true, agents: true, skills: false };
     }
     return {
         readme: docs.readme ?? true,
         agents: docs.agents ?? true,
-        mcp: docs.mcp ?? false,
         skills: docs.skills ?? false,
     };
 }
@@ -97,16 +96,23 @@ function isPostGISField(f) {
     return false;
 }
 function isEmbeddingField(f) {
-    const pgType = f.type.pgType?.toLowerCase();
-    if (pgType === 'vector')
+    // VectorCodecPlugin maps pgvector `vector` columns to the `Vector` GQL scalar.
+    // This is the primary detection path — no _meta or pgType enrichment needed.
+    if (f.type.gqlType === 'Vector')
         return true;
+    // Legacy fallback: name-based heuristic for schemas without VectorCodecPlugin
     if (/embedding$/i.test(f.name) && f.type.isArray && f.type.gqlType === 'Float')
         return true;
     return false;
 }
 function isTsvectorField(f) {
     const pgType = f.type.pgType?.toLowerCase();
-    return pgType === 'tsvector';
+    if (pgType === 'tsvector')
+        return true;
+    // Fallback: PostGraphile maps tsvector columns to the FullText GQL scalar
+    if (f.type.gqlType === 'FullText' && !f.type.isArray)
+        return true;
+    return false;
 }
 function isSearchComputedField(f) {
     if (f.name === 'searchScore')

package/esm/core/codegen/hooks-docs-generator.d.ts

@@ -1,6 +1,5 @@
 import type { Operation, Table, TypeRegistry } from '../../types/schema';
-import type { GeneratedDocFile, McpTool } from './docs-utils';
+import type { GeneratedDocFile } from './docs-utils';
 export declare function generateHooksReadme(tables: Table[], customOperations: Operation[], registry?: TypeRegistry): GeneratedDocFile;
 export declare function generateHooksAgentsDocs(tables: Table[], customOperations: Operation[]): GeneratedDocFile;
-export declare function getHooksMcpTools(tables: Table[], customOperations: Operation[]): McpTool[];
 export declare function generateHooksSkills(tables: Table[], customOperations: Operation[], targetName: string, registry?: TypeRegistry): GeneratedDocFile[];

package/esm/core/codegen/hooks-docs-generator.js

@@ -1,6 +1,6 @@
 import { toKebabCase } from 'komoji';
-import { buildSkillFile, buildSkillReference, formatArgType, fieldPlaceholder, pkPlaceholder, argPlaceholder, getReadmeHeader, getReadmeFooter, gqlTypeToJsonSchemaType, } from './docs-utils';
-import { getTableNames, getScalarFields, getPrimaryKeyInfo, getListQueryHookName, getSingleQueryHookName, getCreateMutationHookName, getUpdateMutationHookName, getDeleteMutationHookName, hasValidPrimaryKey, ucFirst, lcFirst, } from './utils';
+import { buildSkillFile, buildSkillReference, formatArgType, fieldPlaceholder, pkPlaceholder, argPlaceholder, getReadmeHeader, getReadmeFooter, } from './docs-utils';
+import { getTableNames, getScalarFields, getPrimaryKeyInfo, getListQueryHookName, getSingleQueryHookName, getCreateMutationHookName, getUpdateMutationHookName, getDeleteMutationHookName, hasValidPrimaryKey, ucFirst, } from './utils';
 function getCustomHookName(op) {
     if (op.kind === 'query') {
         return `use${ucFirst(op.name)}Query`;
@@ -161,118 +161,6 @@ export function generateHooksAgentsDocs(tables, customOperations) {
         content: lines.join('\n'),
     };
 }
-export function getHooksMcpTools(tables, customOperations) {
-    const tools = [];
-    for (const table of tables) {
-        const { singularName, pluralName } = getTableNames(table);
-        const pk = getPrimaryKeyInfo(table)[0];
-        const scalarFields = getScalarFields(table);
-        tools.push({
-            name: `hooks_${lcFirst(pluralName)}_query`,
-            description: table.description || `React Query hook to list all ${pluralName}`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    fields: {
-                        type: 'object',
-                        description: `Fields to select: { ${scalarFields.map((f) => f.name).join(', ')} }`,
-                    },
-                },
-            },
-        });
-        if (hasValidPrimaryKey(table)) {
-            tools.push({
-                name: `hooks_${lcFirst(singularName)}_query`,
-                description: table.description || `React Query hook to get a single ${singularName} by ${pk.name}`,
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        [pk.name]: {
-                            type: gqlTypeToJsonSchemaType(pk.gqlType),
-                            description: `${table.name} ${pk.name}`,
-                        },
-                    },
-                    required: [pk.name],
-                },
-            });
-        }
-        tools.push({
-            name: `hooks_create_${lcFirst(singularName)}_mutation`,
-            description: table.description || `React Query mutation hook to create a ${singularName}`,
-            inputSchema: {
-                type: 'object',
-                properties: Object.fromEntries(scalarFields
-                    .filter((f) => f.name !== pk.name &&
-                    f.name !== 'nodeId' &&
-                    f.name !== 'createdAt' &&
-                    f.name !== 'updatedAt')
-                    .map((f) => [
-                    f.name,
-                    {
-                        type: gqlTypeToJsonSchemaType(f.type.gqlType),
-                        description: `${table.name} ${f.name}`,
-                    },
-                ])),
-            },
-        });
-        if (hasValidPrimaryKey(table)) {
-            tools.push({
-                name: `hooks_update_${lcFirst(singularName)}_mutation`,
-                description: table.description || `React Query mutation hook to update a ${singularName}`,
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        [pk.name]: {
-                            type: gqlTypeToJsonSchemaType(pk.gqlType),
-                            description: `${table.name} ${pk.name}`,
-                        },
-                    },
-                    required: [pk.name],
-                },
-            });
-            tools.push({
-                name: `hooks_delete_${lcFirst(singularName)}_mutation`,
-                description: table.description || `React Query mutation hook to delete a ${singularName}`,
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        [pk.name]: {
-                            type: gqlTypeToJsonSchemaType(pk.gqlType),
-                            description: `${table.name} ${pk.name}`,
-                        },
-                    },
-                    required: [pk.name],
-                },
-            });
-        }
-    }
-    for (const op of customOperations) {
-        const hookName = getCustomHookName(op);
-        const props = {};
-        const required = [];
-        for (const arg of op.args) {
-            const isRequired = arg.type.kind === 'NON_NULL';
-            const baseType = isRequired && arg.type.ofType ? arg.type.ofType : arg.type;
-            props[arg.name] = {
-                type: gqlTypeToJsonSchemaType(baseType.name ?? 'String'),
-                description: arg.description || arg.name,
-            };
-            if (isRequired) {
-                required.push(arg.name);
-            }
-        }
-        tools.push({
-            name: `hooks_${hookName}`,
-            description: op.description || `${ucFirst(op.kind)} hook for ${op.name}`,
-            inputSchema: {
-                type: 'object',
-                properties: props,
-                ...(required.length > 0 ? { required } : {}),
-            },
-        });
-    }
-    return tools;
-}
 export function generateHooksSkills(tables, customOperations, targetName, registry) {
     const files = [];
     const skillName = `hooks-${targetName}`;

package/esm/core/codegen/orm/docs-generator.d.ts

@@ -1,6 +1,5 @@
 import type { Operation, Table, TypeRegistry } from '../../../types/schema';
-import type { GeneratedDocFile, McpTool } from '../docs-utils';
+import type { GeneratedDocFile } from '../docs-utils';
 export declare function generateOrmReadme(tables: Table[], customOperations: Operation[], registry?: TypeRegistry): GeneratedDocFile;
 export declare function generateOrmAgentsDocs(tables: Table[], customOperations: Operation[]): GeneratedDocFile;
-export declare function getOrmMcpTools(tables: Table[], customOperations: Operation[]): McpTool[];
 export declare function generateOrmSkills(tables: Table[], customOperations: Operation[], targetName: string, registry?: TypeRegistry): GeneratedDocFile[];

package/esm/core/codegen/orm/docs-generator.js

@@ -1,5 +1,5 @@
 import { toKebabCase } from 'komoji';
-import { buildSkillFile, buildSkillReference, formatArgType, fieldPlaceholder, pkPlaceholder, argPlaceholder, getEditableFields, categorizeSpecialFields, buildSpecialFieldsMarkdown, getReadmeHeader, getReadmeFooter, gqlTypeToJsonSchemaType, } from '../docs-utils';
+import { buildSkillFile, buildSkillReference, formatArgType, fieldPlaceholder, pkPlaceholder, argPlaceholder, getEditableFields, categorizeSpecialFields, buildSpecialFieldsMarkdown, getReadmeHeader, getReadmeFooter, } from '../docs-utils';
 import { getScalarFields, getTableNames, getPrimaryKeyInfo, lcFirst, } from '../utils';
 export function generateOrmReadme(tables, customOperations, registry) {
     const lines = [];
@@ -154,131 +154,6 @@ export function generateOrmAgentsDocs(tables, customOperations) {
         content: lines.join('\n'),
     };
 }
-export function getOrmMcpTools(tables, customOperations) {
-    const tools = [];
-    for (const table of tables) {
-        const { singularName } = getTableNames(table);
-        const pk = getPrimaryKeyInfo(table)[0];
-        const scalarFields = getScalarFields(table);
-        const editableFields = getEditableFields(table);
-        tools.push({
-            name: `orm_${lcFirst(singularName)}_findMany`,
-            description: table.description || `List all ${table.name} records via ORM`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    first: {
-                        type: 'integer',
-                        description: 'Limit number of results',
-                    },
-                    offset: {
-                        type: 'integer',
-                        description: 'Offset for pagination',
-                    },
-                },
-            },
-        });
-        tools.push({
-            name: `orm_${lcFirst(singularName)}_findOne`,
-            description: table.description || `Get a single ${table.name} record by ${pk.name}`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    [pk.name]: {
-                        type: gqlTypeToJsonSchemaType(pk.gqlType),
-                        description: `${table.name} ${pk.name}`,
-                    },
-                },
-                required: [pk.name],
-            },
-        });
-        const createProps = {};
-        for (const f of editableFields) {
-            createProps[f.name] = {
-                type: gqlTypeToJsonSchemaType(f.type.gqlType),
-                description: `${table.name} ${f.name}`,
-            };
-        }
-        tools.push({
-            name: `orm_${lcFirst(singularName)}_create`,
-            description: table.description || `Create a new ${table.name} record`,
-            inputSchema: {
-                type: 'object',
-                properties: createProps,
-                required: editableFields.map((f) => f.name),
-            },
-        });
-        const updateProps = {
-            [pk.name]: {
-                type: gqlTypeToJsonSchemaType(pk.gqlType),
-                description: `${table.name} ${pk.name}`,
-            },
-        };
-        for (const f of editableFields) {
-            updateProps[f.name] = {
-                type: gqlTypeToJsonSchemaType(f.type.gqlType),
-                description: `${table.name} ${f.name}`,
-            };
-        }
-        tools.push({
-            name: `orm_${lcFirst(singularName)}_update`,
-            description: table.description || `Update an existing ${table.name} record`,
-            inputSchema: {
-                type: 'object',
-                properties: updateProps,
-                required: [pk.name],
-            },
-        });
-        tools.push({
-            name: `orm_${lcFirst(singularName)}_delete`,
-            description: table.description || `Delete a ${table.name} record by ${pk.name}`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    [pk.name]: {
-                        type: gqlTypeToJsonSchemaType(pk.gqlType),
-                        description: `${table.name} ${pk.name}`,
-                    },
-                },
-                required: [pk.name],
-            },
-            _meta: {
-                fields: scalarFields.map((f) => ({
-                    name: f.name,
-                    type: f.type.gqlType,
-                    editable: editableFields.some((ef) => ef.name === f.name),
-                    primaryKey: f.name === pk.name,
-                })),
-            },
-        });
-    }
-    for (const op of customOperations) {
-        const accessor = op.kind === 'query' ? 'query' : 'mutation';
-        const props = {};
-        const required = [];
-        for (const arg of op.args) {
-            const isRequired = arg.type.kind === 'NON_NULL';
-            const baseType = isRequired && arg.type.ofType ? arg.type.ofType : arg.type;
-            props[arg.name] = {
-                type: gqlTypeToJsonSchemaType(baseType.name ?? 'String'),
-                description: arg.description || arg.name,
-            };
-            if (isRequired) {
-                required.push(arg.name);
-            }
-        }
-        tools.push({
-            name: `orm_${accessor}_${op.name}`,
-            description: op.description || `Execute ${op.name} ${op.kind}`,
-            inputSchema: {
-                type: 'object',
-                properties: props,
-                ...(required.length > 0 ? { required } : {}),
-            },
-        });
-    }
-    return tools;
-}
 export function generateOrmSkills(tables, customOperations, targetName, registry) {
     const files = [];
     const skillName = `orm-${targetName}`;

package/esm/core/codegen/target-docs-generator.d.ts

@@ -1,5 +1,5 @@
 import type { GraphQLSDKConfigTarget } from '../../types/config';
-import type { GeneratedDocFile, McpTool } from './docs-utils';
+import type { GeneratedDocFile } from './docs-utils';
 export interface TargetReadmeOptions {
     hasOrm: boolean;
     hasHooks: boolean;
@@ -10,7 +10,6 @@ export interface TargetReadmeOptions {
     config: GraphQLSDKConfigTarget;
 }
 export declare function generateTargetReadme(options: TargetReadmeOptions): GeneratedDocFile;
-export declare function generateCombinedMcpConfig(tools: McpTool[], name: string): GeneratedDocFile;
 export interface RootRootReadmeTarget {
     name: string;
     output: string;

package/esm/core/codegen/target-docs-generator.js

@@ -72,18 +72,6 @@ export function generateTargetReadme(options) {
         content: lines.join('\n'),
     };
 }
-export function generateCombinedMcpConfig(tools, name) {
-    const mcpConfig = {
-        name,
-        version: '1.0.0',
-        description: `MCP tool definitions for ${name} SDK (auto-generated from GraphQL schema)`,
-        tools,
-    };
-    return {
-        fileName: 'mcp.json',
-        content: JSON.stringify(mcpConfig, null, 2) + '\n',
-    };
-}
 export function generateRootRootReadme(targets) {
     const lines = [];
     lines.push(...getReadmeHeader('GraphQL SDK'));

package/esm/core/codegen/utils.d.ts

@@ -1,9 +1,9 @@
 /**
  * Codegen utilities - naming conventions, type mapping, and helpers
  */
-import { lcFirst, toCamelCase, toPascalCase, toScreamingSnake, ucFirst } from 'inflekt';
+import { lcFirst, toCamelCase, toConstantCase, toPascalCase, ucFirst } from 'inflekt';
 import type { Field, FieldType, Table, TypeRegistry } from '../../types/schema';
-export { lcFirst, toCamelCase, toPascalCase, toScreamingSnake, ucFirst };
+export { lcFirst, toCamelCase, toPascalCase, toConstantCase, ucFirst };
 export interface TableNames {
     /** PascalCase singular (e.g., "Car") */
     typeName: string;

package/esm/core/codegen/utils.js

@@ -1,10 +1,10 @@
 /**
  * Codegen utilities - naming conventions, type mapping, and helpers
  */
-import { lcFirst, pluralize, toCamelCase, toPascalCase, toScreamingSnake, ucFirst, } from 'inflekt';
+import { lcFirst, pluralize, toCamelCase, toConstantCase, toPascalCase, ucFirst, } from 'inflekt';
 import { scalarToFilterType, scalarToTsType } from './scalars';
 // Re-export string manipulation helpers from inflekt (single source of truth)
-export { lcFirst, toCamelCase, toPascalCase, toScreamingSnake, ucFirst };
+export { lcFirst, toCamelCase, toPascalCase, toConstantCase, ucFirst };
 /**
  * Derive all naming variants from a table
  */