@constructive-io/graphql-codegen 4.9.0 → 4.13.0

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

@@ -252,6 +252,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',
@@ -748,10 +753,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 ((0, utils_1.isRelationField)(field.name, table))
@@ -763,17 +773,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 = (0, utils_1.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: (0, utils_1.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 = (0, utils_1.getConditionTypeName)(table);
-        statements.push(createExportedInterface(conditionName, buildTableConditionProperties(table)));
+        statements.push(createExportedInterface(conditionName, buildTableConditionProperties(table, typeRegistry)));
     }
     if (statements.length > 0) {
         addSectionComment(statements, 'Table Condition Types');
@@ -784,9 +815,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 ((0, utils_1.isRelationField)(field.name, table))
@@ -795,16 +830,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 = (0, utils_1.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 = (0, utils_1.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));
@@ -1013,9 +1062,9 @@ function buildTableCrudTypeNames(tables) {
 /**
  * Generate custom input type statements from TypeRegistry
  */
-function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes, comments = true) {
+function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes, comments = true, alreadyGeneratedTypes) {
     const statements = [];
-    const generatedTypes = new Set();
+    const generatedTypes = new Set(alreadyGeneratedTypes ?? []);
     const typesToGenerate = new Set(Array.from(usedInputTypes));
     // Filter out types we've already generated (exact matches for table CRUD types only)
     if (tableCrudTypes) {
@@ -1055,11 +1104,12 @@ function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes,
                     optional,
                     description: (0, utils_1.stripSmartComments)(field.description, comments),
                 });
-                // Follow nested Input types
+                // Follow nested types (Input objects, Enums, etc.) that exist in the registry
                 const baseType = (0, type_resolver_1.getTypeBaseName)(field.type);
                 if (baseType &&
-                    baseType.endsWith('Input') &&
-                    !generatedTypes.has(baseType)) {
+                    !scalars_1.SCALAR_NAMES.has(baseType) &&
+                    !generatedTypes.has(baseType) &&
+                    typeRegistry.has(baseType)) {
                     typesToGenerate.add(baseType);
                 }
             }
@@ -1243,12 +1293,49 @@ 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 = (0, utils_1.getConditionTypeName)(table);
+        const conditionType = typeRegistry.get(conditionTypeName);
+        if (!conditionType ||
+            conditionType.kind !== 'INPUT_OBJECT' ||
+            !conditionType.inputFields) {
+            continue;
+        }
+        const tableFieldNames = new Set(table.fields
+            .filter((f) => !(0, utils_1.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 = (0, type_resolver_1.getTypeBaseName)(field.type);
+            if (baseName && !scalars_1.SCALAR_NAMES.has(baseName)) {
+                extraTypes.add(baseName);
+            }
+        }
+    }
+    return extraTypes;
+}
+// ============================================================================
 // Main Generator (AST-based)
 // ============================================================================
 /**
  * Generate comprehensive input-types.ts file using Babel AST
  */
-function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloadTypes, comments = true) {
+function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloadTypes, comments = true, options) {
+    const conditionEnabled = options?.condition !== false;
     const statements = [];
     const tablesList = tables ?? [];
     const hasTables = tablesList.length > 0;
@@ -1273,9 +1360,15 @@ function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloa
         // 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)
+        if (conditionEnabled) {
+            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));
     }
@@ -1283,8 +1376,21 @@ function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloa
     // 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 && conditionEnabled) {
+        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));
+    // Pass customScalarTypes + enumTypes as already-generated to avoid duplicate declarations
+    const alreadyGenerated = new Set([
+        ...customScalarTypes,
+        ...enumTypes,
+    ]);
+    statements.push(...generateCustomInputTypes(typeRegistry, mergedUsedInputTypes, tableCrudTypes, comments, alreadyGenerated));
     // 8. Payload/return types for custom operations
     if (usedPayloadTypes && usedPayloadTypes.size > 0) {
         const alreadyGeneratedTypes = new Set();

package/core/codegen/orm/model-generator.d.ts

@@ -5,5 +5,9 @@ export interface GeneratedModelFile {
     modelName: string;
     tableName: string;
 }
-export declare function generateModelFile(table: CleanTable, _useSharedTypes: boolean): GeneratedModelFile;
-export declare function generateAllModelFiles(tables: CleanTable[], useSharedTypes: boolean): GeneratedModelFile[];
+export declare function generateModelFile(table: CleanTable, _useSharedTypes: boolean, options?: {
+    condition?: boolean;
+}): GeneratedModelFile;
+export declare function generateAllModelFiles(tables: CleanTable[], useSharedTypes: boolean, options?: {
+    condition?: boolean;
+}): GeneratedModelFile[];

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

@@ -102,7 +102,8 @@ function strictSelectGuard(selectTypeName) {
         t.tsTypeReference(t.identifier(selectTypeName)),
     ]));
 }
-function generateModelFile(table, _useSharedTypes) {
+function generateModelFile(table, _useSharedTypes, options) {
+    const conditionEnabled = options?.condition !== false;
     const { typeName, singularName, pluralName } = (0, utils_1.getTableNames)(table);
     const modelName = `${typeName}Model`;
     const baseFileName = (0, utils_1.lcFirst)(typeName);
@@ -111,6 +112,7 @@ function generateModelFile(table, _useSharedTypes) {
     const selectTypeName = `${typeName}Select`;
     const relationTypeName = `${typeName}WithRelations`;
     const whereTypeName = (0, utils_1.getFilterTypeName)(table);
+    const conditionTypeName = conditionEnabled ? `${typeName}Condition` : undefined;
     const orderByTypeName = (0, utils_1.getOrderByTypeName)(table);
     const createInputTypeName = `Create${typeName}Input`;
     const updateInputTypeName = `Update${typeName}Input`;
@@ -145,16 +147,18 @@ function generateModelFile(table, _useSharedTypes) {
         'InferSelectResult',
         'StrictSelect',
     ], true));
-    statements.push(createImportDeclaration('../input-types', [
+    const inputTypeImports = [
         typeName,
         relationTypeName,
         selectTypeName,
         whereTypeName,
+        ...(conditionTypeName ? [conditionTypeName] : []),
         orderByTypeName,
         createInputTypeName,
         updateInputTypeName,
         patchTypeName,
-    ], true));
+    ];
+    statements.push(createImportDeclaration('../input-types', inputTypeImports, true));
     statements.push(createImportDeclaration('../input-types', ['connectionFieldsMap']));
     const classBody = [];
     // Constructor
@@ -168,11 +172,15 @@ function generateModelFile(table, _useSharedTypes) {
     const pkTsType = () => tsTypeFromPrimitive(pkField.tsType);
     // ── findMany ───────────────────────────────────────────────────────────
     {
-        const argsType = (sel) => t.tsTypeReference(t.identifier('FindManyArgs'), t.tsTypeParameterInstantiation([
-            sel,
-            t.tsTypeReference(t.identifier(whereTypeName)),
-            t.tsTypeReference(t.identifier(orderByTypeName)),
-        ]));
+        const findManyTypeArgs = [
+            (sel) => sel,
+            () => t.tsTypeReference(t.identifier(whereTypeName)),
+            ...(conditionTypeName
+                ? [() => t.tsTypeReference(t.identifier(conditionTypeName))]
+                : []),
+            () => t.tsTypeReference(t.identifier(orderByTypeName)),
+        ];
+        const argsType = (sel) => t.tsTypeReference(t.identifier('FindManyArgs'), t.tsTypeParameterInstantiation(findManyTypeArgs.map(fn => fn(sel))));
         const retType = (sel) => t.tsTypeAnnotation(t.tsTypeReference(t.identifier('QueryBuilder'), t.tsTypeParameterInstantiation([
             t.tsTypeLiteral([
                 t.tsPropertySignature(t.identifier(pluralQueryName), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('ConnectionResult'), t.tsTypeParameterInstantiation([
@@ -190,34 +198,47 @@ function generateModelFile(table, _useSharedTypes) {
             strictSelectGuard(selectTypeName),
         ]));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
+        const findManyObjProps = [
+            t.objectProperty(t.identifier('where'), t.optionalMemberExpression(t.identifier('args'), t.identifier('where'), false, true)),
+            ...(conditionTypeName
+                ? [
+                    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(),
+            ]))),
+            t.objectProperty(t.identifier('first'), t.optionalMemberExpression(t.identifier('args'), t.identifier('first'), false, true)),
+            t.objectProperty(t.identifier('last'), t.optionalMemberExpression(t.identifier('args'), t.identifier('last'), false, true)),
+            t.objectProperty(t.identifier('after'), t.optionalMemberExpression(t.identifier('args'), t.identifier('after'), false, true)),
+            t.objectProperty(t.identifier('before'), t.optionalMemberExpression(t.identifier('args'), t.identifier('before'), false, true)),
+            t.objectProperty(t.identifier('offset'), t.optionalMemberExpression(t.identifier('args'), t.identifier('offset'), false, true)),
+        ];
         const bodyArgs = [
             t.stringLiteral(typeName),
             t.stringLiteral(pluralQueryName),
             selectExpr,
-            t.objectExpression([
-                t.objectProperty(t.identifier('where'), t.optionalMemberExpression(t.identifier('args'), t.identifier('where'), 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(),
-                ]))),
-                t.objectProperty(t.identifier('first'), t.optionalMemberExpression(t.identifier('args'), t.identifier('first'), false, true)),
-                t.objectProperty(t.identifier('last'), t.optionalMemberExpression(t.identifier('args'), t.identifier('last'), false, true)),
-                t.objectProperty(t.identifier('after'), t.optionalMemberExpression(t.identifier('args'), t.identifier('after'), false, true)),
-                t.objectProperty(t.identifier('before'), t.optionalMemberExpression(t.identifier('args'), t.identifier('before'), false, true)),
-                t.objectProperty(t.identifier('offset'), t.optionalMemberExpression(t.identifier('args'), t.identifier('offset'), false, true)),
-            ]),
+            t.objectExpression(findManyObjProps),
             t.stringLiteral(whereTypeName),
             t.stringLiteral(orderByTypeName),
             t.identifier('connectionFieldsMap'),
+            ...(conditionTypeName
+                ? [t.stringLiteral(conditionTypeName)]
+                : []),
         ];
         classBody.push(createClassMethod('findMany', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindManyDocument', bodyArgs, 'query', typeName, pluralQueryName)));
     }
     // ── findFirst ──────────────────────────────────────────────────────────
     {
-        const argsType = (sel) => t.tsTypeReference(t.identifier('FindFirstArgs'), t.tsTypeParameterInstantiation([
-            sel,
-            t.tsTypeReference(t.identifier(whereTypeName)),
-        ]));
+        const findFirstTypeArgs = [
+            (sel) => sel,
+            () => t.tsTypeReference(t.identifier(whereTypeName)),
+            ...(conditionTypeName
+                ? [() => t.tsTypeReference(t.identifier(conditionTypeName))]
+                : []),
+        ];
+        const argsType = (sel) => t.tsTypeReference(t.identifier('FindFirstArgs'), t.tsTypeParameterInstantiation(findFirstTypeArgs.map(fn => fn(sel))));
         const retType = (sel) => t.tsTypeAnnotation(t.tsTypeReference(t.identifier('QueryBuilder'), t.tsTypeParameterInstantiation([
             t.tsTypeLiteral([
                 t.tsPropertySignature(t.identifier(pluralQueryName), t.tsTypeAnnotation(t.tsTypeLiteral([
@@ -235,15 +256,24 @@ function generateModelFile(table, _useSharedTypes) {
             strictSelectGuard(selectTypeName),
         ]));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
+        const findFirstObjProps = [
+            t.objectProperty(t.identifier('where'), t.optionalMemberExpression(t.identifier('args'), t.identifier('where'), false, true)),
+            ...(conditionTypeName
+                ? [
+                    t.objectProperty(t.identifier('condition'), t.optionalMemberExpression(t.identifier('args'), t.identifier('condition'), false, true)),
+                ]
+                : []),
+        ];
         const bodyArgs = [
             t.stringLiteral(typeName),
             t.stringLiteral(pluralQueryName),
             selectExpr,
-            t.objectExpression([
-                t.objectProperty(t.identifier('where'), t.optionalMemberExpression(t.identifier('args'), t.identifier('where'), false, true)),
-            ]),
+            t.objectExpression(findFirstObjProps),
             t.stringLiteral(whereTypeName),
             t.identifier('connectionFieldsMap'),
+            ...(conditionTypeName
+                ? [t.stringLiteral(conditionTypeName)]
+                : []),
         ];
         classBody.push(createClassMethod('findFirst', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindFirstDocument', bodyArgs, 'query', typeName, pluralQueryName)));
     }
@@ -447,6 +477,6 @@ function generateModelFile(table, _useSharedTypes) {
         tableName: table.name,
     };
 }
-function generateAllModelFiles(tables, useSharedTypes) {
-    return tables.map((table) => generateModelFile(table, useSharedTypes));
+function generateAllModelFiles(tables, useSharedTypes, options) {
+    return tables.map((table) => generateModelFile(table, useSharedTypes, options));
 }

package/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/core/codegen/scalars.js

@@ -38,6 +38,8 @@ exports.SCALAR_TS_MAP = {
     MacAddr: 'string',
     TsVector: 'string',
     TsQuery: 'string',
+    // Vector types (pgvector) — serialized as [Float] in GraphQL
+    Vector: 'number[]',
     // File upload
     Upload: 'File',
 };
@@ -56,6 +58,12 @@ exports.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/core/codegen/templates/cli-entry.ts

@@ -17,9 +17,9 @@ if (process.argv.includes('--version') || process.argv.includes('-v')) {
   process.exit(0);
 }
 
-// Check for --tty false to enable non-interactive mode (noTty)
+// Check for --tty false or --no-tty to enable non-interactive mode (noTty)
 const ttyIdx = process.argv.indexOf('--tty');
-const noTty = ttyIdx !== -1 && process.argv[ttyIdx + 1] === 'false';
+const noTty = (ttyIdx !== -1 && process.argv[ttyIdx + 1] === 'false') || process.argv.includes('--no-tty');
 
 const options: Partial<CLIOptions> = {
   noTty,

package/core/codegen/templates/cli-utils.ts

@@ -145,6 +145,34 @@ export function parseMutationInput(
   return answers;
 }
 
+/**
+ * Reconstruct nested objects from dot-notation CLI answers.
+ * When INPUT_OBJECT args are flattened to dot-notation questions
+ * (e.g. `--input.email foo --input.password bar`), this function
+ * rebuilds the nested structure expected by the ORM:
+ *
+ *   { 'input.email': 'foo', 'input.password': 'bar' }
+ *   → { input: { email: 'foo', password: 'bar' } }
+ *
+ * Non-dotted keys are passed through unchanged.
+ * Uses `nested-obj` for safe nested property setting.
+ */
+export function unflattenDotNotation(
+  answers: Record<string, unknown>,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(answers)) {
+    if (key.includes('.')) {
+      objectPath.set(result, key, value);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
 /**
  * Build a select object from a comma-separated list of dot-notation paths.
  * Uses `nested-obj` to parse paths like 'clientMutationId,result.accessToken,result.userId'

package/core/codegen/templates/query-builder.ts

@@ -201,12 +201,13 @@ export function buildSelections(
 // Document Builders
 // ============================================================================
 
-export function buildFindManyDocument<TSelect, TWhere>(
+export function buildFindManyDocument<TSelect, TWhere, TCondition = never>(
   operationName: string,
   queryField: string,
   select: TSelect,
   args: {
     where?: TWhere;
+    condition?: TCondition;
     orderBy?: string[];
     first?: number;
     last?: number;
@@ -217,6 +218,7 @@ export function buildFindManyDocument<TSelect, TWhere>(
   filterTypeName: string,
   orderByTypeName: string,
   connectionFieldsMap?: Record<string, Record<string, string>>,
+  conditionTypeName?: string,
 ): { document: string; variables: Record<string, unknown> } {
   const selections = select
     ? buildSelections(
@@ -230,6 +232,16 @@ export function buildFindManyDocument<TSelect, TWhere>(
   const queryArgs: ArgumentNode[] = [];
   const variables: Record<string, unknown> = {};
 
+  addVariable(
+    {
+      varName: 'condition',
+      typeName: conditionTypeName,
+      value: args.condition,
+    },
+    variableDefinitions,
+    queryArgs,
+    variables,
+  );
   addVariable(
     {
       varName: 'where',
@@ -308,13 +320,14 @@ export function buildFindManyDocument<TSelect, TWhere>(
   return { document: print(document), variables };
 }
 
-export function buildFindFirstDocument<TSelect, TWhere>(
+export function buildFindFirstDocument<TSelect, TWhere, TCondition = never>(
   operationName: string,
   queryField: string,
   select: TSelect,
-  args: { where?: TWhere },
+  args: { where?: TWhere; condition?: TCondition },
   filterTypeName: string,
   connectionFieldsMap?: Record<string, Record<string, string>>,
+  conditionTypeName?: string,
 ): { document: string; variables: Record<string, unknown> } {
   const selections = select
     ? buildSelections(
@@ -335,6 +348,16 @@ export function buildFindFirstDocument<TSelect, TWhere>(
     queryArgs,
     variables,
   );
+  addVariable(
+    {
+      varName: 'condition',
+      typeName: conditionTypeName,
+      value: args.condition,
+    },
+    variableDefinitions,
+    queryArgs,
+    variables,
+  );
   addVariable(
     {
       varName: 'where',
@@ -799,7 +822,7 @@ function buildConnectionSelections(nodeSelections: FieldNode[]): FieldNode[] {
 interface VariableSpec {
   varName: string;
   argName?: string;
-  typeName: string;
+  typeName?: string;
   value: unknown;
 }
 
@@ -850,7 +873,7 @@ function addVariable(
   args: ArgumentNode[],
   variables: Record<string, unknown>,
 ): void {
-  if (spec.value === undefined) return;
+  if (spec.value === undefined || !spec.typeName) return;
 
   definitions.push(
     t.variableDefinition({

package/core/codegen/templates/select-types.ts

@@ -21,9 +21,10 @@ export interface PageInfo {
   endCursor?: string | null;
 }
 
-export interface FindManyArgs<TSelect, TWhere, TOrderBy> {
+export interface FindManyArgs<TSelect, TWhere, TCondition = never, TOrderBy = never> {
   select?: TSelect;
   where?: TWhere;
+  condition?: TCondition;
   orderBy?: TOrderBy[];
   first?: number;
   last?: number;
@@ -32,9 +33,10 @@ export interface FindManyArgs<TSelect, TWhere, TOrderBy> {
   offset?: number;
 }
 
-export interface FindFirstArgs<TSelect, TWhere> {
+export interface FindFirstArgs<TSelect, TWhere, TCondition = never> {
   select?: TSelect;
   where?: TWhere;
+  condition?: TCondition;
 }
 
 export interface CreateArgs<TSelect, TData> {

package/core/generate.js

@@ -316,18 +316,18 @@ async function generate(options = {}, internalOptions) {
             ? config.cli.toolName
             : 'app';
         if (docsConfig.readme) {
-            const readme = (0, docs_generator_1.generateReadme)(tables, allCustomOps, toolName);
+            const readme = (0, docs_generator_1.generateReadme)(tables, allCustomOps, toolName, customOperations.typeRegistry);
             filesToWrite.push({ path: node_path_1.default.posix.join('cli', readme.fileName), content: readme.content });
         }
         if (docsConfig.agents) {
-            const agents = (0, docs_generator_1.generateAgentsDocs)(tables, allCustomOps, toolName);
+            const agents = (0, docs_generator_1.generateAgentsDocs)(tables, allCustomOps, toolName, customOperations.typeRegistry);
             filesToWrite.push({ path: node_path_1.default.posix.join('cli', agents.fileName), content: agents.content });
         }
         if (docsConfig.mcp) {
-            allMcpTools.push(...(0, docs_generator_1.getCliMcpTools)(tables, allCustomOps, toolName));
+            allMcpTools.push(...(0, docs_generator_1.getCliMcpTools)(tables, allCustomOps, toolName, customOperations.typeRegistry));
         }
         if (docsConfig.skills) {
-            for (const skill of (0, docs_generator_1.generateSkills)(tables, allCustomOps, toolName, targetName)) {
+            for (const skill of (0, docs_generator_1.generateSkills)(tables, allCustomOps, toolName, targetName, customOperations.typeRegistry)) {
                 skillsToWrite.push({ path: skill.fileName, content: skill.content });
             }
         }
@@ -616,9 +616,19 @@ async function generateMulti(options) {
             const docsConfig = (0, docs_utils_1.resolveDocsConfig)(firstTargetDocsConfig);
             const { resolveBuiltinNames } = await Promise.resolve().then(() => __importStar(require('./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,