@constructive-io/graphql-codegen 4.8.0 → 4.8.1

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

@@ -38,7 +38,6 @@ const t = __importStar(require("@babel/types"));
 const komoji_1 = require("komoji");
 const babel_ast_1 = require("../babel-ast");
 const utils_1 = require("../utils");
-const utils_2 = require("../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));
@@ -50,6 +49,60 @@ function createImportDeclaration(moduleSpecifier, namedImports, typeOnly = false
  * This is used at runtime for type coercion (string CLI args → proper types).
  * e.g., { name: 'string', isActive: 'boolean', position: 'int', status: 'enum' }
  */
+/**
+ * Returns a t.TSType node for the appropriate TypeScript type assertion
+ * based on a field's GraphQL type. Used to cast `cleanedData.fieldName`
+ * to the correct type expected by the ORM.
+ */
+/**
+ * Known GraphQL scalar types. Anything not in this set is an enum or custom type.
+ */
+const KNOWN_SCALARS = new Set([
+    'String', 'Boolean', 'Int', 'BigInt', 'Float', 'UUID',
+    'JSON', 'GeoJSON', 'Datetime', 'Date', 'Time', 'Cursor',
+    'BigFloat', 'Interval',
+]);
+/**
+ * Returns true if the GraphQL type is a known scalar.
+ * Non-scalar types (enums, custom input types) need different handling.
+ */
+function isKnownScalar(gqlType) {
+    return KNOWN_SCALARS.has(gqlType.replace(/!/g, ''));
+}
+function getTsTypeForField(field) {
+    const gqlType = field.type.gqlType.replace(/!/g, '');
+    // For non-scalar types (enums, custom types), return null to signal
+    // that no type assertion should be emitted — the value will be passed
+    // without casting, which avoids "string is not assignable to EnumType" errors.
+    if (!isKnownScalar(gqlType)) {
+        return null;
+    }
+    // Determine the base scalar type
+    // Note: ORM input types flatten array fields to their scalar base type
+    // (e.g., _uuid[] in PG -> string in the ORM input), so we do NOT wrap
+    // in tsArrayType here.
+    switch (gqlType) {
+        case 'Boolean':
+            return t.tsBooleanKeyword();
+        case 'Int':
+        case 'BigInt':
+        case 'Float':
+        case 'BigFloat':
+            return t.tsNumberKeyword();
+        case 'JSON':
+        case 'GeoJSON':
+            return t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
+                t.tsStringKeyword(),
+                t.tsUnknownKeyword(),
+            ]));
+        case 'Interval':
+            // IntervalInput is a complex type, skip assertion
+            return null;
+        case 'UUID':
+        default:
+            return t.tsStringKeyword();
+    }
+}
 function buildFieldSchemaObject(table) {
     const fields = (0, utils_1.getScalarFields)(table);
     return t.objectExpression(fields.map((f) => {
@@ -162,8 +215,11 @@ function buildGetHandler(table, targetName) {
         t.objectProperty(t.identifier('message'), t.stringLiteral(pk.name)),
         t.objectProperty(t.identifier('required'), t.booleanLiteral(true)),
     ]);
+    const pkTsType = pk.gqlType === 'Int' || pk.gqlType === 'BigInt'
+        ? t.tsNumberKeyword()
+        : t.tsStringKeyword();
     const ormArgs = t.objectExpression([
-        t.objectProperty(t.identifier(pk.name), t.memberExpression(t.identifier('answers'), t.identifier(pk.name))),
+        t.objectProperty(t.identifier(pk.name), t.tsAsExpression(t.memberExpression(t.identifier('answers'), t.identifier(pk.name)), pkTsType)),
         t.objectProperty(t.identifier('select'), selectObj),
     ]);
     const tryBody = [
@@ -189,19 +245,16 @@ function buildGetHandler(table, targetName) {
  * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
  * TypeRegistry and checks each field's defaultValue from introspection.
  */
-function getFieldsWithDefaults(table, typeRegistry) {
-    const fieldsWithDefaults = new Set();
-    if (!typeRegistry)
-        return fieldsWithDefaults;
-    // Look up the CreateXInput type (e.g. CreateDatabaseInput)
-    const createInputTypeName = (0, utils_2.getCreateInputTypeName)(table);
-    const createInputType = typeRegistry.get(createInputTypeName);
-    if (!createInputType?.inputFields)
-        return fieldsWithDefaults;
-    // The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
-    // Find the inner input type that contains the actual field definitions
-    for (const inputField of createInputType.inputFields) {
-        // The inner field's type name is the actual input type (e.g. DatabaseInput)
+/**
+ * Resolve the inner input type from a CreateXInput or UpdateXInput type.
+ * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
+ * that contains the actual field definitions.
+ */
+function resolveInnerInputType(inputTypeName, typeRegistry) {
+    const inputType = typeRegistry.get(inputTypeName);
+    if (!inputType?.inputFields)
+        return null;
+    for (const inputField of inputType.inputFields) {
         const innerTypeName = inputField.type.name
             || inputField.type.ofType?.name
             || inputField.type.ofType?.ofType?.name;
@@ -210,29 +263,70 @@ function getFieldsWithDefaults(table, typeRegistry) {
         const innerType = typeRegistry.get(innerTypeName);
         if (!innerType?.inputFields)
             continue;
-        // Check each field in the inner input type for defaultValue
-        for (const field of innerType.inputFields) {
-            if (field.defaultValue !== undefined) {
-                fieldsWithDefaults.add(field.name);
-            }
-            // Also check if the field is NOT wrapped in NON_NULL (nullable = has default or is optional)
-            if (field.type.kind !== 'NON_NULL') {
-                fieldsWithDefaults.add(field.name);
-            }
+        const fields = new Set(innerType.inputFields.map((f) => f.name));
+        return { name: innerTypeName, fields };
+    }
+    return null;
+}
+function getFieldsWithDefaults(table, typeRegistry) {
+    const fieldsWithDefaults = new Set();
+    if (!typeRegistry)
+        return fieldsWithDefaults;
+    const createInputTypeName = (0, utils_1.getCreateInputTypeName)(table);
+    const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
+    if (!resolved)
+        return fieldsWithDefaults;
+    const innerType = typeRegistry.get(resolved.name);
+    if (!innerType?.inputFields)
+        return fieldsWithDefaults;
+    for (const field of innerType.inputFields) {
+        if (field.defaultValue !== undefined) {
+            fieldsWithDefaults.add(field.name);
+        }
+        if (field.type.kind !== 'NON_NULL') {
+            fieldsWithDefaults.add(field.name);
         }
     }
     return fieldsWithDefaults;
 }
-function buildMutationHandler(table, operation, targetName, typeRegistry) {
+/**
+ * Get the set of field names that actually exist in the create/update input type.
+ * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
+ * should be excluded from the data object in create/update handlers.
+ */
+function getWritableFieldNames(table, typeRegistry) {
+    if (!typeRegistry)
+        return null;
+    const createInputTypeName = (0, utils_1.getCreateInputTypeName)(table);
+    const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
+    return resolved?.fields ?? null;
+}
+function buildMutationHandler(table, operation, targetName, typeRegistry, ormTypes) {
     const { singularName } = (0, utils_1.getTableNames)(table);
     const pkFields = (0, utils_1.getPrimaryKeyInfo)(table);
     const pk = pkFields[0];
-    const editableFields = (0, utils_1.getScalarFields)(table).filter((f) => f.name !== pk.name &&
-        f.name !== 'nodeId' &&
-        f.name !== 'createdAt' &&
-        f.name !== 'updatedAt');
+    // Get the set of writable field names from the type registry
+    // This filters out computed fields (e.g. searchTsvRank, hashUuid) that exist
+    // on the entity type but not on the create/update input type.
+    const writableFields = getWritableFieldNames(table, typeRegistry);
     // Get fields that have defaults from introspection (for create operations)
     const fieldsWithDefaults = getFieldsWithDefaults(table, typeRegistry);
+    // For create: include fields that are in the create input type.
+    // For update/delete: always exclude the PK (it goes in `where`, not `data`).
+    // The ORM input-types generator always excludes these fields from create inputs
+    // (see EXCLUDED_MUTATION_FIELDS in input-types-generator.ts). We must match this
+    // to avoid generating data properties that don't exist on the ORM create type.
+    // For non-'id' PKs (e.g. NodeTypeRegistry.name), we allow them in create data
+    // since they are user-provided natural keys that DO appear in the create input.
+    const ORM_EXCLUDED_FIELDS = ['id', 'createdAt', 'updatedAt', 'nodeId'];
+    const editableFields = (0, utils_1.getScalarFields)(table).filter((f) => 
+    // For update/delete: always exclude PK (it goes in `where`, not `data`)
+    // For create: exclude PK only if it's in the ORM exclusion list (e.g. 'id')
+    (f.name !== pk.name || (operation === 'create' && !ORM_EXCLUDED_FIELDS.includes(pk.name))) &&
+        // Always exclude ORM-excluded fields (except PK which is handled above)
+        (f.name === pk.name || !ORM_EXCLUDED_FIELDS.includes(f.name)) &&
+        // If we have type registry info, only include fields that exist in the input type
+        (writableFields === null || writableFields.has(f.name)));
     const questions = [];
     if (operation === 'update' || operation === 'delete') {
         questions.push(t.objectExpression([
@@ -261,27 +355,36 @@ function buildMutationHandler(table, operation, targetName, typeRegistry) {
         ])
         : buildSelectObject(table);
     let ormArgs;
+    // Build data properties without individual type assertions.
+    // Instead, we build a plain object from cleanedData and cast the entire
+    // data value through `unknown` to bridge the type gap between
+    // Record<string, unknown> and the ORM's specific input type.
+    // This handles scalars, enums (string literal unions like ObjectCategory),
+    // and array fields uniformly without needing to import each type.
+    const buildDataProps = () => editableFields.map((f) => t.objectProperty(t.identifier(f.name), t.memberExpression(t.identifier('cleanedData'), t.identifier(f.name))));
     if (operation === 'create') {
-        const dataProps = editableFields.map((f) => t.objectProperty(t.identifier(f.name), t.memberExpression(t.identifier('cleanedData'), t.identifier(f.name)), false, true));
         ormArgs = t.objectExpression([
-            t.objectProperty(t.identifier('data'), t.objectExpression(dataProps)),
+            t.objectProperty(t.identifier('data'), t.objectExpression(buildDataProps())),
             t.objectProperty(t.identifier('select'), selectObj),
         ]);
     }
     else if (operation === 'update') {
-        const dataProps = editableFields.map((f) => t.objectProperty(t.identifier(f.name), t.memberExpression(t.identifier('cleanedData'), t.identifier(f.name)), false, true));
         ormArgs = t.objectExpression([
             t.objectProperty(t.identifier('where'), t.objectExpression([
-                t.objectProperty(t.identifier(pk.name), t.tsAsExpression(t.memberExpression(t.identifier('answers'), t.identifier(pk.name)), t.tsStringKeyword())),
+                t.objectProperty(t.identifier(pk.name), t.tsAsExpression(t.memberExpression(t.identifier('answers'), t.identifier(pk.name)), pk.gqlType === 'Int' || pk.gqlType === 'BigInt'
+                    ? t.tsNumberKeyword()
+                    : t.tsStringKeyword())),
             ])),
-            t.objectProperty(t.identifier('data'), t.objectExpression(dataProps)),
+            t.objectProperty(t.identifier('data'), t.objectExpression(buildDataProps())),
             t.objectProperty(t.identifier('select'), selectObj),
         ]);
     }
     else {
         ormArgs = t.objectExpression([
             t.objectProperty(t.identifier('where'), t.objectExpression([
-                t.objectProperty(t.identifier(pk.name), t.tsAsExpression(t.memberExpression(t.identifier('answers'), t.identifier(pk.name)), t.tsStringKeyword())),
+                t.objectProperty(t.identifier(pk.name), t.tsAsExpression(t.memberExpression(t.identifier('answers'), t.identifier(pk.name)), pk.gqlType === 'Int' || pk.gqlType === 'BigInt'
+                    ? t.tsNumberKeyword()
+                    : t.tsStringKeyword())),
             ])),
             t.objectProperty(t.identifier('select'), selectObj),
         ]);
@@ -298,11 +401,25 @@ function buildMutationHandler(table, operation, targetName, typeRegistry) {
         ]),
     ];
     if (operation !== 'delete') {
+        // Build stripUndefined call and cast to the proper ORM input type
+        // so that property accesses on cleanedData are correctly typed.
+        const stripUndefinedCall = t.callExpression(t.identifier('stripUndefined'), [
+            t.identifier('answers'),
+            t.identifier('fieldSchema'),
+        ]);
+        let cleanedDataExpr = stripUndefinedCall;
+        if (ormTypes) {
+            if (operation === 'create') {
+                // cleanedData as CreateXxxInput['fieldName']
+                cleanedDataExpr = t.tsAsExpression(stripUndefinedCall, t.tsIndexedAccessType(t.tsTypeReference(t.identifier(ormTypes.createInputTypeName)), t.tsLiteralType(t.stringLiteral(ormTypes.innerFieldName))));
+            }
+            else if (operation === 'update') {
+                // cleanedData as XxxPatch
+                cleanedDataExpr = t.tsAsExpression(stripUndefinedCall, t.tsTypeReference(t.identifier(ormTypes.patchTypeName)));
+            }
+        }
         tryBody.push(t.variableDeclaration('const', [
-            t.variableDeclarator(t.identifier('cleanedData'), t.callExpression(t.identifier('stripUndefined'), [
-                t.identifier('answers'),
-                t.identifier('fieldSchema'),
-            ])),
+            t.variableDeclarator(t.identifier('cleanedData'), cleanedDataExpr),
         ]));
     }
     tryBody.push(buildGetClientStatement(targetName), t.variableDeclaration('const', [
@@ -330,25 +447,60 @@ 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, ['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
+    // (e.g., CreateAppPermissionInput['appPermission'] for create, AppPermissionPatch for update)
+    // instead of remaining as Record<string, unknown>.
+    const createInputTypeName = (0, utils_1.getCreateInputTypeName)(table);
+    const patchTypeName = (0, utils_1.getPatchTypeName)(table);
+    const innerFieldName = (0, utils_1.lcFirst)(table.name);
+    // Commands are at cli/commands/xxx.ts (no target) or cli/commands/{target}/xxx.ts (with target).
+    // ORM input-types is at orm/input-types.ts — two or three levels up from commands.
+    const inputTypesPath = options?.targetName
+        ? `../../../orm/input-types`
+        : `../../orm/input-types`;
+    statements.push(createImportDeclaration(inputTypesPath, [createInputTypeName, patchTypeName], true));
     // Generate field schema for type coercion
+    // Use explicit FieldSchema type annotation so TS narrows string literals to FieldType
+    const fieldSchemaId = t.identifier('fieldSchema');
+    fieldSchemaId.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('FieldSchema')));
     statements.push(t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('fieldSchema'), buildFieldSchemaObject(table)),
+        t.variableDeclarator(fieldSchemaId, buildFieldSchemaObject(table)),
     ]));
-    const subcommands = ['list', 'get', 'create', 'update', 'delete'];
+    // Determine which operations the ORM model supports for this table.
+    // Most tables have `one: null` simply because there's no dedicated GraphQL
+    // findOne query, but the ORM still generates `findOne` using the PK.
+    // The only tables WITHOUT `findOne` are pure record types from SQL functions
+    // (e.g. GetAllRecord, OrgGetManagersRecord) which have no update/delete either.
+    // We detect these by checking: if one, update, AND delete are all null, it's a
+    // read-only record type with no `findOne`.
+    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'];
+    if (hasGet)
+        subcommands.push('get');
+    subcommands.push('create');
+    if (hasUpdate)
+        subcommands.push('update');
+    if (hasDelete)
+        subcommands.push('delete');
     const usageLines = [
         '',
         `${commandName} <command>`,
         '',
         'Commands:',
         `  list                  List all ${singularName} records`,
-        `  get                   Get a ${singularName} by ID`,
-        `  create                Create a new ${singularName}`,
-        `  update                Update an existing ${singularName}`,
-        `  delete                Delete a ${singularName}`,
-        '',
-        '  --help, -h            Show this help message',
-        '',
     ];
+    if (hasGet)
+        usageLines.push(`  get                   Get a ${singularName} by ID`);
+    usageLines.push(`  create                Create a new ${singularName}`);
+    if (hasUpdate)
+        usageLines.push(`  update                Update an existing ${singularName}`);
+    if (hasDelete)
+        usageLines.push(`  delete                Delete a ${singularName}`);
+    usageLines.push('', '  --help, -h            Show this help message', '');
     statements.push(t.variableDeclaration('const', [
         t.variableDeclarator(t.identifier('usage'), t.stringLiteral(usageLines.join('\n'))),
     ]));
@@ -386,7 +538,7 @@ function generateTableCommand(table, options) {
                 ]))),
             ]),
             t.returnStatement(t.callExpression(t.identifier('handleTableSubcommand'), [
-                t.memberExpression(t.identifier('answer'), t.identifier('subcommand')),
+                t.tsAsExpression(t.memberExpression(t.identifier('answer'), t.identifier('subcommand')), t.tsStringKeyword()),
                 t.identifier('newArgv'),
                 t.identifier('prompter'),
             ])),
@@ -408,11 +560,15 @@ function generateTableCommand(table, options) {
         buildSubcommandSwitch(subcommands, 'handle', 'usage'),
     ]), false, true));
     const tn = options?.targetName;
+    const ormTypes = { createInputTypeName, patchTypeName, innerFieldName };
     statements.push(buildListHandler(table, tn));
-    statements.push(buildGetHandler(table, tn));
-    statements.push(buildMutationHandler(table, 'create', tn, options?.typeRegistry));
-    statements.push(buildMutationHandler(table, 'update', tn, options?.typeRegistry));
-    statements.push(buildMutationHandler(table, 'delete', tn, options?.typeRegistry));
+    if (hasGet)
+        statements.push(buildGetHandler(table, tn));
+    statements.push(buildMutationHandler(table, 'create', tn, options?.typeRegistry, ormTypes));
+    if (hasUpdate)
+        statements.push(buildMutationHandler(table, 'update', tn, options?.typeRegistry, ormTypes));
+    if (hasDelete)
+        statements.push(buildMutationHandler(table, 'delete', tn, options?.typeRegistry, ormTypes));
     const header = (0, utils_1.getGeneratedFileHeader)(`CLI commands for ${table.name}`);
     const code = (0, babel_ast_1.generateCode)(statements);
     return {

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

@@ -11,6 +11,25 @@ function createNamedImportDeclaration(moduleSpecifier, namedImports, typeOnly =
     decl.importKind = typeOnly ? 'type' : 'value';
     return decl;
 }
+/**
+ * Build the command handler function type:
+ * (argv: Partial<Record<string, unknown>>, prompter: Inquirerer, options: CLIOptions) => Promise<void>
+ * This matches the actual exported handler signatures from table/custom command files.
+ */
+function buildCommandHandlerType() {
+    const argvParam = t.identifier('argv');
+    argvParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Partial'), t.tsTypeParameterInstantiation([
+        t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
+            t.tsStringKeyword(),
+            t.tsUnknownKeyword(),
+        ])),
+    ])));
+    const prompterParam = t.identifier('prompter');
+    prompterParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Inquirerer')));
+    const optionsParam = t.identifier('options');
+    optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CLIOptions')));
+    return t.tsFunctionType(null, [argvParam, prompterParam, optionsParam], t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tsVoidKeyword()]))));
+}
 export function generateCommandMap(tables, customOperations, toolName) {
     const statements = [];
     statements.push(createNamedImportDeclaration('inquirerer', [
@@ -37,18 +56,17 @@ export function generateCommandMap(tables, customOperations, toolName) {
         statements.push(createImportDeclaration(`./commands/${kebab}`, importName));
     }
     const mapProperties = commandEntries.map((entry) => t.objectProperty(t.stringLiteral(entry.kebab), t.identifier(entry.importName)));
-    const createCommandMapFunc = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('createCommandMap'), t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
-    ]);
-    const createCommandMapAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
-        t.tsStringKeyword(),
-        t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsAnyKeyword())),
-    ])));
+    // Build command handler type matching actual handler signature:
+    // (argv: Partial<Record<string, unknown>>, prompter: Inquirerer, options: CLIOptions) => Promise<void>
+    const commandHandlerType = buildCommandHandlerType();
     const createCommandMapId = t.identifier('createCommandMap');
     createCommandMapId.typeAnnotation = t.tsTypeAnnotation(t.tsParenthesizedType(t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
         t.tsStringKeyword(),
-        t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsUnknownKeyword())),
+        commandHandlerType,
     ]))))));
+    const createCommandMapFunc = t.variableDeclaration('const', [
+        t.variableDeclarator(createCommandMapId, t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
+    ]);
     statements.push(createCommandMapFunc);
     const usageLines = [
         '',
@@ -115,7 +133,7 @@ export function generateCommandMap(tables, customOperations, toolName) {
                     ]),
                 ]))),
             ]),
-            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.memberExpression(t.identifier('answer'), t.identifier('command')))),
+            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.tsAsExpression(t.memberExpression(t.identifier('answer'), t.identifier('command')), t.tsStringKeyword()))),
         ])),
         t.variableDeclaration('const', [
             t.variableDeclarator(t.identifier('commandFn'), t.memberExpression(t.identifier('commandMap'), t.identifier('command'), true)),
@@ -186,8 +204,15 @@ export function generateMultiTargetCommandMap(input) {
         }
     }
     const mapProperties = commandEntries.map((entry) => t.objectProperty(t.stringLiteral(entry.kebab), t.identifier(entry.importName)));
+    // Build command handler type matching actual handler signature
+    const multiTargetCommandHandlerType = buildCommandHandlerType();
+    const multiTargetCreateCommandMapId = t.identifier('createCommandMap');
+    multiTargetCreateCommandMapId.typeAnnotation = t.tsTypeAnnotation(t.tsParenthesizedType(t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
+        t.tsStringKeyword(),
+        multiTargetCommandHandlerType,
+    ]))))));
     const createCommandMapFunc = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('createCommandMap'), t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
+        t.variableDeclarator(multiTargetCreateCommandMapId, t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
     ]);
     statements.push(createCommandMapFunc);
     const usageLines = [
@@ -261,7 +286,7 @@ export function generateMultiTargetCommandMap(input) {
                     ]),
                 ]))),
             ]),
-            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.memberExpression(t.identifier('answer'), t.identifier('command')))),
+            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.tsAsExpression(t.memberExpression(t.identifier('answer'), t.identifier('command')), t.tsStringKeyword()))),
         ])),
         t.variableDeclaration('const', [
             t.variableDeclarator(t.identifier('commandFn'), t.memberExpression(t.identifier('commandMap'), t.identifier('command'), true)),

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

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
 import { toKebabCase } from 'komoji';
 import { generateCode } from '../babel-ast';
-import { getGeneratedFileHeader } from '../utils';
+import { getGeneratedFileHeader, ucFirst } from '../utils';
 import { buildQuestionsArray } from './arg-mapper';
 function createImportDeclaration(moduleSpecifier, namedImports, typeOnly = false) {
     const specifiers = namedImports.map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
@@ -65,22 +65,33 @@ function buildDefaultSelectString(returnType, isMutation) {
     }
     return '';
 }
-function buildOrmCustomCall(opKind, opName, argsExpr, selectExpr, hasArgs = true) {
+function buildOrmCustomCall(opKind, opName, argsExpr, selectExpr, hasArgs = true, selectTypeName) {
     const callArgs = [];
+    // Helper: wrap { select } and cast to `{ select: XxxSelect }` via `unknown`.
+    // The ORM method's second parameter is `{ select: S } & StrictSelect<S, XxxSelect>`.
+    // We import the concrete Select type (e.g. CheckPasswordPayloadSelect) and cast
+    // `{ select: selectFields } as unknown as { select: XxxSelect }` so TS infers
+    // `S = XxxSelect` and StrictSelect is satisfied.
+    const castSelectWrapper = (sel) => {
+        const selectObj = t.objectExpression([
+            t.objectProperty(t.identifier('select'), sel),
+        ]);
+        if (!selectTypeName)
+            return selectObj;
+        return t.tsAsExpression(t.tsAsExpression(selectObj, t.tsUnknownKeyword()), t.tsTypeLiteral([
+            t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(selectTypeName)))),
+        ]));
+    };
     if (hasArgs) {
-        // Operation has arguments: pass args as first param, select as second
+        // Operation has arguments: pass args as first param, select as second.
         callArgs.push(argsExpr);
         if (selectExpr) {
-            callArgs.push(t.objectExpression([
-                t.objectProperty(t.identifier('select'), selectExpr),
-            ]));
+            callArgs.push(castSelectWrapper(selectExpr));
         }
     }
     else if (selectExpr) {
-        // No arguments: pass { select } as the only param (ORM signature)
-        callArgs.push(t.objectExpression([
-            t.objectProperty(t.identifier('select'), selectExpr),
-        ]));
+        // No arguments: pass { select } as the only param (ORM signature).
+        callArgs.push(castSelectWrapper(selectExpr));
     }
     return t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.memberExpression(t.identifier('client'), t.identifier(opKind)), t.identifier(opName)), callArgs), t.identifier('execute')), []);
 }
@@ -116,6 +127,18 @@ export function generateCustomCommand(op, options) {
     if (utilsImports.length > 0) {
         statements.push(createImportDeclaration(utilsPath, utilsImports));
     }
+    // Import the Variables type for this operation from the ORM query/mutation module.
+    // Custom operations define their own Variables types (e.g. CheckPasswordVariables)
+    // in the ORM layer. We import and cast CLI answers to this type for proper typing.
+    if (op.args.length > 0) {
+        const variablesTypeName = `${ucFirst(op.name)}Variables`;
+        // Commands are at cli/commands/xxx.ts (no target) or cli/commands/{target}/xxx.ts (with target).
+        // ORM query/mutation is at orm/{opKind}/ — two or three levels up from commands.
+        const ormOpPath = options?.targetName
+            ? `../../../orm/${opKind}`
+            : `../../orm/${opKind}`;
+        statements.push(createImportDeclaration(ormOpPath, [variablesTypeName], true));
+    }
     const questionsArray = op.args.length > 0
         ? buildQuestionsArray(op.args)
         : t.arrayExpression([]);
@@ -153,10 +176,16 @@ export function generateCustomCommand(op, options) {
             ])),
         ]));
     }
+    // Cast args to the specific Variables type for this operation.
+    // The ORM expects typed variables (e.g. CheckPasswordVariables), and CLI
+    // prompt answers are Record<string, unknown>. We cast through `unknown`
+    // first because Record<string, unknown> doesn't directly overlap with
+    // Variables types that have specific property types (like `input: SomeInput`).
+    const variablesTypeName = `${ucFirst(op.name)}Variables`;
     const argsExpr = op.args.length > 0
-        ? (hasInputObjectArg
+        ? t.tsAsExpression(t.tsAsExpression(hasInputObjectArg
             ? t.identifier('parsedAnswers')
-            : t.identifier('answers'))
+            : t.identifier('answers'), t.tsUnknownKeyword()), t.tsTypeReference(t.identifier(variablesTypeName)))
         : t.objectExpression([]);
     // For OBJECT return types, generate runtime select from --select flag
     // For scalar return types, no select is needed
@@ -166,14 +195,31 @@ export function generateCustomCommand(op, options) {
         // Generate: const selectFields = buildSelectFromPaths(argv.select ?? 'defaultFields')
         bodyStatements.push(t.variableDeclaration('const', [
             t.variableDeclarator(t.identifier('selectFields'), t.callExpression(t.identifier('buildSelectFromPaths'), [
-                t.logicalExpression('??', t.memberExpression(t.identifier('argv'), t.identifier('select')), t.stringLiteral(defaultSelect)),
+                t.logicalExpression('??', t.tsAsExpression(t.memberExpression(t.identifier('argv'), t.identifier('select')), t.tsStringKeyword()), t.stringLiteral(defaultSelect)),
             ])),
         ]));
         selectExpr = t.identifier('selectFields');
     }
+    // Derive the Select type name from the operation's return type.
+    // e.g. CheckPasswordPayload → CheckPasswordPayloadSelect
+    // This is used to cast { select } to the proper type for StrictSelect.
+    let selectTypeName;
+    if (isObjectReturn) {
+        const baseReturnType = unwrapType(op.returnType);
+        if (baseReturnType.name) {
+            selectTypeName = `${baseReturnType.name}Select`;
+        }
+    }
+    // Import the Select type from orm/input-types if we have one
+    if (selectTypeName) {
+        const inputTypesPath = options?.targetName
+            ? `../../../orm/input-types`
+            : `../../orm/input-types`;
+        statements.push(createImportDeclaration(inputTypesPath, [selectTypeName], true));
+    }
     const hasArgs = op.args.length > 0;
     bodyStatements.push(t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('result'), t.awaitExpression(buildOrmCustomCall(opKind, op.name, argsExpr, selectExpr, hasArgs))),
+        t.variableDeclarator(t.identifier('result'), t.awaitExpression(buildOrmCustomCall(opKind, op.name, argsExpr, selectExpr, hasArgs, selectTypeName))),
     ]));
     if (options?.saveToken) {
         bodyStatements.push(t.ifStatement(t.logicalExpression('&&', t.memberExpression(t.identifier('argv'), t.identifier('saveToken')), t.identifier('result')), t.blockStatement([

package/esm/core/codegen/cli/executor-generator.js

@@ -49,9 +49,16 @@ export function generateExecutorFile(toolName, options) {
                 ])),
             ])),
         ])),
-        t.variableDeclaration('const', [
-            t.variableDeclarator(t.identifier('headers'), t.objectExpression([])),
-        ]),
+        (() => {
+            const headersId = t.identifier('headers');
+            headersId.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
+                t.tsStringKeyword(),
+                t.tsStringKeyword(),
+            ])));
+            return t.variableDeclaration('const', [
+                t.variableDeclarator(headersId, t.objectExpression([])),
+            ]);
+        })(),
         t.ifStatement(t.callExpression(t.memberExpression(t.identifier('store'), t.identifier('hasValidCredentials')), [t.memberExpression(t.identifier('ctx'), t.identifier('name'))]), t.blockStatement([
             t.variableDeclaration('const', [
                 t.variableDeclarator(t.identifier('creds'), t.callExpression(t.memberExpression(t.identifier('store'), t.identifier('getCredentials')), [t.memberExpression(t.identifier('ctx'), t.identifier('name'))])),
@@ -156,9 +163,16 @@ export function generateMultiTargetExecutorFile(toolName, targets, options) {
                 ], [t.identifier('targetName')]),
             ])),
         ])),
-        t.variableDeclaration('const', [
-            t.variableDeclarator(t.identifier('headers'), t.objectExpression([])),
-        ]),
+        (() => {
+            const headersId = t.identifier('headers');
+            headersId.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
+                t.tsStringKeyword(),
+                t.tsStringKeyword(),
+            ])));
+            return t.variableDeclaration('const', [
+                t.variableDeclarator(headersId, t.objectExpression([])),
+            ]);
+        })(),
         t.variableDeclaration('let', [
             t.variableDeclarator(t.identifier('endpoint'), t.stringLiteral('')),
         ]),