fix(codegen): upstream CLI fixes - no-arg query signature, field defaults, localhost adapter

1. Fix query call signature for no-arg queries (e.g. currentUser)
   - buildOrmCustomCall now skips empty args object and passes {select} as single param
   - Fixes: .currentUser({}, {select}) -> .currentUser({select})

2. Mark fields with defaults as not-required in create operations
   - Uses TypeRegistry to look up CREATE input type's defaultValue from introspection
   - Fields with defaults or nullable types are marked required: false
   - Passed via new typeRegistry option on TableCommandOptions

3. Add localhost fetch adapter for *.localhost subdomain routing
   - New template: localhost-fetch.ts patches globalThis.fetch using node:http.request
   - Enables local dev with subdomain routing (e.g. auth.localhost:3000)
   - Configurable via cli.localhostAdapter option in CliConfig
   - Auto-imported in executor when enabled

Author: unknown

graphql/codegen/src/__tests__/codegen/__snapshots__/cli-generator.test.ts.snap

@@ -1153,7 +1153,7 @@ export default async (argv: Partial<Record<string, unknown>>, prompter: Inquirer
     }
     const client = getClient();
     const selectFields = buildSelectFromPaths(argv.select ?? "");
-    const result = await client.query.currentUser({}, {
+    const result = await client.query.currentUser({
       select: selectFields
     }).execute();
     console.log(JSON.stringify(result, null, 2));

graphql/codegen/src/core/codegen/cli/custom-command-generator.ts

@@ -143,9 +143,21 @@ function buildOrmCustomCall(
   opName: string,
   argsExpr: t.Expression,
   selectExpr?: t.Expression,
+  hasArgs: boolean = true,
 ): t.Expression {
-  const callArgs: t.Expression[] = [argsExpr];
-  if (selectExpr) {
+  const callArgs: t.Expression[] = [];
+  if (hasArgs) {
+    // 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),
+        ]),
+      );
+    }
+  } else if (selectExpr) {
+    // No arguments: pass { select } as the only param (ORM signature)
     callArgs.push(
       t.objectExpression([
         t.objectProperty(t.identifier('select'), selectExpr),
@@ -343,12 +355,13 @@ export function generateCustomCommand(op: CleanOperation, options?: CustomComman
     selectExpr = t.identifier('selectFields');
   }
 
+  const hasArgs = op.args.length > 0;
   bodyStatements.push(
     t.variableDeclaration('const', [
       t.variableDeclarator(
         t.identifier('result'),
         t.awaitExpression(
-          buildOrmCustomCall(opKind, op.name, argsExpr, selectExpr),
+          buildOrmCustomCall(opKind, op.name, argsExpr, selectExpr, hasArgs),
         ),
       ),
     ]),

graphql/codegen/src/core/codegen/cli/executor-generator.ts

@@ -30,9 +30,21 @@ function createImportDeclaration(
   return decl;
 }
 
-export function generateExecutorFile(toolName: string): GeneratedFile {
+export interface ExecutorOptions {
+  /** Enable localhost fetch adapter import */
+  localhostAdapter?: boolean;
+}
+
+export function generateExecutorFile(toolName: string, options?: ExecutorOptions): GeneratedFile {
   const statements: t.Statement[] = [];
 
+  // Import localhost adapter first (side-effect import patches globalThis.fetch)
+  if (options?.localhostAdapter) {
+    statements.push(
+      t.importDeclaration([], t.stringLiteral('./localhost-fetch')),
+    );
+  }
+
   statements.push(
     createImportDeclaration('appstash', ['createConfigStore']),
   );
@@ -226,9 +238,17 @@ export function generateExecutorFile(toolName: string): GeneratedFile {
 export function generateMultiTargetExecutorFile(
   toolName: string,
   targets: MultiTargetExecutorInput[],
+  options?: ExecutorOptions,
 ): GeneratedFile {
   const statements: t.Statement[] = [];
 
+  // Import localhost adapter first (side-effect import patches globalThis.fetch)
+  if (options?.localhostAdapter) {
+    statements.push(
+      t.importDeclaration([], t.stringLiteral('./localhost-fetch')),
+    );
+  }
+
   statements.push(
     createImportDeclaration('appstash', ['createConfigStore']),
   );

graphql/codegen/src/core/codegen/cli/index.ts

@@ -1,5 +1,5 @@
 import type { BuiltinNames, GraphQLSDKConfigTarget } from '../../../types/config';
-import type { CleanOperation, CleanTable } from '../../../types/schema';
+import type { CleanOperation, CleanTable, TypeRegistry } from '../../../types/schema';
 import { generateCommandMap, generateMultiTargetCommandMap } from './command-map-generator';
 import { generateCustomCommand } from './custom-command-generator';
 import { generateExecutorFile, generateMultiTargetExecutorFile } from './executor-generator';
@@ -11,7 +11,7 @@ import {
   generateMultiTargetContextCommand,
 } from './infra-generator';
 import { generateTableCommand } from './table-command-generator';
-import { generateUtilsFile } from './utils-generator';
+import { generateUtilsFile, generateLocalhostFetchFile } from './utils-generator';
 
 export interface GenerateCliOptions {
   tables: CleanTable[];
@@ -20,6 +20,8 @@ export interface GenerateCliOptions {
     mutations: CleanOperation[];
   };
   config: GraphQLSDKConfigTarget;
+  /** TypeRegistry from introspection, used to check field defaults */
+  typeRegistry?: TypeRegistry;
 }
 
 export interface GenerateCliResult {
@@ -43,20 +45,29 @@ export function generateCli(options: GenerateCliOptions): GenerateCliResult {
       ? cliConfig.toolName
       : 'app';
 
-  const executorFile = generateExecutorFile(toolName);
+  const useLocalhostAdapter = typeof cliConfig === 'object' && !!cliConfig.localhostAdapter;
+
+  const executorFile = generateExecutorFile(toolName, { localhostAdapter: useLocalhostAdapter });
   files.push(executorFile);
 
   const utilsFile = generateUtilsFile();
   files.push(utilsFile);
 
+  // Generate localhost adapter if configured
+  if (useLocalhostAdapter) {
+    files.push(generateLocalhostFetchFile());
+  }
+
   const contextFile = generateContextCommand(toolName);
   files.push(contextFile);
 
   const authFile = generateAuthCommand(toolName);
   files.push(authFile);
 
   for (const table of tables) {
-    const tableFile = generateTableCommand(table);
+    const tableFile = generateTableCommand(table, {
+      typeRegistry: options.typeRegistry,
+    });
     files.push(tableFile);
   }
 
@@ -99,12 +110,16 @@ export interface MultiTargetCliTarget {
     mutations: CleanOperation[];
   };
   isAuthTarget?: boolean;
+  /** TypeRegistry from introspection, used to check field defaults */
+  typeRegistry?: TypeRegistry;
 }
 
 export interface GenerateMultiTargetCliOptions {
   toolName: string;
   builtinNames?: BuiltinNames;
   targets: MultiTargetCliTarget[];
+  /** Enable localhost fetch adapter for *.localhost subdomain routing */
+  localhostAdapter?: boolean;
 }
 
 export function resolveBuiltinNames(
@@ -138,12 +153,19 @@ export function generateMultiTargetCli(
     endpoint: t.endpoint,
     ormImportPath: t.ormImportPath,
   }));
-  const executorFile = generateMultiTargetExecutorFile(toolName, executorInputs);
+  const executorFile = generateMultiTargetExecutorFile(toolName, executorInputs, {
+    localhostAdapter: !!options.localhostAdapter,
+  });
   files.push(executorFile);
 
   const utilsFile = generateUtilsFile();
   files.push(utilsFile);
 
+  // Generate localhost adapter if configured
+  if (options.localhostAdapter) {
+    files.push(generateLocalhostFetchFile());
+  }
+
   const contextFile = generateMultiTargetContextCommand(
     toolName,
     builtinNames.context,
@@ -174,6 +196,7 @@ export function generateMultiTargetCli(
       const tableFile = generateTableCommand(table, {
         targetName: target.name,
         executorImportPath: '../../executor',
+        typeRegistry: target.typeRegistry,
       });
       files.push(tableFile);
     }

graphql/codegen/src/core/codegen/cli/table-command-generator.ts

@@ -9,8 +9,9 @@ import {
   getTableNames,
   ucFirst,
 } from '../utils';
-import type { CleanTable } from '../../../types/schema';
+import type { CleanTable, TypeRegistry } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
+import { getCreateInputTypeName } from '../utils';
 
 function createImportDeclaration(
   moduleSpecifier: string,
@@ -334,10 +335,55 @@ function buildGetHandler(table: CleanTable, targetName?: string): t.FunctionDecl
   );
 }
 
+/**
+ * Get the set of field names that have defaults in the create input type.
+ * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
+ * TypeRegistry and checks each field's defaultValue from introspection.
+ */
+function getFieldsWithDefaults(
+  table: CleanTable,
+  typeRegistry?: TypeRegistry,
+): Set<string> {
+  const fieldsWithDefaults = new Set<string>();
+  if (!typeRegistry) return fieldsWithDefaults;
+
+  // Look up the CreateXInput type (e.g. CreateDatabaseInput)
+  const createInputTypeName = 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)
+    const innerTypeName = inputField.type.name
+      || inputField.type.ofType?.name
+      || inputField.type.ofType?.ofType?.name;
+    if (!innerTypeName) continue;
+
+    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);
+      }
+    }
+  }
+
+  return fieldsWithDefaults;
+}
+
 function buildMutationHandler(
   table: CleanTable,
   operation: 'create' | 'update' | 'delete',
   targetName?: string,
+  typeRegistry?: TypeRegistry,
 ): t.FunctionDeclaration {
   const { singularName } = getTableNames(table);
   const pkFields = getPrimaryKeyInfo(table);
@@ -351,6 +397,9 @@ function buildMutationHandler(
       f.name !== 'updatedAt',
   );
 
+  // Get fields that have defaults from introspection (for create operations)
+  const fieldsWithDefaults = getFieldsWithDefaults(table, typeRegistry);
+
   const questions: t.Expression[] = [];
 
   if (operation === 'update' || operation === 'delete') {
@@ -366,6 +415,9 @@ function buildMutationHandler(
 
   if (operation !== 'delete') {
     for (const field of editableFields) {
+      // 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')),
@@ -379,7 +431,7 @@ function buildMutationHandler(
           ),
           t.objectProperty(
             t.identifier('required'),
-            t.booleanLiteral(operation === 'create'),
+            t.booleanLiteral(isRequired),
           ),
         ]),
       );
@@ -530,6 +582,8 @@ function buildMutationHandler(
 export interface TableCommandOptions {
   targetName?: string;
   executorImportPath?: string;
+  /** TypeRegistry from introspection, used to check field defaults */
+  typeRegistry?: TypeRegistry;
 }
 
 export function generateTableCommand(table: CleanTable, options?: TableCommandOptions): GeneratedFile {
@@ -741,9 +795,9 @@ export function generateTableCommand(table: CleanTable, options?: TableCommandOp
   const tn = options?.targetName;
   statements.push(buildListHandler(table, tn));
   statements.push(buildGetHandler(table, tn));
-  statements.push(buildMutationHandler(table, 'create', tn));
-  statements.push(buildMutationHandler(table, 'update', tn));
-  statements.push(buildMutationHandler(table, 'delete', 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));
 
   const header = getGeneratedFileHeader(`CLI commands for ${table.name}`);
   const code = generateCode(statements);

graphql/codegen/src/core/codegen/cli/utils-generator.ts

@@ -59,3 +59,20 @@ export function generateUtilsFile(): GeneratedFile {
     ),
   };
 }
+
+/**
+ * Generate a localhost-fetch.ts file that patches globalThis.fetch for *.localhost URLs.
+ * This enables seamless local development with subdomain routing (e.g. auth.localhost:3000).
+ *
+ * Node.js cannot resolve *.localhost subdomains and the Fetch API forbids the Host header.
+ * This adapter uses node:http.request to proxy requests with proper Host headers.
+ */
+export function generateLocalhostFetchFile(): GeneratedFile {
+  return {
+    fileName: 'localhost-fetch.ts',
+    content: readTemplateFile(
+      'localhost-fetch.ts',
+      'Localhost fetch adapter — patches globalThis.fetch for *.localhost subdomain routing',
+    ),
+  };
+}