@constructive-io/graphql-codegen 4.12.2 → 4.13.1

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

@@ -25,6 +25,7 @@ export function generateReadme(tables, customOperations, toolName, registry) {
     lines.push('|---------|-------------|');
     lines.push('| `context` | Manage API contexts (endpoints) |');
     lines.push('| `auth` | Manage authentication tokens |');
+    lines.push('| `config` | Manage config key-value store (per-context) |');
     for (const table of tables) {
         const { singularName } = getTableNames(table);
         const kebab = toKebabCase(singularName);
@@ -61,6 +62,19 @@ export function generateReadme(tables, customOperations, toolName, registry) {
     lines.push('| `status` | Show auth status across all contexts |');
     lines.push('| `logout` | Remove credentials for current context |');
     lines.push('');
+    lines.push('### `config`');
+    lines.push('');
+    lines.push('Manage per-context key-value configuration variables.');
+    lines.push('');
+    lines.push('| Subcommand | Description |');
+    lines.push('|------------|-------------|');
+    lines.push('| `get <key>` | Get a config value |');
+    lines.push('| `set <key> <value>` | Set a config value |');
+    lines.push('| `list` | List all config values |');
+    lines.push('| `delete <key>` | Delete a config value |');
+    lines.push('');
+    lines.push(`Variables are scoped to the active context and stored at \`~/.${toolName}/config/\`.`);
+    lines.push('');
     if (tables.length > 0) {
         lines.push('## Table Commands');
         lines.push('');
@@ -221,6 +235,28 @@ export function generateAgentsDocs(tables, customOperations, toolName, registry)
     lines.push('  logout:    { context, status: "logged out" }');
     lines.push('```');
     lines.push('');
+    lines.push('### TOOL: config');
+    lines.push('');
+    lines.push('Manage per-context key-value configuration variables.');
+    lines.push('');
+    lines.push('```');
+    lines.push('SUBCOMMANDS:');
+    lines.push(`  ${toolName} config get <key>             Get a config value`);
+    lines.push(`  ${toolName} config set <key> <value>     Set a config value`);
+    lines.push(`  ${toolName} config list                  List all config values`);
+    lines.push(`  ${toolName} config delete <key>          Delete a config value`);
+    lines.push('');
+    lines.push('INPUT:');
+    lines.push('  key:   string (required for get/set/delete) - Variable name');
+    lines.push('  value: string (required for set) - Variable value');
+    lines.push('');
+    lines.push('OUTPUT: JSON');
+    lines.push('  get:    { key, value }');
+    lines.push('  set:    { key, value }');
+    lines.push('  list:   { vars: { key: value, ... } }');
+    lines.push('  delete: { deleted: key }');
+    lines.push('```');
+    lines.push('');
     for (const table of tables) {
         const { singularName } = getTableNames(table);
         const kebab = toKebabCase(singularName);
@@ -428,6 +464,45 @@ export function getCliMcpTools(tables, customOperations, toolName, registry) {
         description: 'Remove credentials for the current context',
         inputSchema: { type: 'object', properties: {} },
     });
+    tools.push({
+        name: `${toolName}_config_get`,
+        description: 'Get a config variable value for the current context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Variable name' },
+            },
+            required: ['key'],
+        },
+    });
+    tools.push({
+        name: `${toolName}_config_set`,
+        description: 'Set a config variable value for the current context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Variable name' },
+                value: { type: 'string', description: 'Variable value' },
+            },
+            required: ['key', 'value'],
+        },
+    });
+    tools.push({
+        name: `${toolName}_config_list`,
+        description: 'List all config variables for the current context',
+        inputSchema: { type: 'object', properties: {} },
+    });
+    tools.push({
+        name: `${toolName}_config_delete`,
+        description: 'Delete a config variable for the current context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Variable name to delete' },
+            },
+            required: ['key'],
+        },
+    });
     for (const table of tables) {
         const { singularName } = getTableNames(table);
         const kebab = toKebabCase(singularName);
@@ -605,6 +680,34 @@ export function generateSkills(tables, customOperations, toolName, targetName, r
             ],
         }),
     });
+    // Config reference
+    referenceNames.push('config');
+    files.push({
+        fileName: `${skillName}/references/config.md`,
+        content: buildSkillReference({
+            title: 'Config Variables',
+            description: `Manage per-context key-value configuration variables for ${toolName}`,
+            usage: [
+                `${toolName} config get <key>`,
+                `${toolName} config set <key> <value>`,
+                `${toolName} config list`,
+                `${toolName} config delete <key>`,
+            ],
+            examples: [
+                {
+                    description: 'Store and retrieve a config variable',
+                    code: [
+                        `${toolName} config set orgId abc-123`,
+                        `${toolName} config get orgId`,
+                    ],
+                },
+                {
+                    description: 'List all config variables',
+                    code: [`${toolName} config list`],
+                },
+            ],
+        }),
+    });
     // Table references
     for (const table of tables) {
         const { singularName } = getTableNames(table);
@@ -686,6 +789,10 @@ export function generateSkills(tables, customOperations, toolName, targetName, r
                 `# Authentication`,
                 `${toolName} auth set-token <token>`,
                 '',
+                `# Config variables`,
+                `${toolName} config set <key> <value>`,
+                `${toolName} config get <key>`,
+                '',
                 `# CRUD for any table (e.g. ${tableKebabs[0] || 'model'})`,
                 `${toolName} ${tableKebabs[0] || 'model'} list`,
                 `${toolName} ${tableKebabs[0] || 'model'} get --id <value>`,
@@ -781,6 +888,7 @@ export function generateMultiTargetReadme(input) {
     lines.push('|---------|-------------|');
     lines.push(`| \`${builtinNames.context}\` | Manage API contexts (per-target endpoints) |`);
     lines.push(`| \`${builtinNames.auth}\` | Manage authentication tokens |`);
+    lines.push(`| \`${builtinNames.config}\` | Manage config key-value store (per-context) |`);
     lines.push('');
     for (const tgt of targets) {
         lines.push(`### ${tgt.name}`);
@@ -830,6 +938,40 @@ export function generateMultiTargetReadme(input) {
     lines.push('| `status` | Show auth status across all contexts |');
     lines.push('| `logout` | Remove credentials for current context |');
     lines.push('');
+    lines.push(`### \`${builtinNames.config}\``);
+    lines.push('');
+    lines.push('Manage per-context key-value configuration variables.');
+    lines.push('');
+    lines.push('| Subcommand | Description |');
+    lines.push('|------------|-------------|');
+    lines.push('| `get <key>` | Get a config value |');
+    lines.push('| `set <key> <value>` | Set a config value |');
+    lines.push('| `list` | List all config values |');
+    lines.push('| `delete <key>` | Delete a config value |');
+    lines.push('');
+    lines.push(`Variables are scoped to the active context and stored at \`~/.${toolName}/config/\`.`);
+    lines.push('');
+    lines.push('## SDK Helpers');
+    lines.push('');
+    lines.push('The generated `helpers.ts` provides typed client factories for use in scripts and services:');
+    lines.push('');
+    lines.push('```typescript');
+    for (const tgt of targets) {
+        const pascalName = tgt.name.charAt(0).toUpperCase() + tgt.name.slice(1);
+        lines.push(`import { create${pascalName}Client } from './helpers';`);
+    }
+    lines.push('');
+    for (const tgt of targets) {
+        const pascalName = tgt.name.charAt(0).toUpperCase() + tgt.name.slice(1);
+        lines.push(`const ${tgt.name} = create${pascalName}Client();`);
+    }
+    lines.push('```');
+    lines.push('');
+    lines.push('Credential resolution order:');
+    lines.push(`1. appstash store (\`~/.${toolName}/config/\`)`);
+    lines.push(`2. Environment variables (\`${toolName.toUpperCase().replace(/-/g, '_')}_TOKEN\`, \`${toolName.toUpperCase().replace(/-/g, '_')}_<TARGET>_ENDPOINT\`)`);
+    lines.push('3. Throws with actionable error message');
+    lines.push('');
     for (const tgt of targets) {
         if (tgt.tables.length === 0 && tgt.customOperations.length === 0)
             continue;
@@ -956,6 +1098,7 @@ export function generateMultiTargetAgentsDocs(input) {
     lines.push(`  ${toolName} <target>:<command> <subcommand> [flags]    Target-specific commands`);
     lines.push(`  ${toolName} ${builtinNames.context} <subcommand> [flags]              Context management`);
     lines.push(`  ${toolName} ${builtinNames.auth} <subcommand> [flags]                 Authentication`);
+    lines.push(`  ${toolName} ${builtinNames.config} <subcommand> [flags]               Config key-value store`);
     lines.push('');
     lines.push('## PREREQUISITES');
     lines.push('');
@@ -1020,6 +1163,51 @@ export function generateMultiTargetAgentsDocs(input) {
     lines.push('  logout:    { context, status: "logged out" }');
     lines.push('```');
     lines.push('');
+    lines.push(`### TOOL: ${builtinNames.config}`);
+    lines.push('');
+    lines.push('Manage per-context key-value configuration variables.');
+    lines.push('');
+    lines.push('```');
+    lines.push('SUBCOMMANDS:');
+    lines.push(`  ${toolName} ${builtinNames.config} get <key>             Get a config value`);
+    lines.push(`  ${toolName} ${builtinNames.config} set <key> <value>     Set a config value`);
+    lines.push(`  ${toolName} ${builtinNames.config} list                  List all config values`);
+    lines.push(`  ${toolName} ${builtinNames.config} delete <key>          Delete a config value`);
+    lines.push('');
+    lines.push('INPUT:');
+    lines.push('  key:   string (required for get/set/delete) - Variable name');
+    lines.push('  value: string (required for set) - Variable value');
+    lines.push('');
+    lines.push('OUTPUT: JSON');
+    lines.push('  get:    { key, value }');
+    lines.push('  set:    { key, value }');
+    lines.push('  list:   { vars: { key: value, ... } }');
+    lines.push('  delete: { deleted: key }');
+    lines.push('```');
+    lines.push('');
+    lines.push('### TOOL: helpers (SDK)');
+    lines.push('');
+    lines.push('Typed client factories for use in scripts and services (generated helpers.ts).');
+    lines.push('Resolves credentials via: appstash store -> env vars -> throw.');
+    lines.push('');
+    lines.push('```');
+    lines.push('FACTORIES:');
+    for (const tgt of targets) {
+        const pascalName = tgt.name.charAt(0).toUpperCase() + tgt.name.slice(1);
+        lines.push(`  create${pascalName}Client(contextName?)   Create a configured ${tgt.name} ORM client`);
+    }
+    lines.push('');
+    lines.push('USAGE:');
+    lines.push(`  import { create${targets[0] ? targets[0].name.charAt(0).toUpperCase() + targets[0].name.slice(1) : 'Target'}Client } from './helpers';`);
+    lines.push(`  const client = create${targets[0] ? targets[0].name.charAt(0).toUpperCase() + targets[0].name.slice(1) : 'Target'}Client();`);
+    lines.push('');
+    lines.push('CREDENTIAL RESOLUTION:');
+    lines.push(`  1. appstash store (~/.${toolName}/config/)`);
+    const envPrefix = toolName.toUpperCase().replace(/-/g, '_');
+    lines.push(`  2. env vars (${envPrefix}_TOKEN, ${envPrefix}_<TARGET>_ENDPOINT)`);
+    lines.push('  3. throws with actionable error message');
+    lines.push('```');
+    lines.push('');
     for (const tgt of targets) {
         for (const table of tgt.tables) {
             const { singularName } = getTableNames(table);
@@ -1245,6 +1433,45 @@ export function getMultiTargetCliMcpTools(input) {
         description: 'Remove credentials for the current context',
         inputSchema: { type: 'object', properties: {} },
     });
+    tools.push({
+        name: `${toolName}_${builtinNames.config}_get`,
+        description: 'Get a config variable value for the current context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Variable name' },
+            },
+            required: ['key'],
+        },
+    });
+    tools.push({
+        name: `${toolName}_${builtinNames.config}_set`,
+        description: 'Set a config variable value for the current context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Variable name' },
+                value: { type: 'string', description: 'Variable value' },
+            },
+            required: ['key', 'value'],
+        },
+    });
+    tools.push({
+        name: `${toolName}_${builtinNames.config}_list`,
+        description: 'List all config variables for the current context',
+        inputSchema: { type: 'object', properties: {} },
+    });
+    tools.push({
+        name: `${toolName}_${builtinNames.config}_delete`,
+        description: 'Delete a config variable for the current context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Variable name to delete' },
+            },
+            required: ['key'],
+        },
+    });
     for (const tgt of targets) {
         for (const table of tgt.tables) {
             const { singularName } = getTableNames(table);
@@ -1439,12 +1666,40 @@ export function generateMultiTargetSkills(input) {
             ],
         }),
     });
+    // Config reference
+    commonReferenceNames.push('config');
+    files.push({
+        fileName: `${commonSkillName}/references/config.md`,
+        content: buildSkillReference({
+            title: 'Config Variables',
+            description: `Manage per-context key-value configuration variables for ${toolName}`,
+            usage: [
+                `${toolName} ${builtinNames.config} get <key>`,
+                `${toolName} ${builtinNames.config} set <key> <value>`,
+                `${toolName} ${builtinNames.config} list`,
+                `${toolName} ${builtinNames.config} delete <key>`,
+            ],
+            examples: [
+                {
+                    description: 'Store and retrieve a config variable',
+                    code: [
+                        `${toolName} ${builtinNames.config} set orgId abc-123`,
+                        `${toolName} ${builtinNames.config} get orgId`,
+                    ],
+                },
+                {
+                    description: 'List all config variables',
+                    code: [`${toolName} ${builtinNames.config} list`],
+                },
+            ],
+        }),
+    });
     // Common SKILL.md
     files.push({
         fileName: `${commonSkillName}/SKILL.md`,
         content: buildSkillFile({
             name: commonSkillName,
-            description: `Shared CLI utilities for ${toolName} — context management and authentication across targets: ${targets.map((t) => t.name).join(', ')}`,
+            description: `Shared CLI utilities for ${toolName} — context management, authentication, and config across targets: ${targets.map((t) => t.name).join(', ')}`,
             usage: [
                 `# Context management`,
                 `${toolName} ${builtinNames.context} create <name>`,
@@ -1453,6 +1708,11 @@ export function generateMultiTargetSkills(input) {
                 `# Authentication`,
                 `${toolName} ${builtinNames.auth} set-token <token>`,
                 `${toolName} ${builtinNames.auth} status`,
+                '',
+                `# Config variables`,
+                `${toolName} ${builtinNames.config} set <key> <value>`,
+                `${toolName} ${builtinNames.config} get <key>`,
+                `${toolName} ${builtinNames.config} list`,
             ],
             examples: [
                 {
@@ -1463,6 +1723,12 @@ export function generateMultiTargetSkills(input) {
                         `${toolName} ${builtinNames.auth} set-token <token>`,
                     ],
                 },
+                {
+                    description: 'Store a config variable',
+                    code: [
+                        `${toolName} ${builtinNames.config} set orgId abc-123`,
+                    ],
+                },
             ],
         }, commonReferenceNames),
     });

package/esm/core/codegen/cli/helpers-generator.d.ts

@@ -0,0 +1,15 @@
+import type { GeneratedFile } from './executor-generator';
+export interface HelpersGeneratorInput {
+    name: string;
+    ormImportPath: string;
+}
+/**
+ * Generate helpers.ts with typed per-target client factories.
+ *
+ * Each target gets a `createXxxClient(contextName?)` function that uses
+ * `store.getClientConfig(targetName, contextName)` under the hood with
+ * 3-tier resolution: appstash store -> env vars -> throw.
+ *
+ * Also re-exports the store for direct config/var access.
+ */
+export declare function generateHelpersFile(toolName: string, targets: HelpersGeneratorInput[]): GeneratedFile;

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

@@ -0,0 +1,83 @@
+import * as t from '@babel/types';
+import { generateCode } from '../babel-ast';
+import { getGeneratedFileHeader } from '../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));
+    decl.importKind = typeOnly ? 'type' : 'value';
+    return decl;
+}
+/**
+ * Generate helpers.ts with typed per-target client factories.
+ *
+ * Each target gets a `createXxxClient(contextName?)` function that uses
+ * `store.getClientConfig(targetName, contextName)` under the hood with
+ * 3-tier resolution: appstash store -> env vars -> throw.
+ *
+ * Also re-exports the store for direct config/var access.
+ */
+export function generateHelpersFile(toolName, targets) {
+    const statements = [];
+    // import { createConfigStore } from 'appstash';
+    statements.push(createImportDeclaration('appstash', ['createConfigStore']));
+    // import type { ClientConfig } from 'appstash';
+    statements.push(createImportDeclaration('appstash', ['ClientConfig'], true));
+    // Import createClient from each target's ORM
+    for (const target of targets) {
+        const aliasName = `create${target.name[0].toUpperCase()}${target.name.slice(1)}OrmClient`;
+        const specifier = t.importSpecifier(t.identifier(aliasName), t.identifier('createClient'));
+        statements.push(t.importDeclaration([specifier], t.stringLiteral(target.ormImportPath)));
+    }
+    // const store = createConfigStore('toolName');
+    statements.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('store'), t.callExpression(t.identifier('createConfigStore'), [
+            t.stringLiteral(toolName),
+        ])),
+    ]));
+    // export const getStore = () => store;
+    const getStoreExport = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('getStore'), t.arrowFunctionExpression([], t.identifier('store'))),
+    ]);
+    statements.push(t.exportNamedDeclaration(getStoreExport));
+    // export function getClientConfig(targetName: string, contextName?: string): ClientConfig
+    const targetNameParam = t.identifier('targetName');
+    targetNameParam.typeAnnotation = t.tsTypeAnnotation(t.tsStringKeyword());
+    const contextNameParam = t.identifier('contextName');
+    contextNameParam.optional = true;
+    contextNameParam.typeAnnotation = t.tsTypeAnnotation(t.tsStringKeyword());
+    const getClientConfigBody = t.blockStatement([
+        t.returnStatement(t.callExpression(t.memberExpression(t.identifier('store'), t.identifier('getClientConfig')), [t.identifier('targetName'), t.identifier('contextName')])),
+    ]);
+    const getClientConfigFunc = t.functionDeclaration(t.identifier('getClientConfig'), [targetNameParam, contextNameParam], getClientConfigBody);
+    // Add return type annotation
+    const returnTypeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('ClientConfig')));
+    getClientConfigFunc.returnType = returnTypeAnnotation;
+    statements.push(t.exportNamedDeclaration(getClientConfigFunc));
+    // Generate typed factory for each target
+    for (const target of targets) {
+        const factoryName = `create${target.name[0].toUpperCase()}${target.name.slice(1)}Client`;
+        const ormAliasName = `create${target.name[0].toUpperCase()}${target.name.slice(1)}OrmClient`;
+        const ctxParam = t.identifier('contextName');
+        ctxParam.optional = true;
+        ctxParam.typeAnnotation = t.tsTypeAnnotation(t.tsStringKeyword());
+        const factoryBody = t.blockStatement([
+            t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier('config'), t.callExpression(t.memberExpression(t.identifier('store'), t.identifier('getClientConfig')), [t.stringLiteral(target.name), t.identifier('contextName')])),
+            ]),
+            t.returnStatement(t.callExpression(t.identifier(ormAliasName), [
+                t.objectExpression([
+                    t.objectProperty(t.identifier('endpoint'), t.memberExpression(t.identifier('config'), t.identifier('endpoint'))),
+                    t.objectProperty(t.identifier('headers'), t.memberExpression(t.identifier('config'), t.identifier('headers'))),
+                ]),
+            ])),
+        ]);
+        const factoryFunc = t.functionDeclaration(t.identifier(factoryName), [ctxParam], factoryBody);
+        statements.push(t.exportNamedDeclaration(factoryFunc));
+    }
+    const header = getGeneratedFileHeader('SDK helpers — typed per-target client factories with 3-tier credential resolution');
+    const code = generateCode(statements);
+    return {
+        fileName: 'helpers.ts',
+        content: header + '\n' + code,
+    };
+}

package/esm/core/codegen/cli/index.d.ts

@@ -47,12 +47,16 @@ export interface GenerateMultiTargetCliOptions {
 export declare function resolveBuiltinNames(targetNames: string[], userOverrides?: BuiltinNames): {
     auth: string;
     context: string;
+    config: string;
 };
 export declare function generateMultiTargetCli(options: GenerateMultiTargetCliOptions): GenerateCliResult;
 export { generateExecutorFile, generateMultiTargetExecutorFile } from './executor-generator';
 export { generateTableCommand } from './table-command-generator';
 export { generateCustomCommand } from './custom-command-generator';
 export { generateCommandMap, generateMultiTargetCommandMap } from './command-map-generator';
+export { generateConfigCommand } from './config-command-generator';
+export { generateHelpersFile } from './helpers-generator';
+export type { HelpersGeneratorInput } from './helpers-generator';
 export { generateContextCommand, generateAuthCommand, generateMultiTargetContextCommand, generateAuthCommandWithName, } from './infra-generator';
 export { generateReadme, generateAgentsDocs, getCliMcpTools, generateSkills, generateMultiTargetReadme, generateMultiTargetAgentsDocs, getMultiTargetCliMcpTools, generateMultiTargetSkills, } from './docs-generator';
 export type { MultiTargetDocsInput } from './docs-generator';

package/esm/core/codegen/cli/index.js

@@ -1,6 +1,8 @@
 import { generateCommandMap, generateMultiTargetCommandMap } from './command-map-generator';
+import { generateConfigCommand } from './config-command-generator';
 import { generateCustomCommand } from './custom-command-generator';
 import { generateExecutorFile, generateMultiTargetExecutorFile } from './executor-generator';
+import { generateHelpersFile } from './helpers-generator';
 import { generateAuthCommand, generateAuthCommandWithName, generateContextCommand, generateMultiTargetContextCommand, } from './infra-generator';
 import { generateTableCommand } from './table-command-generator';
 import { generateUtilsFile, generateNodeFetchFile, generateEntryPointFile } from './utils-generator';
@@ -62,13 +64,17 @@ export function generateCli(options) {
 export function resolveBuiltinNames(targetNames, userOverrides) {
     let authName = userOverrides?.auth ?? 'auth';
     let contextName = userOverrides?.context ?? 'context';
+    let configName = userOverrides?.config ?? 'config';
     if (targetNames.includes(authName) && !userOverrides?.auth) {
         authName = 'credentials';
     }
     if (targetNames.includes(contextName) && !userOverrides?.context) {
         contextName = 'env';
     }
-    return { auth: authName, context: contextName };
+    if (targetNames.includes(configName) && !userOverrides?.config) {
+        configName = 'vars';
+    }
+    return { auth: authName, context: contextName, config: configName };
 }
 export function generateMultiTargetCli(options) {
     const { toolName, targets } = options;
@@ -94,6 +100,14 @@ export function generateMultiTargetCli(options) {
     files.push(contextFile);
     const authFile = generateAuthCommandWithName(toolName, builtinNames.auth);
     files.push(authFile);
+    const configFile = generateConfigCommand(toolName, builtinNames.config);
+    files.push(configFile);
+    const helpersInputs = targets.map((t) => ({
+        name: t.name,
+        ormImportPath: t.ormImportPath,
+    }));
+    const helpersFile = generateHelpersFile(toolName, helpersInputs);
+    files.push(helpersFile);
     let totalTables = 0;
     let totalQueries = 0;
     let totalMutations = 0;
@@ -145,7 +159,7 @@ export function generateMultiTargetCli(options) {
             tables: totalTables,
             customQueries: totalQueries,
             customMutations: totalMutations,
-            infraFiles: 4,
+            infraFiles: 6,
             totalFiles: files.length,
         },
     };
@@ -154,6 +168,8 @@ export { generateExecutorFile, generateMultiTargetExecutorFile } from './executo
 export { generateTableCommand } from './table-command-generator';
 export { generateCustomCommand } from './custom-command-generator';
 export { generateCommandMap, generateMultiTargetCommandMap } from './command-map-generator';
+export { generateConfigCommand } from './config-command-generator';
+export { generateHelpersFile } from './helpers-generator';
 export { generateContextCommand, generateAuthCommand, generateMultiTargetContextCommand, generateAuthCommandWithName, } from './infra-generator';
 export { generateReadme, generateAgentsDocs, getCliMcpTools, generateSkills, generateMultiTargetReadme, generateMultiTargetAgentsDocs, getMultiTargetCliMcpTools, generateMultiTargetSkills, } from './docs-generator';
 export { resolveDocsConfig } from '../docs-utils';

package/esm/core/codegen/orm/index.js

@@ -9,6 +9,7 @@ import { generateAllModelFiles } from './model-generator';
 export function generateOrm(options) {
     const { tables, customOperations, sharedTypesPath } = options;
     const commentsEnabled = options.config.codegen?.comments !== false;
+    const conditionEnabled = options.config.codegen?.condition !== false;
     const files = [];
     // Use shared types when a sharedTypesPath is provided (unified output mode)
     const useSharedTypes = !!sharedTypesPath;
@@ -29,7 +30,7 @@ export function generateOrm(options) {
         content: selectTypesFile.content,
     });
     // 2. Generate model files
-    const modelFiles = generateAllModelFiles(tables, useSharedTypes);
+    const modelFiles = generateAllModelFiles(tables, useSharedTypes, { condition: conditionEnabled });
     for (const modelFile of modelFiles) {
         files.push({
             path: `models/${modelFile.fileName}`,
@@ -66,7 +67,7 @@ export function generateOrm(options) {
                 }
             }
         }
-        const inputTypesFile = generateInputTypesFile(typeRegistry ?? new Map(), usedInputTypes, tables, usedPayloadTypes, commentsEnabled);
+        const inputTypesFile = generateInputTypesFile(typeRegistry ?? new Map(), usedInputTypes, tables, usedPayloadTypes, commentsEnabled, { condition: conditionEnabled });
         files.push({
             path: inputTypesFile.fileName,
             content: inputTypesFile.content,

package/esm/core/codegen/orm/input-types-generator.d.ts

@@ -18,4 +18,6 @@ export declare function collectPayloadTypeNames(operations: Array<{
 /**
  * Generate comprehensive input-types.ts file using Babel AST
  */
-export declare function generateInputTypesFile(typeRegistry: TypeRegistry, usedInputTypes: Set<string>, tables?: CleanTable[], usedPayloadTypes?: Set<string>, comments?: boolean): GeneratedInputTypesFile;
+export declare function generateInputTypesFile(typeRegistry: TypeRegistry, usedInputTypes: Set<string>, tables?: CleanTable[], usedPayloadTypes?: Set<string>, comments?: boolean, options?: {
+    condition?: boolean;
+}): GeneratedInputTypesFile;

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

@@ -1024,9 +1024,9 @@ function buildTableCrudTypeNames(tables) {
 /**
  * Generate custom input type statements from TypeRegistry
  */
-function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes, comments = true) {
+function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes, comments = true, alreadyGeneratedTypes) {
     const statements = [];
-    const generatedTypes = new Set();
+    const generatedTypes = new Set(alreadyGeneratedTypes ?? []);
     const typesToGenerate = new Set(Array.from(usedInputTypes));
     // Filter out types we've already generated (exact matches for table CRUD types only)
     if (tableCrudTypes) {
@@ -1296,7 +1296,8 @@ function collectConditionExtraInputTypes(tables, typeRegistry) {
 /**
  * Generate comprehensive input-types.ts file using Babel AST
  */
-export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloadTypes, comments = true) {
+export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloadTypes, comments = true, options) {
+    const conditionEnabled = options?.condition !== false;
     const statements = [];
     const tablesList = tables ?? [];
     const hasTables = tablesList.length > 0;
@@ -1323,7 +1324,9 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
         // 4b. Table condition types (simple equality filter)
         // Pass typeRegistry to merge plugin-injected condition fields
         // (e.g., vectorEmbedding from VectorSearchPlugin)
-        statements.push(...generateTableConditionTypes(tablesList, typeRegistry));
+        if (conditionEnabled) {
+            statements.push(...generateTableConditionTypes(tablesList, typeRegistry));
+        }
         // 5. OrderBy types
         // Pass typeRegistry to merge plugin-injected orderBy values
         // (e.g., EMBEDDING_DISTANCE_ASC/DESC from VectorSearchPlugin)
@@ -1337,14 +1340,19 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
     // 7. Custom input types from TypeRegistry
     // Also include any extra types referenced by plugin-injected condition fields
     const mergedUsedInputTypes = new Set(usedInputTypes);
-    if (hasTables) {
+    if (hasTables && conditionEnabled) {
         const conditionExtraTypes = collectConditionExtraInputTypes(tablesList, typeRegistry);
         for (const typeName of conditionExtraTypes) {
             mergedUsedInputTypes.add(typeName);
         }
     }
     const tableCrudTypes = tables ? buildTableCrudTypeNames(tables) : undefined;
-    statements.push(...generateCustomInputTypes(typeRegistry, mergedUsedInputTypes, tableCrudTypes, comments));
+    // Pass customScalarTypes + enumTypes as already-generated to avoid duplicate declarations
+    const alreadyGenerated = new Set([
+        ...customScalarTypes,
+        ...enumTypes,
+    ]);
+    statements.push(...generateCustomInputTypes(typeRegistry, mergedUsedInputTypes, tableCrudTypes, comments, alreadyGenerated));
     // 8. Payload/return types for custom operations
     if (usedPayloadTypes && usedPayloadTypes.size > 0) {
         const alreadyGeneratedTypes = new Set();

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

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