postgresdk 0.16.9 → 0.16.12

package/README.md

@@ -584,6 +584,58 @@ const nestedResult = await sdk.authors.list({
 const authorsWithBooksAndTags = nestedResult.data;
 ```
 
+**Typed Include Methods:**
+
+For convenience and better type safety, the SDK generates `listWith*` and `getByPkWith*` methods for common include patterns:
+
+```typescript
+// Typed methods provide full autocomplete and type safety
+const result = await sdk.authors.listWithBooks();
+// result.data[0].books is typed as SelectBooks[]
+
+// Control included relations with options
+const topAuthors = await sdk.authors.listWithBooks({
+  limit: 10,
+  booksInclude: {
+    orderBy: 'published_at',
+    order: 'desc',
+    limit: 5  // Only get top 5 books per author
+  }
+});
+
+// Parallel includes (multiple relations at once)
+const result2 = await sdk.books.listWithAuthorAndTags({
+  tagsInclude: {
+    orderBy: 'name',
+    limit: 3
+  }
+  // author is included automatically (one-to-one)
+});
+
+// Nested includes with control at each level
+const result3 = await sdk.authors.listWithBooksAndTags({
+  booksInclude: {
+    orderBy: 'title',
+    limit: 10,
+    include: {
+      tags: {
+        orderBy: 'name',
+        order: 'asc',
+        limit: 5
+      }
+    }
+  }
+});
+
+// Works with getByPk too
+const author = await sdk.authors.getByPkWithBooks('author-id', {
+  booksInclude: {
+    orderBy: 'published_at',
+    limit: 3
+  }
+});
+```
+
 #### Filtering & Pagination
 
 All `list()` methods return pagination metadata:

package/dist/cli.js

@@ -2810,7 +2810,7 @@ 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; };
+        out += `  ${relKey}?: boolean | { include?: ${toPascal(edge.target)}IncludeSpec; limit?: number; offset?: number; orderBy?: string; order?: "asc" | "desc"; };
 `;
       } else {
         out += `  ${relKey}?: boolean | ${toPascal(edge.target)}IncludeSpec;
@@ -3255,6 +3255,24 @@ function isJsonbType(pgType) {
   const t = pgType.toLowerCase();
   return t === "json" || t === "jsonb";
 }
+function toIncludeParamName(relationKey) {
+  return `${relationKey}Include`;
+}
+function analyzeIncludeSpec(includeSpec) {
+  const keys = Object.keys(includeSpec);
+  if (keys.length > 1) {
+    return { type: "parallel", keys };
+  }
+  const key = keys[0];
+  if (!key) {
+    return { type: "single", keys: [] };
+  }
+  const value = includeSpec[key];
+  if (typeof value === "object" && value !== null) {
+    return { type: "nested", keys: [key], nestedKey: key, nestedValue: value };
+  }
+  return { type: "single", keys: [key] };
+}
 function emitClient(table, graph, opts, model) {
   const Type = pascal(table.name);
   const ext = opts.useJsExtensions ? ".js" : "";
@@ -3293,39 +3311,157 @@ function emitClient(table, graph, opts, model) {
   let includeMethodsCode = "";
   for (const method of includeMethods) {
     const isGetByPk = method.name.startsWith("getByPk");
-    const baseParams = isGetByPk ? "" : `params?: Omit<{ limit?: number; offset?: number; where?: Where<Select${Type}>; orderBy?: string | string[]; order?: "asc" | "desc" | ("asc" | "desc")[]; }, "include">`;
+    const pattern = analyzeIncludeSpec(method.includeSpec);
     const relationshipDesc = method.path.map((p, i) => {
       const isLast = i === method.path.length - 1;
       const relation = method.isMany[i] ? "many" : "one";
       return isLast ? p : `${p} -> `;
     }).join("");
+    let paramsType = "";
+    const includeParamNames = [];
+    if (pattern.type === "single") {
+      const key = pattern.keys[0];
+      if (key) {
+        const paramName = toIncludeParamName(key);
+        includeParamNames.push(paramName);
+        paramsType = `{
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+    ${paramName}?: {
+      orderBy?: string | string[];
+      order?: "asc" | "desc";
+      limit?: number;
+      offset?: number;
+    };
+  }`;
+      }
+    } else if (pattern.type === "parallel") {
+      const includeParams = pattern.keys.map((key) => {
+        const paramName = toIncludeParamName(key);
+        includeParamNames.push(paramName);
+        return `${paramName}?: {
+      orderBy?: string | string[];
+      order?: "asc" | "desc";
+      limit?: number;
+      offset?: number;
+    }`;
+      }).join(`;
+    `);
+      paramsType = `{
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+    ${includeParams};
+  }`;
+    } else if (pattern.type === "nested" && pattern.nestedKey) {
+      const paramName = toIncludeParamName(pattern.nestedKey);
+      includeParamNames.push(paramName);
+      paramsType = `{
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+    ${paramName}?: {
+      orderBy?: string | string[];
+      order?: "asc" | "desc";
+      limit?: number;
+      offset?: number;
+      include?: any;
+    };
+  }`;
+    }
     if (isGetByPk) {
       const pkWhere = hasCompositePk ? `{ ${safePk.map((col) => `${col}: pk.${col}`).join(", ")} }` : `{ ${safePk[0] || "id"}: pk }`;
       const baseReturnType = method.returnType.replace(" | null", "");
+      let transformCode = "";
+      if (includeParamNames.length > 0) {
+        const destructure = includeParamNames.map((name) => name).join(", ");
+        if (pattern.type === "single") {
+          const key = pattern.keys[0];
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure} } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};`;
+        } else if (pattern.type === "parallel") {
+          const includeSpecCode = pattern.keys.map((key, idx) => {
+            const paramName = includeParamNames[idx];
+            return `${key}: ${paramName} ?? true`;
+          }).join(", ");
+          transformCode = `
+    const { ${destructure} } = params ?? {};
+    const includeSpec = { ${includeSpecCode} };`;
+        } else if (pattern.type === "nested" && pattern.nestedKey) {
+          const key = pattern.nestedKey;
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure} } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};`;
+        }
+      } else {
+        transformCode = `
+    const includeSpec = ${JSON.stringify(method.includeSpec)};`;
+      }
       includeMethodsCode += `
   /**
    * 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
    * @returns The record with nested ${method.path.join(" and ")} if found, null otherwise
    */
-  async ${method.name}(pk: ${pkType}): Promise<${method.returnType}> {
+  async ${method.name}(pk: ${pkType}, params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
     const results = await this.post<PaginatedResponse<${baseReturnType}>>(\`\${this.resource}/list\`, {
       where: ${pkWhere},
-      include: ${JSON.stringify(method.includeSpec)},
+      include: includeSpec,
       limit: 1
     });
     return (results.data[0] as ${baseReturnType}) ?? null;
   }
 `;
     } else {
+      let transformCode = "";
+      if (includeParamNames.length > 0) {
+        const destructure = includeParamNames.map((name) => name).join(", ");
+        if (pattern.type === "single") {
+          const key = pattern.keys[0];
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure}, ...baseParams } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
+        } else if (pattern.type === "parallel") {
+          const includeSpecCode = pattern.keys.map((key, idx) => {
+            const paramName = includeParamNames[idx];
+            return `${key}: ${paramName} ?? true`;
+          }).join(", ");
+          transformCode = `
+    const { ${destructure}, ...baseParams } = params ?? {};
+    const includeSpec = { ${includeSpecCode} };
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
+        } else if (pattern.type === "nested" && pattern.nestedKey) {
+          const key = pattern.nestedKey;
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure}, ...baseParams } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
+        }
+      } else {
+        transformCode = `
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...params, include: ${JSON.stringify(method.includeSpec)} });`;
+      }
       includeMethodsCode += `
   /**
    * List ${table.name} records with included related ${relationshipDesc}
-   * @param params - Query parameters (where, orderBy, order, limit, offset)
+   * @param params - Query parameters (where, orderBy, order, limit, offset) and include options
    * @returns Paginated results with nested ${method.path.join(" and ")} included
    */
-  async ${method.name}(${baseParams}): Promise<${method.returnType}> {
-    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...params, include: ${JSON.stringify(method.includeSpec)} });
+  async ${method.name}(params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
   }
 `;
     }
@@ -3402,7 +3538,7 @@ ${hasJsonbColumns ? `  /**
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
    * @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: 100)
+   * @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
@@ -3431,7 +3567,7 @@ ${hasJsonbColumns ? `  /**
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
    * @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: 100)
+   * @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
@@ -3768,6 +3904,13 @@ type Graph = typeof RELATION_GRAPH;
 type TableName = keyof Graph;
 type IncludeSpec = any;
 
+type RelationOptions = {
+  limit?: number;
+  offset?: number;
+  orderBy?: string;
+  order?: "asc" | "desc";
+};
+
 // Debug helpers (enabled with SDK_DEBUG=1)
 const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
 const log = {
@@ -3869,14 +4012,43 @@ export async function loadIncludes(
       // Safely run each loader; never let one bad edge 500 the route
       if (rel.via) {
         // M:N via junction
+        const specValue = s[key];
+        const options: RelationOptions = {};
+        let childSpec: any = undefined;
+
+        if (specValue && typeof specValue === "object" && specValue !== true) {
+          // Extract options
+          if (specValue.limit !== undefined) options.limit = specValue.limit;
+          if (specValue.offset !== undefined) options.offset = specValue.offset;
+          if (specValue.orderBy !== undefined) options.orderBy = specValue.orderBy;
+          if (specValue.order !== undefined) options.order = specValue.order;
+
+          // Extract nested spec - support both formats:
+          // New: { limit: 3, include: { tags: true } }
+          // Old: { tags: true } (backward compatibility)
+          if (specValue.include !== undefined) {
+            childSpec = specValue.include;
+          } else {
+            // Build childSpec from non-option keys
+            const nonOptionKeys = Object.keys(specValue).filter(
+              k => k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
+            );
+            if (nonOptionKeys.length > 0) {
+              childSpec = {};
+              for (const k of nonOptionKeys) {
+                childSpec[k] = specValue[k];
+              }
+            }
+          }
+        }
+
         try {
-          await loadManyToMany(table, target, rel.via as string, rows, key);
+          await loadManyToMany(table, target, rel.via as string, rows, key, options);
         } catch (e: any) {
           log.error("loadManyToMany failed", { table, key, via: rel.via, target }, e?.message ?? e);
           for (const r of rows) r[key] = [];
         }
-        // Recurse if nested include specified
-        const childSpec = s[key] && typeof s[key] === "object" ? s[key] : undefined;
+
         if (childSpec) {
           const children = rows.flatMap(r => (r[key] ?? []));
           try {
@@ -3890,13 +4062,43 @@ export async function loadIncludes(
 
       if (rel.kind === "many") {
         // 1:N target has FK to current
+        const specValue = s[key];
+        const options: RelationOptions = {};
+        let childSpec: any = undefined;
+
+        if (specValue && typeof specValue === "object" && specValue !== true) {
+          // Extract options
+          if (specValue.limit !== undefined) options.limit = specValue.limit;
+          if (specValue.offset !== undefined) options.offset = specValue.offset;
+          if (specValue.orderBy !== undefined) options.orderBy = specValue.orderBy;
+          if (specValue.order !== undefined) options.order = specValue.order;
+
+          // Extract nested spec - support both formats:
+          // New: { limit: 3, include: { tags: true } }
+          // Old: { tags: true } (backward compatibility)
+          if (specValue.include !== undefined) {
+            childSpec = specValue.include;
+          } else {
+            // Build childSpec from non-option keys
+            const nonOptionKeys = Object.keys(specValue).filter(
+              k => k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
+            );
+            if (nonOptionKeys.length > 0) {
+              childSpec = {};
+              for (const k of nonOptionKeys) {
+                childSpec[k] = specValue[k];
+              }
+            }
+          }
+        }
+
         try {
-          await loadOneToMany(table, target, rows, key);
+          await loadOneToMany(table, target, rows, key, options);
         } catch (e: any) {
           log.error("loadOneToMany failed", { table, key, target }, e?.message ?? e);
           for (const r of rows) r[key] = [];
         }
-        const childSpec = s[key] && typeof s[key] === "object" ? s[key] : undefined;
+
         if (childSpec) {
           const children = rows.flatMap(r => (r[key] ?? []));
           try {
@@ -3984,7 +4186,7 @@ export async function loadIncludes(
     }
   }
 
-  async function loadOneToMany(curr: TableName, target: TableName, rows: any[], key: string) {
+  async function loadOneToMany(curr: TableName, target: TableName, rows: any[], key: string, options: RelationOptions = {}) {
     // target has FK cols referencing current PK
     const fk = (FK_INDEX as any)[target].find((f: any) => f.toTable === curr);
     if (!fk) { for (const r of rows) r[key] = []; return; }
@@ -3995,18 +4197,50 @@ export async function loadIncludes(
 
     const where = buildOrAndPredicate(fk.from, tuples.length, 1);
     const params = tuples.flat();
-    const sql = \`SELECT * FROM "\${target}" WHERE \${where}\`;
-    log.debug("oneToMany SQL", { curr, target, key, sql, paramsCount: params.length });
+
+    // Build SQL with optional ORDER BY, LIMIT, OFFSET
+    let sql = \`SELECT * FROM "\${target}" WHERE \${where}\`;
+
+    // If limit/offset are needed, use window functions to limit per parent
+    if (options.limit !== undefined || options.offset !== undefined) {
+      const orderByClause = options.orderBy
+        ? \`ORDER BY "\${options.orderBy}" \${options.order === 'desc' ? 'DESC' : 'ASC'}\`
+        : 'ORDER BY (SELECT NULL)';
+
+      const partitionCols = fk.from.map((c: string) => \`"\${c}"\`).join(', ');
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? 999999999;
+
+      sql = \`
+        SELECT * FROM (
+          SELECT *, ROW_NUMBER() OVER (PARTITION BY \${partitionCols} \${orderByClause}) as __rn
+          FROM "\${target}"
+          WHERE \${where}
+        ) __sub
+        WHERE __rn > \${offset} AND __rn <= \${offset + limit}
+      \`;
+    } else if (options.orderBy) {
+      // Just ORDER BY without limit/offset
+      sql += \` ORDER BY "\${options.orderBy}" \${options.order === 'desc' ? 'DESC' : 'ASC'}\`;
+    }
+
+    log.debug("oneToMany SQL", { curr, target, key, sql, paramsCount: params.length, options });
     const { rows: children } = await pg.query(sql, params);
 
-    const groups = groupByTuple(children, fk.from);
+    // Remove __rn column if it exists
+    const cleanChildren = children.map((row: any) => {
+      const { __rn, ...rest } = row;
+      return rest;
+    });
+
+    const groups = groupByTuple(cleanChildren, fk.from);
     for (const r of rows) {
       const keyStr = JSON.stringify(pkCols.map((c: string) => r[c]));
       r[key] = groups.get(keyStr) ?? [];
     }
   }
 
-  async function loadManyToMany(curr: TableName, target: TableName, via: string, rows: any[], key: string) {
+  async function loadManyToMany(curr: TableName, target: TableName, via: string, rows: any[], key: string, options: RelationOptions = {}) {
     // via has two FKs: one to curr, one to target
     const toCurr = (FK_INDEX as any)[via].find((f: any) => f.toTable === curr);
     const toTarget = (FK_INDEX as any)[via].find((f: any) => f.toTable === target);
@@ -4016,31 +4250,83 @@ export async function loadIncludes(
     const tuples = distinctTuples(rows, pkCols).filter(t => t.every((v: any) => v != null));
     if (!tuples.length) { for (const r of rows) r[key] = []; return; }
 
-    // 1) Load junction rows for current parents
     const whereVia = buildOrAndPredicate(toCurr.from, tuples.length, 1);
-    const sqlVia = \`SELECT * FROM "\${via}" WHERE \${whereVia}\`;
-    const paramsVia = tuples.flat();
-    log.debug("manyToMany junction SQL", { curr, target, via, key, sql: sqlVia, paramsCount: paramsVia.length });
-    const { rows: jrows } = await pg.query(sqlVia, paramsVia);
-
-    if (!jrows.length) { for (const r of rows) r[key] = []; return; }
+    const params = tuples.flat();
 
-    // 2) Load targets by distinct target fk tuples in junction
-    const tTuples = distinctTuples(jrows, toTarget.from);
-    const whereT = buildOrAndPredicate((PKS as any)[target], tTuples.length, 1);
-    const sqlT = \`SELECT * FROM "\${target}" WHERE \${whereT}\`;
-    const paramsT = tTuples.flat();
-    log.debug("manyToMany target SQL", { curr, target, via, key, sql: sqlT, paramsCount: paramsT.length });
-    const { rows: targets } = await pg.query(sqlT, paramsT);
+    // If we have limit/offset/orderBy, use a JOIN with window functions
+    if (options.limit !== undefined || options.offset !== undefined || options.orderBy) {
+      const orderByClause = options.orderBy
+        ? \`ORDER BY t."\${options.orderBy}" \${options.order === 'desc' ? 'DESC' : 'ASC'}\`
+        : 'ORDER BY (SELECT NULL)';
+
+      const partitionCols = toCurr.from.map((c: string) => \`j."\${c}"\`).join(', ');
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? 999999999;
+
+      const targetPkCols = (PKS as any)[target] as string[];
+      const joinConditions = toTarget.from.map((jCol: string, i: number) => {
+        return \`j."\${jCol}" = t."\${targetPkCols[i]}"\`;
+      }).join(' AND ');
+
+      const sql = \`
+        SELECT __numbered.*
+        FROM (
+          SELECT t.*,
+                 ROW_NUMBER() OVER (PARTITION BY \${partitionCols} \${orderByClause}) as __rn,
+                 \${toCurr.from.map((c: string) => \`j."\${c}"\`).join(' || \\',\\' || ')} as __parent_fk
+          FROM "\${via}" j
+          INNER JOIN "\${target}" t ON \${joinConditions}
+          WHERE \${whereVia}
+        ) __numbered
+        WHERE __numbered.__rn > \${offset} AND __numbered.__rn <= \${offset + limit}
+      \`;
+
+      log.debug("manyToMany SQL with options", { curr, target, via, key, sql, paramsCount: params.length, options });
+      const { rows: results } = await pg.query(sql, params);
+
+      // Clean and group results
+      const cleanResults = results.map((row: any) => {
+        const { __rn, __parent_fk, ...rest } = row;
+        return { ...rest, __parent_fk };
+      });
 
-    const tIdx = indexByTuple(targets, (PKS as any)[target]);
+      const grouped = new Map<string, any[]>();
+      for (const row of cleanResults) {
+        const { __parent_fk, ...cleanRow } = row;
+        const arr = grouped.get(__parent_fk) ?? [];
+        arr.push(cleanRow);
+        grouped.set(__parent_fk, arr);
+      }
 
-    // 3) Group junction rows by current pk tuple, map to target rows
-    const byCurr = groupByTuple(jrows, toCurr.from);
-    for (const r of rows) {
-      const currKey = JSON.stringify(pkCols.map((c: string) => r[c]));
-      const j = byCurr.get(currKey) ?? [];
-      r[key] = j.map(jr => tIdx.get(JSON.stringify(toTarget.from.map((c: string) => jr[c])))).filter(Boolean);
+      for (const r of rows) {
+        const currKey = pkCols.map((c: string) => r[c]).join(',');
+        r[key] = grouped.get(currKey) ?? [];
+      }
+    } else {
+      // Original logic without options
+      const sqlVia = \`SELECT * FROM "\${via}" WHERE \${whereVia}\`;
+      log.debug("manyToMany junction SQL", { curr, target, via, key, sql: sqlVia, paramsCount: params.length });
+      const { rows: jrows } = await pg.query(sqlVia, params);
+
+      if (!jrows.length) { for (const r of rows) r[key] = []; return; }
+
+      // 2) Load targets by distinct target fk tuples in junction
+      const tTuples = distinctTuples(jrows, toTarget.from);
+      const whereT = buildOrAndPredicate((PKS as any)[target], tTuples.length, 1);
+      const sqlT = \`SELECT * FROM "\${target}" WHERE \${whereT}\`;
+      const paramsT = tTuples.flat();
+      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]);
+
+      // 3) Group junction rows by current pk tuple, map to target rows
+      const byCurr = groupByTuple(jrows, toCurr.from);
+      for (const r of rows) {
+        const currKey = JSON.stringify(pkCols.map((c: string) => r[c]));
+        const j = byCurr.get(currKey) ?? [];
+        r[key] = j.map(jr => tIdx.get(JSON.stringify(toTarget.from.map((c: string) => jr[c])))).filter(Boolean);
+      }
     }
   }
 }
@@ -4119,7 +4405,9 @@ ${baseSelectType}
  * @example Insert${Type}<{ metadata: MyMetadataType }>
  */
 export type Insert${Type}<TJsonb extends Partial<_Insert${Type}Base> = {}> =
-  Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb;
+  {} extends TJsonb
+    ? _Insert${Type}Base
+    : Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb;
 
 /**
  * Type for updating an existing ${table.name} record.
@@ -4129,7 +4417,9 @@ export type Insert${Type}<TJsonb extends Partial<_Insert${Type}Base> = {}> =
  * @example Update${Type}<{ metadata: MyMetadataType }>
  */
 export type Update${Type}<TJsonb extends Partial<_Select${Type}Base> = {}> =
-  Partial<Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb>;
+  {} extends TJsonb
+    ? Partial<_Insert${Type}Base>
+    : Partial<Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb>;
 
 /**
  * Type representing a ${table.name} record from the database.
@@ -4139,7 +4429,9 @@ export type Update${Type}<TJsonb extends Partial<_Select${Type}Base> = {}> =
  * @example Select${Type}<{ metadata: MyMetadataType }>
  */
 export type Select${Type}<TJsonb extends Partial<_Select${Type}Base> = {}> =
-  Omit<_Select${Type}Base, keyof TJsonb> & TJsonb;
+  {} extends TJsonb
+    ? _Select${Type}Base
+    : Omit<_Select${Type}Base, keyof TJsonb> & TJsonb;
 `;
   }
   return `/**

package/dist/index.js

@@ -1909,7 +1909,7 @@ 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; };
+        out += `  ${relKey}?: boolean | { include?: ${toPascal(edge.target)}IncludeSpec; limit?: number; offset?: number; orderBy?: string; order?: "asc" | "desc"; };
 `;
       } else {
         out += `  ${relKey}?: boolean | ${toPascal(edge.target)}IncludeSpec;
@@ -2354,6 +2354,24 @@ function isJsonbType(pgType) {
   const t = pgType.toLowerCase();
   return t === "json" || t === "jsonb";
 }
+function toIncludeParamName(relationKey) {
+  return `${relationKey}Include`;
+}
+function analyzeIncludeSpec(includeSpec) {
+  const keys = Object.keys(includeSpec);
+  if (keys.length > 1) {
+    return { type: "parallel", keys };
+  }
+  const key = keys[0];
+  if (!key) {
+    return { type: "single", keys: [] };
+  }
+  const value = includeSpec[key];
+  if (typeof value === "object" && value !== null) {
+    return { type: "nested", keys: [key], nestedKey: key, nestedValue: value };
+  }
+  return { type: "single", keys: [key] };
+}
 function emitClient(table, graph, opts, model) {
   const Type = pascal(table.name);
   const ext = opts.useJsExtensions ? ".js" : "";
@@ -2392,39 +2410,157 @@ function emitClient(table, graph, opts, model) {
   let includeMethodsCode = "";
   for (const method of includeMethods) {
     const isGetByPk = method.name.startsWith("getByPk");
-    const baseParams = isGetByPk ? "" : `params?: Omit<{ limit?: number; offset?: number; where?: Where<Select${Type}>; orderBy?: string | string[]; order?: "asc" | "desc" | ("asc" | "desc")[]; }, "include">`;
+    const pattern = analyzeIncludeSpec(method.includeSpec);
     const relationshipDesc = method.path.map((p, i) => {
       const isLast = i === method.path.length - 1;
       const relation = method.isMany[i] ? "many" : "one";
       return isLast ? p : `${p} -> `;
     }).join("");
+    let paramsType = "";
+    const includeParamNames = [];
+    if (pattern.type === "single") {
+      const key = pattern.keys[0];
+      if (key) {
+        const paramName = toIncludeParamName(key);
+        includeParamNames.push(paramName);
+        paramsType = `{
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+    ${paramName}?: {
+      orderBy?: string | string[];
+      order?: "asc" | "desc";
+      limit?: number;
+      offset?: number;
+    };
+  }`;
+      }
+    } else if (pattern.type === "parallel") {
+      const includeParams = pattern.keys.map((key) => {
+        const paramName = toIncludeParamName(key);
+        includeParamNames.push(paramName);
+        return `${paramName}?: {
+      orderBy?: string | string[];
+      order?: "asc" | "desc";
+      limit?: number;
+      offset?: number;
+    }`;
+      }).join(`;
+    `);
+      paramsType = `{
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+    ${includeParams};
+  }`;
+    } else if (pattern.type === "nested" && pattern.nestedKey) {
+      const paramName = toIncludeParamName(pattern.nestedKey);
+      includeParamNames.push(paramName);
+      paramsType = `{
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+    ${paramName}?: {
+      orderBy?: string | string[];
+      order?: "asc" | "desc";
+      limit?: number;
+      offset?: number;
+      include?: any;
+    };
+  }`;
+    }
     if (isGetByPk) {
       const pkWhere = hasCompositePk ? `{ ${safePk.map((col) => `${col}: pk.${col}`).join(", ")} }` : `{ ${safePk[0] || "id"}: pk }`;
       const baseReturnType = method.returnType.replace(" | null", "");
+      let transformCode = "";
+      if (includeParamNames.length > 0) {
+        const destructure = includeParamNames.map((name) => name).join(", ");
+        if (pattern.type === "single") {
+          const key = pattern.keys[0];
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure} } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};`;
+        } else if (pattern.type === "parallel") {
+          const includeSpecCode = pattern.keys.map((key, idx) => {
+            const paramName = includeParamNames[idx];
+            return `${key}: ${paramName} ?? true`;
+          }).join(", ");
+          transformCode = `
+    const { ${destructure} } = params ?? {};
+    const includeSpec = { ${includeSpecCode} };`;
+        } else if (pattern.type === "nested" && pattern.nestedKey) {
+          const key = pattern.nestedKey;
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure} } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};`;
+        }
+      } else {
+        transformCode = `
+    const includeSpec = ${JSON.stringify(method.includeSpec)};`;
+      }
       includeMethodsCode += `
   /**
    * 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
    * @returns The record with nested ${method.path.join(" and ")} if found, null otherwise
    */
-  async ${method.name}(pk: ${pkType}): Promise<${method.returnType}> {
+  async ${method.name}(pk: ${pkType}, params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
     const results = await this.post<PaginatedResponse<${baseReturnType}>>(\`\${this.resource}/list\`, {
       where: ${pkWhere},
-      include: ${JSON.stringify(method.includeSpec)},
+      include: includeSpec,
       limit: 1
     });
     return (results.data[0] as ${baseReturnType}) ?? null;
   }
 `;
     } else {
+      let transformCode = "";
+      if (includeParamNames.length > 0) {
+        const destructure = includeParamNames.map((name) => name).join(", ");
+        if (pattern.type === "single") {
+          const key = pattern.keys[0];
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure}, ...baseParams } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
+        } else if (pattern.type === "parallel") {
+          const includeSpecCode = pattern.keys.map((key, idx) => {
+            const paramName = includeParamNames[idx];
+            return `${key}: ${paramName} ?? true`;
+          }).join(", ");
+          transformCode = `
+    const { ${destructure}, ...baseParams } = params ?? {};
+    const includeSpec = { ${includeSpecCode} };
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
+        } else if (pattern.type === "nested" && pattern.nestedKey) {
+          const key = pattern.nestedKey;
+          const paramName = includeParamNames[0];
+          transformCode = `
+    const { ${destructure}, ...baseParams } = params ?? {};
+    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
+        }
+      } else {
+        transformCode = `
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...params, include: ${JSON.stringify(method.includeSpec)} });`;
+      }
       includeMethodsCode += `
   /**
    * List ${table.name} records with included related ${relationshipDesc}
-   * @param params - Query parameters (where, orderBy, order, limit, offset)
+   * @param params - Query parameters (where, orderBy, order, limit, offset) and include options
    * @returns Paginated results with nested ${method.path.join(" and ")} included
    */
-  async ${method.name}(${baseParams}): Promise<${method.returnType}> {
-    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...params, include: ${JSON.stringify(method.includeSpec)} });
+  async ${method.name}(params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
   }
 `;
     }
@@ -2501,7 +2637,7 @@ ${hasJsonbColumns ? `  /**
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
    * @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: 100)
+   * @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
@@ -2530,7 +2666,7 @@ ${hasJsonbColumns ? `  /**
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
    * @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: 100)
+   * @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
@@ -2867,6 +3003,13 @@ type Graph = typeof RELATION_GRAPH;
 type TableName = keyof Graph;
 type IncludeSpec = any;
 
+type RelationOptions = {
+  limit?: number;
+  offset?: number;
+  orderBy?: string;
+  order?: "asc" | "desc";
+};
+
 // Debug helpers (enabled with SDK_DEBUG=1)
 const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
 const log = {
@@ -2968,14 +3111,43 @@ export async function loadIncludes(
       // Safely run each loader; never let one bad edge 500 the route
       if (rel.via) {
         // M:N via junction
+        const specValue = s[key];
+        const options: RelationOptions = {};
+        let childSpec: any = undefined;
+
+        if (specValue && typeof specValue === "object" && specValue !== true) {
+          // Extract options
+          if (specValue.limit !== undefined) options.limit = specValue.limit;
+          if (specValue.offset !== undefined) options.offset = specValue.offset;
+          if (specValue.orderBy !== undefined) options.orderBy = specValue.orderBy;
+          if (specValue.order !== undefined) options.order = specValue.order;
+
+          // Extract nested spec - support both formats:
+          // New: { limit: 3, include: { tags: true } }
+          // Old: { tags: true } (backward compatibility)
+          if (specValue.include !== undefined) {
+            childSpec = specValue.include;
+          } else {
+            // Build childSpec from non-option keys
+            const nonOptionKeys = Object.keys(specValue).filter(
+              k => k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
+            );
+            if (nonOptionKeys.length > 0) {
+              childSpec = {};
+              for (const k of nonOptionKeys) {
+                childSpec[k] = specValue[k];
+              }
+            }
+          }
+        }
+
         try {
-          await loadManyToMany(table, target, rel.via as string, rows, key);
+          await loadManyToMany(table, target, rel.via as string, rows, key, options);
         } catch (e: any) {
           log.error("loadManyToMany failed", { table, key, via: rel.via, target }, e?.message ?? e);
           for (const r of rows) r[key] = [];
         }
-        // Recurse if nested include specified
-        const childSpec = s[key] && typeof s[key] === "object" ? s[key] : undefined;
+
         if (childSpec) {
           const children = rows.flatMap(r => (r[key] ?? []));
           try {
@@ -2989,13 +3161,43 @@ export async function loadIncludes(
 
       if (rel.kind === "many") {
         // 1:N target has FK to current
+        const specValue = s[key];
+        const options: RelationOptions = {};
+        let childSpec: any = undefined;
+
+        if (specValue && typeof specValue === "object" && specValue !== true) {
+          // Extract options
+          if (specValue.limit !== undefined) options.limit = specValue.limit;
+          if (specValue.offset !== undefined) options.offset = specValue.offset;
+          if (specValue.orderBy !== undefined) options.orderBy = specValue.orderBy;
+          if (specValue.order !== undefined) options.order = specValue.order;
+
+          // Extract nested spec - support both formats:
+          // New: { limit: 3, include: { tags: true } }
+          // Old: { tags: true } (backward compatibility)
+          if (specValue.include !== undefined) {
+            childSpec = specValue.include;
+          } else {
+            // Build childSpec from non-option keys
+            const nonOptionKeys = Object.keys(specValue).filter(
+              k => k !== 'limit' && k !== 'offset' && k !== 'orderBy' && k !== 'order'
+            );
+            if (nonOptionKeys.length > 0) {
+              childSpec = {};
+              for (const k of nonOptionKeys) {
+                childSpec[k] = specValue[k];
+              }
+            }
+          }
+        }
+
         try {
-          await loadOneToMany(table, target, rows, key);
+          await loadOneToMany(table, target, rows, key, options);
         } catch (e: any) {
           log.error("loadOneToMany failed", { table, key, target }, e?.message ?? e);
           for (const r of rows) r[key] = [];
         }
-        const childSpec = s[key] && typeof s[key] === "object" ? s[key] : undefined;
+
         if (childSpec) {
           const children = rows.flatMap(r => (r[key] ?? []));
           try {
@@ -3083,7 +3285,7 @@ export async function loadIncludes(
     }
   }
 
-  async function loadOneToMany(curr: TableName, target: TableName, rows: any[], key: string) {
+  async function loadOneToMany(curr: TableName, target: TableName, rows: any[], key: string, options: RelationOptions = {}) {
     // target has FK cols referencing current PK
     const fk = (FK_INDEX as any)[target].find((f: any) => f.toTable === curr);
     if (!fk) { for (const r of rows) r[key] = []; return; }
@@ -3094,18 +3296,50 @@ export async function loadIncludes(
 
     const where = buildOrAndPredicate(fk.from, tuples.length, 1);
     const params = tuples.flat();
-    const sql = \`SELECT * FROM "\${target}" WHERE \${where}\`;
-    log.debug("oneToMany SQL", { curr, target, key, sql, paramsCount: params.length });
+
+    // Build SQL with optional ORDER BY, LIMIT, OFFSET
+    let sql = \`SELECT * FROM "\${target}" WHERE \${where}\`;
+
+    // If limit/offset are needed, use window functions to limit per parent
+    if (options.limit !== undefined || options.offset !== undefined) {
+      const orderByClause = options.orderBy
+        ? \`ORDER BY "\${options.orderBy}" \${options.order === 'desc' ? 'DESC' : 'ASC'}\`
+        : 'ORDER BY (SELECT NULL)';
+
+      const partitionCols = fk.from.map((c: string) => \`"\${c}"\`).join(', ');
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? 999999999;
+
+      sql = \`
+        SELECT * FROM (
+          SELECT *, ROW_NUMBER() OVER (PARTITION BY \${partitionCols} \${orderByClause}) as __rn
+          FROM "\${target}"
+          WHERE \${where}
+        ) __sub
+        WHERE __rn > \${offset} AND __rn <= \${offset + limit}
+      \`;
+    } else if (options.orderBy) {
+      // Just ORDER BY without limit/offset
+      sql += \` ORDER BY "\${options.orderBy}" \${options.order === 'desc' ? 'DESC' : 'ASC'}\`;
+    }
+
+    log.debug("oneToMany SQL", { curr, target, key, sql, paramsCount: params.length, options });
     const { rows: children } = await pg.query(sql, params);
 
-    const groups = groupByTuple(children, fk.from);
+    // Remove __rn column if it exists
+    const cleanChildren = children.map((row: any) => {
+      const { __rn, ...rest } = row;
+      return rest;
+    });
+
+    const groups = groupByTuple(cleanChildren, fk.from);
     for (const r of rows) {
       const keyStr = JSON.stringify(pkCols.map((c: string) => r[c]));
       r[key] = groups.get(keyStr) ?? [];
     }
   }
 
-  async function loadManyToMany(curr: TableName, target: TableName, via: string, rows: any[], key: string) {
+  async function loadManyToMany(curr: TableName, target: TableName, via: string, rows: any[], key: string, options: RelationOptions = {}) {
     // via has two FKs: one to curr, one to target
     const toCurr = (FK_INDEX as any)[via].find((f: any) => f.toTable === curr);
     const toTarget = (FK_INDEX as any)[via].find((f: any) => f.toTable === target);
@@ -3115,31 +3349,83 @@ export async function loadIncludes(
     const tuples = distinctTuples(rows, pkCols).filter(t => t.every((v: any) => v != null));
     if (!tuples.length) { for (const r of rows) r[key] = []; return; }
 
-    // 1) Load junction rows for current parents
     const whereVia = buildOrAndPredicate(toCurr.from, tuples.length, 1);
-    const sqlVia = \`SELECT * FROM "\${via}" WHERE \${whereVia}\`;
-    const paramsVia = tuples.flat();
-    log.debug("manyToMany junction SQL", { curr, target, via, key, sql: sqlVia, paramsCount: paramsVia.length });
-    const { rows: jrows } = await pg.query(sqlVia, paramsVia);
-
-    if (!jrows.length) { for (const r of rows) r[key] = []; return; }
+    const params = tuples.flat();
 
-    // 2) Load targets by distinct target fk tuples in junction
-    const tTuples = distinctTuples(jrows, toTarget.from);
-    const whereT = buildOrAndPredicate((PKS as any)[target], tTuples.length, 1);
-    const sqlT = \`SELECT * FROM "\${target}" WHERE \${whereT}\`;
-    const paramsT = tTuples.flat();
-    log.debug("manyToMany target SQL", { curr, target, via, key, sql: sqlT, paramsCount: paramsT.length });
-    const { rows: targets } = await pg.query(sqlT, paramsT);
+    // If we have limit/offset/orderBy, use a JOIN with window functions
+    if (options.limit !== undefined || options.offset !== undefined || options.orderBy) {
+      const orderByClause = options.orderBy
+        ? \`ORDER BY t."\${options.orderBy}" \${options.order === 'desc' ? 'DESC' : 'ASC'}\`
+        : 'ORDER BY (SELECT NULL)';
+
+      const partitionCols = toCurr.from.map((c: string) => \`j."\${c}"\`).join(', ');
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? 999999999;
+
+      const targetPkCols = (PKS as any)[target] as string[];
+      const joinConditions = toTarget.from.map((jCol: string, i: number) => {
+        return \`j."\${jCol}" = t."\${targetPkCols[i]}"\`;
+      }).join(' AND ');
+
+      const sql = \`
+        SELECT __numbered.*
+        FROM (
+          SELECT t.*,
+                 ROW_NUMBER() OVER (PARTITION BY \${partitionCols} \${orderByClause}) as __rn,
+                 \${toCurr.from.map((c: string) => \`j."\${c}"\`).join(' || \\',\\' || ')} as __parent_fk
+          FROM "\${via}" j
+          INNER JOIN "\${target}" t ON \${joinConditions}
+          WHERE \${whereVia}
+        ) __numbered
+        WHERE __numbered.__rn > \${offset} AND __numbered.__rn <= \${offset + limit}
+      \`;
+
+      log.debug("manyToMany SQL with options", { curr, target, via, key, sql, paramsCount: params.length, options });
+      const { rows: results } = await pg.query(sql, params);
+
+      // Clean and group results
+      const cleanResults = results.map((row: any) => {
+        const { __rn, __parent_fk, ...rest } = row;
+        return { ...rest, __parent_fk };
+      });
 
-    const tIdx = indexByTuple(targets, (PKS as any)[target]);
+      const grouped = new Map<string, any[]>();
+      for (const row of cleanResults) {
+        const { __parent_fk, ...cleanRow } = row;
+        const arr = grouped.get(__parent_fk) ?? [];
+        arr.push(cleanRow);
+        grouped.set(__parent_fk, arr);
+      }
 
-    // 3) Group junction rows by current pk tuple, map to target rows
-    const byCurr = groupByTuple(jrows, toCurr.from);
-    for (const r of rows) {
-      const currKey = JSON.stringify(pkCols.map((c: string) => r[c]));
-      const j = byCurr.get(currKey) ?? [];
-      r[key] = j.map(jr => tIdx.get(JSON.stringify(toTarget.from.map((c: string) => jr[c])))).filter(Boolean);
+      for (const r of rows) {
+        const currKey = pkCols.map((c: string) => r[c]).join(',');
+        r[key] = grouped.get(currKey) ?? [];
+      }
+    } else {
+      // Original logic without options
+      const sqlVia = \`SELECT * FROM "\${via}" WHERE \${whereVia}\`;
+      log.debug("manyToMany junction SQL", { curr, target, via, key, sql: sqlVia, paramsCount: params.length });
+      const { rows: jrows } = await pg.query(sqlVia, params);
+
+      if (!jrows.length) { for (const r of rows) r[key] = []; return; }
+
+      // 2) Load targets by distinct target fk tuples in junction
+      const tTuples = distinctTuples(jrows, toTarget.from);
+      const whereT = buildOrAndPredicate((PKS as any)[target], tTuples.length, 1);
+      const sqlT = \`SELECT * FROM "\${target}" WHERE \${whereT}\`;
+      const paramsT = tTuples.flat();
+      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]);
+
+      // 3) Group junction rows by current pk tuple, map to target rows
+      const byCurr = groupByTuple(jrows, toCurr.from);
+      for (const r of rows) {
+        const currKey = JSON.stringify(pkCols.map((c: string) => r[c]));
+        const j = byCurr.get(currKey) ?? [];
+        r[key] = j.map(jr => tIdx.get(JSON.stringify(toTarget.from.map((c: string) => jr[c])))).filter(Boolean);
+      }
     }
   }
 }
@@ -3218,7 +3504,9 @@ ${baseSelectType}
  * @example Insert${Type}<{ metadata: MyMetadataType }>
  */
 export type Insert${Type}<TJsonb extends Partial<_Insert${Type}Base> = {}> =
-  Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb;
+  {} extends TJsonb
+    ? _Insert${Type}Base
+    : Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb;
 
 /**
  * Type for updating an existing ${table.name} record.
@@ -3228,7 +3516,9 @@ export type Insert${Type}<TJsonb extends Partial<_Insert${Type}Base> = {}> =
  * @example Update${Type}<{ metadata: MyMetadataType }>
  */
 export type Update${Type}<TJsonb extends Partial<_Select${Type}Base> = {}> =
-  Partial<Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb>;
+  {} extends TJsonb
+    ? Partial<_Insert${Type}Base>
+    : Partial<Omit<_Insert${Type}Base, keyof TJsonb> & TJsonb>;
 
 /**
  * Type representing a ${table.name} record from the database.
@@ -3238,7 +3528,9 @@ export type Update${Type}<TJsonb extends Partial<_Select${Type}Base> = {}> =
  * @example Select${Type}<{ metadata: MyMetadataType }>
  */
 export type Select${Type}<TJsonb extends Partial<_Select${Type}Base> = {}> =
-  Omit<_Select${Type}Base, keyof TJsonb> & TJsonb;
+  {} extends TJsonb
+    ? _Select${Type}Base
+    : Omit<_Select${Type}Base, keyof TJsonb> & TJsonb;
 `;
   }
   return `/**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.16.9",
+  "version": "0.16.12",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {
@@ -22,7 +22,7 @@
   },
   "scripts": {
     "build": "bun build src/cli.ts src/index.ts --outdir dist --target node --format esm --external=pg --external=zod --external=hono --external=prompts --external=node:* && tsc -p tsconfig.build.json --emitDeclarationOnly",
-    "test": "bun test:init && bun test:gen && bun test test/test-where-clause.test.ts && bun test test/test-where-or-and.test.ts && bun test:gen-with-tests && bun test:pull && bun test:enums && bun test:typecheck && bun test:drizzle-e2e",
+    "test": "bun test:init && bun test:gen && bun test test/test-where-clause.test.ts && bun test test/test-where-or-and.test.ts && bun test test/test-nested-include-options.test.ts && bun test test/test-include-methods-with-options.test.ts && bun test:gen-with-tests && bun test:pull && bun test:enums && bun test:typecheck && bun test:drizzle-e2e",
     "test:init": "bun test/test-init.ts",
     "test:gen": "bun test/test-gen.ts",
     "test:gen-with-tests": "bun test/test-gen-with-tests.ts",