@constructive-io/graphql-codegen 4.9.0 → 4.13.0

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/cli/table-command-generator.d.ts

@@ -1,5 +1,20 @@
 import type { CleanTable, TypeRegistry } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
+/**
+ * Get the set of field names that have defaults in the create input type.
+ * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
+ * TypeRegistry and checks each field's defaultValue from introspection.
+ */
+/**
+ * Resolve the inner input type from a CreateXInput or UpdateXInput type.
+ * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
+ * that contains the actual field definitions.
+ */
+export declare function resolveInnerInputType(inputTypeName: string, typeRegistry: TypeRegistry): {
+    name: string;
+    fields: Set<string>;
+} | null;
+export declare function getFieldsWithDefaults(table: CleanTable, typeRegistry?: TypeRegistry): Set<string>;
 export interface TableCommandOptions {
     targetName?: string;
     executorImportPath?: string;

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

@@ -33,6 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInnerInputType = resolveInnerInputType;
+exports.getFieldsWithDefaults = getFieldsWithDefaults;
 exports.generateTableCommand = generateTableCommand;
 const t = __importStar(require("@babel/types"));
 const komoji_1 = require("komoji");
@@ -103,6 +105,22 @@ function getTsTypeForField(field) {
             return t.tsStringKeyword();
     }
 }
+/**
+ * Maps a GraphQL scalar type to the appropriate inquirerer question type.
+ * Used by table CRUD commands to generate semantic prompts.
+ */
+function getQuestionTypeForField(field) {
+    const gqlType = field.type.gqlType.replace(/!/g, '');
+    switch (gqlType) {
+        case 'Boolean':
+            return 'boolean';
+        case 'JSON':
+        case 'GeoJSON':
+            return 'json';
+        default:
+            return 'text';
+    }
+}
 function buildFieldSchemaObject(table) {
     const fields = (0, utils_1.getScalarFields)(table);
     return t.objectExpression(fields.map((f) => {
@@ -342,8 +360,9 @@ function buildMutationHandler(table, operation, targetName, typeRegistry, ormTyp
             // For update: all fields are optional (user only updates what they want)
             const isRequired = operation === 'create' && !fieldsWithDefaults.has(field.name);
             const hasDefault = fieldsWithDefaults.has(field.name);
+            const questionType = getQuestionTypeForField(field);
             const questionProps = [
-                t.objectProperty(t.identifier('type'), t.stringLiteral('text')),
+                t.objectProperty(t.identifier('type'), t.stringLiteral(questionType)),
                 t.objectProperty(t.identifier('name'), t.stringLiteral(field.name)),
                 t.objectProperty(t.identifier('message'), t.stringLiteral(field.name)),
                 t.objectProperty(t.identifier('required'), t.booleanLiteral(isRequired)),

package/core/codegen/docs-utils.d.ts

@@ -1,5 +1,5 @@
 import type { DocsConfig } from '../../types/config';
-import type { CleanField, CleanOperation, CleanTable } from '../../types/schema';
+import type { CleanArgument, CleanField, CleanOperation, CleanTable, TypeRegistry } from '../../types/schema';
 export interface GeneratedDocFile {
     fileName: string;
     content: string;
@@ -36,6 +36,31 @@ export declare function resolveDocsConfig(docs: DocsConfig | boolean | undefined
 export declare function formatArgType(arg: CleanOperation['args'][number]): string;
 export declare function formatTypeRef(t: CleanOperation['args'][number]['type']): string;
 export declare function getEditableFields(table: CleanTable): CleanField[];
+/**
+ * Represents a flattened argument for docs/skills generation.
+ * INPUT_OBJECT args are expanded to dot-notation fields.
+ */
+export interface FlattenedArg {
+    /** Flag name for CLI usage, e.g. 'input.email' or 'clientMutationId' */
+    flag: string;
+    /** Human-readable type string */
+    type: string;
+    /** Whether the argument is required */
+    required: boolean;
+    /** Description from schema */
+    description?: string;
+}
+/**
+ * Strip internal type prefixes for cleaner docs display.
+ * e.g. 'ConstructiveInternalTypeEmail' -> 'Email'
+ */
+export declare function cleanTypeName(name: string): string;
+export declare function flattenArgs(args: CleanArgument[], registry?: TypeRegistry): FlattenedArg[];
+/**
+ * Build CLI flags string from flattened args.
+ * e.g. '--input.email <value> --input.password <value>'
+ */
+export declare function flattenedArgsToFlags(flatArgs: FlattenedArg[]): string;
 export declare function gqlTypeToJsonSchemaType(gqlType: string): string;
 export declare function buildSkillFile(skill: SkillDefinition, referenceNames?: string[]): string;
 export declare function buildSkillReference(ref: SkillReferenceDefinition): string;

package/core/codegen/docs-utils.js

@@ -6,6 +6,9 @@ exports.resolveDocsConfig = resolveDocsConfig;
 exports.formatArgType = formatArgType;
 exports.formatTypeRef = formatTypeRef;
 exports.getEditableFields = getEditableFields;
+exports.cleanTypeName = cleanTypeName;
+exports.flattenArgs = flattenArgs;
+exports.flattenedArgsToFlags = flattenedArgsToFlags;
 exports.gqlTypeToJsonSchemaType = gqlTypeToJsonSchemaType;
 exports.buildSkillFile = buildSkillFile;
 exports.buildSkillReference = buildSkillReference;
@@ -78,6 +81,108 @@ function getEditableFields(table) {
         f.name !== 'createdAt' &&
         f.name !== 'updatedAt');
 }
+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;
+}
+/**
+ * Strip internal type prefixes for cleaner docs display.
+ * e.g. 'ConstructiveInternalTypeEmail' -> 'Email'
+ */
+function cleanTypeName(name) {
+    if (name.startsWith('ConstructiveInternalType')) {
+        return name.slice('ConstructiveInternalType'.length);
+    }
+    return name;
+}
+function getScalarTypeName(typeRef) {
+    const base = resolveBaseType(typeRef);
+    return cleanTypeName(base.name ?? 'String');
+}
+/**
+ * Flatten operation args for docs/skills, expanding INPUT_OBJECT types
+ * to dot-notation fields (e.g. input.email, input.password).
+ * Mirrors the logic in arg-mapper.ts buildQuestionsArray.
+ */
+/**
+ * Resolve inputFields for an INPUT_OBJECT type.
+ * Checks the CleanTypeRef first, then falls back to the TypeRegistry.
+ */
+function resolveInputFields(typeRef, registry) {
+    if (typeRef.inputFields && typeRef.inputFields.length > 0) {
+        return typeRef.inputFields;
+    }
+    if (registry && typeRef.name) {
+        const resolved = registry.get(typeRef.name);
+        if (resolved?.kind === 'INPUT_OBJECT' && resolved.inputFields && resolved.inputFields.length > 0) {
+            return resolved.inputFields;
+        }
+    }
+    return undefined;
+}
+function flattenArgs(args, registry) {
+    const result = [];
+    for (const arg of args) {
+        const { inner, required } = unwrapNonNull(arg.type);
+        const base = resolveBaseType(arg.type);
+        // Try to resolve inputFields from the inner type first (unwrapped NON_NULL)
+        const innerFields = inner.kind === 'INPUT_OBJECT'
+            ? resolveInputFields(inner, registry)
+            : undefined;
+        if (innerFields) {
+            for (const field of innerFields) {
+                const { required: fieldRequired } = unwrapNonNull(field.type);
+                result.push({
+                    flag: `${arg.name}.${field.name}`,
+                    type: getScalarTypeName(field.type),
+                    required: required && fieldRequired,
+                    description: field.description,
+                });
+            }
+        }
+        else {
+            // Try the base type (unwrapped LIST+NON_NULL)
+            const baseFields = base.kind === 'INPUT_OBJECT'
+                ? resolveInputFields(base, registry)
+                : undefined;
+            if (baseFields) {
+                for (const field of baseFields) {
+                    const { required: fieldRequired } = unwrapNonNull(field.type);
+                    result.push({
+                        flag: `${arg.name}.${field.name}`,
+                        type: getScalarTypeName(field.type),
+                        required: required && fieldRequired,
+                        description: field.description,
+                    });
+                }
+            }
+            else {
+                result.push({
+                    flag: arg.name,
+                    type: getScalarTypeName(arg.type),
+                    required,
+                    description: arg.description,
+                });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Build CLI flags string from flattened args.
+ * e.g. '--input.email <value> --input.password <value>'
+ */
+function flattenedArgsToFlags(flatArgs) {
+    return flatArgs.map((a) => `--${a.flag} <value>`).join(' ');
+}
 function gqlTypeToJsonSchemaType(gqlType) {
     switch (gqlType) {
         case 'Int':

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;