postgresdk 0.15.6 → 0.16.1

package/dist/cli.js

@@ -1051,6 +1051,8 @@ function postgresTypeToTsType(column, enums) {
       case "_int8":
       case "_integer":
         return "number[]";
+      case "vector":
+        return "number[]";
       default:
         return "string";
     }
@@ -1204,6 +1206,8 @@ function postgresTypeToJsonType(pgType, enums) {
     case "_int8":
     case "_integer":
       return "number[]";
+    case "vector":
+      return "number[]";
     default:
       return "string";
   }
@@ -1397,6 +1401,12 @@ function generateUnifiedContractMarkdown(contract) {
   lines.push("| `$ilike` | Pattern match (case-insensitive) | `{ email: { $ilike: '%@GMAIL%' } }` | String |");
   lines.push("| `$is` | IS NULL | `{ deleted_at: { $is: null } }` | Nullable fields |");
   lines.push("| `$isNot` | IS NOT NULL | `{ created_by: { $isNot: null } }` | Nullable fields |");
+  lines.push("| `$jsonbContains` | JSONB contains | `{ metadata: { $jsonbContains: { tags: ['premium'] } } }` | JSONB/JSON |");
+  lines.push("| `$jsonbContainedBy` | JSONB contained by | `{ metadata: { $jsonbContainedBy: {...} } }` | JSONB/JSON |");
+  lines.push("| `$jsonbHasKey` | JSONB has key | `{ settings: { $jsonbHasKey: 'theme' } }` | JSONB/JSON |");
+  lines.push("| `$jsonbHasAnyKeys` | JSONB has any keys | `{ settings: { $jsonbHasAnyKeys: ['dark', 'light'] } }` | JSONB/JSON |");
+  lines.push("| `$jsonbHasAllKeys` | JSONB has all keys | `{ config: { $jsonbHasAllKeys: ['api', 'db'] } }` | JSONB/JSON |");
+  lines.push("| `$jsonbPath` | JSONB nested value | `{ meta: { $jsonbPath: { path: ['user', 'age'], operator: '$gte', value: 18 } } }` | JSONB/JSON |");
   lines.push("");
   lines.push("### Logical Operators");
   lines.push("");
@@ -1505,6 +1515,43 @@ function generateUnifiedContractMarkdown(contract) {
   lines.push("");
   lines.push("**Note:** Column names are validated by Zod schemas. Only valid table columns are accepted, preventing SQL injection.");
   lines.push("");
+  lines.push("## Vector Search");
+  lines.push("");
+  lines.push("For tables with `vector` columns (requires pgvector extension), use the `vector` parameter for similarity search:");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("// Basic similarity search");
+  lines.push("const results = await sdk.embeddings.list({");
+  lines.push("  vector: {");
+  lines.push("    field: 'embedding',");
+  lines.push("    query: [0.1, 0.2, 0.3, ...],  // Your embedding vector");
+  lines.push("    metric: 'cosine'  // 'cosine' (default), 'l2', or 'inner'");
+  lines.push("  },");
+  lines.push("  limit: 10");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Results include _distance field");
+  lines.push("results.data[0]._distance;  // Similarity distance");
+  lines.push("");
+  lines.push("// Distance threshold filtering");
+  lines.push("const closeMatches = await sdk.embeddings.list({");
+  lines.push("  vector: {");
+  lines.push("    field: 'embedding',");
+  lines.push("    query: queryVector,");
+  lines.push("    maxDistance: 0.5  // Only return results within this distance");
+  lines.push("  }");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Hybrid search: vector + WHERE filters");
+  lines.push("const filtered = await sdk.embeddings.list({");
+  lines.push("  vector: { field: 'embedding', query: queryVector },");
+  lines.push("  where: {");
+  lines.push("    status: 'published',");
+  lines.push("    embedding: { $isNot: null }");
+  lines.push("  }");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
   lines.push("## Resources");
   lines.push("");
   for (const resource of contract.resources) {
@@ -2510,19 +2557,35 @@ async function introspect(connectionString, schema) {
     for (const r of tablesRows.rows)
       ensureTable(tables, r.table);
     const colsRows = await pg.query(`
-      SELECT table_name, column_name, is_nullable, udt_name, data_type, column_default
-      FROM information_schema.columns
-      WHERE table_schema = $1
-      ORDER BY table_name, ordinal_position
+      SELECT
+        c.table_name,
+        c.column_name,
+        c.is_nullable,
+        c.udt_name,
+        c.data_type,
+        c.column_default,
+        a.atttypmod
+      FROM information_schema.columns c
+      LEFT JOIN pg_catalog.pg_class cl ON cl.relname = c.table_name
+      LEFT JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace AND n.nspname = c.table_schema
+      LEFT JOIN pg_catalog.pg_attribute a ON a.attrelid = cl.oid AND a.attname = c.column_name
+      WHERE c.table_schema = $1
+      ORDER BY c.table_name, c.ordinal_position
       `, [schema]);
     for (const r of colsRows.rows) {
       const t = ensureTable(tables, r.table_name);
-      t.columns.push({
+      const pgType = (r.udt_name ?? r.data_type).toLowerCase();
+      const col = {
         name: r.column_name,
-        pgType: (r.udt_name ?? r.data_type).toLowerCase(),
+        pgType,
         nullable: r.is_nullable === "YES",
         hasDefault: r.column_default != null
-      });
+      };
+      const isVectorType = pgType === "vector" || pgType === "halfvec" || pgType === "sparsevec" || pgType === "bit";
+      if (isVectorType && r.atttypmod != null && r.atttypmod !== -1) {
+        col.vectorDimension = r.atttypmod - 4;
+      }
+      t.columns.push(col);
     }
     const pkRows = await pg.query(`
       SELECT
@@ -2799,6 +2862,7 @@ function emitParamsZod(table, graph) {
   const includeSpecSchema = `z.any()`;
   const pkSchema = hasCompositePk ? `z.object({ ${safePk.map((col) => `${col}: z.string().min(1)`).join(", ")} })` : `z.string().min(1)`;
   return `import { z } from "zod";
+import { VectorSearchParamsSchema } from "./shared.js";
 
 // Schema for primary key parameters
 export const ${Type}PkSchema = ${pkSchema};
@@ -2809,6 +2873,7 @@ export const ${Type}ListParamsSchema = z.object({
   limit: z.number().int().positive().max(1000).optional(),
   offset: z.number().int().nonnegative().optional(),
   where: z.any().optional(),
+  vector: VectorSearchParamsSchema.optional(),
   orderBy: z.enum([${columnNames}]).optional(),
   order: z.enum(["asc", "desc"]).optional()
 }).strict();
@@ -2835,7 +2900,16 @@ export const PaginationParamsSchema = z.object({
   offset: z.number().int().nonnegative().optional()
 }).strict();
 
+// Shared vector search schema (used across all tables)
+export const VectorSearchParamsSchema = z.object({
+  field: z.string().min(1),
+  query: z.array(z.number()),
+  metric: z.enum(["cosine", "l2", "inner"]).optional(),
+  maxDistance: z.number().nonnegative().optional()
+}).strict();
+
 export type PaginationParams = z.infer<typeof PaginationParamsSchema>;
+export type VectorSearchParams = z.infer<typeof VectorSearchParamsSchema>;
 `;
 }
 
@@ -2904,7 +2978,13 @@ const listSchema = z.object({
   limit: z.number().int().positive().max(1000).optional(),
   offset: z.number().int().min(0).optional(),
   orderBy: z.union([columnEnum, z.array(columnEnum)]).optional(),
-  order: z.union([z.enum(["asc", "desc"]), z.array(z.enum(["asc", "desc"]))]).optional()
+  order: z.union([z.enum(["asc", "desc"]), z.array(z.enum(["asc", "desc"]))]).optional(),
+  vector: z.object({
+    field: z.string(),
+    query: z.array(z.number()),
+    metric: z.enum(["cosine", "l2", "inner"]).optional(),
+    maxDistance: z.number().optional()
+  }).optional()
 });
 
 /**
@@ -3086,9 +3166,14 @@ ${hasAuth ? `
 // src/emit-client.ts
 init_utils();
 init_emit_include_methods();
+function isVectorType(pgType) {
+  const t = pgType.toLowerCase();
+  return t === "vector" || t === "halfvec" || t === "sparsevec" || t === "bit";
+}
 function emitClient(table, graph, opts, model) {
   const Type = pascal(table.name);
   const ext = opts.useJsExtensions ? ".js" : "";
+  const hasVectorColumns = table.columns.some((c) => isVectorType(c.pgType));
   const pkCols = Array.isArray(table.pk) ? table.pk : table.pk ? [table.pk] : [];
   const safePk = pkCols.length ? pkCols : ["id"];
   const hasCompositePk = safePk.length > 1;
@@ -3168,6 +3253,13 @@ ${typeImports}
 ${otherTableImports.join(`
 `)}
 
+/**
+ * Helper type to merge JSONB type overrides into base types
+ * @example
+ * type UserWithMetadata = MergeJsonb<SelectUser, { metadata: { tags: string[] } }>;
+ */
+type MergeJsonb<TBase, TJsonb> = Omit<TBase, keyof TJsonb> & TJsonb;
+
 /**
  * Client for ${table.name} table operations
  */
@@ -3179,8 +3271,20 @@ export class ${Type}Client extends BaseClient {
    * @param data - The data to insert
    * @returns The created record
    */
-  async create(data: Insert${Type}): Promise<Select${Type}> {
-    return this.post<Select${Type}>(this.resource, data);
+  async create(data: Insert${Type}): Promise<Select${Type}>;
+  /**
+   * Create a new ${table.name} record with JSONB type overrides
+   * @param data - The data to insert
+   * @returns The created record with typed JSONB fields
+   * @example
+   * type Metadata = { tags: string[]; prefs: { theme: 'light' | 'dark' } };
+   * const user = await client.create<{ metadata: Metadata }>({ name: 'Alice', metadata: { tags: [], prefs: { theme: 'light' } } });
+   */
+  async create<TJsonb extends Partial<Select${Type}>>(
+    data: MergeJsonb<Insert${Type}, TJsonb>
+  ): Promise<MergeJsonb<Select${Type}, TJsonb>>;
+  async create(data: any): Promise<any> {
+    return this.post<any>(this.resource, data);
   }
 
   /**
@@ -3188,9 +3292,18 @@ export class ${Type}Client extends BaseClient {
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @returns The record if found, null otherwise
    */
-  async getByPk(pk: ${pkType}): Promise<Select${Type} | null> {
+  async getByPk(pk: ${pkType}): Promise<Select${Type} | null>;
+  /**
+   * Get a ${table.name} record by primary key with JSONB type overrides
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @returns The record with typed JSONB fields if found, null otherwise
+   */
+  async getByPk<TJsonb extends Partial<Select${Type}>>(
+    pk: ${pkType}
+  ): Promise<MergeJsonb<Select${Type}, TJsonb> | null>;
+  async getByPk(pk: ${pkType}): Promise<any> {
     const path = ${pkPathExpr};
-    return this.get<Select${Type} | null>(\`\${this.resource}/\${path}\`);
+    return this.get<any>(\`\${this.resource}/\${path}\`);
   }
 
   /**
@@ -3211,8 +3324,48 @@ export class ${Type}Client extends BaseClient {
     where?: Where<Select${Type}>;
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<Select${Type}>> {
-    return this.post<PaginatedResponse<Select${Type}>>(\`\${this.resource}/list\`, params ?? {});
+  }): Promise<PaginatedResponse<Select${Type}>>;${hasVectorColumns ? `
+  /**
+   * List ${table.name} records with vector similarity search
+   * @param params - Query parameters with vector search enabled
+   * @param params.vector - Vector similarity search configuration
+   * @returns Paginated results with _distance field included
+   */
+  async list(params: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;
+    vector: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Select${Type} & { _distance: number }>>;` : ""}
+  /**
+   * List ${table.name} records with pagination and filtering, with JSONB type overrides
+   * @param params - Query parameters with typed JSONB fields in where clause
+   * @returns Paginated results with typed JSONB fields
+   */
+  async list<TJsonb extends Partial<Select${Type}>>(params?: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<MergeJsonb<Select${Type}, TJsonb>>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<MergeJsonb<Select${Type}, TJsonb>>>;
+  async list(params?: any): Promise<any> {
+    return this.post<any>(\`\${this.resource}/list\`, params ?? {});
   }
 
   /**
@@ -3221,9 +3374,20 @@ export class ${Type}Client extends BaseClient {
    * @param patch - Partial data to update
    * @returns The updated record if found, null otherwise
    */
-  async update(pk: ${pkType}, patch: Update${Type}): Promise<Select${Type} | null> {
+  async update(pk: ${pkType}, patch: Update${Type}): Promise<Select${Type} | null>;
+  /**
+   * Update a ${table.name} record by primary key with JSONB type overrides
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update with typed JSONB fields
+   * @returns The updated record with typed JSONB fields if found, null otherwise
+   */
+  async update<TJsonb extends Partial<Select${Type}>>(
+    pk: ${pkType},
+    patch: MergeJsonb<Update${Type}, TJsonb>
+  ): Promise<MergeJsonb<Select${Type}, TJsonb> | null>;
+  async update(pk: ${pkType}, patch: any): Promise<any> {
     const path = ${pkPathExpr};
-    return this.patch<Select${Type} | null>(\`\${this.resource}/\${path}\`, patch);
+    return this.patch<any>(\`\${this.resource}/\${path}\`, patch);
   }
 
   /**
@@ -3231,9 +3395,18 @@ export class ${Type}Client extends BaseClient {
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @returns The deleted record if found, null otherwise
    */
-  async delete(pk: ${pkType}): Promise<Select${Type} | null> {
+  async delete(pk: ${pkType}): Promise<Select${Type} | null>;
+  /**
+   * Delete a ${table.name} record by primary key with JSONB type overrides
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @returns The deleted record with typed JSONB fields if found, null otherwise
+   */
+  async delete<TJsonb extends Partial<Select${Type}>>(
+    pk: ${pkType}
+  ): Promise<MergeJsonb<Select${Type}, TJsonb> | null>;
+  async delete(pk: ${pkType}): Promise<any> {
     const path = ${pkPathExpr};
-    return this.del<Select${Type} | null>(\`\${this.resource}/\${path}\`);
+    return this.del<any>(\`\${this.resource}/\${path}\`);
   }
 ${includeMethodsCode}}
 `;
@@ -3904,6 +4077,25 @@ function emitWhereTypes() {
  * To make changes, modify your schema or configuration and regenerate.
  */
 
+/**
+ * Deep partial type for JSONB contains operator
+ */
+type DeepPartial<T> = T extends object ? {
+  [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+
+/**
+ * JSONB path query configuration
+ */
+type JsonbPathQuery = {
+  /** Array of keys to traverse (e.g., ['user', 'preferences', 'theme']) */
+  path: string[];
+  /** Operator to apply to the value at the path (defaults to '$eq') */
+  operator?: '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$like' | '$ilike';
+  /** Value to compare against */
+  value: any;
+};
+
 /**
  * WHERE clause operators for filtering
  */
@@ -3932,6 +4124,20 @@ export type WhereOperator<T> = {
   $is?: null;
   /** IS NOT NULL */
   $isNot?: null;
+
+  // JSONB operators (only available for object/unknown types)
+  /** JSONB contains (@>) - check if column contains the specified JSON structure */
+  $jsonbContains?: T extends object | unknown ? (unknown extends T ? any : DeepPartial<T>) : never;
+  /** JSONB contained by (<@) - check if column is contained by the specified JSON */
+  $jsonbContainedBy?: T extends object | unknown ? any : never;
+  /** JSONB has key (?) - check if top-level key exists */
+  $jsonbHasKey?: T extends object | unknown ? string : never;
+  /** JSONB has any keys (?|) - check if any of the specified keys exist */
+  $jsonbHasAnyKeys?: T extends object | unknown ? string[] : never;
+  /** JSONB has all keys (?&) - check if all of the specified keys exist */
+  $jsonbHasAllKeys?: T extends object | unknown ? string[] : never;
+  /** JSONB path query - query nested values. For multiple paths on same column, use $and */
+  $jsonbPath?: T extends object | unknown ? JsonbPathQuery : never;
 };
 
 /**
@@ -4565,6 +4771,100 @@ function buildWhereClause(
               whereParts.push(\`"\${key}" IS NOT NULL\`);
             }
             break;
+          case '$jsonbContains':
+            whereParts.push(\`"\${key}" @> $\${paramIndex}\`);
+            whereParams.push(JSON.stringify(opValue));
+            paramIndex++;
+            break;
+          case '$jsonbContainedBy':
+            whereParts.push(\`"\${key}" <@ $\${paramIndex}\`);
+            whereParams.push(JSON.stringify(opValue));
+            paramIndex++;
+            break;
+          case '$jsonbHasKey':
+            whereParts.push(\`"\${key}" ? $\${paramIndex}\`);
+            whereParams.push(opValue);
+            paramIndex++;
+            break;
+          case '$jsonbHasAnyKeys':
+            if (Array.isArray(opValue) && opValue.length > 0) {
+              whereParts.push(\`"\${key}" ?| $\${paramIndex}\`);
+              whereParams.push(opValue);
+              paramIndex++;
+            }
+            break;
+          case '$jsonbHasAllKeys':
+            if (Array.isArray(opValue) && opValue.length > 0) {
+              whereParts.push(\`"\${key}" ?& $\${paramIndex}\`);
+              whereParams.push(opValue);
+              paramIndex++;
+            }
+            break;
+          case '$jsonbPath':
+            const pathConfig = opValue;
+            const pathKeys = pathConfig.path;
+            const pathOperator = pathConfig.operator || '$eq';
+            const pathValue = pathConfig.value;
+
+            if (!Array.isArray(pathKeys) || pathKeys.length === 0) {
+              break;
+            }
+
+            // Build path accessor: metadata->'user'->'preferences'->>'theme'
+            // Use -> for all keys except the last one, use ->> for the last to get text
+            const pathParts = pathKeys.slice(0, -1);
+            const lastKey = pathKeys[pathKeys.length - 1];
+
+            let pathExpr = \`"\${key}"\`;
+            for (const part of pathParts) {
+              pathExpr += \`->'\${part}'\`;
+            }
+            pathExpr += \`->>'\${lastKey}'\`;
+
+            // Apply the operator
+            switch (pathOperator) {
+              case '$eq':
+                whereParts.push(\`\${pathExpr} = $\${paramIndex}\`);
+                whereParams.push(String(pathValue));
+                paramIndex++;
+                break;
+              case '$ne':
+                whereParts.push(\`\${pathExpr} != $\${paramIndex}\`);
+                whereParams.push(String(pathValue));
+                paramIndex++;
+                break;
+              case '$gt':
+                whereParts.push(\`(\${pathExpr})::numeric > $\${paramIndex}\`);
+                whereParams.push(pathValue);
+                paramIndex++;
+                break;
+              case '$gte':
+                whereParts.push(\`(\${pathExpr})::numeric >= $\${paramIndex}\`);
+                whereParams.push(pathValue);
+                paramIndex++;
+                break;
+              case '$lt':
+                whereParts.push(\`(\${pathExpr})::numeric < $\${paramIndex}\`);
+                whereParams.push(pathValue);
+                paramIndex++;
+                break;
+              case '$lte':
+                whereParts.push(\`(\${pathExpr})::numeric <= $\${paramIndex}\`);
+                whereParams.push(pathValue);
+                paramIndex++;
+                break;
+              case '$like':
+                whereParts.push(\`\${pathExpr} LIKE $\${paramIndex}\`);
+                whereParams.push(pathValue);
+                paramIndex++;
+                break;
+              case '$ilike':
+                whereParts.push(\`\${pathExpr} ILIKE $\${paramIndex}\`);
+                whereParams.push(pathValue);
+                paramIndex++;
+                break;
+            }
+            break;
         }
       }
     } else if (value === null) {
@@ -4620,17 +4920,51 @@ function buildWhereClause(
 }
 
 /**
- * LIST operation - Get multiple records with optional filters
+ * Get distance operator for vector similarity search
+ */
+function getVectorDistanceOperator(metric?: string): string {
+  switch (metric) {
+    case "l2":
+      return "<->";
+    case "inner":
+      return "<#>";
+    case "cosine":
+    default:
+      return "<=>";
+  }
+}
+
+/**
+ * LIST operation - Get multiple records with optional filters and vector search
  */
 export async function listRecords(
   ctx: OperationContext,
-  params: { where?: any; limit?: number; offset?: number; include?: any; orderBy?: string | string[]; order?: "asc" | "desc" | ("asc" | "desc")[] }
+  params: {
+    where?: any;
+    limit?: number;
+    offset?: number;
+    include?: any;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };
+  }
 ): Promise<{ data?: any; total?: number; limit?: number; offset?: number; hasMore?: boolean; error?: string; issues?: any; needsIncludes?: boolean; includeSpec?: any; status: number }> {
   try {
-    const { where: whereClause, limit = 50, offset = 0, include, orderBy, order } = params;
+    const { where: whereClause, limit = 50, offset = 0, include, orderBy, order, vector } = params;
+
+    // Get distance operator if vector search
+    const distanceOp = vector ? getVectorDistanceOperator(vector.metric) : "";
+
+    // Add vector to params array if present
+    const queryParams: any[] = vector ? [JSON.stringify(vector.query)] : [];
 
-    // Build WHERE clause
-    let paramIndex = 1;
+    // Build WHERE clause for SELECT/UPDATE queries (with vector as $1 if present)
+    let paramIndex = vector ? 2 : 1;
     const whereParts: string[] = [];
     let whereParams: any[] = [];
 
@@ -4649,11 +4983,47 @@ export async function listRecords(
       }
     }
 
+    // Add vector distance threshold filter if specified
+    if (vector?.maxDistance !== undefined) {
+      whereParts.push(\`("\${vector.field}" \${distanceOp} ($1)::vector) < \${vector.maxDistance}\`);
+    }
+
     const whereSQL = whereParts.length > 0 ? \`WHERE \${whereParts.join(" AND ")}\` : "";
 
+    // Build WHERE clause for COUNT query (may need different param indices)
+    let countWhereSQL = whereSQL;
+    let countParams = whereParams;
+
+    if (vector && vector.maxDistance === undefined && whereParams.length > 0) {
+      // COUNT query doesn't use vector, so rebuild WHERE without vector offset
+      const countWhereParts: string[] = [];
+      if (ctx.softDeleteColumn) {
+        countWhereParts.push(\`"\${ctx.softDeleteColumn}" IS NULL\`);
+      }
+      if (whereClause) {
+        const result = buildWhereClause(whereClause, 1); // Start at $1 for count
+        if (result.sql) {
+          countWhereParts.push(result.sql);
+          countParams = result.params;
+        }
+      }
+      countWhereSQL = countWhereParts.length > 0 ? \`WHERE \${countWhereParts.join(" AND ")}\` : "";
+    } else if (vector?.maxDistance !== undefined) {
+      // COUNT query includes vector for maxDistance filter
+      countParams = [...queryParams, ...whereParams];
+    }
+
+    // Build SELECT clause
+    const selectClause = vector
+      ? \`*, ("\${vector.field}" \${distanceOp} ($1)::vector) AS _distance\`
+      : "*";
+
     // Build ORDER BY clause
     let orderBySQL = "";
-    if (orderBy) {
+    if (vector) {
+      // For vector search, always order by distance
+      orderBySQL = \`ORDER BY "\${vector.field}" \${distanceOp} ($1)::vector\`;
+    } else if (orderBy) {
       const columns = Array.isArray(orderBy) ? orderBy : [orderBy];
       const directions = Array.isArray(order) ? order : (order ? Array(columns.length).fill(order) : Array(columns.length).fill("asc"));
 
@@ -4668,16 +5038,16 @@ export async function listRecords(
     // Add limit and offset params
     const limitParam = \`$\${paramIndex}\`;
     const offsetParam = \`$\${paramIndex + 1}\`;
-    const allParams = [...whereParams, limit, offset];
+    const allParams = [...queryParams, ...whereParams, limit, offset];
 
     // Get total count for pagination
-    const countText = \`SELECT COUNT(*) FROM "\${ctx.table}" \${whereSQL}\`;
-    log.debug(\`LIST \${ctx.table} COUNT SQL:\`, countText, "params:", whereParams);
-    const countResult = await ctx.pg.query(countText, whereParams);
+    const countText = \`SELECT COUNT(*) FROM "\${ctx.table}" \${countWhereSQL}\`;
+    log.debug(\`LIST \${ctx.table} COUNT SQL:\`, countText, "params:", countParams);
+    const countResult = await ctx.pg.query(countText, countParams);
     const total = parseInt(countResult.rows[0].count, 10);
 
     // Get paginated data
-    const text = \`SELECT * FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+    const text = \`SELECT \${selectClause} FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
     log.debug(\`LIST \${ctx.table} SQL:\`, text, "params:", allParams);
 
     const { rows } = await ctx.pg.query(text, allParams);