@constructive-io/graphql-codegen 4.0.2 → 4.1.1

package/esm/cli/handler.js

@@ -0,0 +1,71 @@
+import { findConfigFile, loadConfigFile } from '../core/config';
+import { expandApiNamesToMultiTarget, expandSchemaDirToMultiTarget, generate, generateMulti } from '../core/generate';
+import { buildDbConfig, buildGenerateOptions, camelizeArgv, codegenQuestions, hasResolvedCodegenSource, normalizeCodegenListOptions, printResult, seedArgvFromConfig, } from './shared';
+export async function runCodegenHandler(argv, prompter) {
+    const args = camelizeArgv(argv);
+    const schemaOnly = Boolean(args.schemaOnly);
+    const hasSourceFlags = Boolean(args.endpoint || args.schemaFile || args.schemaDir || args.schemas || args.apiNames);
+    const configPath = args.config ||
+        (!hasSourceFlags ? findConfigFile() : undefined);
+    const targetName = args.target;
+    let fileConfig = {};
+    if (configPath) {
+        const loaded = await loadConfigFile(configPath);
+        if (!loaded.success) {
+            console.error('x', loaded.error);
+            process.exit(1);
+        }
+        const config = loaded.config;
+        const isMulti = !('endpoint' in config ||
+            'schemaFile' in config ||
+            'schemaDir' in config ||
+            'db' in config);
+        if (isMulti) {
+            const targets = config;
+            if (targetName && !targets[targetName]) {
+                console.error('x', `Target "${targetName}" not found. Available: ${Object.keys(targets).join(', ')}`);
+                process.exit(1);
+            }
+            const cliOptions = buildDbConfig(normalizeCodegenListOptions(args));
+            const selectedTargets = targetName
+                ? { [targetName]: targets[targetName] }
+                : targets;
+            const { results, hasError } = await generateMulti({
+                configs: selectedTargets,
+                cliOverrides: cliOptions,
+                schemaOnly,
+            });
+            for (const { name, result } of results) {
+                console.log(`\n[${name}]`);
+                printResult(result);
+            }
+            if (hasError)
+                process.exit(1);
+            return;
+        }
+        fileConfig = config;
+    }
+    const seeded = seedArgvFromConfig(args, fileConfig);
+    const answers = hasResolvedCodegenSource(seeded)
+        ? seeded
+        : await prompter.prompt(seeded, codegenQuestions);
+    const options = buildGenerateOptions(answers, fileConfig);
+    const expandedApi = expandApiNamesToMultiTarget(options);
+    const expandedDir = expandSchemaDirToMultiTarget(options);
+    const expanded = expandedApi || expandedDir;
+    if (expanded) {
+        const { results, hasError } = await generateMulti({
+            configs: expanded,
+            schemaOnly,
+        });
+        for (const { name, result } of results) {
+            console.log(`\n[${name}]`);
+            printResult(result);
+        }
+        if (hasError)
+            process.exit(1);
+        return;
+    }
+    const result = await generate({ ...options, schemaOnly });
+    printResult(result);
+}

package/esm/cli/index.js

@@ -6,10 +6,7 @@
  * All business logic is in the core modules.
  */
 import { CLI, getPackageJson } from 'inquirerer';
-import { findConfigFile, loadConfigFile } from '../core/config';
-import { generate } from '../core/generate';
-import { mergeConfig } from '../types/config';
-import { buildDbConfig, buildGenerateOptions, camelizeArgv, codegenQuestions, hasResolvedCodegenSource, normalizeCodegenListOptions, printResult, seedArgvFromConfig, } from './shared';
+import { runCodegenHandler } from './handler';
 const usage = `
 graphql-codegen - GraphQL SDK generator for Constructive databases
 
@@ -20,10 +17,12 @@ Source Options (choose one):
   -c, --config <path>           Path to config file
   -e, --endpoint <url>          GraphQL endpoint URL
   -s, --schema-file <path>      Path to GraphQL schema file
+  --schema-dir <dir>            Directory of .graphql files (auto-expands to multi-target)
 
 Database Options:
   --schemas <list>              Comma-separated PostgreSQL schemas
   --api-names <list>            Comma-separated API names (mutually exclusive with --schemas)
+                                Multiple apiNames auto-expand to multi-target (one schema per API).
 
 Generator Options:
   --react-query                 Generate React Query hooks
@@ -34,6 +33,11 @@ Generator Options:
   --dry-run                     Preview without writing files
   -v, --verbose                 Show detailed output
 
+Schema Export:
+  --schema-only                 Export GraphQL SDL instead of running full codegen.
+                                Works with any source (endpoint, file, database, PGPM).
+                                With multiple apiNames, writes one .graphql per API.
+
   -h, --help                    Show this help message
   --version                     Show version number
 `;
@@ -47,56 +51,7 @@ export const commands = async (argv, prompter, _options) => {
         console.log(usage);
         process.exit(0);
     }
-    const hasSourceFlags = Boolean(argv.endpoint ||
-        argv.e ||
-        argv['schema-file'] ||
-        argv.s ||
-        argv.schemas ||
-        argv['api-names']);
-    const explicitConfigPath = (argv.config || argv.c);
-    const configPath = explicitConfigPath || (!hasSourceFlags ? findConfigFile() : undefined);
-    const targetName = (argv.target || argv.t);
-    let fileConfig = {};
-    if (configPath) {
-        const loaded = await loadConfigFile(configPath);
-        if (!loaded.success) {
-            console.error('x', loaded.error);
-            process.exit(1);
-        }
-        const config = loaded.config;
-        const isMulti = !('endpoint' in config ||
-            'schemaFile' in config ||
-            'db' in config);
-        if (isMulti) {
-            const targets = config;
-            const names = targetName ? [targetName] : Object.keys(targets);
-            if (targetName && !targets[targetName]) {
-                console.error('x', `Target "${targetName}" not found. Available: ${Object.keys(targets).join(', ')}`);
-                process.exit(1);
-            }
-            const cliOptions = buildDbConfig(normalizeCodegenListOptions(camelizeArgv(argv)));
-            let hasError = false;
-            for (const name of names) {
-                console.log(`\n[${name}]`);
-                const result = await generate(mergeConfig(targets[name], cliOptions));
-                printResult(result);
-                if (!result.success)
-                    hasError = true;
-            }
-            prompter.close();
-            if (hasError)
-                process.exit(1);
-            return argv;
-        }
-        fileConfig = config;
-    }
-    const seeded = seedArgvFromConfig(argv, fileConfig);
-    const answers = hasResolvedCodegenSource(seeded)
-        ? seeded
-        : await prompter.prompt(seeded, codegenQuestions);
-    const options = buildGenerateOptions(answers, fileConfig);
-    const result = await generate(options);
-    printResult(result);
+    await runCodegenHandler(argv, prompter);
     prompter.close();
     return argv;
 };
@@ -112,16 +67,15 @@ export const options = {
             a: 'authorization',
             v: 'verbose',
         },
+        boolean: ['schema-only'],
         string: [
             'config',
             'endpoint',
             'schema-file',
+            'schema-dir',
             'output',
             'target',
             'authorization',
-            'pgpm-module-path',
-            'pgpm-workspace-path',
-            'pgpm-module-name',
             'schemas',
             'api-names',
         ],

package/esm/core/codegen/barrel.d.ts

@@ -27,6 +27,7 @@ export interface RootBarrelOptions {
     hasTypes?: boolean;
     hasHooks?: boolean;
     hasOrm?: boolean;
+    hasCli?: boolean;
 }
 /**
  * Generate the root index.ts barrel file for the output directory.

package/esm/core/codegen/barrel.js

@@ -135,7 +135,7 @@ export function generateMainBarrel(tables, options = {}) {
  * Re-exports from subdirectories based on which generators are enabled.
  */
 export function generateRootBarrel(options = {}) {
-    const { hasTypes = false, hasHooks = false, hasOrm = false } = options;
+    const { hasTypes = false, hasHooks = false, hasOrm = false, hasCli = false } = options;
     const statements = [];
     if (hasTypes) {
         statements.push(exportAllFrom('./types'));
@@ -146,7 +146,10 @@ export function generateRootBarrel(options = {}) {
     if (hasOrm) {
         statements.push(exportAllFrom('./orm'));
     }
-    // Add file header as leading comment on first statement
+    if (hasCli) {
+        statements.push(exportAllFrom('./cli'));
+    }
+    // Add file headeras leading comment on first statement
     if (statements.length > 0) {
         addJSDocComment(statements[0], [
             'Generated SDK - auto-generated, do not edit',

package/esm/core/codegen/cli/arg-mapper.d.ts

@@ -0,0 +1,4 @@
+import * as t from '@babel/types';
+import type { CleanArgument } from '../../../types/schema';
+export declare function buildQuestionObject(arg: CleanArgument): t.ObjectExpression;
+export declare function buildQuestionsArray(args: CleanArgument[]): t.ArrayExpression;

package/esm/core/codegen/cli/arg-mapper.js

@@ -0,0 +1,80 @@
+import * as t from '@babel/types';
+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;
+}
+export function buildQuestionObject(arg) {
+    const { inner, required } = unwrapNonNull(arg.type);
+    const base = resolveBaseType(arg.type);
+    const props = [];
+    if (base.kind === 'ENUM' && base.enumValues && base.enumValues.length > 0) {
+        props.push(t.objectProperty(t.identifier('type'), t.stringLiteral('autocomplete')));
+        props.push(t.objectProperty(t.identifier('name'), t.stringLiteral(arg.name)));
+        props.push(t.objectProperty(t.identifier('message'), t.stringLiteral(arg.description || arg.name)));
+        props.push(t.objectProperty(t.identifier('options'), t.arrayExpression(base.enumValues.map((v) => t.stringLiteral(v)))));
+    }
+    else if (base.kind === 'SCALAR' && base.name === 'Boolean') {
+        props.push(t.objectProperty(t.identifier('type'), t.stringLiteral('confirm')));
+        props.push(t.objectProperty(t.identifier('name'), t.stringLiteral(arg.name)));
+        props.push(t.objectProperty(t.identifier('message'), t.stringLiteral(arg.description || arg.name)));
+        props.push(t.objectProperty(t.identifier('default'), t.booleanLiteral(false)));
+    }
+    else if (base.kind === 'SCALAR' &&
+        (base.name === 'Int' || base.name === 'Float')) {
+        props.push(t.objectProperty(t.identifier('type'), t.stringLiteral('text')));
+        props.push(t.objectProperty(t.identifier('name'), t.stringLiteral(arg.name)));
+        props.push(t.objectProperty(t.identifier('message'), t.stringLiteral(arg.description || `${arg.name} (number)`)));
+    }
+    else if (inner.kind === 'INPUT_OBJECT' && inner.inputFields) {
+        return buildInputObjectQuestion(arg.name, inner, required);
+    }
+    else {
+        props.push(t.objectProperty(t.identifier('type'), t.stringLiteral('text')));
+        props.push(t.objectProperty(t.identifier('name'), t.stringLiteral(arg.name)));
+        props.push(t.objectProperty(t.identifier('message'), t.stringLiteral(arg.description || arg.name)));
+    }
+    if (required) {
+        props.push(t.objectProperty(t.identifier('required'), t.booleanLiteral(true)));
+    }
+    return t.objectExpression(props);
+}
+function buildInputObjectQuestion(_name, typeRef, _required) {
+    if (typeRef.inputFields && typeRef.inputFields.length > 0) {
+        const firstField = typeRef.inputFields[0];
+        return buildQuestionObject(firstField);
+    }
+    return t.objectExpression([
+        t.objectProperty(t.identifier('type'), t.stringLiteral('text')),
+        t.objectProperty(t.identifier('name'), t.stringLiteral(_name)),
+        t.objectProperty(t.identifier('message'), t.stringLiteral(_name)),
+    ]);
+}
+export function buildQuestionsArray(args) {
+    const questions = [];
+    for (const arg of args) {
+        const base = resolveBaseType(arg.type);
+        const { inner } = unwrapNonNull(arg.type);
+        if (inner.kind === 'INPUT_OBJECT' && inner.inputFields) {
+            for (const field of inner.inputFields) {
+                questions.push(buildQuestionObject(field));
+            }
+        }
+        else if (base.kind === 'INPUT_OBJECT' && base.inputFields) {
+            for (const field of base.inputFields) {
+                questions.push(buildQuestionObject(field));
+            }
+        }
+        else {
+            questions.push(buildQuestionObject(arg));
+        }
+    }
+    return t.arrayExpression(questions);
+}

package/esm/core/codegen/cli/command-map-generator.d.ts

@@ -0,0 +1,16 @@
+import type { CleanTable, CleanOperation } from '../../../types/schema';
+import type { GeneratedFile } from './executor-generator';
+export declare function generateCommandMap(tables: CleanTable[], customOperations: CleanOperation[], toolName: string): GeneratedFile;
+export interface MultiTargetCommandMapInput {
+    toolName: string;
+    builtinNames: {
+        auth: string;
+        context: string;
+    };
+    targets: Array<{
+        name: string;
+        tables: CleanTable[];
+        customOperations: CleanOperation[];
+    }>;
+}
+export declare function generateMultiTargetCommandMap(input: MultiTargetCommandMapInput): GeneratedFile;

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

@@ -0,0 +1,301 @@
+import * as t from '@babel/types';
+import { toKebabCase } from 'komoji';
+import { generateCode } from '../babel-ast';
+import { getGeneratedFileHeader, getTableNames } from '../utils';
+function createImportDeclaration(moduleSpecifier, defaultImportName) {
+    return t.importDeclaration([t.importDefaultSpecifier(t.identifier(defaultImportName))], t.stringLiteral(moduleSpecifier));
+}
+function createNamedImportDeclaration(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));
+    decl.importKind = typeOnly ? 'type' : 'value';
+    return decl;
+}
+export function generateCommandMap(tables, customOperations, toolName) {
+    const statements = [];
+    statements.push(createNamedImportDeclaration('inquirerer', [
+        'CLIOptions',
+        'Inquirerer',
+        'extractFirst',
+    ]));
+    const commandEntries = [];
+    commandEntries.push({ kebab: 'context', importName: 'contextCmd' });
+    statements.push(createImportDeclaration('./commands/context', 'contextCmd'));
+    commandEntries.push({ kebab: 'auth', importName: 'authCmd' });
+    statements.push(createImportDeclaration('./commands/auth', 'authCmd'));
+    for (const table of tables) {
+        const { singularName } = getTableNames(table);
+        const kebab = toKebabCase(singularName);
+        const importName = `${singularName}Cmd`;
+        commandEntries.push({ kebab, importName });
+        statements.push(createImportDeclaration(`./commands/${kebab}`, importName));
+    }
+    for (const op of customOperations) {
+        const kebab = toKebabCase(op.name);
+        const importName = `${op.name}Cmd`;
+        commandEntries.push({ kebab, importName });
+        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())),
+    ])));
+    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())),
+    ]))))));
+    statements.push(createCommandMapFunc);
+    const usageLines = [
+        '',
+        `${toolName} <command>`,
+        '',
+        'Commands:',
+        '  context               Manage API contexts',
+        '  auth                  Manage authentication',
+    ];
+    for (const table of tables) {
+        const { singularName } = getTableNames(table);
+        const kebab = toKebabCase(singularName);
+        usageLines.push(`  ${kebab.padEnd(20)} ${singularName} CRUD operations`);
+    }
+    for (const op of customOperations) {
+        const kebab = toKebabCase(op.name);
+        usageLines.push(`  ${kebab.padEnd(20)} ${op.description || op.name}`);
+    }
+    usageLines.push('');
+    usageLines.push('  --help, -h            Show this help message');
+    usageLines.push('  --version, -v         Show version');
+    usageLines.push('');
+    statements.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('usage'), t.stringLiteral(usageLines.join('\n'))),
+    ]));
+    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')));
+    const commandsBody = [
+        t.ifStatement(t.logicalExpression('||', t.memberExpression(t.identifier('argv'), t.identifier('help')), t.memberExpression(t.identifier('argv'), t.identifier('h'))), t.blockStatement([
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('console'), t.identifier('log')), [t.identifier('usage')])),
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('process'), t.identifier('exit')), [t.numericLiteral(0)])),
+        ])),
+        t.variableDeclaration('let', [
+            t.variableDeclarator(t.objectPattern([
+                t.objectProperty(t.identifier('first'), t.identifier('command')),
+                t.objectProperty(t.identifier('newArgv'), t.identifier('newArgv'), false, true),
+            ]), t.callExpression(t.identifier('extractFirst'), [
+                t.identifier('argv'),
+            ])),
+        ]),
+        t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier('commandMap'), t.callExpression(t.identifier('createCommandMap'), [])),
+        ]),
+        t.ifStatement(t.unaryExpression('!', t.identifier('command')), t.blockStatement([
+            t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier('answer'), t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('prompter'), t.identifier('prompt')), [
+                    t.identifier('argv'),
+                    t.arrayExpression([
+                        t.objectExpression([
+                            t.objectProperty(t.identifier('type'), t.stringLiteral('autocomplete')),
+                            t.objectProperty(t.identifier('name'), t.stringLiteral('command')),
+                            t.objectProperty(t.identifier('message'), t.stringLiteral('What do you want to do?')),
+                            t.objectProperty(t.identifier('options'), t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('keys')), [t.identifier('commandMap')])),
+                        ]),
+                    ]),
+                ]))),
+            ]),
+            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.memberExpression(t.identifier('answer'), t.identifier('command')))),
+        ])),
+        t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier('commandFn'), t.memberExpression(t.identifier('commandMap'), t.identifier('command'), true)),
+        ]),
+        t.ifStatement(t.unaryExpression('!', t.identifier('commandFn')), t.blockStatement([
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('console'), t.identifier('log')), [t.identifier('usage')])),
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('console'), t.identifier('error')), [
+                t.templateLiteral([
+                    t.templateElement({
+                        raw: 'Unknown command: ',
+                        cooked: 'Unknown command: ',
+                    }),
+                    t.templateElement({ raw: '', cooked: '' }, true),
+                ], [t.identifier('command')]),
+            ])),
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('process'), t.identifier('exit')), [t.numericLiteral(1)])),
+        ])),
+        t.expressionStatement(t.awaitExpression(t.callExpression(t.identifier('commandFn'), [
+            t.identifier('newArgv'),
+            t.identifier('prompter'),
+            t.identifier('options'),
+        ]))),
+        t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('prompter'), t.identifier('close')), [])),
+        t.returnStatement(t.identifier('argv')),
+    ];
+    const commandsFunc = t.arrowFunctionExpression([argvParam, prompterParam, optionsParam], t.blockStatement(commandsBody), true);
+    const commandsDecl = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('commands'), commandsFunc),
+    ]);
+    statements.push(t.exportNamedDeclaration(commandsDecl));
+    const header = getGeneratedFileHeader('CLI command map and entry point');
+    const code = generateCode(statements);
+    return {
+        fileName: 'commands.ts',
+        content: header + '\n' + code,
+    };
+}
+export function generateMultiTargetCommandMap(input) {
+    const { toolName, builtinNames, targets } = input;
+    const statements = [];
+    statements.push(createNamedImportDeclaration('inquirerer', [
+        'CLIOptions',
+        'Inquirerer',
+        'extractFirst',
+    ]));
+    const commandEntries = [];
+    const contextImportName = `${builtinNames.context}Cmd`;
+    commandEntries.push({ kebab: builtinNames.context, importName: contextImportName });
+    statements.push(createImportDeclaration(`./commands/${builtinNames.context}`, contextImportName));
+    const authImportName = `${builtinNames.auth}Cmd`;
+    commandEntries.push({ kebab: builtinNames.auth, importName: authImportName });
+    statements.push(createImportDeclaration(`./commands/${builtinNames.auth}`, authImportName));
+    for (const target of targets) {
+        for (const table of target.tables) {
+            const { singularName } = getTableNames(table);
+            const kebab = toKebabCase(singularName);
+            const prefixedKebab = `${target.name}:${kebab}`;
+            const importName = `${target.name}${singularName[0].toUpperCase()}${singularName.slice(1)}Cmd`;
+            commandEntries.push({ kebab: prefixedKebab, importName });
+            statements.push(createImportDeclaration(`./commands/${target.name}/${kebab}`, importName));
+        }
+        for (const op of target.customOperations) {
+            const kebab = toKebabCase(op.name);
+            const prefixedKebab = `${target.name}:${kebab}`;
+            const importName = `${target.name}${op.name[0].toUpperCase()}${op.name.slice(1)}Cmd`;
+            commandEntries.push({ kebab: prefixedKebab, importName });
+            statements.push(createImportDeclaration(`./commands/${target.name}/${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))),
+    ]);
+    statements.push(createCommandMapFunc);
+    const usageLines = [
+        '',
+        `${toolName} <command>`,
+        '',
+        'Commands:',
+        `  ${builtinNames.context.padEnd(20)} Manage API contexts`,
+        `  ${builtinNames.auth.padEnd(20)} Manage authentication`,
+    ];
+    for (const target of targets) {
+        usageLines.push('');
+        usageLines.push(`  ${target.name}:`);
+        for (const table of target.tables) {
+            const { singularName } = getTableNames(table);
+            const kebab = toKebabCase(singularName);
+            const cmd = `${target.name}:${kebab}`;
+            usageLines.push(`    ${cmd.padEnd(22)} ${singularName} CRUD operations`);
+        }
+        for (const op of target.customOperations) {
+            const kebab = toKebabCase(op.name);
+            const cmd = `${target.name}:${kebab}`;
+            usageLines.push(`    ${cmd.padEnd(22)} ${op.description || op.name}`);
+        }
+    }
+    usageLines.push('');
+    usageLines.push('  --help, -h            Show this help message');
+    usageLines.push('  --version, -v         Show version');
+    usageLines.push('');
+    statements.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('usage'), t.stringLiteral(usageLines.join('\n'))),
+    ]));
+    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')));
+    const commandsBody = [
+        t.ifStatement(t.logicalExpression('||', t.memberExpression(t.identifier('argv'), t.identifier('help')), t.memberExpression(t.identifier('argv'), t.identifier('h'))), t.blockStatement([
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('console'), t.identifier('log')), [t.identifier('usage')])),
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('process'), t.identifier('exit')), [t.numericLiteral(0)])),
+        ])),
+        t.variableDeclaration('let', [
+            t.variableDeclarator(t.objectPattern([
+                t.objectProperty(t.identifier('first'), t.identifier('command')),
+                t.objectProperty(t.identifier('newArgv'), t.identifier('newArgv'), false, true),
+            ]), t.callExpression(t.identifier('extractFirst'), [
+                t.identifier('argv'),
+            ])),
+        ]),
+        t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier('commandMap'), t.callExpression(t.identifier('createCommandMap'), [])),
+        ]),
+        t.ifStatement(t.unaryExpression('!', t.identifier('command')), t.blockStatement([
+            t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier('answer'), t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('prompter'), t.identifier('prompt')), [
+                    t.identifier('argv'),
+                    t.arrayExpression([
+                        t.objectExpression([
+                            t.objectProperty(t.identifier('type'), t.stringLiteral('autocomplete')),
+                            t.objectProperty(t.identifier('name'), t.stringLiteral('command')),
+                            t.objectProperty(t.identifier('message'), t.stringLiteral('What do you want to do?')),
+                            t.objectProperty(t.identifier('options'), t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('keys')), [t.identifier('commandMap')])),
+                        ]),
+                    ]),
+                ]))),
+            ]),
+            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.memberExpression(t.identifier('answer'), t.identifier('command')))),
+        ])),
+        t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier('commandFn'), t.memberExpression(t.identifier('commandMap'), t.identifier('command'), true)),
+        ]),
+        t.ifStatement(t.unaryExpression('!', t.identifier('commandFn')), t.blockStatement([
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('console'), t.identifier('log')), [t.identifier('usage')])),
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('console'), t.identifier('error')), [
+                t.templateLiteral([
+                    t.templateElement({
+                        raw: 'Unknown command: ',
+                        cooked: 'Unknown command: ',
+                    }),
+                    t.templateElement({ raw: '', cooked: '' }, true),
+                ], [t.identifier('command')]),
+            ])),
+            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('process'), t.identifier('exit')), [t.numericLiteral(1)])),
+        ])),
+        t.expressionStatement(t.awaitExpression(t.callExpression(t.identifier('commandFn'), [
+            t.identifier('newArgv'),
+            t.identifier('prompter'),
+            t.identifier('options'),
+        ]))),
+        t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('prompter'), t.identifier('close')), [])),
+        t.returnStatement(t.identifier('argv')),
+    ];
+    const commandsFunc = t.arrowFunctionExpression([argvParam, prompterParam, optionsParam], t.blockStatement(commandsBody), true);
+    const commandsDecl = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('commands'), commandsFunc),
+    ]);
+    statements.push(t.exportNamedDeclaration(commandsDecl));
+    const header = getGeneratedFileHeader('Multi-target CLI command map and entry point');
+    const code = generateCode(statements);
+    return {
+        fileName: 'commands.ts',
+        content: header + '\n' + code,
+    };
+}

package/esm/core/codegen/cli/custom-command-generator.d.ts

@@ -0,0 +1,8 @@
+import type { CleanOperation } from '../../../types/schema';
+import type { GeneratedFile } from './executor-generator';
+export interface CustomCommandOptions {
+    targetName?: string;
+    executorImportPath?: string;
+    saveToken?: boolean;
+}
+export declare function generateCustomCommand(op: CleanOperation, options?: CustomCommandOptions): GeneratedFile;