postgresdk 0.17.0 → 0.18.1

package/dist/cli.js

@@ -2982,10 +2982,10 @@ function emitIncludeSpec(graph) {
 `;
     for (const [relKey, edge] of entries) {
       if (edge.kind === "many") {
-        out += `  ${relKey}?: boolean | { include?: ${toPascal(edge.target)}IncludeSpec; limit?: number; offset?: number; orderBy?: string; order?: "asc" | "desc"; };
+        out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; include?: ${toPascal(edge.target)}IncludeSpec; limit?: number; offset?: number; orderBy?: string; order?: "asc" | "desc"; };
 `;
       } else {
-        out += `  ${relKey}?: boolean | ${toPascal(edge.target)}IncludeSpec;
+        out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; } | ${toPascal(edge.target)}IncludeSpec;
 `;
       }
     }
@@ -3234,9 +3234,30 @@ ${authImport}
 
 const columnEnum = z.enum([${columnNames}]);
 
+const createSchema = Insert${Type}Schema;
+const updateSchema = Update${Type}Schema;
+
+const deleteSchema = z.object({
+  select: z.array(z.string()).min(1).optional(),
+  exclude: z.array(z.string()).min(1).optional()
+}).strict().refine(
+  (data) => !(data.select && data.exclude),
+  { message: "Cannot specify both 'select' and 'exclude' parameters" }
+);
+
+const getByPkQuerySchema = z.object({
+  select: z.array(z.string()).min(1).optional(),
+  exclude: z.array(z.string()).min(1).optional()
+}).strict().refine(
+  (data) => !(data.select && data.exclude),
+  { message: "Cannot specify both 'select' and 'exclude' parameters" }
+);
+
 const listSchema = z.object({
   where: z.any().optional(),
   include: z.any().optional(),
+  select: z.array(z.string()).min(1).optional(),
+  exclude: z.array(z.string()).min(1).optional(),
   limit: z.number().int().positive().max(1000).optional(),
   offset: z.number().int().min(0).optional(),
   orderBy: z.union([columnEnum, z.array(columnEnum)]).optional(),
@@ -3247,7 +3268,10 @@ const listSchema = z.object({
     metric: z.enum(["cosine", "l2", "inner"]).optional(),
     maxDistance: z.number().optional()
   }).optional()` : ""}
-});
+}).strict().refine(
+  (data) => !(data.select && data.exclude),
+  { message: "Cannot specify both 'select' and 'exclude' parameters" }
+);
 
 /**
  * Register all CRUD routes for the ${fileTableName} table
@@ -3260,12 +3284,13 @@ export function register${Type}Routes(app: Hono, deps: { pg: { query: (text: str
   const base = "${opts.apiPathPrefix}/${fileTableName}";
   
   // Create operation context
-  const ctx: coreOps.OperationContext = {
+  const baseCtx: coreOps.OperationContext = {
     pg: deps.pg,
     table: "${fileTableName}",
     pkColumns: ${JSON.stringify(safePkCols)},
     softDeleteColumn: ${softDel ? `"${softDel}"` : "null"},
-    includeMethodsDepth: ${opts.includeMethodsDepth}${vectorColumns.length > 0 ? `,
+    includeMethodsDepth: ${opts.includeMethodsDepth},
+    allColumnNames: [${table.columns.map((c) => `"${c.name}"`).join(", ")}]${vectorColumns.length > 0 ? `,
     vectorColumns: ${JSON.stringify(vectorColumns)}` : ""}
   };
 ${hasAuth ? `
@@ -3276,23 +3301,34 @@ ${hasAuth ? `
   // CREATE
   app.post(base, async (c) => {
     const body = await c.req.json().catch(() => ({}));
-    const parsed = Insert${Type}Schema.safeParse(body);
+    const parsed = createSchema.safeParse(body);
 
     if (!parsed.success) {
       const issues = parsed.error.flatten();
       return c.json({ error: "Invalid body", issues }, 400);
     }
 
+    // Get select/exclude from query params
+    const selectParam = c.req.query("select");
+    const excludeParam = c.req.query("exclude");
+    const select = selectParam ? selectParam.split(",") : undefined;
+    const exclude = excludeParam ? excludeParam.split(",") : undefined;
+
+    if (select && exclude) {
+      return c.json({ error: "Cannot specify both 'select' and 'exclude' parameters" }, 400);
+    }
+
     if (deps.onRequest) {
       await deps.onRequest(c, deps.pg);
     }
 
+    const ctx = { ...baseCtx, select, exclude };
     const result = await coreOps.createRecord(ctx, parsed.data);
-    
+
     if (result.error) {
       return c.json({ error: result.error }, result.status as any);
     }
-    
+
     return c.json(result.data, result.status as any);
   });
 
@@ -3300,16 +3336,30 @@ ${hasAuth ? `
   app.get(\`\${base}/${pkPath}\`, async (c) => {
     ${getPkParams}
 
+    // Parse query params for select/exclude
+    const selectParam = c.req.query("select");
+    const excludeParam = c.req.query("exclude");
+    const queryData: any = {};
+    if (selectParam) queryData.select = selectParam.split(",");
+    if (excludeParam) queryData.exclude = excludeParam.split(",");
+
+    const queryParsed = getByPkQuerySchema.safeParse(queryData);
+    if (!queryParsed.success) {
+      const issues = queryParsed.error.flatten();
+      return c.json({ error: "Invalid query parameters", issues }, 400);
+    }
+
     if (deps.onRequest) {
       await deps.onRequest(c, deps.pg);
     }
 
+    const ctx = { ...baseCtx, select: queryParsed.data.select, exclude: queryParsed.data.exclude };
     const result = await coreOps.getByPk(ctx, pkValues);
-    
+
     if (result.error) {
       return c.json({ error: result.error }, result.status as any);
     }
-    
+
     return c.json(result.data, result.status as any);
   });
 
@@ -3326,6 +3376,7 @@ ${hasAuth ? `
       await deps.onRequest(c, deps.pg);
     }
 
+    const ctx = { ...baseCtx, select: body.data.select, exclude: body.data.exclude };
     const result = await coreOps.listRecords(ctx, body.data);
     
     if (result.error) {
@@ -3386,23 +3437,34 @@ ${hasAuth ? `
   app.patch(\`\${base}/${pkPath}\`, async (c) => {
     ${getPkParams}
     const body = await c.req.json().catch(() => ({}));
-    const parsed = Update${Type}Schema.safeParse(body);
+    const parsed = updateSchema.safeParse(body);
 
     if (!parsed.success) {
       const issues = parsed.error.flatten();
       return c.json({ error: "Invalid body", issues }, 400);
     }
 
+    // Get select/exclude from query params
+    const selectParam = c.req.query("select");
+    const excludeParam = c.req.query("exclude");
+    const select = selectParam ? selectParam.split(",") : undefined;
+    const exclude = excludeParam ? excludeParam.split(",") : undefined;
+
+    if (select && exclude) {
+      return c.json({ error: "Cannot specify both 'select' and 'exclude' parameters" }, 400);
+    }
+
     if (deps.onRequest) {
       await deps.onRequest(c, deps.pg);
     }
 
+    const ctx = { ...baseCtx, select, exclude };
     const result = await coreOps.updateRecord(ctx, pkValues, parsed.data);
-    
+
     if (result.error) {
       return c.json({ error: result.error }, result.status as any);
     }
-    
+
     return c.json(result.data, result.status as any);
   });
 
@@ -3410,16 +3472,30 @@ ${hasAuth ? `
   app.delete(\`\${base}/${pkPath}\`, async (c) => {
     ${getPkParams}
 
+    // Parse query params for select/exclude
+    const selectParam = c.req.query("select");
+    const excludeParam = c.req.query("exclude");
+    const queryData: any = {};
+    if (selectParam) queryData.select = selectParam.split(",");
+    if (excludeParam) queryData.exclude = excludeParam.split(",");
+
+    const queryParsed = deleteSchema.safeParse(queryData);
+    if (!queryParsed.success) {
+      const issues = queryParsed.error.flatten();
+      return c.json({ error: "Invalid query parameters", issues }, 400);
+    }
+
     if (deps.onRequest) {
       await deps.onRequest(c, deps.pg);
     }
 
+    const ctx = { ...baseCtx, select: queryParsed.data.select, exclude: queryParsed.data.exclude };
     const result = await coreOps.deleteRecord(ctx, pkValues);
-    
+
     if (result.error) {
       return c.json({ error: result.error }, result.status as any);
     }
-    
+
     return c.json(result.data, result.status as any);
   });
 }
@@ -3507,12 +3583,16 @@ function emitClient(table, graph, opts, model) {
         const paramName = toIncludeParamName(key);
         includeParamNames.push(paramName);
         paramsType = `{
+    select?: string[];
+    exclude?: string[];
     limit?: number;
     offset?: number;
     where?: Where<Select${Type}>;
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
     ${paramName}?: {
+      select?: string[];
+      exclude?: string[];
       orderBy?: string | string[];
       order?: "asc" | "desc";
       limit?: number;
@@ -3525,6 +3605,8 @@ function emitClient(table, graph, opts, model) {
         const paramName = toIncludeParamName(key);
         includeParamNames.push(paramName);
         return `${paramName}?: {
+      select?: string[];
+      exclude?: string[];
       orderBy?: string | string[];
       order?: "asc" | "desc";
       limit?: number;
@@ -3533,6 +3615,8 @@ function emitClient(table, graph, opts, model) {
       }).join(`;
     `);
       paramsType = `{
+    select?: string[];
+    exclude?: string[];
     limit?: number;
     offset?: number;
     where?: Where<Select${Type}>;
@@ -3544,12 +3628,16 @@ function emitClient(table, graph, opts, model) {
       const paramName = toIncludeParamName(pattern.nestedKey);
       includeParamNames.push(paramName);
       paramsType = `{
+    select?: string[];
+    exclude?: string[];
     limit?: number;
     offset?: number;
     where?: Where<Select${Type}>;
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
     ${paramName}?: {
+      select?: string[];
+      exclude?: string[];
       orderBy?: string | string[];
       order?: "asc" | "desc";
       limit?: number;
@@ -3593,12 +3681,14 @@ function emitClient(table, graph, opts, model) {
   /**
    * Get a ${table.name} record by primary key with included related ${relationshipDesc}
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param params - Optional include options
+   * @param params - Optional include options (including select/exclude for base and nested tables)
    * @returns The record with nested ${method.path.join(" and ")} if found, null otherwise
    */
   async ${method.name}(pk: ${pkType}, params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
     const results = await this.post<PaginatedResponse<${baseReturnType}>>(\`\${this.resource}/list\`, {
       where: ${pkWhere},
+      select: params?.select,
+      exclude: params?.exclude,
       include: includeSpec,
       limit: 1
     });
@@ -3672,6 +3762,7 @@ export class ${Type}Client extends BaseClient {
 ${hasJsonbColumns ? `  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
+   * @param options - Optional select/exclude for returned fields
    * @returns The created record
    * @example
    * // With JSONB type override:
@@ -3679,45 +3770,78 @@ ${hasJsonbColumns ? `  /**
    * const user = await client.create<{ metadata: Metadata }>({ name: 'Alice', metadata: { tags: [], prefs: { theme: 'light' } } });
    */
   async create<TJsonb extends Partial<Select${Type}> = {}>(
-    data: NoInfer<Insert${Type}<TJsonb>>
-  ): Promise<Select${Type}<TJsonb>> {
-    return this.post<Select${Type}<TJsonb>>(this.resource, data);
+    data: NoInfer<Insert${Type}<TJsonb>>,
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>> {
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}?\${query}\` : this.resource;
+    return this.post<Select${Type}<TJsonb>>(url, data);
   }` : `  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
+   * @param options - Optional select/exclude for returned fields
    * @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},
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type} | Partial<Select${Type}>> {
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}?\${query}\` : this.resource;
+    return this.post<Select${Type}>(url, data);
   }`}
 
 ${hasJsonbColumns ? `  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Optional select/exclude for returned fields
    * @returns The record if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.getByPk<{ metadata: Metadata }>('user-id');
    */
   async getByPk<TJsonb extends Partial<Select${Type}> = {}>(
-    pk: ${pkType}
-  ): Promise<Select${Type}<TJsonb> | null> {
+    pk: ${pkType},
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>> | null> {
     const path = ${pkPathExpr};
-    return this.get<Select${Type}<TJsonb> | null>(\`\${this.resource}/\${path}\`);
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
+    return this.get<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Optional select/exclude for returned fields
    * @returns The record if found, null otherwise
    */
-  async getByPk(pk: ${pkType}): Promise<Select${Type} | null> {
+  async getByPk(
+    pk: ${pkType},
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type} | Partial<Select${Type}> | null> {
     const path = ${pkPathExpr};
-    return this.get<Select${Type} | null>(\`\${this.resource}/\${path}\`);
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
+    return this.get<Select${Type} | null>(url);
   }`}
 
 ${hasJsonbColumns ? `  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
+   * @param params.select - Array of field names to include in response
+   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
@@ -3727,9 +3851,14 @@ ${hasJsonbColumns ? `  /**
    * @example
    * // With JSONB type override:
    * const users = await client.list<{ metadata: Metadata }>({ where: { status: 'active' } });
+   * @example
+   * // With select:
+   * const users = await client.list({ select: ['id', 'email'] });
    */
   async list<TJsonb extends Partial<Select${Type}> = {}>(params?: {
     include?: any;
+    select?: string[];
+    exclude?: string[];
     limit?: number;
     offset?: number;
     where?: Where<Select${Type}<TJsonb>>;${hasVectorColumns ? `
@@ -3741,21 +3870,28 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<(Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
     return this.post<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }` : `  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
+   * @param params.select - Array of field names to include in response
+   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (see listWith* methods for typed includes)
    * @returns Paginated results with data, total count, and hasMore flag
+   * @example
+   * // With select:
+   * const users = await client.list({ select: ['id', 'email'] });
    */
   async list(params?: {
     include?: any;
+    select?: string[];
+    exclude?: string[];
     limit?: number;
     offset?: number;
     where?: Where<Select${Type}>;${hasVectorColumns ? `
@@ -3767,7 +3903,7 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<(Select${Type} | Partial<Select${Type}>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
     return this.post<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }`}
 
@@ -3775,6 +3911,7 @@ ${hasJsonbColumns ? `  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
+   * @param options - Optional select/exclude for returned fields
    * @returns The updated record if found, null otherwise
    * @example
    * // With JSONB type override:
@@ -3782,42 +3919,74 @@ ${hasJsonbColumns ? `  /**
    */
   async update<TJsonb extends Partial<Select${Type}> = {}>(
     pk: ${pkType},
-    patch: NoInfer<Update${Type}<TJsonb>>
-  ): Promise<Select${Type}<TJsonb> | null> {
+    patch: NoInfer<Update${Type}<TJsonb>>,
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>> | null> {
     const path = ${pkPathExpr};
-    return this.patch<Select${Type}<TJsonb> | null>(\`\${this.resource}/\${path}\`, patch);
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
+    return this.patch<Select${Type}<TJsonb> | null>(url, patch);
   }` : `  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
+   * @param options - Optional select/exclude for returned fields
    * @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},
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type} | Partial<Select${Type}> | null> {
     const path = ${pkPathExpr};
-    return this.patch<Select${Type} | null>(\`\${this.resource}/\${path}\`, patch);
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
+    return this.patch<Select${Type} | null>(url, patch);
   }`}
 
 ${hasJsonbColumns ? `  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Optional select/exclude for returned fields
    * @returns The deleted record if found, null otherwise
    * @example
    * // With JSONB type override:
    * const user = await client.delete<{ metadata: Metadata }>('user-id');
    */
   async delete<TJsonb extends Partial<Select${Type}> = {}>(
-    pk: ${pkType}
-  ): Promise<Select${Type}<TJsonb> | null> {
+    pk: ${pkType},
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>> | null> {
     const path = ${pkPathExpr};
-    return this.del<Select${Type}<TJsonb> | null>(\`\${this.resource}/\${path}\`);
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
+    return this.del<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Optional select/exclude for returned fields
    * @returns The deleted record if found, null otherwise
    */
-  async delete(pk: ${pkType}): Promise<Select${Type} | null> {
+  async delete(
+    pk: ${pkType},
+    options?: { select?: string[]; exclude?: string[] }
+  ): Promise<Select${Type} | Partial<Select${Type}> | null> {
     const path = ${pkPathExpr};
-    return this.del<Select${Type} | null>(\`\${this.resource}/\${path}\`);
+    const queryParams = new URLSearchParams();
+    if (options?.select) queryParams.set('select', options.select.join(','));
+    if (options?.exclude) queryParams.set('exclude', options.exclude.join(','));
+    const query = queryParams.toString();
+    const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
+    return this.del<Select${Type} | null>(url);
   }`}
 ${includeMethodsCode}}
 `;
@@ -4087,6 +4256,8 @@ type TableName = keyof Graph;
 type IncludeSpec = any;
 
 type RelationOptions = {
+  select?: string[];
+  exclude?: string[];
   limit?: number;
   offset?: number;
   orderBy?: string;
@@ -4155,6 +4326,44 @@ function groupByTuple(rows: any[], cols: string[]) {
   return map;
 }
 
+/**
+ * Filters row fields based on select/exclude
+ * @param rows - Rows to filter
+ * @param select - Fields to keep
+ * @param exclude - Fields to remove
+ * @returns Filtered rows
+ */
+function filterFields<T extends Record<string, any>>(
+  rows: T[],
+  select?: string[],
+  exclude?: string[]
+): T[] {
+  if (!select && !exclude) return rows;
+
+  if (select && exclude) {
+    throw new Error("Cannot specify both select and exclude");
+  }
+
+  return rows.map(row => {
+    if (select) {
+      // Keep only selected fields
+      const filtered: any = {};
+      for (const key of select) {
+        if (key in row) filtered[key] = row[key];
+      }
+      return filtered as T;
+    } else if (exclude) {
+      // Remove excluded fields
+      const filtered = { ...row };
+      for (const key of exclude) {
+        delete filtered[key];
+      }
+      return filtered as T;
+    }
+    return row;
+  });
+}
+
 // Public entry
 export async function loadIncludes(
   root: TableName,
@@ -4200,6 +4409,8 @@ export async function loadIncludes(
 
         if (specValue && typeof specValue === "object" && specValue !== true) {
           // Extract options
+          if (specValue.select !== undefined) options.select = specValue.select;
+          if (specValue.exclude !== undefined) options.exclude = specValue.exclude;
           if (specValue.limit !== undefined) options.limit = specValue.limit;
           if (specValue.offset !== undefined) options.offset = specValue.offset;
           if (specValue.orderBy !== undefined) options.orderBy = specValue.orderBy;
@@ -4213,7 +4424,7 @@ export async function loadIncludes(
           } else {
             // Build childSpec from non-option keys
             const nonOptionKeys = Object.keys(specValue).filter(
-              k => k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
+              k => k !== 'select' && k !== 'exclude' && k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
             );
             if (nonOptionKeys.length > 0) {
               childSpec = {};
@@ -4250,6 +4461,8 @@ export async function loadIncludes(
 
         if (specValue && typeof specValue === "object" && specValue !== true) {
           // Extract options
+          if (specValue.select !== undefined) options.select = specValue.select;
+          if (specValue.exclude !== undefined) options.exclude = specValue.exclude;
           if (specValue.limit !== undefined) options.limit = specValue.limit;
           if (specValue.offset !== undefined) options.offset = specValue.offset;
           if (specValue.orderBy !== undefined) options.orderBy = specValue.orderBy;
@@ -4263,7 +4476,7 @@ export async function loadIncludes(
           } else {
             // Build childSpec from non-option keys
             const nonOptionKeys = Object.keys(specValue).filter(
-              k => k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
+              k => k !== 'select' && k !== 'exclude' && k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
             );
             if (nonOptionKeys.length > 0) {
               childSpec = {};
@@ -4292,18 +4505,25 @@ export async function loadIncludes(
       } else {
         // kind === "one"
         // Could be belongs-to (current has FK to target) OR has-one (target unique-FK to current)
+        const specValue = s[key];
+        const options: RelationOptions = {};
+        if (specValue && typeof specValue === "object" && specValue !== true) {
+          if (specValue.select !== undefined) options.select = specValue.select;
+          if (specValue.exclude !== undefined) options.exclude = specValue.exclude;
+        }
+
         const currFks = (FK_INDEX as any)[table] as Array<{from:string[];toTable:string;to:string[]}>;
         const toTarget = currFks.find(f => f.toTable === target);
         if (toTarget) {
           try {
-            await loadBelongsTo(table, target, rows, key);
+            await loadBelongsTo(table, target, rows, key, options);
           } catch (e: any) {
             log.error("loadBelongsTo failed", { table, key, target }, e?.message ?? e);
             for (const r of rows) r[key] = null;
           }
         } else {
           try {
-            await loadHasOne(table, target, rows, key);
+            await loadHasOne(table, target, rows, key, options);
           } catch (e: any) {
             log.error("loadHasOne failed", { table, key, target }, e?.message ?? e);
             for (const r of rows) r[key] = null;
@@ -4322,7 +4542,7 @@ export async function loadIncludes(
     }
   }
 
-  async function loadBelongsTo(curr: TableName, target: TableName, rows: any[], key: string) {
+  async function loadBelongsTo(curr: TableName, target: TableName, rows: any[], key: string, options: RelationOptions = {}) {
     // current has FK cols referencing target PK
     const fk = (FK_INDEX as any)[curr].find((f: any) => f.toTable === target);
     if (!fk) { for (const r of rows) r[key] = null; return; }
@@ -4337,7 +4557,10 @@ export async function loadIncludes(
     log.debug("belongsTo SQL", { curr, target, key, sql, paramsCount: params.length });
     const { rows: targets } = await pg.query(sql, params);
 
-    const idx = indexByTuple(targets, pkCols);
+    // Apply select/exclude filtering
+    const filteredTargets = filterFields(targets, options.select, options.exclude);
+
+    const idx = indexByTuple(filteredTargets, pkCols);
     for (const r of rows) {
       const tup = fk.from.map((c: string) => r[c]);
       const keyStr = JSON.stringify(tup);
@@ -4345,7 +4568,7 @@ export async function loadIncludes(
     }
   }
 
-  async function loadHasOne(curr: TableName, target: TableName, rows: any[], key: string) {
+  async function loadHasOne(curr: TableName, target: TableName, rows: any[], key: string, options: RelationOptions = {}) {
     // target has FK cols referencing current PK (unique)
     const fk = (FK_INDEX as any)[target].find((f: any) => f.toTable === curr);
     if (!fk) { for (const r of rows) r[key] = null; return; }
@@ -4361,7 +4584,10 @@ export async function loadIncludes(
     log.debug("hasOne SQL", { curr, target, key, sql, paramsCount: params.length });
     const { rows: targets } = await pg.query(sql, params);
 
-    const idx = indexByTuple(targets, fk.from);
+    // Apply select/exclude filtering
+    const filteredTargets = filterFields(targets, options.select, options.exclude);
+
+    const idx = indexByTuple(filteredTargets, fk.from);
     for (const r of rows) {
       const keyStr = JSON.stringify(pkCols.map((c: string) => r[c]));
       r[key] = idx.get(keyStr) ?? null;
@@ -4415,7 +4641,10 @@ export async function loadIncludes(
       return rest;
     });
 
-    const groups = groupByTuple(cleanChildren, fk.from);
+    // Apply select/exclude filtering
+    const filteredChildren = filterFields(cleanChildren, options.select, options.exclude);
+
+    const groups = groupByTuple(filteredChildren, fk.from);
     for (const r of rows) {
       const keyStr = JSON.stringify(pkCols.map((c: string) => r[c]));
       r[key] = groups.get(keyStr) ?? [];
@@ -4472,8 +4701,15 @@ export async function loadIncludes(
         return { ...rest, __parent_fk };
       });
 
+      // Apply select/exclude filtering (preserve __parent_fk for grouping)
+      const filteredResults = cleanResults.map((row: any) => {
+        const { __parent_fk, ...rest } = row;
+        const filtered = filterFields([rest], options.select, options.exclude)[0] ?? rest;
+        return { ...filtered, __parent_fk };
+      });
+
       const grouped = new Map<string, any[]>();
-      for (const row of cleanResults) {
+      for (const row of filteredResults) {
         const { __parent_fk, ...cleanRow } = row;
         const arr = grouped.get(__parent_fk) ?? [];
         arr.push(cleanRow);
@@ -4500,7 +4736,10 @@ export async function loadIncludes(
       log.debug("manyToMany target SQL", { curr, target, via, key, sql: sqlT, paramsCount: paramsT.length });
       const { rows: targets } = await pg.query(sqlT, paramsT);
 
-      const tIdx = indexByTuple(targets, (PKS as any)[target]);
+      // Apply select/exclude filtering
+      const filteredTargets = filterFields(targets, options.select, options.exclude);
+
+      const tIdx = indexByTuple(filteredTargets, (PKS as any)[target]);
 
       // 3) Group junction rows by current pk tuple, map to target rows
       const byCurr = groupByTuple(jrows, toCurr.from);
@@ -5264,6 +5503,9 @@ export interface OperationContext {
   softDeleteColumn?: string | null;
   includeMethodsDepth: number;
   vectorColumns?: string[];
+  allColumnNames?: string[];
+  select?: string[];
+  exclude?: string[];
 }
 
 const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
@@ -5272,6 +5514,49 @@ const log = {
   error: (...args: any[]) => console.error("[sdk]", ...args),
 };
 
+/**
+ * Builds SQL column list from select/exclude parameters
+ * @param select - Columns to include (mutually exclusive with exclude)
+ * @param exclude - Columns to exclude (mutually exclusive with select)
+ * @param allColumns - All available columns for the table
+ * @param alwaysInclude - Columns to always include (e.g., vector distance)
+ * @returns SQL column list string (e.g., "id", "name", "email")
+ */
+function buildColumnList(
+  select: string[] | undefined,
+  exclude: string[] | undefined,
+  allColumns: string[] | undefined,
+  alwaysInclude: string[] = []
+): string {
+  if (select && exclude) {
+    throw new Error("Cannot specify both 'select' and 'exclude' parameters");
+  }
+
+  // If no allColumns provided, fallback to *
+  if (!allColumns || allColumns.length === 0) {
+    return "*";
+  }
+
+  let columns: string[];
+
+  if (select) {
+    // Use only selected columns
+    columns = select;
+  } else if (exclude) {
+    // Use all except excluded
+    columns = allColumns.filter(col => !exclude.includes(col));
+  } else {
+    // Use all columns (default behavior)
+    return "*";
+  }
+
+  // Add always-include columns (e.g., _distance for vector search)
+  const finalColumns = [...new Set([...columns, ...alwaysInclude])];
+
+  // Quote column names and join
+  return finalColumns.map(col => \`"\${col}"\`).join(", ");
+}
+
 /**
  * Prepare query parameters for PostgreSQL.
  * The pg library should handle JSONB automatically, but there are edge cases
@@ -5328,9 +5613,10 @@ export async function createRecord(
     }
 
     const placeholders = cols.map((_, i) => '$' + (i + 1)).join(", ");
+    const returningClause = buildColumnList(ctx.select, ctx.exclude, ctx.allColumnNames);
     const text = \`INSERT INTO "\${ctx.table}" (\${cols.map(c => '"' + c + '"').join(", ")})
                    VALUES (\${placeholders})
-                   RETURNING *\`;
+                   RETURNING \${returningClause}\`;
 
     log.debug("SQL:", text, "vals:", vals);
     const { rows } = await ctx.pg.query(text, prepareParams(vals));
@@ -5370,8 +5656,9 @@ export async function getByPk(
     const wherePkSql = hasCompositePk
       ? ctx.pkColumns.map((c, i) => \`"\${c}" = $\${i + 1}\`).join(" AND ")
       : \`"\${ctx.pkColumns[0]}" = $1\`;
-    
-    const text = \`SELECT * FROM "\${ctx.table}" WHERE \${wherePkSql} LIMIT 1\`;
+
+    const columns = buildColumnList(ctx.select, ctx.exclude, ctx.allColumnNames);
+    const text = \`SELECT \${columns} FROM "\${ctx.table}" WHERE \${wherePkSql} LIMIT 1\`;
     log.debug(\`GET \${ctx.table} by PK:\`, pkValues, "SQL:", text);
 
     const { rows } = await ctx.pg.query(text, prepareParams(pkValues));
@@ -5740,9 +6027,10 @@ export async function listRecords(
     }
 
     // Build SELECT clause
+    const baseColumns = buildColumnList(ctx.select, ctx.exclude, ctx.allColumnNames);
     const selectClause = vector
-      ? \`*, ("\${vector.field}" \${distanceOp} ($1)::vector) AS _distance\`
-      : "*";
+      ? \`\${baseColumns}, ("\${vector.field}" \${distanceOp} ($1)::vector) AS _distance\`
+      : baseColumns;
 
     // Build ORDER BY clause
     let orderBySQL = "";
@@ -5843,7 +6131,8 @@ export async function updateRecord(
       .map((k, i) => \`"\${k}" = $\${i + pkValues.length + 1}\`)
       .join(", ");
 
-    const text = \`UPDATE "\${ctx.table}" SET \${setSql} WHERE \${wherePkSql} RETURNING *\`;
+    const returningClause = buildColumnList(ctx.select, ctx.exclude, ctx.allColumnNames);
+    const text = \`UPDATE "\${ctx.table}" SET \${setSql} WHERE \${wherePkSql} RETURNING \${returningClause}\`;
     const params = [...pkValues, ...Object.values(filteredData)];
 
     log.debug(\`PATCH \${ctx.table} SQL:\`, text, "params:", params);
@@ -5891,10 +6180,11 @@ export async function deleteRecord(
     const wherePkSql = hasCompositePk
       ? ctx.pkColumns.map((c, i) => \`"\${c}" = $\${i + 1}\`).join(" AND ")
       : \`"\${ctx.pkColumns[0]}" = $1\`;
-    
+
+    const returningClause = buildColumnList(ctx.select, ctx.exclude, ctx.allColumnNames);
     const text = ctx.softDeleteColumn
-      ? \`UPDATE "\${ctx.table}" SET "\${ctx.softDeleteColumn}" = NOW() WHERE \${wherePkSql} RETURNING *\`
-      : \`DELETE FROM "\${ctx.table}" WHERE \${wherePkSql} RETURNING *\`;
+      ? \`UPDATE "\${ctx.table}" SET "\${ctx.softDeleteColumn}" = NOW() WHERE \${wherePkSql} RETURNING \${returningClause}\`
+      : \`DELETE FROM "\${ctx.table}" WHERE \${wherePkSql} RETURNING \${returningClause}\`;
 
     log.debug(\`DELETE \${ctx.softDeleteColumn ? '(soft)' : ''} \${ctx.table} SQL:\`, text, "pk:", pkValues);
     const { rows } = await ctx.pg.query(text, prepareParams(pkValues));