@constructive-io/graphql-codegen 4.9.0 → 4.13.0

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/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/esm/core/codegen/cli/table-command-generator.js

@@ -67,6 +67,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 = getScalarFields(table);
     return t.objectExpression(fields.map((f) => {
@@ -214,7 +230,7 @@ function buildGetHandler(table, targetName) {
  * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
  * that contains the actual field definitions.
  */
-function resolveInnerInputType(inputTypeName, typeRegistry) {
+export function resolveInnerInputType(inputTypeName, typeRegistry) {
     const inputType = typeRegistry.get(inputTypeName);
     if (!inputType?.inputFields)
         return null;
@@ -232,7 +248,7 @@ function resolveInnerInputType(inputTypeName, typeRegistry) {
     }
     return null;
 }
-function getFieldsWithDefaults(table, typeRegistry) {
+export function getFieldsWithDefaults(table, typeRegistry) {
     const fieldsWithDefaults = new Set();
     if (!typeRegistry)
         return fieldsWithDefaults;
@@ -306,8 +322,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/esm/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/esm/core/codegen/docs-utils.js

@@ -67,6 +67,108 @@ export 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'
+ */
+export 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;
+}
+export 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>'
+ */
+export function flattenedArgsToFlags(flatArgs) {
+    return flatArgs.map((a) => `--${a.flag} <value>`).join(' ');
+}
 export function gqlTypeToJsonSchemaType(gqlType) {
     switch (gqlType) {
         case 'Int':

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

@@ -214,6 +214,11 @@ const SCALAR_FILTER_CONFIGS = [
         operators: ['equality', 'distinct', 'inArray', 'comparison', 'inet'],
     },
     { name: 'FullTextFilter', tsType: 'string', operators: ['fulltext'] },
+    // VectorFilter: equality/distinct operators for vector columns on Filter types.
+    // Similarity search uses condition types (embeddingNearby), not filters, but
+    // connection-filter may still generate a filter for vector columns. This ensures
+    // the generated type uses number[] rather than being silently omitted.
+    { name: 'VectorFilter', tsType: 'number[]', operators: ['equality', 'distinct'] },
     // List filters (for array fields like string[], int[], uuid[])
     {
         name: 'StringListFilter',
@@ -710,10 +715,15 @@ function generateTableFilterTypes(tables) {
 // ============================================================================
 /**
  * Build properties for a table condition interface
- * Condition types are simpler than Filter types - they use direct value equality
+ * Condition types are simpler than Filter types - they use direct value equality.
+ *
+ * Also merges any extra fields from the GraphQL schema's condition type
+ * (e.g., plugin-injected fields like vectorEmbedding from VectorSearchPlugin)
+ * that are not derived from the table's own columns.
  */
-function buildTableConditionProperties(table) {
+function buildTableConditionProperties(table, typeRegistry) {
     const properties = [];
+    const generatedFieldNames = new Set();
     for (const field of table.fields) {
         const fieldType = typeof field.type === 'string' ? field.type : field.type.gqlType;
         if (isRelationField(field.name, table))
@@ -725,17 +735,38 @@ function buildTableConditionProperties(table) {
             type: `${tsType} | null`,
             optional: true,
         });
+        generatedFieldNames.add(field.name);
+    }
+    // Merge any additional fields from the schema's condition type
+    // (e.g., plugin-added fields like vectorEmbedding from VectorSearchPlugin)
+    if (typeRegistry) {
+        const conditionTypeName = getConditionTypeName(table);
+        const conditionType = typeRegistry.get(conditionTypeName);
+        if (conditionType?.kind === 'INPUT_OBJECT' &&
+            conditionType.inputFields) {
+            for (const field of conditionType.inputFields) {
+                if (generatedFieldNames.has(field.name))
+                    continue;
+                const tsType = typeRefToTs(field.type);
+                properties.push({
+                    name: field.name,
+                    type: tsType,
+                    optional: true,
+                    description: stripSmartComments(field.description, true),
+                });
+            }
+        }
     }
     return properties;
 }
 /**
  * Generate table condition type statements
  */
-function generateTableConditionTypes(tables) {
+function generateTableConditionTypes(tables, typeRegistry) {
     const statements = [];
     for (const table of tables) {
         const conditionName = getConditionTypeName(table);
-        statements.push(createExportedInterface(conditionName, buildTableConditionProperties(table)));
+        statements.push(createExportedInterface(conditionName, buildTableConditionProperties(table, typeRegistry)));
     }
     if (statements.length > 0) {
         addSectionComment(statements, 'Table Condition Types');
@@ -746,9 +777,13 @@ function generateTableConditionTypes(tables) {
 // OrderBy Types Generator (AST-based)
 // ============================================================================
 /**
- * Build OrderBy union type values
+ * Build OrderBy union type values.
+ *
+ * Also merges any extra values from the GraphQL schema's orderBy enum
+ * (e.g., plugin-injected values like EMBEDDING_DISTANCE_ASC/DESC
+ * from VectorSearchPlugin).
  */
-function buildOrderByValues(table) {
+function buildOrderByValues(table, typeRegistry) {
     const values = ['PRIMARY_KEY_ASC', 'PRIMARY_KEY_DESC', 'NATURAL'];
     for (const field of table.fields) {
         if (isRelationField(field.name, table))
@@ -757,16 +792,30 @@ function buildOrderByValues(table) {
         values.push(`${upperSnake}_ASC`);
         values.push(`${upperSnake}_DESC`);
     }
+    // Merge any additional values from the schema's orderBy enum type
+    // (e.g., plugin-added values like EMBEDDING_DISTANCE_ASC/DESC)
+    if (typeRegistry) {
+        const orderByTypeName = getOrderByTypeName(table);
+        const orderByType = typeRegistry.get(orderByTypeName);
+        if (orderByType?.kind === 'ENUM' && orderByType.enumValues) {
+            const existingValues = new Set(values);
+            for (const value of orderByType.enumValues) {
+                if (!existingValues.has(value)) {
+                    values.push(value);
+                }
+            }
+        }
+    }
     return values;
 }
 /**
  * Generate OrderBy type statements
  */
-function generateOrderByTypes(tables) {
+function generateOrderByTypes(tables, typeRegistry) {
     const statements = [];
     for (const table of tables) {
         const enumName = getOrderByTypeName(table);
-        const values = buildOrderByValues(table);
+        const values = buildOrderByValues(table, typeRegistry);
         const unionType = createStringLiteralUnion(values);
         const typeAlias = t.tsTypeAliasDeclaration(t.identifier(enumName), null, unionType);
         statements.push(t.exportNamedDeclaration(typeAlias));
@@ -975,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) {
@@ -1017,11 +1066,12 @@ function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes,
                     optional,
                     description: stripSmartComments(field.description, comments),
                 });
-                // Follow nested Input types
+                // Follow nested types (Input objects, Enums, etc.) that exist in the registry
                 const baseType = getTypeBaseName(field.type);
                 if (baseType &&
-                    baseType.endsWith('Input') &&
-                    !generatedTypes.has(baseType)) {
+                    !SCALAR_NAMES.has(baseType) &&
+                    !generatedTypes.has(baseType) &&
+                    typeRegistry.has(baseType)) {
                     typesToGenerate.add(baseType);
                 }
             }
@@ -1205,12 +1255,49 @@ function generateConnectionFieldsMap(tables, tableByName) {
     return statements;
 }
 // ============================================================================
+// Plugin-Injected Type Collector
+// ============================================================================
+/**
+ * Collect extra input type names referenced by plugin-injected condition fields.
+ *
+ * When plugins (like VectorSearchPlugin) inject fields into condition types,
+ * they reference types (like VectorNearbyInput, VectorMetric) that also need
+ * to be generated. This function discovers those types by comparing the
+ * schema's condition type fields against the table's own columns.
+ */
+function collectConditionExtraInputTypes(tables, typeRegistry) {
+    const extraTypes = new Set();
+    for (const table of tables) {
+        const conditionTypeName = getConditionTypeName(table);
+        const conditionType = typeRegistry.get(conditionTypeName);
+        if (!conditionType ||
+            conditionType.kind !== 'INPUT_OBJECT' ||
+            !conditionType.inputFields) {
+            continue;
+        }
+        const tableFieldNames = new Set(table.fields
+            .filter((f) => !isRelationField(f.name, table))
+            .map((f) => f.name));
+        for (const field of conditionType.inputFields) {
+            if (tableFieldNames.has(field.name))
+                continue;
+            // Collect the base type name of this extra field
+            const baseName = getTypeBaseName(field.type);
+            if (baseName && !SCALAR_NAMES.has(baseName)) {
+                extraTypes.add(baseName);
+            }
+        }
+    }
+    return extraTypes;
+}
+// ============================================================================
 // Main Generator (AST-based)
 // ============================================================================
 /**
  * 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;
@@ -1235,9 +1322,15 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
         // 4. Table filter types
         statements.push(...generateTableFilterTypes(tablesList));
         // 4b. Table condition types (simple equality filter)
-        statements.push(...generateTableConditionTypes(tablesList));
+        // Pass typeRegistry to merge plugin-injected condition fields
+        // (e.g., vectorEmbedding from VectorSearchPlugin)
+        if (conditionEnabled) {
+            statements.push(...generateTableConditionTypes(tablesList, typeRegistry));
+        }
         // 5. OrderBy types
-        statements.push(...generateOrderByTypes(tablesList));
+        // Pass typeRegistry to merge plugin-injected orderBy values
+        // (e.g., EMBEDDING_DISTANCE_ASC/DESC from VectorSearchPlugin)
+        statements.push(...generateOrderByTypes(tablesList, typeRegistry));
         // 6. CRUD input types
         statements.push(...generateAllCrudInputTypes(tablesList, typeRegistry));
     }
@@ -1245,8 +1338,21 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
     // Always emit this export so generated model/custom-op imports stay valid.
     statements.push(...generateConnectionFieldsMap(tablesList, tableByName));
     // 7. Custom input types from TypeRegistry
+    // Also include any extra types referenced by plugin-injected condition fields
+    const mergedUsedInputTypes = new Set(usedInputTypes);
+    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, usedInputTypes, 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();