postgresdk 0.15.6 → 0.16.0

package/README.md

@@ -54,6 +54,7 @@ const filtered = await sdk.users.list({
 - 🔒 **Type Safety** - Full TypeScript types derived from your database schema (including enum types)
 - ✅ **Runtime Validation** - Zod schemas for request/response validation
 - 🔗 **Smart Relationships** - Automatic handling of 1:N and M:N relationships with eager loading
+- 🔍 **Vector Search** - Built-in pgvector support for similarity search with multiple distance metrics
 - 🔐 **Built-in Auth** - API key and JWT authentication
 - 🎯 **Zero Config** - Works out of the box with sensible defaults
 - 📦 **Lightweight** - Minimal dependencies, optimized bundle size
@@ -157,7 +158,8 @@ export default {
     jwt: {                              // JWT with multi-service support
       services: [
         { issuer: "my-app", secret: "env:JWT_SECRET" }  // Use "env:" prefix!
-      ]
+      ],
+      audience: "my-api"                // Optional: validate aud claim
     }
   },
 
@@ -599,6 +601,8 @@ result.limit;      // number - page size used
 result.offset;     // number - offset used
 result.hasMore;    // boolean - more pages available
 
+// Note: Maximum limit is 1000 records per request
+
 // Calculate pagination info
 const totalPages = Math.ceil(result.total / result.limit);
 const currentPage = Math.floor(result.offset / result.limit) + 1;
@@ -667,9 +671,127 @@ do {
   offset += limit;
   if (!page.hasMore) break;
 } while (true);
+
+// JSONB queries
+const products = await sdk.products.list({
+  where: {
+    metadata: { $jsonbContains: { tags: ["premium"] } },  // Contains check
+    settings: { $jsonbHasKey: "theme" },                  // Key exists
+    $and: [
+      { config: { $jsonbPath: { path: ["price"], operator: "$gte", value: 100 } } },  // Nested value
+      { config: { $jsonbPath: { path: ["category"], value: "electronics" } } }
+    ]
+  }
+});
+
+// Type-safe JSONB with generics
+type Metadata = { tags: string[]; stats: { views: number } };
+const users = await sdk.users.list<{ metadata: Metadata }>({
+  where: {
+    metadata: { $jsonbContains: { tags: ["vip"] } }  // Fully typed!
+  }
+});
+users.data[0].metadata.stats.views;  // TypeScript knows this is a number
+```
+
+#### Vector Search (pgvector)
+
+PostgreSDK automatically detects `vector` columns and enables similarity search using [pgvector](https://github.com/pgvector/pgvector). Requires pgvector extension installed.
+
+```sql
+-- Example schema with vector columns
+CREATE EXTENSION vector;
+
+CREATE TABLE video_sections (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  title TEXT NOT NULL,
+  vision_embedding vector(1536),  -- Image/video embeddings
+  text_embedding vector(1536),     -- Text embeddings
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
 ```
 
-See the generated SDK documentation for all available operators: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$like`, `$ilike`, `$is`, `$isNot`, `$or`, `$and`.
+```typescript
+// Basic vector similarity search
+const results = await sdk.video_sections.list({
+  vector: {
+    field: "vision_embedding",
+    query: visionEmbeddingArray,  // number[] - your embedding vector
+    metric: "cosine"  // "cosine" (default), "l2", or "inner"
+  },
+  limit: 10
+});
+
+// Returns records ordered by similarity, with distance included
+results.data.forEach(section => {
+  console.log(section.title, section._distance);  // _distance auto-included
+});
+
+// Distance threshold filtering
+const closeMatches = await sdk.video_sections.list({
+  vector: {
+    field: "vision_embedding",
+    query: embedding,
+    metric: "cosine",
+    maxDistance: 0.5  // Only return results within this distance
+  },
+  limit: 50
+});
+
+// Hybrid search: combine vector similarity with traditional filters
+const results = await sdk.video_sections.list({
+  vector: {
+    field: "vision_embedding",
+    query: embedding,
+    maxDistance: 0.6
+  },
+  where: {
+    status: "published",
+    vision_embedding: { $isNot: null }  // Ensure embedding exists
+  },
+  limit: 20
+});
+
+// Parallel multi-modal search (vision + text)
+const [visionResults, textResults] = await Promise.all([
+  sdk.video_sections.list({
+    vector: {
+      field: "vision_embedding",
+      query: visionQueryEmbedding,
+      metric: "cosine",
+      maxDistance: 0.6
+    },
+    where: { vision_embedding: { $isNot: null } },
+    limit: 50
+  }),
+
+  sdk.video_sections.list({
+    vector: {
+      field: "text_embedding",
+      query: textQueryEmbedding,
+      metric: "cosine",
+      maxDistance: 0.5
+    },
+    where: { text_embedding: { $isNot: null } },
+    limit: 50
+  })
+]);
+
+// Merge and deduplicate results
+const allResults = [...visionResults.data, ...textResults.data];
+const uniqueResults = Array.from(
+  new Map(allResults.map(r => [r.id, r])).values()
+);
+```
+
+**Distance Metrics:**
+- `cosine`: Cosine distance (best for normalized embeddings, range 0-2)
+- `l2`: Euclidean distance (L2 norm)
+- `inner`: Inner product (negative for similarity)
+
+**Note:** Vector columns are auto-detected during introspection. Rows with `NULL` embeddings are excluded from vector search results.
+
+See the generated SDK documentation for all available operators: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$like`, `$ilike`, `$is`, `$isNot`, `$or`, `$and`, `$jsonbContains`, `$jsonbContainedBy`, `$jsonbHasKey`, `$jsonbHasAnyKeys`, `$jsonbHasAllKeys`, `$jsonbPath`.
 
 ---
 

package/dist/cli.js

@@ -2510,19 +2510,34 @@ 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
-      });
+      };
+      if (pgType === "vector" && r.atttypmod != null && r.atttypmod !== -1) {
+        col.vectorDimension = r.atttypmod - 4;
+      }
+      t.columns.push(col);
     }
     const pkRows = await pg.query(`
       SELECT
@@ -2799,6 +2814,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 +2825,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 +2852,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 +2930,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()
 });
 
 /**
@@ -3168,6 +3200,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 +3218,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 +3239,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 +3271,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}>>;
+  /**
+   * 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>>;
+    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 +3321,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 +3342,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 +4024,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 +4071,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 +4718,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 +4867,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) : "";
 
-    // Build WHERE clause
-    let paramIndex = 1;
+    // Add vector to params array if present
+    const queryParams: any[] = vector ? [JSON.stringify(vector.query)] : [];
+
+    // 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 +4930,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 +4985,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);

package/dist/index.js

@@ -1681,19 +1681,34 @@ 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
-      });
+      };
+      if (pgType === "vector" && r.atttypmod != null && r.atttypmod !== -1) {
+        col.vectorDimension = r.atttypmod - 4;
+      }
+      t.columns.push(col);
     }
     const pkRows = await pg.query(`
       SELECT
@@ -1970,6 +1985,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};
@@ -1980,6 +1996,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();
@@ -2006,7 +2023,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>;
 `;
 }
 
@@ -2075,7 +2101,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()
 });
 
 /**
@@ -2339,6 +2371,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
  */
@@ -2350,8 +2389,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);
   }
 
   /**
@@ -2359,9 +2410,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}\`);
   }
 
   /**
@@ -2382,8 +2442,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}>>;
+  /**
+   * 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>>;
+    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 ?? {});
   }
 
   /**
@@ -2392,9 +2492,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);
   }
 
   /**
@@ -2402,9 +2513,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}}
 `;
@@ -3075,6 +3195,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
  */
@@ -3103,6 +3242,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;
 };
 
 /**
@@ -3736,6 +3889,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) {
@@ -3791,17 +4038,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) : "";
 
-    // Build WHERE clause
-    let paramIndex = 1;
+    // Add vector to params array if present
+    const queryParams: any[] = vector ? [JSON.stringify(vector.query)] : [];
+
+    // Build WHERE clause for SELECT/UPDATE queries (with vector as $1 if present)
+    let paramIndex = vector ? 2 : 1;
     const whereParts: string[] = [];
     let whereParams: any[] = [];
 
@@ -3820,11 +4101,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"));
 
@@ -3839,16 +4156,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);

package/dist/introspect.d.ts

@@ -3,6 +3,7 @@ export type Column = {
     pgType: string;
     nullable: boolean;
     hasDefault: boolean;
+    vectorDimension?: number;
 };
 export type ForeignKey = {
     from: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.15.6",
+  "version": "0.16.0",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {