@constructive-io/graphql-codegen 4.26.0 → 4.27.1

package/core/codegen/index.js

@@ -97,7 +97,7 @@ function generate(options) {
         hasInvalidation = true;
     }
     // Condition types (PostGraphile simple equality filters)
-    const conditionEnabled = config.codegen?.condition !== false;
+    const conditionEnabled = config.codegen?.condition === true;
     // 4. Generate table-based query hooks (queries/*.ts)
     const queryHooks = (0, queries_1.generateAllQueryHooks)(tables, {
         reactQueryEnabled,

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateOrmReadme = generateOrmReadme;
 exports.generateOrmAgentsDocs = generateOrmAgentsDocs;
 exports.generateOrmSkills = generateOrmSkills;
-const komoji_1 = require("komoji");
+const inflekt_1 = require("inflekt");
 const docs_utils_1 = require("../docs-utils");
 const utils_1 = require("../utils");
 function generateOrmReadme(tables, customOperations, registry) {
@@ -169,7 +169,7 @@ function generateOrmSkills(tables, customOperations, targetName, registry) {
         const pk = (0, utils_1.getPrimaryKeyInfo)(table)[0];
         const editableFields = (0, docs_utils_1.getEditableFields)(table);
         const modelName = (0, utils_1.lcFirst)(singularName);
-        const refName = (0, komoji_1.toKebabCase)(singularName);
+        const refName = (0, inflekt_1.toKebabCase)(singularName);
         referenceNames.push(refName);
         const ormSkillSpecialGroups = (0, docs_utils_1.categorizeSpecialFields)(table);
         const ormSkillBaseDesc = table.description || `ORM operations for ${table.name} records`;
@@ -218,7 +218,7 @@ function generateOrmSkills(tables, customOperations, targetName, registry) {
         const callArgs = op.args.length > 0
             ? `{ ${op.args.map((a) => `${a.name}: ${(0, docs_utils_1.argPlaceholder)(a, registry)}`).join(', ')} }`
             : '';
-        const refName = (0, komoji_1.toKebabCase)(op.name);
+        const refName = (0, inflekt_1.toKebabCase)(op.name);
         referenceNames.push(refName);
         files.push({
             fileName: `${skillName}/references/${refName}.md`,

package/core/codegen/orm/index.js

@@ -13,7 +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 conditionEnabled = options.config.codegen?.condition === true;
     const files = [];
     // Use shared types when a sharedTypesPath is provided (unified output mode)
     const useSharedTypes = !!sharedTypesPath;

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

@@ -1420,7 +1420,7 @@ function collectConditionExtraInputTypes(tables, typeRegistry) {
  * Generate comprehensive input-types.ts file using Babel AST
  */
 function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloadTypes, comments = true, options) {
-    const conditionEnabled = options?.condition !== false;
+    const conditionEnabled = options?.condition === true;
     const statements = [];
     const tablesList = tables ?? [];
     const hasTables = tablesList.length > 0;

package/core/codegen/orm/model-generator.js

@@ -104,7 +104,7 @@ function strictSelectGuard(selectTypeName) {
     ]));
 }
 function generateModelFile(table, _useSharedTypes, options, allTables) {
-    const conditionEnabled = options?.condition !== false;
+    const conditionEnabled = options?.condition === true;
     const { typeName, singularName, pluralName } = (0, utils_1.getTableNames)(table);
     const modelName = `${typeName}Model`;
     const baseFileName = (0, utils_1.lcFirst)(typeName);

package/core/codegen/queries.js

@@ -49,7 +49,7 @@ const babel_ast_1 = require("./babel-ast");
 const hooks_ast_1 = require("./hooks-ast");
 const utils_1 = require("./utils");
 function generateListQueryHook(table, options = {}) {
-    const { reactQueryEnabled = true, useCentralizedKeys = true, hasRelationships = false, condition: conditionEnabled = true, } = options;
+    const { reactQueryEnabled = true, useCentralizedKeys = true, hasRelationships = false, condition: conditionEnabled = false, } = options;
     const { typeName, pluralName, singularName } = (0, utils_1.getTableNames)(table);
     const hookName = (0, utils_1.getListQueryHookName)(table);
     const queryName = (0, utils_1.getAllRowsQueryName)(table);

package/core/codegen/templates/cli-utils.ts

@@ -229,16 +229,16 @@ export function parseOrderByFlag(
 }
 
 /**
- * Parse --fields flag into a select object, falling back to a default.
- * e.g. --fields id,name → { id: true, name: true }
+ * Parse --select flag into a select object, falling back to a default.
+ * e.g. --select id,name → { id: true, name: true }
  */
 export function parseSelectFlag(
   argv: Record<string, unknown>,
   defaultSelect: Record<string, unknown>,
 ): Record<string, unknown> {
-  const fields = argv.fields;
-  return typeof fields === 'string'
-    ? buildSelectFromPaths(fields)
+  const raw = argv.select;
+  return typeof raw === 'string'
+    ? buildSelectFromPaths(raw)
     : defaultSelect;
 }
 
@@ -252,11 +252,11 @@ export function parseSelectFlag(
  *   const findManyArgs = parseFindManyArgs(argv, { id: true, name: true });
  *   const result = await client.user.findMany(findManyArgs).execute();
  */
-export function parseFindManyArgs(
+export function parseFindManyArgs<T = Record<string, unknown>>(
   argv: Record<string, unknown>,
   defaultSelect: Record<string, unknown>,
   extraWhere?: Record<string, unknown>,
-): Record<string, unknown> {
+): T {
   const limit = parseIntFlag(argv, 'limit');
   const last = parseIntFlag(argv, 'last');
   const offset = parseIntFlag(argv, 'offset');
@@ -280,7 +280,7 @@ export function parseFindManyArgs(
     ...(where !== undefined ? { where } : {}),
     ...(condition !== undefined ? { condition } : {}),
     ...(orderBy !== undefined ? { orderBy } : {}),
-  };
+  } as unknown as T;
 }
 
 /**
@@ -288,10 +288,10 @@ export function parseFindManyArgs(
  * Like parseFindManyArgs but only includes select, where, and condition
  * (no pagination flags — findFirst returns the first matching record).
  */
-export function parseFindFirstArgs(
+export function parseFindFirstArgs<T = Record<string, unknown>>(
   argv: Record<string, unknown>,
   defaultSelect: Record<string, unknown>,
-): Record<string, unknown> {
+): T {
   const select = parseSelectFlag(argv, defaultSelect);
   const parsed = unflattenDotNotation(argv);
   const where = parsed.where;
@@ -301,7 +301,7 @@ export function parseFindFirstArgs(
     select,
     ...(where !== undefined ? { where } : {}),
     ...(condition !== undefined ? { condition } : {}),
-  };
+  } as unknown as T;
 }
 
 export function buildSelectFromPaths(

package/core/codegen/templates/embedder.ts

@@ -0,0 +1,175 @@
+/**
+ * CLI Embedder — pluggable text-to-vector embedding for CLI commands
+ *
+ * This is RUNTIME code that gets copied to generated output.
+ * Provides a pluggable system for registering embedding functions so that
+ * CLI commands can convert text queries into vector arrays for pgvector
+ * similarity search (list/search) and create/update vector fields inline.
+ *
+ * Configuration via appstash config or environment variables:
+ *   embedder.provider  = 'ollama' | 'custom'
+ *   embedder.model     = 'nomic-embed-text' (default)
+ *   embedder.baseUrl   = 'http://localhost:11434' (Ollama endpoint)
+ *
+ * Uses @agentic-kit/ollama for the built-in Ollama provider.
+ *
+ * NOTE: This file is read at codegen time and written to output.
+ * Any changes here will affect all generated CLI embedder modules.
+ */
+
+import OllamaClient from '@agentic-kit/ollama';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type EmbedderFunction = (text: string) => Promise<number[]>;
+
+export interface EmbedderConfig {
+  /** Provider name: 'ollama' or 'custom' */
+  provider: string;
+  /** Model identifier (e.g. 'nomic-embed-text') */
+  model?: string;
+  /** Base URL for the provider (e.g. 'http://localhost:11434' for Ollama) */
+  baseUrl?: string;
+}
+
+// ─── Built-in Ollama Provider ────────────────────────────────────────────────
+
+function createOllamaEmbedder(
+  baseUrl: string = 'http://localhost:11434',
+  model: string = 'nomic-embed-text',
+): EmbedderFunction {
+  const client = new OllamaClient(baseUrl);
+  return async (text: string): Promise<number[]> => {
+    return client.generateEmbedding(text, model);
+  };
+}
+
+// ─── Embedder Resolution ─────────────────────────────────────────────────────
+
+/**
+ * Resolve an embedder function from environment variables or appstash config.
+ *
+ * Resolution order:
+ *   1. EMBEDDER_PROVIDER env var (+ EMBEDDER_MODEL, EMBEDDER_BASE_URL)
+ *   2. appstash config keys: embedder.provider, embedder.model, embedder.baseUrl
+ *   3. null (no embedder configured)
+ *
+ * @param store - Optional appstash config store for reading persisted config
+ * @returns An EmbedderFunction or null if no embedder is configured
+ */
+export function resolveEmbedder(
+  store?: { getVar: (key: string) => string | undefined },
+): EmbedderFunction | null {
+  // 1. Check environment variables first
+  const envProvider = process.env.EMBEDDER_PROVIDER;
+  if (envProvider) {
+    return buildEmbedder({
+      provider: envProvider,
+      model: process.env.EMBEDDER_MODEL,
+      baseUrl: process.env.EMBEDDER_BASE_URL,
+    });
+  }
+
+  // 2. Check appstash config
+  if (store) {
+    const configProvider = store.getVar('embedder.provider');
+    if (configProvider) {
+      return buildEmbedder({
+        provider: configProvider,
+        model: store.getVar('embedder.model'),
+        baseUrl: store.getVar('embedder.baseUrl'),
+      });
+    }
+  }
+
+  // 3. No embedder configured
+  return null;
+}
+
+/**
+ * Build an embedder function from a config object.
+ */
+function buildEmbedder(config: EmbedderConfig): EmbedderFunction | null {
+  switch (config.provider) {
+    case 'ollama':
+      return createOllamaEmbedder(config.baseUrl, config.model);
+    default:
+      console.error(
+        `Unknown embedder provider: '${config.provider}'. Supported: ollama`,
+      );
+      return null;
+  }
+}
+
+/**
+ * Auto-embed text values in vector where-clause fields.
+ *
+ * When --auto-embed is passed, any vector field in the where clause that
+ * contains a text string (instead of a float array) will be converted to
+ * an embedding vector using the configured embedder.
+ *
+ * @param where - The where clause object (mutated in place)
+ * @param vectorFieldNames - Names of vector embedding fields (e.g. ['vectorEmbedding'])
+ * @param embedder - The resolved embedder function
+ * @returns The modified where clause
+ */
+export async function autoEmbedWhere(
+  where: Record<string, unknown>,
+  vectorFieldNames: string[],
+  embedder: EmbedderFunction,
+): Promise<Record<string, unknown>> {
+  for (const fieldName of vectorFieldNames) {
+    const fieldValue = where[fieldName];
+    if (fieldValue && typeof fieldValue === 'object') {
+      const input = fieldValue as Record<string, unknown>;
+      // If 'vector' is a string, embed it
+      if (typeof input.vector === 'string') {
+        const text = input.vector;
+        const embedding = await embedder(text);
+        input.vector = embedding;
+      }
+    } else if (typeof fieldValue === 'string') {
+      // Shorthand: --where.vectorEmbedding "text" with --auto-embed
+      // becomes { vector: [embedded], metric: 'COSINE' }
+      const embedding = await embedder(fieldValue);
+      where[fieldName] = { vector: embedding };
+    }
+  }
+  return where;
+}
+
+/**
+ * Auto-embed text values in mutation input data (create/update).
+ *
+ * When --auto-embed is passed on create or update, any vector field in
+ * the input data that contains a text string will be converted to an
+ * embedding vector using the configured embedder.
+ *
+ * Usage:
+ *   csdk article create --input.embedding "Machine learning concepts" --auto-embed
+ *   csdk article update --id xxx --input.embedding "Updated description" --auto-embed
+ *
+ * This is a CLI-only convenience — in production, database triggers or
+ * a job queue should handle embedding generation.
+ *
+ * @param data - The mutation input data object (mutated in place)
+ * @param vectorFieldNames - Names of vector embedding fields (e.g. ['embedding'])
+ * @param embedder - The resolved embedder function
+ * @returns The modified data object with text values replaced by vectors
+ */
+export async function autoEmbedInput(
+  data: Record<string, unknown>,
+  vectorFieldNames: string[],
+  embedder: EmbedderFunction,
+): Promise<Record<string, unknown>> {
+  for (const fieldName of vectorFieldNames) {
+    const fieldValue = data[fieldName];
+    if (typeof fieldValue === 'string') {
+      // Text string → embed to vector array
+      const embedding = await embedder(fieldValue);
+      data[fieldName] = embedding;
+    }
+    // If it's already an array (pre-computed vector), leave it as-is
+  }
+  return data;
+}

package/core/generate.js

@@ -587,12 +587,14 @@ async function generateMulti(options) {
             const firstTargetConfig = configs[names[0]];
             const multiNodeHttpAdapter = firstTargetConfig?.nodeHttpAdapter === true ||
                 (firstTargetConfig?.nodeHttpAdapter !== false);
+            const multiConditionEnabled = firstTargetConfig?.codegen?.condition === true;
             const { files } = (0, cli_1.generateMultiTargetCli)({
                 toolName,
                 builtinNames: cliConfig.builtinNames,
                 targets: cliTargets,
                 nodeHttpAdapter: multiNodeHttpAdapter,
                 entryPoint: cliConfig.entryPoint,
+                condition: multiConditionEnabled,
             });
             const cliFilesToWrite = files.map((file) => ({
                 path: node_path_1.default.posix.join('cli', file.fileName),

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

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { toKebabCase } from 'komoji';
+import { toKebabCase } from 'inflekt';
 import { generateCode } from '../babel-ast';
 import { getGeneratedFileHeader, getTableNames } from '../utils';
 function createImportDeclaration(moduleSpecifier, defaultImportName) {

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

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { toKebabCase } from 'komoji';
+import { toKebabCase } from 'inflekt';
 import { generateCode } from '../babel-ast';
 import { getGeneratedFileHeader, ucFirst } from '../utils';
 import { buildQuestionsArray } from './arg-mapper';

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

@@ -1,5 +1,5 @@
-import { toKebabCase } from 'komoji';
-import { flattenArgs, flattenedArgsToFlags, cleanTypeName, getEditableFields, categorizeSpecialFields, buildSpecialFieldsMarkdown, getReadmeHeader, getReadmeFooter, buildSkillFile, buildSkillReference, } from '../docs-utils';
+import { toKebabCase } from 'inflekt';
+import { flattenArgs, flattenedArgsToFlags, cleanTypeName, getEditableFields, categorizeSpecialFields, buildSpecialFieldsMarkdown, buildSearchExamples, buildSearchExamplesMarkdown, getReadmeHeader, getReadmeFooter, buildSkillFile, buildSkillReference, } from '../docs-utils';
 import { getScalarFields, getTableNames, getPrimaryKeyInfo, } from '../utils';
 import { getFieldsWithDefaults } from './table-command-generator';
 export { resolveDocsConfig } from '../docs-utils';
@@ -124,6 +124,7 @@ export function generateReadme(tables, customOperations, toolName, registry) {
             }
             const specialGroups = categorizeSpecialFields(table, registry);
             lines.push(...buildSpecialFieldsMarkdown(specialGroups));
+            lines.push(...buildSearchExamplesMarkdown(specialGroups, toolName, kebab));
             lines.push('');
         }
     }
@@ -358,18 +359,13 @@ export function generateSkills(tables, customOperations, toolName, targetName, r
                     },
                     {
                         description: `List ${singularName} records with field selection`,
-                        code: [`${toolName} ${kebab} list --fields id,${pk.name}`],
+                        code: [`${toolName} ${kebab} list --select id,${pk.name}`],
                     },
                     {
                         description: `List ${singularName} records with filtering and ordering`,
                         code: [`${toolName} ${kebab} list --where.${pk.name}.equalTo <value> --orderBy ${pk.name.replace(/([A-Z])/g, '_$1').toUpperCase()}_ASC`],
                     },
-                    ...(skillSpecialGroups.some((g) => g.category === 'search' || g.category === 'embedding')
-                        ? [{
-                                description: `Search ${singularName} records`,
-                                code: [`${toolName} ${kebab} search "query text" --limit 10 --fields id,searchScore`],
-                            }]
-                        : []),
+                    ...buildSearchExamples(skillSpecialGroups, toolName, kebab),
                     {
                         description: `Create a ${singularName}`,
                         code: [
@@ -656,6 +652,7 @@ export function generateMultiTargetReadme(input) {
             }
             const mtSpecialGroups = categorizeSpecialFields(table, registry);
             lines.push(...buildSpecialFieldsMarkdown(mtSpecialGroups));
+            lines.push(...buildSearchExamplesMarkdown(mtSpecialGroups, toolName, `${tgt.name}:${kebab}`));
             lines.push('');
         }
         for (const op of tgt.customOperations) {
@@ -958,12 +955,7 @@ export function generateMultiTargetSkills(input) {
                             description: `List ${singularName} records with filtering and ordering`,
                             code: [`${toolName} ${cmd} list --where.${pk.name}.equalTo <value> --orderBy ${pk.name.replace(/([A-Z])/g, '_$1').toUpperCase()}_ASC`],
                         },
-                        ...(mtSkillSpecialGroups.some((g) => g.category === 'search' || g.category === 'embedding')
-                            ? [{
-                                    description: `Search ${singularName} records`,
-                                    code: [`${toolName} ${cmd} search "query text" --limit 10 --fields id,searchScore`],
-                                }]
-                            : []),
+                        ...buildSearchExamples(mtSkillSpecialGroups, toolName, cmd),
                         {
                             description: `Create a ${singularName}`,
                             code: [

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

@@ -43,6 +43,8 @@ export interface GenerateMultiTargetCliOptions {
     nodeHttpAdapter?: boolean;
     /** Generate a runnable index.ts entry point */
     entryPoint?: boolean;
+    /** Whether PostGraphile condition types are enabled (default: true) */
+    condition?: boolean;
 }
 export declare function resolveBuiltinNames(targetNames: string[], userOverrides?: BuiltinNames): {
     auth: string;
@@ -62,5 +64,5 @@ export { generateReadme, generateAgentsDocs, generateSkills, generateMultiTarget
 export type { MultiTargetDocsInput } from './docs-generator';
 export { resolveDocsConfig } from '../docs-utils';
 export type { GeneratedDocFile } from '../docs-utils';
-export { generateUtilsFile, generateEntryPointFile } from './utils-generator';
+export { generateUtilsFile, generateEntryPointFile, generateEmbedderFile } from './utils-generator';
 export type { GeneratedFile, MultiTargetExecutorInput } from './executor-generator';

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

@@ -5,7 +5,7 @@ import { generateExecutorFile, generateMultiTargetExecutorFile } from './executo
 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';
+import { generateUtilsFile, generateNodeFetchFile, generateEntryPointFile, generateEmbedderFile } from './utils-generator';
 export function generateCli(options) {
     const { tables, customOperations, config } = options;
     const files = [];
@@ -21,6 +21,11 @@ export function generateCli(options) {
     files.push(executorFile);
     const utilsFile = generateUtilsFile();
     files.push(utilsFile);
+    // Generate embedder module if any table has vector embedding fields
+    const hasAnyEmbeddings = tables.some((t) => t.fields.some((f) => f.type.gqlType === 'Vector' || f.type.gqlType === '[Float]'));
+    if (hasAnyEmbeddings) {
+        files.push(generateEmbedderFile());
+    }
     // Generate node HTTP adapter if configured (for *.localhost subdomain routing)
     if (useNodeHttpAdapter) {
         files.push(generateNodeFetchFile());
@@ -29,9 +34,11 @@ export function generateCli(options) {
     files.push(contextFile);
     const authFile = generateAuthCommand(toolName);
     files.push(authFile);
+    const conditionEnabled = config.codegen?.condition === true;
     for (const table of tables) {
         const tableFile = generateTableCommand(table, {
             typeRegistry: options.typeRegistry,
+            condition: conditionEnabled,
         });
         files.push(tableFile);
     }
@@ -78,6 +85,7 @@ export function resolveBuiltinNames(targetNames, userOverrides) {
 }
 export function generateMultiTargetCli(options) {
     const { toolName, targets } = options;
+    const conditionEnabled = options.condition === true;
     const files = [];
     const targetNames = targets.map((t) => t.name);
     const builtinNames = resolveBuiltinNames(targetNames, options.builtinNames);
@@ -92,6 +100,11 @@ export function generateMultiTargetCli(options) {
     files.push(executorFile);
     const utilsFile = generateUtilsFile();
     files.push(utilsFile);
+    // Generate embedder module if any target has tables with vector embedding fields
+    const hasAnyMtEmbeddings = targets.some((tgt) => tgt.tables.some((t) => t.fields.some((f) => f.type.gqlType === 'Vector' || f.type.gqlType === '[Float]')));
+    if (hasAnyMtEmbeddings) {
+        files.push(generateEmbedderFile());
+    }
     // Generate node HTTP adapter if configured (for *.localhost subdomain routing)
     if (options.nodeHttpAdapter) {
         files.push(generateNodeFetchFile());
@@ -122,6 +135,7 @@ export function generateMultiTargetCli(options) {
                 targetName: target.name,
                 executorImportPath: '../../executor',
                 typeRegistry: target.typeRegistry,
+                condition: conditionEnabled,
             });
             files.push(tableFile);
         }
@@ -173,4 +187,4 @@ export { generateHelpersFile } from './helpers-generator';
 export { generateContextCommand, generateAuthCommand, generateMultiTargetContextCommand, generateAuthCommandWithName, } from './infra-generator';
 export { generateReadme, generateAgentsDocs, generateSkills, generateMultiTargetReadme, generateMultiTargetAgentsDocs, generateMultiTargetSkills, } from './docs-generator';
 export { resolveDocsConfig } from '../docs-utils';
-export { generateUtilsFile, generateEntryPointFile } from './utils-generator';
+export { generateUtilsFile, generateEntryPointFile, generateEmbedderFile } from './utils-generator';

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

@@ -6,5 +6,7 @@ export interface TableCommandOptions {
     executorImportPath?: string;
     /** TypeRegistry from introspection, used to check field defaults */
     typeRegistry?: TypeRegistry;
+    /** Whether PostGraphile condition types are enabled (default: true) */
+    condition?: boolean;
 }
 export declare function generateTableCommand(table: Table, options?: TableCommandOptions): GeneratedFile;