@constructive-io/graphql-codegen 4.12.2 → 4.13.1

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

@@ -37,6 +37,7 @@ 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 } = (0, utils_1.getTableNames)(table);
         const kebab = (0, komoji_1.toKebabCase)(singularName);
@@ -73,6 +74,19 @@ 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('');
@@ -233,6 +247,28 @@ 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 } = (0, utils_1.getTableNames)(table);
         const kebab = (0, komoji_1.toKebabCase)(singularName);
@@ -440,6 +476,45 @@ 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 } = (0, utils_1.getTableNames)(table);
         const kebab = (0, komoji_1.toKebabCase)(singularName);
@@ -617,6 +692,34 @@ function generateSkills(tables, customOperations, toolName, targetName, registry
             ],
         }),
     });
+    // Config reference
+    referenceNames.push('config');
+    files.push({
+        fileName: `${skillName}/references/config.md`,
+        content: (0, docs_utils_1.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 } = (0, utils_1.getTableNames)(table);
@@ -698,6 +801,10 @@ function generateSkills(tables, customOperations, toolName, targetName, registry
                 `# 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>`,
@@ -793,6 +900,7 @@ 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}`);
@@ -842,6 +950,40 @@ 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;
@@ -968,6 +1110,7 @@ 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('');
@@ -1032,6 +1175,51 @@ 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 } = (0, utils_1.getTableNames)(table);
@@ -1257,6 +1445,45 @@ 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 } = (0, utils_1.getTableNames)(table);
@@ -1451,12 +1678,40 @@ function generateMultiTargetSkills(input) {
             ],
         }),
     });
+    // Config reference
+    commonReferenceNames.push('config');
+    files.push({
+        fileName: `${commonSkillName}/references/config.md`,
+        content: (0, docs_utils_1.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: (0, docs_utils_1.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>`,
@@ -1465,6 +1720,11 @@ 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: [
                 {
@@ -1475,6 +1735,12 @@ function generateMultiTargetSkills(input) {
                         `${toolName} ${builtinNames.auth} set-token <token>`,
                     ],
                 },
+                {
+                    description: 'Store a config variable',
+                    code: [
+                        `${toolName} ${builtinNames.config} set orgId abc-123`,
+                    ],
+                },
             ],
         }, commonReferenceNames),
     });

package/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/core/codegen/cli/helpers-generator.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHelpersFile = generateHelpersFile;
+const t = __importStar(require("@babel/types"));
+const babel_ast_1 = require("../babel-ast");
+const utils_1 = 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));
+    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.
+ */
+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 = (0, utils_1.getGeneratedFileHeader)('SDK helpers — typed per-target client factories with 3-tier credential resolution');
+    const code = (0, babel_ast_1.generateCode)(statements);
+    return {
+        fileName: 'helpers.ts',
+        content: header + '\n' + code,
+    };
+}

package/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/core/codegen/cli/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateEntryPointFile = exports.generateUtilsFile = exports.resolveDocsConfig = exports.generateMultiTargetSkills = exports.getMultiTargetCliMcpTools = exports.generateMultiTargetAgentsDocs = exports.generateMultiTargetReadme = exports.generateSkills = exports.getCliMcpTools = exports.generateAgentsDocs = exports.generateReadme = exports.generateAuthCommandWithName = exports.generateMultiTargetContextCommand = exports.generateAuthCommand = exports.generateContextCommand = exports.generateMultiTargetCommandMap = exports.generateCommandMap = exports.generateCustomCommand = exports.generateTableCommand = exports.generateMultiTargetExecutorFile = exports.generateExecutorFile = void 0;
+exports.generateEntryPointFile = exports.generateUtilsFile = exports.resolveDocsConfig = exports.generateMultiTargetSkills = exports.getMultiTargetCliMcpTools = exports.generateMultiTargetAgentsDocs = exports.generateMultiTargetReadme = exports.generateSkills = exports.getCliMcpTools = exports.generateAgentsDocs = exports.generateReadme = exports.generateAuthCommandWithName = exports.generateMultiTargetContextCommand = exports.generateAuthCommand = exports.generateContextCommand = exports.generateHelpersFile = exports.generateConfigCommand = exports.generateMultiTargetCommandMap = exports.generateCommandMap = exports.generateCustomCommand = exports.generateTableCommand = exports.generateMultiTargetExecutorFile = exports.generateExecutorFile = void 0;
 exports.generateCli = generateCli;
 exports.resolveBuiltinNames = resolveBuiltinNames;
 exports.generateMultiTargetCli = generateMultiTargetCli;
 const command_map_generator_1 = require("./command-map-generator");
+const config_command_generator_1 = require("./config-command-generator");
 const custom_command_generator_1 = require("./custom-command-generator");
 const executor_generator_1 = require("./executor-generator");
+const helpers_generator_1 = require("./helpers-generator");
 const infra_generator_1 = require("./infra-generator");
 const table_command_generator_1 = require("./table-command-generator");
 const utils_generator_1 = require("./utils-generator");
@@ -68,13 +70,17 @@ function generateCli(options) {
 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 };
 }
 function generateMultiTargetCli(options) {
     const { toolName, targets } = options;
@@ -100,6 +106,14 @@ function generateMultiTargetCli(options) {
     files.push(contextFile);
     const authFile = (0, infra_generator_1.generateAuthCommandWithName)(toolName, builtinNames.auth);
     files.push(authFile);
+    const configFile = (0, config_command_generator_1.generateConfigCommand)(toolName, builtinNames.config);
+    files.push(configFile);
+    const helpersInputs = targets.map((t) => ({
+        name: t.name,
+        ormImportPath: t.ormImportPath,
+    }));
+    const helpersFile = (0, helpers_generator_1.generateHelpersFile)(toolName, helpersInputs);
+    files.push(helpersFile);
     let totalTables = 0;
     let totalQueries = 0;
     let totalMutations = 0;
@@ -151,7 +165,7 @@ function generateMultiTargetCli(options) {
             tables: totalTables,
             customQueries: totalQueries,
             customMutations: totalMutations,
-            infraFiles: 4,
+            infraFiles: 6,
             totalFiles: files.length,
         },
     };
@@ -166,6 +180,10 @@ Object.defineProperty(exports, "generateCustomCommand", { enumerable: true, get:
 var command_map_generator_2 = require("./command-map-generator");
 Object.defineProperty(exports, "generateCommandMap", { enumerable: true, get: function () { return command_map_generator_2.generateCommandMap; } });
 Object.defineProperty(exports, "generateMultiTargetCommandMap", { enumerable: true, get: function () { return command_map_generator_2.generateMultiTargetCommandMap; } });
+var config_command_generator_2 = require("./config-command-generator");
+Object.defineProperty(exports, "generateConfigCommand", { enumerable: true, get: function () { return config_command_generator_2.generateConfigCommand; } });
+var helpers_generator_2 = require("./helpers-generator");
+Object.defineProperty(exports, "generateHelpersFile", { enumerable: true, get: function () { return helpers_generator_2.generateHelpersFile; } });
 var infra_generator_2 = require("./infra-generator");
 Object.defineProperty(exports, "generateContextCommand", { enumerable: true, get: function () { return infra_generator_2.generateContextCommand; } });
 Object.defineProperty(exports, "generateAuthCommand", { enumerable: true, get: function () { return infra_generator_2.generateAuthCommand; } });

package/core/codegen/orm/index.js

@@ -13,6 +13,7 @@ const model_generator_1 = require("./model-generator");
 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;
@@ -33,7 +34,7 @@ function generateOrm(options) {
         content: selectTypesFile.content,
     });
     // 2. Generate model files
-    const modelFiles = (0, model_generator_1.generateAllModelFiles)(tables, useSharedTypes);
+    const modelFiles = (0, model_generator_1.generateAllModelFiles)(tables, useSharedTypes, { condition: conditionEnabled });
     for (const modelFile of modelFiles) {
         files.push({
             path: `models/${modelFile.fileName}`,
@@ -70,7 +71,7 @@ function generateOrm(options) {
                 }
             }
         }
-        const inputTypesFile = (0, input_types_generator_1.generateInputTypesFile)(typeRegistry ?? new Map(), usedInputTypes, tables, usedPayloadTypes, commentsEnabled);
+        const inputTypesFile = (0, input_types_generator_1.generateInputTypesFile)(typeRegistry ?? new Map(), usedInputTypes, tables, usedPayloadTypes, commentsEnabled, { condition: conditionEnabled });
         files.push({
             path: inputTypesFile.fileName,
             content: inputTypesFile.content,

package/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;