@constructive-io/graphql-codegen 4.8.1 → 4.12.2

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

@@ -67,6 +67,22 @@ function getTsTypeForField(field) {
             return t.tsStringKeyword();
     }
 }
+/**
+ * Maps a GraphQL scalar type to the appropriate inquirerer question type.
+ * Used by table CRUD commands to generate semantic prompts.
+ */
+function getQuestionTypeForField(field) {
+    const gqlType = field.type.gqlType.replace(/!/g, '');
+    switch (gqlType) {
+        case 'Boolean':
+            return 'boolean';
+        case 'JSON':
+        case 'GeoJSON':
+            return 'json';
+        default:
+            return 'text';
+    }
+}
 function buildFieldSchemaObject(table) {
     const fields = getScalarFields(table);
     return t.objectExpression(fields.map((f) => {
@@ -214,7 +230,7 @@ function buildGetHandler(table, targetName) {
  * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
  * that contains the actual field definitions.
  */
-function resolveInnerInputType(inputTypeName, typeRegistry) {
+export function resolveInnerInputType(inputTypeName, typeRegistry) {
     const inputType = typeRegistry.get(inputTypeName);
     if (!inputType?.inputFields)
         return null;
@@ -232,7 +248,7 @@ function resolveInnerInputType(inputTypeName, typeRegistry) {
     }
     return null;
 }
-function getFieldsWithDefaults(table, typeRegistry) {
+export function getFieldsWithDefaults(table, typeRegistry) {
     const fieldsWithDefaults = new Set();
     if (!typeRegistry)
         return fieldsWithDefaults;
@@ -305,12 +321,20 @@ function buildMutationHandler(table, operation, targetName, typeRegistry, ormTyp
             // For create: field is required only if it has no default value
             // For update: all fields are optional (user only updates what they want)
             const isRequired = operation === 'create' && !fieldsWithDefaults.has(field.name);
-            questions.push(t.objectExpression([
-                t.objectProperty(t.identifier('type'), t.stringLiteral('text')),
+            const hasDefault = fieldsWithDefaults.has(field.name);
+            const questionType = getQuestionTypeForField(field);
+            const questionProps = [
+                t.objectProperty(t.identifier('type'), t.stringLiteral(questionType)),
                 t.objectProperty(t.identifier('name'), t.stringLiteral(field.name)),
                 t.objectProperty(t.identifier('message'), t.stringLiteral(field.name)),
                 t.objectProperty(t.identifier('required'), t.booleanLiteral(isRequired)),
-            ]));
+            ];
+            // Skip prompting for fields with backend-managed defaults.
+            // The field still appears in man pages and can be overridden via CLI flags.
+            if (hasDefault) {
+                questionProps.push(t.objectProperty(t.identifier('skipPrompt'), t.booleanLiteral(true)));
+            }
+            questions.push(t.objectExpression(questionProps));
         }
     }
     const selectObj = operation === 'delete'

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

@@ -1,5 +1,5 @@
 import type { DocsConfig } from '../../types/config';
-import type { CleanField, CleanOperation, CleanTable } from '../../types/schema';
+import type { CleanArgument, CleanField, CleanOperation, CleanTable, TypeRegistry } from '../../types/schema';
 export interface GeneratedDocFile {
     fileName: string;
     content: string;
@@ -36,6 +36,31 @@ export declare function resolveDocsConfig(docs: DocsConfig | boolean | undefined
 export declare function formatArgType(arg: CleanOperation['args'][number]): string;
 export declare function formatTypeRef(t: CleanOperation['args'][number]['type']): string;
 export declare function getEditableFields(table: CleanTable): CleanField[];
+/**
+ * Represents a flattened argument for docs/skills generation.
+ * INPUT_OBJECT args are expanded to dot-notation fields.
+ */
+export interface FlattenedArg {
+    /** Flag name for CLI usage, e.g. 'input.email' or 'clientMutationId' */
+    flag: string;
+    /** Human-readable type string */
+    type: string;
+    /** Whether the argument is required */
+    required: boolean;
+    /** Description from schema */
+    description?: string;
+}
+/**
+ * Strip internal type prefixes for cleaner docs display.
+ * e.g. 'ConstructiveInternalTypeEmail' -> 'Email'
+ */
+export declare function cleanTypeName(name: string): string;
+export declare function flattenArgs(args: CleanArgument[], registry?: TypeRegistry): FlattenedArg[];
+/**
+ * Build CLI flags string from flattened args.
+ * e.g. '--input.email <value> --input.password <value>'
+ */
+export declare function flattenedArgsToFlags(flatArgs: FlattenedArg[]): string;
 export declare function gqlTypeToJsonSchemaType(gqlType: string): string;
 export declare function buildSkillFile(skill: SkillDefinition, referenceNames?: string[]): string;
 export declare function buildSkillReference(ref: SkillReferenceDefinition): string;

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

@@ -67,6 +67,108 @@ export function getEditableFields(table) {
         f.name !== 'createdAt' &&
         f.name !== 'updatedAt');
 }
+function unwrapNonNull(typeRef) {
+    if (typeRef.kind === 'NON_NULL' && typeRef.ofType) {
+        return { inner: typeRef.ofType, required: true };
+    }
+    return { inner: typeRef, required: false };
+}
+function resolveBaseType(typeRef) {
+    if ((typeRef.kind === 'NON_NULL' || typeRef.kind === 'LIST') && typeRef.ofType) {
+        return resolveBaseType(typeRef.ofType);
+    }
+    return typeRef;
+}
+/**
+ * Strip internal type prefixes for cleaner docs display.
+ * e.g. 'ConstructiveInternalTypeEmail' -> 'Email'
+ */
+export function cleanTypeName(name) {
+    if (name.startsWith('ConstructiveInternalType')) {
+        return name.slice('ConstructiveInternalType'.length);
+    }
+    return name;
+}
+function getScalarTypeName(typeRef) {
+    const base = resolveBaseType(typeRef);
+    return cleanTypeName(base.name ?? 'String');
+}
+/**
+ * Flatten operation args for docs/skills, expanding INPUT_OBJECT types
+ * to dot-notation fields (e.g. input.email, input.password).
+ * Mirrors the logic in arg-mapper.ts buildQuestionsArray.
+ */
+/**
+ * Resolve inputFields for an INPUT_OBJECT type.
+ * Checks the CleanTypeRef first, then falls back to the TypeRegistry.
+ */
+function resolveInputFields(typeRef, registry) {
+    if (typeRef.inputFields && typeRef.inputFields.length > 0) {
+        return typeRef.inputFields;
+    }
+    if (registry && typeRef.name) {
+        const resolved = registry.get(typeRef.name);
+        if (resolved?.kind === 'INPUT_OBJECT' && resolved.inputFields && resolved.inputFields.length > 0) {
+            return resolved.inputFields;
+        }
+    }
+    return undefined;
+}
+export function flattenArgs(args, registry) {
+    const result = [];
+    for (const arg of args) {
+        const { inner, required } = unwrapNonNull(arg.type);
+        const base = resolveBaseType(arg.type);
+        // Try to resolve inputFields from the inner type first (unwrapped NON_NULL)
+        const innerFields = inner.kind === 'INPUT_OBJECT'
+            ? resolveInputFields(inner, registry)
+            : undefined;
+        if (innerFields) {
+            for (const field of innerFields) {
+                const { required: fieldRequired } = unwrapNonNull(field.type);
+                result.push({
+                    flag: `${arg.name}.${field.name}`,
+                    type: getScalarTypeName(field.type),
+                    required: required && fieldRequired,
+                    description: field.description,
+                });
+            }
+        }
+        else {
+            // Try the base type (unwrapped LIST+NON_NULL)
+            const baseFields = base.kind === 'INPUT_OBJECT'
+                ? resolveInputFields(base, registry)
+                : undefined;
+            if (baseFields) {
+                for (const field of baseFields) {
+                    const { required: fieldRequired } = unwrapNonNull(field.type);
+                    result.push({
+                        flag: `${arg.name}.${field.name}`,
+                        type: getScalarTypeName(field.type),
+                        required: required && fieldRequired,
+                        description: field.description,
+                    });
+                }
+            }
+            else {
+                result.push({
+                    flag: arg.name,
+                    type: getScalarTypeName(arg.type),
+                    required,
+                    description: arg.description,
+                });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Build CLI flags string from flattened args.
+ * e.g. '--input.email <value> --input.password <value>'
+ */
+export function flattenedArgsToFlags(flatArgs) {
+    return flatArgs.map((a) => `--${a.flag} <value>`).join(' ');
+}
 export function gqlTypeToJsonSchemaType(gqlType) {
     switch (gqlType) {
         case 'Int':

package/esm/core/codegen/orm/input-types-generator.js

@@ -214,6 +214,11 @@ const SCALAR_FILTER_CONFIGS = [
         operators: ['equality', 'distinct', 'inArray', 'comparison', 'inet'],
     },
     { name: 'FullTextFilter', tsType: 'string', operators: ['fulltext'] },
+    // VectorFilter: equality/distinct operators for vector columns on Filter types.
+    // Similarity search uses condition types (embeddingNearby), not filters, but
+    // connection-filter may still generate a filter for vector columns. This ensures
+    // the generated type uses number[] rather than being silently omitted.
+    { name: 'VectorFilter', tsType: 'number[]', operators: ['equality', 'distinct'] },
     // List filters (for array fields like string[], int[], uuid[])
     {
         name: 'StringListFilter',
@@ -710,10 +715,15 @@ function generateTableFilterTypes(tables) {
 // ============================================================================
 /**
  * Build properties for a table condition interface
- * Condition types are simpler than Filter types - they use direct value equality
+ * Condition types are simpler than Filter types - they use direct value equality.
+ *
+ * Also merges any extra fields from the GraphQL schema's condition type
+ * (e.g., plugin-injected fields like vectorEmbedding from VectorSearchPlugin)
+ * that are not derived from the table's own columns.
  */
-function buildTableConditionProperties(table) {
+function buildTableConditionProperties(table, typeRegistry) {
     const properties = [];
+    const generatedFieldNames = new Set();
     for (const field of table.fields) {
         const fieldType = typeof field.type === 'string' ? field.type : field.type.gqlType;
         if (isRelationField(field.name, table))
@@ -725,17 +735,38 @@ function buildTableConditionProperties(table) {
             type: `${tsType} | null`,
             optional: true,
         });
+        generatedFieldNames.add(field.name);
+    }
+    // Merge any additional fields from the schema's condition type
+    // (e.g., plugin-added fields like vectorEmbedding from VectorSearchPlugin)
+    if (typeRegistry) {
+        const conditionTypeName = getConditionTypeName(table);
+        const conditionType = typeRegistry.get(conditionTypeName);
+        if (conditionType?.kind === 'INPUT_OBJECT' &&
+            conditionType.inputFields) {
+            for (const field of conditionType.inputFields) {
+                if (generatedFieldNames.has(field.name))
+                    continue;
+                const tsType = typeRefToTs(field.type);
+                properties.push({
+                    name: field.name,
+                    type: tsType,
+                    optional: true,
+                    description: stripSmartComments(field.description, true),
+                });
+            }
+        }
     }
     return properties;
 }
 /**
  * Generate table condition type statements
  */
-function generateTableConditionTypes(tables) {
+function generateTableConditionTypes(tables, typeRegistry) {
     const statements = [];
     for (const table of tables) {
         const conditionName = getConditionTypeName(table);
-        statements.push(createExportedInterface(conditionName, buildTableConditionProperties(table)));
+        statements.push(createExportedInterface(conditionName, buildTableConditionProperties(table, typeRegistry)));
     }
     if (statements.length > 0) {
         addSectionComment(statements, 'Table Condition Types');
@@ -746,9 +777,13 @@ function generateTableConditionTypes(tables) {
 // OrderBy Types Generator (AST-based)
 // ============================================================================
 /**
- * Build OrderBy union type values
+ * Build OrderBy union type values.
+ *
+ * Also merges any extra values from the GraphQL schema's orderBy enum
+ * (e.g., plugin-injected values like EMBEDDING_DISTANCE_ASC/DESC
+ * from VectorSearchPlugin).
  */
-function buildOrderByValues(table) {
+function buildOrderByValues(table, typeRegistry) {
     const values = ['PRIMARY_KEY_ASC', 'PRIMARY_KEY_DESC', 'NATURAL'];
     for (const field of table.fields) {
         if (isRelationField(field.name, table))
@@ -757,16 +792,30 @@ function buildOrderByValues(table) {
         values.push(`${upperSnake}_ASC`);
         values.push(`${upperSnake}_DESC`);
     }
+    // Merge any additional values from the schema's orderBy enum type
+    // (e.g., plugin-added values like EMBEDDING_DISTANCE_ASC/DESC)
+    if (typeRegistry) {
+        const orderByTypeName = getOrderByTypeName(table);
+        const orderByType = typeRegistry.get(orderByTypeName);
+        if (orderByType?.kind === 'ENUM' && orderByType.enumValues) {
+            const existingValues = new Set(values);
+            for (const value of orderByType.enumValues) {
+                if (!existingValues.has(value)) {
+                    values.push(value);
+                }
+            }
+        }
+    }
     return values;
 }
 /**
  * Generate OrderBy type statements
  */
-function generateOrderByTypes(tables) {
+function generateOrderByTypes(tables, typeRegistry) {
     const statements = [];
     for (const table of tables) {
         const enumName = getOrderByTypeName(table);
-        const values = buildOrderByValues(table);
+        const values = buildOrderByValues(table, typeRegistry);
         const unionType = createStringLiteralUnion(values);
         const typeAlias = t.tsTypeAliasDeclaration(t.identifier(enumName), null, unionType);
         statements.push(t.exportNamedDeclaration(typeAlias));
@@ -1017,11 +1066,12 @@ function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes,
                     optional,
                     description: stripSmartComments(field.description, comments),
                 });
-                // Follow nested Input types
+                // Follow nested types (Input objects, Enums, etc.) that exist in the registry
                 const baseType = getTypeBaseName(field.type);
                 if (baseType &&
-                    baseType.endsWith('Input') &&
-                    !generatedTypes.has(baseType)) {
+                    !SCALAR_NAMES.has(baseType) &&
+                    !generatedTypes.has(baseType) &&
+                    typeRegistry.has(baseType)) {
                     typesToGenerate.add(baseType);
                 }
             }
@@ -1205,6 +1255,42 @@ function generateConnectionFieldsMap(tables, tableByName) {
     return statements;
 }
 // ============================================================================
+// Plugin-Injected Type Collector
+// ============================================================================
+/**
+ * Collect extra input type names referenced by plugin-injected condition fields.
+ *
+ * When plugins (like VectorSearchPlugin) inject fields into condition types,
+ * they reference types (like VectorNearbyInput, VectorMetric) that also need
+ * to be generated. This function discovers those types by comparing the
+ * schema's condition type fields against the table's own columns.
+ */
+function collectConditionExtraInputTypes(tables, typeRegistry) {
+    const extraTypes = new Set();
+    for (const table of tables) {
+        const conditionTypeName = getConditionTypeName(table);
+        const conditionType = typeRegistry.get(conditionTypeName);
+        if (!conditionType ||
+            conditionType.kind !== 'INPUT_OBJECT' ||
+            !conditionType.inputFields) {
+            continue;
+        }
+        const tableFieldNames = new Set(table.fields
+            .filter((f) => !isRelationField(f.name, table))
+            .map((f) => f.name));
+        for (const field of conditionType.inputFields) {
+            if (tableFieldNames.has(field.name))
+                continue;
+            // Collect the base type name of this extra field
+            const baseName = getTypeBaseName(field.type);
+            if (baseName && !SCALAR_NAMES.has(baseName)) {
+                extraTypes.add(baseName);
+            }
+        }
+    }
+    return extraTypes;
+}
+// ============================================================================
 // Main Generator (AST-based)
 // ============================================================================
 /**
@@ -1235,9 +1321,13 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
         // 4. Table filter types
         statements.push(...generateTableFilterTypes(tablesList));
         // 4b. Table condition types (simple equality filter)
-        statements.push(...generateTableConditionTypes(tablesList));
+        // Pass typeRegistry to merge plugin-injected condition fields
+        // (e.g., vectorEmbedding from VectorSearchPlugin)
+        statements.push(...generateTableConditionTypes(tablesList, typeRegistry));
         // 5. OrderBy types
-        statements.push(...generateOrderByTypes(tablesList));
+        // Pass typeRegistry to merge plugin-injected orderBy values
+        // (e.g., EMBEDDING_DISTANCE_ASC/DESC from VectorSearchPlugin)
+        statements.push(...generateOrderByTypes(tablesList, typeRegistry));
         // 6. CRUD input types
         statements.push(...generateAllCrudInputTypes(tablesList, typeRegistry));
     }
@@ -1245,8 +1335,16 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
     // Always emit this export so generated model/custom-op imports stay valid.
     statements.push(...generateConnectionFieldsMap(tablesList, tableByName));
     // 7. Custom input types from TypeRegistry
+    // Also include any extra types referenced by plugin-injected condition fields
+    const mergedUsedInputTypes = new Set(usedInputTypes);
+    if (hasTables) {
+        const conditionExtraTypes = collectConditionExtraInputTypes(tablesList, typeRegistry);
+        for (const typeName of conditionExtraTypes) {
+            mergedUsedInputTypes.add(typeName);
+        }
+    }
     const tableCrudTypes = tables ? buildTableCrudTypeNames(tables) : undefined;
-    statements.push(...generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes, comments));
+    statements.push(...generateCustomInputTypes(typeRegistry, mergedUsedInputTypes, tableCrudTypes, comments));
     // 8. Payload/return types for custom operations
     if (usedPayloadTypes && usedPayloadTypes.size > 0) {
         const alreadyGeneratedTypes = new Set();

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

@@ -74,6 +74,7 @@ export function generateModelFile(table, _useSharedTypes) {
     const selectTypeName = `${typeName}Select`;
     const relationTypeName = `${typeName}WithRelations`;
     const whereTypeName = getFilterTypeName(table);
+    const conditionTypeName = `${typeName}Condition`;
     const orderByTypeName = getOrderByTypeName(table);
     const createInputTypeName = `Create${typeName}Input`;
     const updateInputTypeName = `Update${typeName}Input`;
@@ -113,6 +114,7 @@ export function generateModelFile(table, _useSharedTypes) {
         relationTypeName,
         selectTypeName,
         whereTypeName,
+        conditionTypeName,
         orderByTypeName,
         createInputTypeName,
         updateInputTypeName,
@@ -134,6 +136,7 @@ export function generateModelFile(table, _useSharedTypes) {
         const argsType = (sel) => t.tsTypeReference(t.identifier('FindManyArgs'), t.tsTypeParameterInstantiation([
             sel,
             t.tsTypeReference(t.identifier(whereTypeName)),
+            t.tsTypeReference(t.identifier(conditionTypeName)),
             t.tsTypeReference(t.identifier(orderByTypeName)),
         ]));
         const retType = (sel) => t.tsTypeAnnotation(t.tsTypeReference(t.identifier('QueryBuilder'), t.tsTypeParameterInstantiation([
@@ -159,6 +162,7 @@ export function generateModelFile(table, _useSharedTypes) {
             selectExpr,
             t.objectExpression([
                 t.objectProperty(t.identifier('where'), t.optionalMemberExpression(t.identifier('args'), t.identifier('where'), false, true)),
+                t.objectProperty(t.identifier('condition'), t.optionalMemberExpression(t.identifier('args'), t.identifier('condition'), false, true)),
                 t.objectProperty(t.identifier('orderBy'), t.tsAsExpression(t.optionalMemberExpression(t.identifier('args'), t.identifier('orderBy'), false, true), t.tsUnionType([
                     t.tsArrayType(t.tsStringKeyword()),
                     t.tsUndefinedKeyword(),
@@ -172,6 +176,7 @@ export function generateModelFile(table, _useSharedTypes) {
             t.stringLiteral(whereTypeName),
             t.stringLiteral(orderByTypeName),
             t.identifier('connectionFieldsMap'),
+            t.stringLiteral(conditionTypeName),
         ];
         classBody.push(createClassMethod('findMany', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindManyDocument', bodyArgs, 'query', typeName, pluralQueryName)));
     }
@@ -180,6 +185,7 @@ export function generateModelFile(table, _useSharedTypes) {
         const argsType = (sel) => t.tsTypeReference(t.identifier('FindFirstArgs'), t.tsTypeParameterInstantiation([
             sel,
             t.tsTypeReference(t.identifier(whereTypeName)),
+            t.tsTypeReference(t.identifier(conditionTypeName)),
         ]));
         const retType = (sel) => t.tsTypeAnnotation(t.tsTypeReference(t.identifier('QueryBuilder'), t.tsTypeParameterInstantiation([
             t.tsTypeLiteral([
@@ -204,9 +210,11 @@ export function generateModelFile(table, _useSharedTypes) {
             selectExpr,
             t.objectExpression([
                 t.objectProperty(t.identifier('where'), t.optionalMemberExpression(t.identifier('args'), t.identifier('where'), false, true)),
+                t.objectProperty(t.identifier('condition'), t.optionalMemberExpression(t.identifier('args'), t.identifier('condition'), false, true)),
             ]),
             t.stringLiteral(whereTypeName),
             t.identifier('connectionFieldsMap'),
+            t.stringLiteral(conditionTypeName),
         ];
         classBody.push(createClassMethod('findFirst', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindFirstDocument', bodyArgs, 'query', typeName, pluralQueryName)));
     }

package/esm/core/codegen/orm/select-types.d.ts

@@ -150,9 +150,10 @@ export interface PageInfo {
 /**
  * Arguments for findMany operations
  */
-export interface FindManyArgs<TSelect, TWhere, TOrderBy> {
+export interface FindManyArgs<TSelect, TWhere, TCondition, TOrderBy> {
     select?: TSelect;
     where?: TWhere;
+    condition?: TCondition;
     orderBy?: TOrderBy[];
     first?: number;
     last?: number;
@@ -163,9 +164,10 @@ export interface FindManyArgs<TSelect, TWhere, TOrderBy> {
 /**
  * Arguments for findFirst/findUnique operations
  */
-export interface FindFirstArgs<TSelect, TWhere> {
+export interface FindFirstArgs<TSelect, TWhere, TCondition> {
     select?: TSelect;
     where?: TWhere;
+    condition?: TCondition;
 }
 /**
  * Arguments for create operations

package/esm/core/codegen/scalars.js

@@ -33,6 +33,8 @@ export const SCALAR_TS_MAP = {
     MacAddr: 'string',
     TsVector: 'string',
     TsQuery: 'string',
+    // Vector types (pgvector) — serialized as [Float] in GraphQL
+    Vector: 'number[]',
     // File upload
     Upload: 'File',
 };
@@ -51,6 +53,12 @@ export const SCALAR_FILTER_MAP = {
     BigFloat: 'BigFloatFilter',
     BitString: 'BitStringFilter',
     InternetAddress: 'InternetAddressFilter',
+    // VectorFilter provides equality/distinct operators (isNull, equalTo, etc.) for vector
+    // columns on Filter types. While similarity search is done via condition types
+    // (e.g., embeddingNearby on ContactCondition), postgraphile-plugin-connection-filter
+    // may still auto-generate a filter type for vector columns. Without this mapping,
+    // those fields would be silently omitted from the generated SDK.
+    Vector: 'VectorFilter',
     FullText: 'FullTextFilter',
     Interval: 'StringFilter',
 };

package/esm/core/generate.js

@@ -274,18 +274,18 @@ export async function generate(options = {}, internalOptions) {
             ? config.cli.toolName
             : 'app';
         if (docsConfig.readme) {
-            const readme = generateCliReadme(tables, allCustomOps, toolName);
+            const readme = generateCliReadme(tables, allCustomOps, toolName, customOperations.typeRegistry);
             filesToWrite.push({ path: path.posix.join('cli', readme.fileName), content: readme.content });
         }
         if (docsConfig.agents) {
-            const agents = generateCliAgentsDocs(tables, allCustomOps, toolName);
+            const agents = generateCliAgentsDocs(tables, allCustomOps, toolName, customOperations.typeRegistry);
             filesToWrite.push({ path: path.posix.join('cli', agents.fileName), content: agents.content });
         }
         if (docsConfig.mcp) {
-            allMcpTools.push(...getCliMcpTools(tables, allCustomOps, toolName));
+            allMcpTools.push(...getCliMcpTools(tables, allCustomOps, toolName, customOperations.typeRegistry));
         }
         if (docsConfig.skills) {
-            for (const skill of generateCliSkills(tables, allCustomOps, toolName, targetName)) {
+            for (const skill of generateCliSkills(tables, allCustomOps, toolName, targetName, customOperations.typeRegistry)) {
                 skillsToWrite.push({ path: skill.fileName, content: skill.content });
             }
         }
@@ -574,9 +574,19 @@ export async function generateMulti(options) {
             const docsConfig = resolveDocsConfig(firstTargetDocsConfig);
             const { resolveBuiltinNames } = await import('./codegen/cli');
             const builtinNames = resolveBuiltinNames(cliTargets.map((t) => t.name), cliConfig.builtinNames);
+            // Merge all target type registries into a combined registry for docs generation
+            const combinedRegistry = new Map();
+            for (const t of cliTargets) {
+                if (t.typeRegistry) {
+                    for (const [key, value] of t.typeRegistry) {
+                        combinedRegistry.set(key, value);
+                    }
+                }
+            }
             const docsInput = {
                 toolName,
                 builtinNames,
+                registry: combinedRegistry.size > 0 ? combinedRegistry : undefined,
                 targets: cliTargets.map((t) => ({
                     name: t.name,
                     endpoint: t.endpoint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-codegen",
-  "version": "4.8.1",
+  "version": "4.12.2",
   "description": "GraphQL SDK generator for Constructive databases with React Query hooks",
   "keywords": [
     "graphql",
@@ -56,25 +56,25 @@
     "@0no-co/graphql.web": "^1.1.2",
     "@babel/generator": "^7.29.1",
     "@babel/types": "^7.29.0",
-    "@constructive-io/graphql-query": "^3.3.4",
-    "@constructive-io/graphql-types": "^3.1.2",
+    "@constructive-io/graphql-query": "^3.5.2",
+    "@constructive-io/graphql-types": "^3.3.2",
     "@inquirerer/utils": "^3.3.1",
-    "@pgpmjs/core": "^6.4.2",
+    "@pgpmjs/core": "^6.6.2",
     "ajv": "^8.18.0",
     "deepmerge": "^4.3.1",
     "find-and-require-package-json": "^0.9.1",
-    "gql-ast": "^3.1.1",
-    "graphile-schema": "^1.3.4",
+    "gql-ast": "^3.3.2",
+    "graphile-schema": "^1.5.2",
     "graphql": "^16.13.0",
     "inflekt": "^0.3.3",
     "inquirerer": "^4.5.2",
     "jiti": "^2.6.1",
     "komoji": "^0.8.1",
     "oxfmt": "^0.36.0",
-    "pg-cache": "^3.1.1",
-    "pg-env": "^1.5.0",
-    "pgsql-client": "^3.3.2",
-    "pgsql-seed": "^2.3.2",
+    "pg-cache": "^3.3.2",
+    "pg-env": "^1.7.2",
+    "pgsql-client": "^3.5.2",
+    "pgsql-seed": "^2.5.2",
     "undici": "^7.22.0"
   },
   "peerDependencies": {
@@ -101,5 +101,5 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "f4176b73429bffca0aec8dc89abe9835bf40e5c6"
+  "gitHead": "4fd2c9be786ad9ae2213453276a69723435d5315"
 }