@constructive-io/graphql-codegen 4.8.1 → 4.12.2

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

@@ -33,6 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInnerInputType = resolveInnerInputType;
+exports.getFieldsWithDefaults = getFieldsWithDefaults;
 exports.generateTableCommand = generateTableCommand;
 const t = __importStar(require("@babel/types"));
 const komoji_1 = require("komoji");
@@ -103,6 +105,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 = (0, utils_1.getScalarFields)(table);
     return t.objectExpression(fields.map((f) => {
@@ -341,12 +359,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/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/core/codegen/docs-utils.js

@@ -6,6 +6,9 @@ exports.resolveDocsConfig = resolveDocsConfig;
 exports.formatArgType = formatArgType;
 exports.formatTypeRef = formatTypeRef;
 exports.getEditableFields = getEditableFields;
+exports.cleanTypeName = cleanTypeName;
+exports.flattenArgs = flattenArgs;
+exports.flattenedArgsToFlags = flattenedArgsToFlags;
 exports.gqlTypeToJsonSchemaType = gqlTypeToJsonSchemaType;
 exports.buildSkillFile = buildSkillFile;
 exports.buildSkillReference = buildSkillReference;
@@ -78,6 +81,108 @@ 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'
+ */
+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;
+}
+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>'
+ */
+function flattenedArgsToFlags(flatArgs) {
+    return flatArgs.map((a) => `--${a.flag} <value>`).join(' ');
+}
 function gqlTypeToJsonSchemaType(gqlType) {
     switch (gqlType) {
         case 'Int':

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));
@@ -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,6 +1293,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 = (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)
 // ============================================================================
 /**
@@ -1273,9 +1359,13 @@ 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)
+        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 +1373,16 @@ 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) {
+        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/core/codegen/orm/model-generator.js

@@ -111,6 +111,7 @@ function generateModelFile(table, _useSharedTypes) {
     const selectTypeName = `${typeName}Select`;
     const relationTypeName = `${typeName}WithRelations`;
     const whereTypeName = (0, utils_1.getFilterTypeName)(table);
+    const conditionTypeName = `${typeName}Condition`;
     const orderByTypeName = (0, utils_1.getOrderByTypeName)(table);
     const createInputTypeName = `Create${typeName}Input`;
     const updateInputTypeName = `Update${typeName}Input`;
@@ -150,6 +151,7 @@ function generateModelFile(table, _useSharedTypes) {
         relationTypeName,
         selectTypeName,
         whereTypeName,
+        conditionTypeName,
         orderByTypeName,
         createInputTypeName,
         updateInputTypeName,
@@ -171,6 +173,7 @@ 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([
@@ -196,6 +199,7 @@ 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(),
@@ -209,6 +213,7 @@ 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)));
     }
@@ -217,6 +222,7 @@ 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([
@@ -241,9 +247,11 @@ 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/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>(
   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>(
   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({