postgresdk 0.19.2 → 0.19.4

package/README.md

@@ -154,6 +154,7 @@ export default {
     },
   },
   numericMode: "auto",                 // "auto" | "number" | "string" - How to type numeric columns
+  maxLimit: 1000,                      // Max allowed `limit` value (0 = no cap)
   includeMethodsDepth: 2,              // Max depth for nested includes
   dateType: "date",                    // "date" | "string" - How to handle timestamps
   serverFramework: "hono",             // Currently only hono is supported
@@ -715,15 +716,15 @@ const result = await sdk.users.list({
 // Access results
 result.data;       // User[] - array of records
 result.total;      // number - total matching records
-result.limit;      // number - page size used
+result.limit;      // number | undefined - page size used (absent when no limit specified)
 result.offset;     // number - offset used
-result.hasMore;    // boolean - more pages available
+result.hasMore;    // boolean - more pages available (false when no limit)
 
-// Note: Maximum limit is 1000 records per request
+// Note: Omitting `limit` returns all matching records. Max limit is controlled by `maxLimit` config (default: 1000).
 
-// Calculate pagination info
-const totalPages = Math.ceil(result.total / result.limit);
-const currentPage = Math.floor(result.offset / result.limit) + 1;
+// Calculate pagination info (when using explicit limit)
+const totalPages = result.limit ? Math.ceil(result.total / result.limit) : 1;
+const currentPage = result.limit ? Math.floor(result.offset / result.limit) + 1 : 1;
 
 // Multi-column sorting
 const sorted = await sdk.users.list({

package/dist/cli.js

@@ -583,7 +583,8 @@ function buildReturnType(baseTable, path, isMany, targets, graph) {
       continue;
     const targetType = `Select${pascal(target)}`;
     if (i === 0) {
-      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : targetType}`);
+      const edgeNull = !isMany[i] && graph[baseTable]?.[key]?.nullable ? " | null" : "";
+      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : `${targetType}${edgeNull}`}`);
     } else {
       let nestedType = targetType;
       for (let j = i;j < path.length; j++) {
@@ -593,13 +594,26 @@ function buildReturnType(baseTable, path, isMany, targets, graph) {
           if (!nestedKey || !nestedTarget)
             continue;
           const nestedTargetType = `Select${pascal(nestedTarget)}`;
-          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : nestedTargetType} }`;
+          const nestedSource = targets[j - 1];
+          const nestedNull = !isMany[j] && graph[nestedSource]?.[nestedKey]?.nullable ? " | null" : "";
+          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : `${nestedTargetType}${nestedNull}`} }`;
         }
       }
       const prevKey = path[i - 1];
       const prevTarget = targets[i - 1];
       if (prevKey && prevTarget) {
-        parts[parts.length - 1] = `${prevKey}: ${isMany[i - 1] ? `(Select${pascal(prevTarget)} & { ${key}: ${isMany[i] ? `${targetType}[]` : targetType} })[]` : `Select${pascal(prevTarget)} & { ${key}: ${isMany[i] ? `${targetType}[]` : targetType} }`}`;
+        const prevSource = i - 1 === 0 ? baseTable : targets[i - 2];
+        const innerNull = !isMany[i] && graph[prevTarget]?.[key]?.nullable ? " | null" : "";
+        const prevNullable = !isMany[i - 1] && graph[prevSource]?.[prevKey]?.nullable;
+        const inner = isMany[i] ? `${targetType}[]` : `${targetType}${innerNull}`;
+        const composite = `Select${pascal(prevTarget)} & { ${key}: ${inner} }`;
+        if (isMany[i - 1]) {
+          parts[parts.length - 1] = `${prevKey}: (${composite})[]`;
+        } else if (prevNullable) {
+          parts[parts.length - 1] = `${prevKey}: (${composite}) | null`;
+        } else {
+          parts[parts.length - 1] = `${prevKey}: ${composite}`;
+        }
       }
       break;
     }
@@ -689,8 +703,10 @@ function generateIncludeMethods(table, graph, opts, allTables) {
             }
             const combinedPath = [key1, key2];
             const combinedSuffix = `With${pascal(key1)}And${pascal(key2)}`;
-            const type1 = `${key1}: ${edge1.kind === "many" ? `Select${pascal(edge1.target)}[]` : `Select${pascal(edge1.target)}`}`;
-            const type2 = `${key2}: ${edge2.kind === "many" ? `Select${pascal(edge2.target)}[]` : `Select${pascal(edge2.target)}`}`;
+            const null1 = edge1.kind === "one" && edge1.nullable ? " | null" : "";
+            const null2 = edge2.kind === "one" && edge2.nullable ? " | null" : "";
+            const type1 = `${key1}: ${edge1.kind === "many" ? `Select${pascal(edge1.target)}[]` : `Select${pascal(edge1.target)}${null1}`}`;
+            const type2 = `${key2}: ${edge2.kind === "many" ? `Select${pascal(edge2.target)}[]` : `Select${pascal(edge2.target)}${null2}`}`;
             const combinedBaseType = `Select${pascal(baseTableName)} & { ${type1}; ${type2} }`;
             const combinedTypeName = `Select${pascal(baseTableName)}${combinedSuffix}`;
             methods.push({
@@ -1205,7 +1221,7 @@ function generateExampleValue(column) {
 }
 function generateQueryParams(table, enums) {
   const params = {
-    limit: "number - Max records to return (default: 50)",
+    limit: "number - Max records to return (omit for all)",
     offset: "number - Records to skip",
     orderBy: "string | string[] - Field(s) to sort by",
     order: "'asc' | 'desc' | ('asc' | 'desc')[] - Sort direction(s)"
@@ -2639,7 +2655,14 @@ function buildGraph(model) {
       const upKey = singular(parent.name);
       const downKey = plural(child.name);
       if (!(upKey in childNode)) {
-        childNode[upKey] = { from: child.name, key: upKey, kind: "one", target: parent.name };
+        const fkNullable = fk.from.some((colName) => child.columns.find((c) => c.name === colName)?.nullable);
+        childNode[upKey] = {
+          from: child.name,
+          key: upKey,
+          kind: "one",
+          target: parent.name,
+          ...fkNullable && { nullable: true }
+        };
       }
       if (!(downKey in parentNode)) {
         parentNode[downKey] = { from: parent.name, key: downKey, kind: "many", target: child.name };
@@ -2757,10 +2780,11 @@ function emitIncludeResolver(graph, useJsExtensions) {
           : Select${targetType}[]
       )`;
       } else {
+        const nullSuffix = edge.nullable ? " | null" : "";
         out += `(
         TInclude[K] extends { include: infer U extends ${targetType}IncludeSpec }
-          ? ${targetType}WithIncludes<U>
-          : Select${targetType}
+          ? ${targetType}WithIncludes<U>${nullSuffix}
+          : Select${targetType}${nullSuffix}
       )`;
       }
       out += ` :${isLast ? `
@@ -2896,7 +2920,7 @@ export const Upsert${Type}Schema = z.object({
 
 // src/emit-params-zod.ts
 init_utils();
-function emitParamsZod(table, graph) {
+function emitParamsZod(table, graph, opts) {
   const Type = pascal(table.name);
   const columnNames = table.columns.map((c) => `"${c.name}"`).join(", ");
   const pkCols = Array.isArray(table.pk) ? table.pk : table.pk ? [table.pk] : [];
@@ -2913,7 +2937,7 @@ export const ${Type}PkSchema = ${pkSchema};
 // Schema for list query parameters
 export const ${Type}ListParamsSchema = z.object({
   include: ${includeSpecSchema}.optional(),
-  limit: z.number().int().positive().max(1000).optional(),
+  limit: z.number().int().positive()${opts.maxLimit > 0 ? `.max(${opts.maxLimit})` : ""}.optional(),
   offset: z.number().int().nonnegative().optional(),
   where: z.any().optional(),
   vector: VectorSearchParamsSchema.optional(),
@@ -2935,12 +2959,12 @@ export type ${Type}OrderParams = z.infer<typeof ${Type}OrderParamsSchema>;
 }
 
 // src/emit-shared-params-zod.ts
-function emitSharedParamsZod() {
+function emitSharedParamsZod(opts) {
   return `import { z } from "zod";
 
 // Shared pagination schema (used across all tables)
 export const PaginationParamsSchema = z.object({
-  limit: z.number().int().positive().max(1000).optional(),
+  limit: z.number().int().positive()${opts.maxLimit > 0 ? `.max(${opts.maxLimit})` : ""}.optional(),
   offset: z.number().int().nonnegative().optional()
 }).strict();
 
@@ -2972,8 +2996,8 @@ export interface PaginatedResponse<T> {
   data: T[];
   /** Total number of records matching the query (across all pages) */
   total: number;
-  /** Maximum number of records per page */
-  limit: number;
+  /** Maximum number of records per page (absent when no limit was specified) */
+  limit?: number;
   /** Number of records skipped (for pagination) */
   offset: number;
   /** Whether there are more records available after this page */
@@ -3048,7 +3072,7 @@ const listSchema = z.object({
   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(),
+  limit: z.number().int().positive()${opts.maxLimit > 0 ? `.max(${opts.maxLimit})` : ""}.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(),
@@ -3961,7 +3985,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: 1000)
+   * @param params.limit - Maximum number of records to return${opts.maxLimit > 0 ? ` (max: ${opts.maxLimit})` : ""}. Omit to return all matching records.
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (return type automatically infers included relations)
    * @returns Paginated results with all fields (and included relations if specified)
@@ -4061,7 +4085,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: 1000)
+   * @param params.limit - Maximum number of records to return${opts.maxLimit > 0 ? ` (max: ${opts.maxLimit})` : ""}. Omit to return all matching records.
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (return type automatically infers included relations)
    * @returns Paginated results with all fields (and included relations if specified)
@@ -6555,7 +6579,7 @@ export async function listRecords(
   }
 ): 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, vector, trigram, distinctOn, includeSoftDeleted } = params;
+    const { where: whereClause, limit, offset = 0, include, orderBy, order, vector, trigram, distinctOn, includeSoftDeleted } = params;
 
     // DISTINCT ON support
     const distinctCols: string[] | null = distinctOn ? (Array.isArray(distinctOn) ? distinctOn : [distinctOn]) : null;
@@ -6691,10 +6715,22 @@ export async function listRecords(
       orderBySQL = buildOrderBySQL(userOrderCols, userDirs);
     }
 
-    // Add limit and offset params
-    const limitParam = \`$\${paramIndex}\`;
-    const offsetParam = \`$\${paramIndex + 1}\`;
-    const allParams = [...queryParams, ...whereParams, limit, offset];
+    // Add limit and offset params (conditional — omit LIMIT clause when limit is undefined)
+    let limitOffsetSQL: string;
+    let allParams: any[];
+    if (limit !== undefined) {
+      const limitParam = \`$\${paramIndex}\`;
+      const offsetParam = \`$\${paramIndex + 1}\`;
+      limitOffsetSQL = \`LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+      allParams = [...queryParams, ...whereParams, limit, offset];
+    } else if (offset > 0) {
+      const offsetParam = \`$\${paramIndex}\`;
+      limitOffsetSQL = \`OFFSET \${offsetParam}\`;
+      allParams = [...queryParams, ...whereParams, offset];
+    } else {
+      limitOffsetSQL = '';
+      allParams = [...queryParams, ...whereParams];
+    }
 
     // Get total count for pagination
     const countText = distinctCols
@@ -6710,9 +6746,9 @@ export async function listRecords(
       // Inner query: DISTINCT ON with only the distinctCols ORDER BY prefix (PG requirement).
       // Outer query: free ORDER BY from the user's full orderBy list, plus LIMIT/OFFSET.
       const innerQuery = \`SELECT DISTINCT ON (\${_distinctOnColsSQL}) \${baseColumns} FROM "\${ctx.table}" \${whereSQL} ORDER BY \${_distinctOnColsSQL}\`;
-      text = \`SELECT * FROM (\${innerQuery}) __distinct \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+      text = \`SELECT * FROM (\${innerQuery}) __distinct \${orderBySQL} \${limitOffsetSQL}\`.trim();
     } else {
-      text = \`SELECT \${selectClause} FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+      text = \`SELECT \${selectClause} FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} \${limitOffsetSQL}\`.trim();
     }
     log.debug(\`LIST \${ctx.table} SQL:\`, text, "params:", allParams);
 
@@ -6720,7 +6756,7 @@ export async function listRecords(
     const parsedRows = parseVectorColumns(rows, ctx.vectorColumns);
 
     // Calculate hasMore
-    const hasMore = offset + limit < total;
+    const hasMore = limit !== undefined ? offset + limit < total : false;
 
     const metadata = {
       data: parsedRows,
@@ -7760,6 +7796,7 @@ async function generate(configPath, options) {
     clientDir = join2(originalClientDir, "sdk");
   }
   const serverFramework = cfg.serverFramework || "hono";
+  const maxLimit = cfg.maxLimit ?? 1000;
   const generateTests = cfg.tests?.generate ?? false;
   const originalTestDir = cfg.tests?.output || "./api/tests";
   let testDir = originalTestDir;
@@ -7788,7 +7825,7 @@ async function generate(configPath, options) {
   files.push({ path: join2(clientDir, "include-spec.ts"), content: includeSpec });
   const includeResolver = emitIncludeResolver(graph, cfg.useJsExtensions);
   files.push({ path: join2(clientDir, "include-resolver.ts"), content: includeResolver });
-  files.push({ path: join2(clientDir, "params", "shared.ts"), content: emitSharedParamsZod() });
+  files.push({ path: join2(clientDir, "params", "shared.ts"), content: emitSharedParamsZod({ maxLimit }) });
   files.push({ path: join2(clientDir, "types", "shared.ts"), content: emitSharedTypes() });
   files.push({ path: join2(clientDir, "base-client.ts"), content: emitBaseClient() });
   files.push({ path: join2(clientDir, "where-types.ts"), content: emitWhereTypes() });
@@ -7825,7 +7862,7 @@ async function generate(configPath, options) {
     const zodSrc = emitZod(table, { numericMode }, model.enums);
     files.push({ path: join2(serverDir, "zod", `${table.name}.ts`), content: zodSrc });
     files.push({ path: join2(clientDir, "zod", `${table.name}.ts`), content: zodSrc });
-    const paramsZodSrc = emitParamsZod(table, graph);
+    const paramsZodSrc = emitParamsZod(table, graph, { maxLimit });
     files.push({ path: join2(clientDir, "params", `${table.name}.ts`), content: paramsZodSrc });
     let routeContent;
     if (serverFramework === "hono") {
@@ -7835,7 +7872,8 @@ async function generate(configPath, options) {
         includeMethodsDepth: cfg.includeMethodsDepth || 2,
         authStrategy: getAuthStrategy(normalizedAuth),
         useJsExtensions: cfg.useJsExtensions,
-        apiPathPrefix: cfg.apiPathPrefix || "/v1"
+        apiPathPrefix: cfg.apiPathPrefix || "/v1",
+        maxLimit
       });
     } else {
       throw new Error(`Framework "${serverFramework}" is not yet supported. Currently only "hono" is available.`);
@@ -7851,7 +7889,8 @@ async function generate(configPath, options) {
         exposeHardDelete,
         useJsExtensions: cfg.useJsExtensionsClient,
         includeMethodsDepth: cfg.includeMethodsDepth ?? 2,
-        skipJunctionTables: cfg.skipJunctionTables ?? true
+        skipJunctionTables: cfg.skipJunctionTables ?? true,
+        maxLimit
       }, model)
     });
   }

package/dist/emit-client.d.ts

@@ -6,6 +6,7 @@ export declare function emitClient(table: Table, graph: Graph, opts: {
     useJsExtensions?: boolean;
     includeMethodsDepth?: number;
     skipJunctionTables?: boolean;
+    maxLimit: number;
 }, model?: Model): string;
 export declare function emitClientIndex(tables: Table[], useJsExtensions?: boolean, graph?: Graph, includeOpts?: {
     maxDepth: number;

package/dist/emit-params-zod.d.ts

@@ -1,3 +1,5 @@
 import type { Table } from "./introspect";
 import type { Graph } from "./rel-classify";
-export declare function emitParamsZod(table: Table, graph: Graph): string;
+export declare function emitParamsZod(table: Table, graph: Graph, opts: {
+    maxLimit: number;
+}): string;

package/dist/emit-routes-hono.d.ts

@@ -10,4 +10,5 @@ export declare function emitHonoRoutes(table: Table, _graph: Graph, opts: {
     authStrategy?: string;
     useJsExtensions?: boolean;
     apiPathPrefix: string;
+    maxLimit: number;
 }): string;

package/dist/emit-routes.d.ts

@@ -18,4 +18,5 @@ export declare function emitRoutes(table: Table, _graph: Graph, opts: {
     softDeleteColumn: string | null;
     includeMethodsDepth: number;
     authStrategy?: string;
+    maxLimit: number;
 }): string;

package/dist/emit-shared-params-zod.d.ts

@@ -1 +1,3 @@
-export declare function emitSharedParamsZod(): string;
+export declare function emitSharedParamsZod(opts: {
+    maxLimit: number;
+}): string;

package/dist/index.js

@@ -582,7 +582,8 @@ function buildReturnType(baseTable, path, isMany, targets, graph) {
       continue;
     const targetType = `Select${pascal(target)}`;
     if (i === 0) {
-      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : targetType}`);
+      const edgeNull = !isMany[i] && graph[baseTable]?.[key]?.nullable ? " | null" : "";
+      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : `${targetType}${edgeNull}`}`);
     } else {
       let nestedType = targetType;
       for (let j = i;j < path.length; j++) {
@@ -592,13 +593,26 @@ function buildReturnType(baseTable, path, isMany, targets, graph) {
           if (!nestedKey || !nestedTarget)
             continue;
           const nestedTargetType = `Select${pascal(nestedTarget)}`;
-          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : nestedTargetType} }`;
+          const nestedSource = targets[j - 1];
+          const nestedNull = !isMany[j] && graph[nestedSource]?.[nestedKey]?.nullable ? " | null" : "";
+          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : `${nestedTargetType}${nestedNull}`} }`;
         }
       }
       const prevKey = path[i - 1];
       const prevTarget = targets[i - 1];
       if (prevKey && prevTarget) {
-        parts[parts.length - 1] = `${prevKey}: ${isMany[i - 1] ? `(Select${pascal(prevTarget)} & { ${key}: ${isMany[i] ? `${targetType}[]` : targetType} })[]` : `Select${pascal(prevTarget)} & { ${key}: ${isMany[i] ? `${targetType}[]` : targetType} }`}`;
+        const prevSource = i - 1 === 0 ? baseTable : targets[i - 2];
+        const innerNull = !isMany[i] && graph[prevTarget]?.[key]?.nullable ? " | null" : "";
+        const prevNullable = !isMany[i - 1] && graph[prevSource]?.[prevKey]?.nullable;
+        const inner = isMany[i] ? `${targetType}[]` : `${targetType}${innerNull}`;
+        const composite = `Select${pascal(prevTarget)} & { ${key}: ${inner} }`;
+        if (isMany[i - 1]) {
+          parts[parts.length - 1] = `${prevKey}: (${composite})[]`;
+        } else if (prevNullable) {
+          parts[parts.length - 1] = `${prevKey}: (${composite}) | null`;
+        } else {
+          parts[parts.length - 1] = `${prevKey}: ${composite}`;
+        }
       }
       break;
     }
@@ -688,8 +702,10 @@ function generateIncludeMethods(table, graph, opts, allTables) {
             }
             const combinedPath = [key1, key2];
             const combinedSuffix = `With${pascal(key1)}And${pascal(key2)}`;
-            const type1 = `${key1}: ${edge1.kind === "many" ? `Select${pascal(edge1.target)}[]` : `Select${pascal(edge1.target)}`}`;
-            const type2 = `${key2}: ${edge2.kind === "many" ? `Select${pascal(edge2.target)}[]` : `Select${pascal(edge2.target)}`}`;
+            const null1 = edge1.kind === "one" && edge1.nullable ? " | null" : "";
+            const null2 = edge2.kind === "one" && edge2.nullable ? " | null" : "";
+            const type1 = `${key1}: ${edge1.kind === "many" ? `Select${pascal(edge1.target)}[]` : `Select${pascal(edge1.target)}${null1}`}`;
+            const type2 = `${key2}: ${edge2.kind === "many" ? `Select${pascal(edge2.target)}[]` : `Select${pascal(edge2.target)}${null2}`}`;
             const combinedBaseType = `Select${pascal(baseTableName)} & { ${type1}; ${type2} }`;
             const combinedTypeName = `Select${pascal(baseTableName)}${combinedSuffix}`;
             methods.push({
@@ -1204,7 +1220,7 @@ function generateExampleValue(column) {
 }
 function generateQueryParams(table, enums) {
   const params = {
-    limit: "number - Max records to return (default: 50)",
+    limit: "number - Max records to return (omit for all)",
     offset: "number - Records to skip",
     orderBy: "string | string[] - Field(s) to sort by",
     order: "'asc' | 'desc' | ('asc' | 'desc')[] - Sort direction(s)"
@@ -1679,7 +1695,14 @@ function buildGraph(model) {
       const upKey = singular(parent.name);
       const downKey = plural(child.name);
       if (!(upKey in childNode)) {
-        childNode[upKey] = { from: child.name, key: upKey, kind: "one", target: parent.name };
+        const fkNullable = fk.from.some((colName) => child.columns.find((c) => c.name === colName)?.nullable);
+        childNode[upKey] = {
+          from: child.name,
+          key: upKey,
+          kind: "one",
+          target: parent.name,
+          ...fkNullable && { nullable: true }
+        };
       }
       if (!(downKey in parentNode)) {
         parentNode[downKey] = { from: parent.name, key: downKey, kind: "many", target: child.name };
@@ -1797,10 +1820,11 @@ function emitIncludeResolver(graph, useJsExtensions) {
           : Select${targetType}[]
       )`;
       } else {
+        const nullSuffix = edge.nullable ? " | null" : "";
         out += `(
         TInclude[K] extends { include: infer U extends ${targetType}IncludeSpec }
-          ? ${targetType}WithIncludes<U>
-          : Select${targetType}
+          ? ${targetType}WithIncludes<U>${nullSuffix}
+          : Select${targetType}${nullSuffix}
       )`;
       }
       out += ` :${isLast ? `
@@ -1936,7 +1960,7 @@ export const Upsert${Type}Schema = z.object({
 
 // src/emit-params-zod.ts
 init_utils();
-function emitParamsZod(table, graph) {
+function emitParamsZod(table, graph, opts) {
   const Type = pascal(table.name);
   const columnNames = table.columns.map((c) => `"${c.name}"`).join(", ");
   const pkCols = Array.isArray(table.pk) ? table.pk : table.pk ? [table.pk] : [];
@@ -1953,7 +1977,7 @@ export const ${Type}PkSchema = ${pkSchema};
 // Schema for list query parameters
 export const ${Type}ListParamsSchema = z.object({
   include: ${includeSpecSchema}.optional(),
-  limit: z.number().int().positive().max(1000).optional(),
+  limit: z.number().int().positive()${opts.maxLimit > 0 ? `.max(${opts.maxLimit})` : ""}.optional(),
   offset: z.number().int().nonnegative().optional(),
   where: z.any().optional(),
   vector: VectorSearchParamsSchema.optional(),
@@ -1975,12 +1999,12 @@ export type ${Type}OrderParams = z.infer<typeof ${Type}OrderParamsSchema>;
 }
 
 // src/emit-shared-params-zod.ts
-function emitSharedParamsZod() {
+function emitSharedParamsZod(opts) {
   return `import { z } from "zod";
 
 // Shared pagination schema (used across all tables)
 export const PaginationParamsSchema = z.object({
-  limit: z.number().int().positive().max(1000).optional(),
+  limit: z.number().int().positive()${opts.maxLimit > 0 ? `.max(${opts.maxLimit})` : ""}.optional(),
   offset: z.number().int().nonnegative().optional()
 }).strict();
 
@@ -2012,8 +2036,8 @@ export interface PaginatedResponse<T> {
   data: T[];
   /** Total number of records matching the query (across all pages) */
   total: number;
-  /** Maximum number of records per page */
-  limit: number;
+  /** Maximum number of records per page (absent when no limit was specified) */
+  limit?: number;
   /** Number of records skipped (for pagination) */
   offset: number;
   /** Whether there are more records available after this page */
@@ -2088,7 +2112,7 @@ const listSchema = z.object({
   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(),
+  limit: z.number().int().positive()${opts.maxLimit > 0 ? `.max(${opts.maxLimit})` : ""}.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(),
@@ -3001,7 +3025,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: 1000)
+   * @param params.limit - Maximum number of records to return${opts.maxLimit > 0 ? ` (max: ${opts.maxLimit})` : ""}. Omit to return all matching records.
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (return type automatically infers included relations)
    * @returns Paginated results with all fields (and included relations if specified)
@@ -3101,7 +3125,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: 1000)
+   * @param params.limit - Maximum number of records to return${opts.maxLimit > 0 ? ` (max: ${opts.maxLimit})` : ""}. Omit to return all matching records.
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (return type automatically infers included relations)
    * @returns Paginated results with all fields (and included relations if specified)
@@ -5595,7 +5619,7 @@ export async function listRecords(
   }
 ): 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, vector, trigram, distinctOn, includeSoftDeleted } = params;
+    const { where: whereClause, limit, offset = 0, include, orderBy, order, vector, trigram, distinctOn, includeSoftDeleted } = params;
 
     // DISTINCT ON support
     const distinctCols: string[] | null = distinctOn ? (Array.isArray(distinctOn) ? distinctOn : [distinctOn]) : null;
@@ -5731,10 +5755,22 @@ export async function listRecords(
       orderBySQL = buildOrderBySQL(userOrderCols, userDirs);
     }
 
-    // Add limit and offset params
-    const limitParam = \`$\${paramIndex}\`;
-    const offsetParam = \`$\${paramIndex + 1}\`;
-    const allParams = [...queryParams, ...whereParams, limit, offset];
+    // Add limit and offset params (conditional — omit LIMIT clause when limit is undefined)
+    let limitOffsetSQL: string;
+    let allParams: any[];
+    if (limit !== undefined) {
+      const limitParam = \`$\${paramIndex}\`;
+      const offsetParam = \`$\${paramIndex + 1}\`;
+      limitOffsetSQL = \`LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+      allParams = [...queryParams, ...whereParams, limit, offset];
+    } else if (offset > 0) {
+      const offsetParam = \`$\${paramIndex}\`;
+      limitOffsetSQL = \`OFFSET \${offsetParam}\`;
+      allParams = [...queryParams, ...whereParams, offset];
+    } else {
+      limitOffsetSQL = '';
+      allParams = [...queryParams, ...whereParams];
+    }
 
     // Get total count for pagination
     const countText = distinctCols
@@ -5750,9 +5786,9 @@ export async function listRecords(
       // Inner query: DISTINCT ON with only the distinctCols ORDER BY prefix (PG requirement).
       // Outer query: free ORDER BY from the user's full orderBy list, plus LIMIT/OFFSET.
       const innerQuery = \`SELECT DISTINCT ON (\${_distinctOnColsSQL}) \${baseColumns} FROM "\${ctx.table}" \${whereSQL} ORDER BY \${_distinctOnColsSQL}\`;
-      text = \`SELECT * FROM (\${innerQuery}) __distinct \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+      text = \`SELECT * FROM (\${innerQuery}) __distinct \${orderBySQL} \${limitOffsetSQL}\`.trim();
     } else {
-      text = \`SELECT \${selectClause} FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+      text = \`SELECT \${selectClause} FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} \${limitOffsetSQL}\`.trim();
     }
     log.debug(\`LIST \${ctx.table} SQL:\`, text, "params:", allParams);
 
@@ -5760,7 +5796,7 @@ export async function listRecords(
     const parsedRows = parseVectorColumns(rows, ctx.vectorColumns);
 
     // Calculate hasMore
-    const hasMore = offset + limit < total;
+    const hasMore = limit !== undefined ? offset + limit < total : false;
 
     const metadata = {
       data: parsedRows,
@@ -6800,6 +6836,7 @@ async function generate(configPath, options) {
     clientDir = join2(originalClientDir, "sdk");
   }
   const serverFramework = cfg.serverFramework || "hono";
+  const maxLimit = cfg.maxLimit ?? 1000;
   const generateTests = cfg.tests?.generate ?? false;
   const originalTestDir = cfg.tests?.output || "./api/tests";
   let testDir = originalTestDir;
@@ -6828,7 +6865,7 @@ async function generate(configPath, options) {
   files.push({ path: join2(clientDir, "include-spec.ts"), content: includeSpec });
   const includeResolver = emitIncludeResolver(graph, cfg.useJsExtensions);
   files.push({ path: join2(clientDir, "include-resolver.ts"), content: includeResolver });
-  files.push({ path: join2(clientDir, "params", "shared.ts"), content: emitSharedParamsZod() });
+  files.push({ path: join2(clientDir, "params", "shared.ts"), content: emitSharedParamsZod({ maxLimit }) });
   files.push({ path: join2(clientDir, "types", "shared.ts"), content: emitSharedTypes() });
   files.push({ path: join2(clientDir, "base-client.ts"), content: emitBaseClient() });
   files.push({ path: join2(clientDir, "where-types.ts"), content: emitWhereTypes() });
@@ -6865,7 +6902,7 @@ async function generate(configPath, options) {
     const zodSrc = emitZod(table, { numericMode }, model.enums);
     files.push({ path: join2(serverDir, "zod", `${table.name}.ts`), content: zodSrc });
     files.push({ path: join2(clientDir, "zod", `${table.name}.ts`), content: zodSrc });
-    const paramsZodSrc = emitParamsZod(table, graph);
+    const paramsZodSrc = emitParamsZod(table, graph, { maxLimit });
     files.push({ path: join2(clientDir, "params", `${table.name}.ts`), content: paramsZodSrc });
     let routeContent;
     if (serverFramework === "hono") {
@@ -6875,7 +6912,8 @@ async function generate(configPath, options) {
         includeMethodsDepth: cfg.includeMethodsDepth || 2,
         authStrategy: getAuthStrategy(normalizedAuth),
         useJsExtensions: cfg.useJsExtensions,
-        apiPathPrefix: cfg.apiPathPrefix || "/v1"
+        apiPathPrefix: cfg.apiPathPrefix || "/v1",
+        maxLimit
       });
     } else {
       throw new Error(`Framework "${serverFramework}" is not yet supported. Currently only "hono" is available.`);
@@ -6891,7 +6929,8 @@ async function generate(configPath, options) {
         exposeHardDelete,
         useJsExtensions: cfg.useJsExtensionsClient,
         includeMethodsDepth: cfg.includeMethodsDepth ?? 2,
-        skipJunctionTables: cfg.skipJunctionTables ?? true
+        skipJunctionTables: cfg.skipJunctionTables ?? true,
+        maxLimit
       }, model)
     });
   }

package/dist/rel-classify.d.ts

@@ -5,6 +5,8 @@ export type Edge = {
     kind: "one" | "many";
     target: string;
     via?: string;
+    /** True when the FK column(s) are nullable (belongs-to may return null). */
+    nullable?: boolean;
 };
 export type Graph = Record<string, Record<string, Edge>>;
 export declare function buildGraph(model: Model): Graph;

package/dist/types.d.ts

@@ -38,6 +38,8 @@ export interface Config {
     skipJunctionTables?: boolean;
     serverFramework?: "hono" | "express" | "fastify";
     apiPathPrefix?: string;
+    /** Maximum allowed value for the `limit` parameter in list operations (default: 1000). Set to 0 to disable. */
+    maxLimit?: number;
     auth?: AuthConfigInput;
     pullToken?: string;
     pull?: PullConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.19.2",
+  "version": "0.19.4",
   "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:write-files && 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 && bun test test/test-numeric-mode-integration.test.ts && bun test test/test-jsonb-array-serialization.test.ts && bun test test/test-trigram-search.test.ts && bun test test/test-soft-delete-config.test.ts && bun test test/test-soft-delete-include-loader.test.ts && bun test test/test-soft-delete-nested-include.test.ts && bun test test/test-transaction.test.ts",
+    "test": "bun test:write-files && 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 && bun test test/test-numeric-mode-integration.test.ts && bun test test/test-jsonb-array-serialization.test.ts && bun test test/test-trigram-search.test.ts && bun test test/test-soft-delete-config.test.ts && bun test test/test-soft-delete-include-loader.test.ts && bun test test/test-soft-delete-nested-include.test.ts && bun test test/test-transaction.test.ts && bun test test/test-nullable-belongs-to.test.ts && bun test test/test-no-default-limit.test.ts",
     "test:write-files": "bun test/test-write-files-if-changed.ts",
     "test:init": "bun test/test-init.ts",
     "test:gen": "bun test/test-gen.ts",