postgresdk 0.11.0 → 0.12.1

package/README.md

@@ -7,7 +7,7 @@ Generate a typed server/client SDK from your PostgreSQL database schema.
 ## Features
 
 - 🚀 **Instant SDK Generation** - Point at your PostgreSQL database and get a complete SDK
-- 🔒 **Type Safety** - Full TypeScript types derived from your database schema  
+- 🔒 **Type Safety** - Full TypeScript types derived from your database schema (including enum types)
 - ✅ **Runtime Validation** - Zod schemas for request/response validation
 - 🔗 **Smart Relationships** - Automatic handling of 1:N and M:N relationships with eager loading
 - 🔐 **Built-in Auth** - API key and JWT authentication
@@ -160,7 +160,7 @@ const authors = await sdk.authors.list({
 ### Filtering & Pagination
 
 ```typescript
-// Simple equality filtering
+// Simple equality filtering with single-column sorting
 const users = await sdk.users.list({
   where: { status: "active" },
   orderBy: "created_at",
@@ -169,6 +169,12 @@ const users = await sdk.users.list({
   offset: 40
 });
 
+// Multi-column sorting
+const sorted = await sdk.users.list({
+  orderBy: ["status", "created_at"],
+  order: ["asc", "desc"]  // or use single direction: order: "asc"
+});
+
 // Advanced WHERE operators
 const filtered = await sdk.users.list({
   where: {

package/dist/cli.js

@@ -780,6 +780,7 @@ function generateResourceWithSDK(table, model, graph, config) {
   const basePath = `/v1/${tableName}`;
   const hasSinglePK = table.pk.length === 1;
   const pkField = hasSinglePK ? table.pk[0] : "id";
+  const enums = model.enums || {};
   const sdkMethods = [];
   const endpoints = [];
   sdkMethods.push({
@@ -793,9 +794,9 @@ const items = await sdk.${tableName}.list();
 const filtered = await sdk.${tableName}.list({
   limit: 20,
   offset: 0,
-  ${table.columns[0]?.name || "field"}_like: 'search',
-  order_by: '${table.columns[0]?.name || "created_at"}',
-  order_dir: 'desc'
+  where: { ${table.columns[0]?.name || "field"}: { $like: '%search%' } },
+  orderBy: '${table.columns[0]?.name || "created_at"}',
+  order: 'desc'
 });`,
     correspondsTo: `GET ${basePath}`
   });
@@ -803,7 +804,7 @@ const filtered = await sdk.${tableName}.list({
     method: "GET",
     path: basePath,
     description: `List all ${tableName} records`,
-    queryParameters: generateQueryParams(table),
+    queryParameters: generateQueryParams(table, enums),
     responseBody: `${Type}[]`
   });
   if (hasSinglePK) {
@@ -911,7 +912,7 @@ const filtered = await sdk.${tableName}.${method.name}({
       });
     }
   }
-  const fields = table.columns.map((col) => generateFieldContract(col, table));
+  const fields = table.columns.map((col) => generateFieldContract(col, table, enums));
   return {
     name: Type,
     tableName,
@@ -926,11 +927,11 @@ const filtered = await sdk.${tableName}.${method.name}({
     fields
   };
 }
-function generateFieldContract(column, table) {
+function generateFieldContract(column, table, enums) {
   const field = {
     name: column.name,
-    type: postgresTypeToJsonType(column.pgType),
-    tsType: postgresTypeToTsType(column),
+    type: postgresTypeToJsonType(column.pgType, enums),
+    tsType: postgresTypeToTsType(column, enums),
     required: !column.nullable && !column.hasDefault,
     description: generateFieldDescription(column, table)
   };
@@ -943,16 +944,41 @@ function generateFieldContract(column, table) {
   }
   return field;
 }
-function postgresTypeToTsType(column) {
+function postgresTypeToTsType(column, enums) {
+  const pgType = column.pgType.toLowerCase();
+  if (enums[pgType]) {
+    const enumType = enums[pgType].map((v) => `"${v}"`).join(" | ");
+    if (column.nullable) {
+      return `${enumType} | null`;
+    }
+    return enumType;
+  }
+  if (pgType.startsWith("_")) {
+    const enumName = pgType.slice(1);
+    const enumValues = enums[enumName];
+    if (enumValues) {
+      const enumType = enumValues.map((v) => `"${v}"`).join(" | ");
+      const arrayType = `(${enumType})[]`;
+      if (column.nullable) {
+        return `${arrayType} | null`;
+      }
+      return arrayType;
+    }
+  }
   const baseType = (() => {
-    switch (column.pgType) {
+    switch (pgType) {
       case "int":
+      case "int2":
+      case "int4":
+      case "int8":
       case "integer":
       case "smallint":
       case "bigint":
       case "decimal":
       case "numeric":
       case "real":
+      case "float4":
+      case "float8":
       case "double precision":
       case "float":
         return "number";
@@ -970,9 +996,16 @@ function postgresTypeToTsType(column) {
         return "string";
       case "text[]":
       case "varchar[]":
+      case "_text":
+      case "_varchar":
         return "string[]";
       case "int[]":
       case "integer[]":
+      case "_int":
+      case "_int2":
+      case "_int4":
+      case "_int8":
+      case "_integer":
         return "number[]";
       default:
         return "string";
@@ -1054,18 +1087,18 @@ function generateExampleValue(column) {
       return `'example value'`;
   }
 }
-function generateQueryParams(table) {
+function generateQueryParams(table, enums) {
   const params = {
     limit: "number - Max records to return (default: 50)",
     offset: "number - Records to skip",
-    order_by: "string - Field to sort by",
-    order_dir: "'asc' | 'desc' - Sort direction"
+    orderBy: "string | string[] - Field(s) to sort by",
+    order: "'asc' | 'desc' | ('asc' | 'desc')[] - Sort direction(s)"
   };
   let filterCount = 0;
   for (const col of table.columns) {
     if (filterCount >= 3)
       break;
-    const type = postgresTypeToJsonType(col.pgType);
+    const type = postgresTypeToJsonType(col.pgType, enums);
     params[col.name] = `${type} - Filter by ${col.name}`;
     if (type === "string") {
       params[`${col.name}_like`] = `string - Search in ${col.name}`;
@@ -1078,15 +1111,27 @@ function generateQueryParams(table) {
   params["..."] = "Additional filters for all fields";
   return params;
 }
-function postgresTypeToJsonType(pgType) {
-  switch (pgType) {
+function postgresTypeToJsonType(pgType, enums) {
+  const t = pgType.toLowerCase();
+  if (enums[t]) {
+    return t;
+  }
+  if (t.startsWith("_") && enums[t.slice(1)]) {
+    return `${t.slice(1)}[]`;
+  }
+  switch (t) {
     case "int":
+    case "int2":
+    case "int4":
+    case "int8":
     case "integer":
     case "smallint":
     case "bigint":
     case "decimal":
     case "numeric":
     case "real":
+    case "float4":
+    case "float8":
     case "double precision":
     case "float":
       return "number";
@@ -1104,9 +1149,16 @@ function postgresTypeToJsonType(pgType) {
       return "uuid";
     case "text[]":
     case "varchar[]":
+    case "_text":
+    case "_varchar":
       return "string[]";
     case "int[]":
     case "integer[]":
+    case "_int":
+    case "_int2":
+    case "_int4":
+    case "_int8":
+    case "_integer":
       return "number[]";
     default:
       return "string";
@@ -1351,6 +1403,64 @@ function generateUnifiedContractMarkdown(contract) {
   lines.push("");
   lines.push("**Note:** The WHERE clause types are fully type-safe. TypeScript will only allow operators that are valid for each field type.");
   lines.push("");
+  lines.push("## Sorting");
+  lines.push("");
+  lines.push("Sort query results using the `orderBy` and `order` parameters. Supports both single and multi-column sorting.");
+  lines.push("");
+  lines.push("### Single Column Sorting");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("// Sort by one column ascending");
+  lines.push("const users = await sdk.users.list({");
+  lines.push("  orderBy: 'created_at',");
+  lines.push("  order: 'asc'");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Sort descending");
+  lines.push("const latest = await sdk.users.list({");
+  lines.push("  orderBy: 'created_at',");
+  lines.push("  order: 'desc'");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Order defaults to 'asc' if not specified");
+  lines.push("const sorted = await sdk.users.list({");
+  lines.push("  orderBy: 'name'");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Multi-Column Sorting");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("// Sort by multiple columns (all same direction)");
+  lines.push("const users = await sdk.users.list({");
+  lines.push("  orderBy: ['status', 'created_at'],");
+  lines.push("  order: 'desc'");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Different direction per column");
+  lines.push("const sorted = await sdk.users.list({");
+  lines.push("  orderBy: ['status', 'created_at'],");
+  lines.push("  order: ['asc', 'desc']  // status ASC, created_at DESC");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Combining Sorting with Filters");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("const results = await sdk.users.list({");
+  lines.push("  where: {");
+  lines.push("    status: 'active',");
+  lines.push("    age: { $gte: 18 }");
+  lines.push("  },");
+  lines.push("  orderBy: 'created_at',");
+  lines.push("  order: 'desc',");
+  lines.push("  limit: 50,");
+  lines.push("  offset: 0");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("**Note:** Column names are validated by Zod schemas. Only valid table columns are accepted, preventing SQL injection.");
+  lines.push("");
   lines.push("## Resources");
   lines.push("");
   for (const resource of contract.resources) {
@@ -2508,23 +2618,28 @@ export const buildWithFor = (t: TableName) =>
 
 // src/emit-zod.ts
 init_utils();
-function emitZod(table, opts) {
+function emitZod(table, opts, enums) {
   const Type = pascal(table.name);
   const zFor = (pg) => {
-    if (pg === "uuid")
+    const t = pg.toLowerCase();
+    if (enums[t]) {
+      const values = enums[t].map((v) => `"${v}"`).join(", ");
+      return `z.enum([${values}])`;
+    }
+    if (t === "uuid")
       return `z.string()`;
-    if (pg === "bool" || pg === "boolean")
+    if (t === "bool" || t === "boolean")
       return `z.boolean()`;
-    if (pg === "int2" || pg === "int4" || pg === "int8")
+    if (t === "int2" || t === "int4" || t === "int8")
       return opts.numericMode === "number" ? `z.number()` : `z.string()`;
-    if (pg === "numeric" || pg === "float4" || pg === "float8")
+    if (t === "numeric" || t === "float4" || t === "float8")
       return opts.numericMode === "number" ? `z.number()` : `z.string()`;
-    if (pg === "jsonb" || pg === "json")
+    if (t === "jsonb" || t === "json")
       return `z.unknown()`;
-    if (pg === "date" || pg.startsWith("timestamp"))
+    if (t === "date" || t.startsWith("timestamp"))
       return `z.string()`;
-    if (pg.startsWith("_"))
-      return `z.array(${zFor(pg.slice(1))})`;
+    if (t.startsWith("_"))
+      return `z.array(${zFor(t.slice(1))})`;
     return `z.string()`;
   };
   const selectFields = table.columns.map((c) => {
@@ -2625,6 +2740,7 @@ function emitHonoRoutes(table, _graph, opts) {
   const hasAuth = opts.authStrategy && opts.authStrategy !== "none";
   const ext = opts.useJsExtensions ? ".js" : "";
   const authImport = hasAuth ? `import { authMiddleware } from "../auth${ext}";` : "";
+  const columnNames = table.columns.map((c) => `"${c.name}"`).join(", ");
   return `/**
  * AUTO-GENERATED FILE - DO NOT EDIT
  *
@@ -2641,12 +2757,15 @@ import { loadIncludes } from "../include-loader${ext}";
 import * as coreOps from "../core/operations${ext}";
 ${authImport}
 
+const columnEnum = z.enum([${columnNames}]);
+
 const listSchema = z.object({
   where: z.any().optional(),
   include: z.any().optional(),
   limit: z.number().int().positive().max(100).optional(),
   offset: z.number().int().min(0).optional(),
-  orderBy: z.any().optional()
+  orderBy: z.union([columnEnum, z.array(columnEnum)]).optional(),
+  order: z.union([z.enum(["asc", "desc"]), z.array(z.enum(["asc", "desc"]))]).optional()
 });
 
 export function register${Type}Routes(app: Hono, deps: { pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> }, onRequest?: (c: Context, pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> }) => Promise<void> }) {
@@ -2835,7 +2954,7 @@ 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; order?: "asc" | "desc"; }, "include">`;
+    const baseParams = isGetByPk ? "" : `params?: Omit<{ limit?: number; offset?: number; where?: Where<Select${Type}>; orderBy?: string | string[]; order?: "asc" | "desc" | ("asc" | "desc")[]; }, "include">`;
     if (isGetByPk) {
       const pkWhere = hasCompositePk ? `{ ${safePk.map((col) => `${col}: pk.${col}`).join(", ")} }` : `{ ${safePk[0] || "id"}: pk }`;
       const baseReturnType = method.returnType.replace(" | null", "");
@@ -2891,8 +3010,8 @@ export class ${Type}Client extends BaseClient {
     limit?: number;
     offset?: number;
     where?: Where<Select${Type}>;
-    orderBy?: string;
-    order?: "asc" | "desc";
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
   }): Promise<Select${Type}[]> {
     return this.post<Select${Type}[]>(\`\${this.resource}/list\`, params ?? {});
   }
@@ -3448,10 +3567,13 @@ export async function loadIncludes(
 }
 
 // src/emit-types.ts
-function tsTypeFor(pgType, opts) {
+function tsTypeFor(pgType, opts, enums) {
   const t = pgType.toLowerCase();
+  if (enums[t]) {
+    return enums[t].map((v) => `"${v}"`).join(" | ");
+  }
   if (t.startsWith("_"))
-    return `${tsTypeFor(t.slice(1), opts)}[]`;
+    return `(${tsTypeFor(t.slice(1), opts, enums)})[]`;
   if (t === "uuid")
     return "string";
   if (t === "bool" || t === "boolean")
@@ -3466,17 +3588,17 @@ function tsTypeFor(pgType, opts) {
   return "string";
 }
 var pascal2 = (s) => s.split(/[_\s-]+/).map((w) => w?.[0] ? w[0].toUpperCase() + w.slice(1) : "").join("");
-function emitTypes(table, opts) {
+function emitTypes(table, opts, enums) {
   const Type = pascal2(table.name);
   const insertFields = table.columns.map((col) => {
-    const base = tsTypeFor(col.pgType, opts);
+    const base = tsTypeFor(col.pgType, opts, enums);
     const optional = col.hasDefault || col.nullable ? "?" : "";
     const valueType = col.nullable ? `${base} | null` : base;
     return `  ${col.name}${optional}: ${valueType};`;
   }).join(`
 `);
   const selectFields = table.columns.map((col) => {
-    const base = tsTypeFor(col.pgType, opts);
+    const base = tsTypeFor(col.pgType, opts, enums);
     const valueType = col.nullable ? `${base} | null` : base;
     return `  ${col.name}: ${valueType};`;
   }).join(`
@@ -4226,10 +4348,10 @@ function buildWhereClause(
  */
 export async function listRecords(
   ctx: OperationContext,
-  params: { where?: any; limit?: number; offset?: number; include?: any }
+  params: { where?: any; limit?: number; offset?: number; include?: any; orderBy?: string | string[]; order?: "asc" | "desc" | ("asc" | "desc")[] }
 ): Promise<{ data?: any; error?: string; issues?: any; needsIncludes?: boolean; includeSpec?: any; status: number }> {
   try {
-    const { where: whereClause, limit = 50, offset = 0, include } = params;
+    const { where: whereClause, limit = 50, offset = 0, include, orderBy, order } = params;
 
     // Build WHERE clause
     let paramIndex = 1;
@@ -4253,12 +4375,26 @@ export async function listRecords(
 
     const whereSQL = whereParts.length > 0 ? \`WHERE \${whereParts.join(" AND ")}\` : "";
 
+    // Build ORDER BY clause
+    let orderBySQL = "";
+    if (orderBy) {
+      const columns = Array.isArray(orderBy) ? orderBy : [orderBy];
+      const directions = Array.isArray(order) ? order : (order ? Array(columns.length).fill(order) : Array(columns.length).fill("asc"));
+
+      const orderParts = columns.map((col, i) => {
+        const dir = (directions[i] || "asc").toUpperCase();
+        return \`"\${col}" \${dir}\`;
+      });
+
+      orderBySQL = \`ORDER BY \${orderParts.join(", ")}\`;
+    }
+
     // Add limit and offset params
     const limitParam = \`$\${paramIndex}\`;
     const offsetParam = \`$\${paramIndex + 1}\`;
     const allParams = [...whereParams, limit, offset];
 
-    const text = \`SELECT * FROM "\${ctx.table}" \${whereSQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+    const text = \`SELECT * FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
     log.debug(\`LIST \${ctx.table} SQL:\`, text, "params:", allParams);
 
     const { rows } = await ctx.pg.query(text, allParams);
@@ -5200,10 +5336,10 @@ async function generate(configPath) {
     console.log(`[Index] About to process ${Object.keys(model.tables || {}).length} tables for generation`);
   }
   for (const table of Object.values(model.tables)) {
-    const typesSrc = emitTypes(table, { numericMode: "string" });
+    const typesSrc = emitTypes(table, { numericMode: "string" }, model.enums);
     files.push({ path: join(serverDir, "types", `${table.name}.ts`), content: typesSrc });
     files.push({ path: join(clientDir, "types", `${table.name}.ts`), content: typesSrc });
-    const zodSrc = emitZod(table, { numericMode: "string" });
+    const zodSrc = emitZod(table, { numericMode: "string" }, model.enums);
     files.push({ path: join(serverDir, "zod", `${table.name}.ts`), content: zodSrc });
     files.push({ path: join(clientDir, "zod", `${table.name}.ts`), content: zodSrc });
     const paramsZodSrc = emitParamsZod(table, graph);

package/dist/core/operations.d.ts

@@ -39,6 +39,8 @@ export declare function listRecords(ctx: OperationContext, params: {
     limit?: number;
     offset?: number;
     include?: any;
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
 }): Promise<{
     data?: any;
     error?: string;

package/dist/emit-types.d.ts

@@ -1,4 +1,4 @@
 import type { Table } from "./introspect";
 export declare function emitTypes(table: Table, opts: {
     numericMode: "string" | "number";
-}): string;
+}, enums: Record<string, string[]>): string;

package/dist/emit-zod.d.ts

@@ -1,4 +1,4 @@
 import type { Table } from "./introspect";
 export declare function emitZod(table: Table, opts: {
     numericMode: "string" | "number";
-}): string;
+}, enums: Record<string, string[]>): string;

package/dist/index.js

@@ -779,6 +779,7 @@ function generateResourceWithSDK(table, model, graph, config) {
   const basePath = `/v1/${tableName}`;
   const hasSinglePK = table.pk.length === 1;
   const pkField = hasSinglePK ? table.pk[0] : "id";
+  const enums = model.enums || {};
   const sdkMethods = [];
   const endpoints = [];
   sdkMethods.push({
@@ -792,9 +793,9 @@ const items = await sdk.${tableName}.list();
 const filtered = await sdk.${tableName}.list({
   limit: 20,
   offset: 0,
-  ${table.columns[0]?.name || "field"}_like: 'search',
-  order_by: '${table.columns[0]?.name || "created_at"}',
-  order_dir: 'desc'
+  where: { ${table.columns[0]?.name || "field"}: { $like: '%search%' } },
+  orderBy: '${table.columns[0]?.name || "created_at"}',
+  order: 'desc'
 });`,
     correspondsTo: `GET ${basePath}`
   });
@@ -802,7 +803,7 @@ const filtered = await sdk.${tableName}.list({
     method: "GET",
     path: basePath,
     description: `List all ${tableName} records`,
-    queryParameters: generateQueryParams(table),
+    queryParameters: generateQueryParams(table, enums),
     responseBody: `${Type}[]`
   });
   if (hasSinglePK) {
@@ -910,7 +911,7 @@ const filtered = await sdk.${tableName}.${method.name}({
       });
     }
   }
-  const fields = table.columns.map((col) => generateFieldContract(col, table));
+  const fields = table.columns.map((col) => generateFieldContract(col, table, enums));
   return {
     name: Type,
     tableName,
@@ -925,11 +926,11 @@ const filtered = await sdk.${tableName}.${method.name}({
     fields
   };
 }
-function generateFieldContract(column, table) {
+function generateFieldContract(column, table, enums) {
   const field = {
     name: column.name,
-    type: postgresTypeToJsonType(column.pgType),
-    tsType: postgresTypeToTsType(column),
+    type: postgresTypeToJsonType(column.pgType, enums),
+    tsType: postgresTypeToTsType(column, enums),
     required: !column.nullable && !column.hasDefault,
     description: generateFieldDescription(column, table)
   };
@@ -942,16 +943,41 @@ function generateFieldContract(column, table) {
   }
   return field;
 }
-function postgresTypeToTsType(column) {
+function postgresTypeToTsType(column, enums) {
+  const pgType = column.pgType.toLowerCase();
+  if (enums[pgType]) {
+    const enumType = enums[pgType].map((v) => `"${v}"`).join(" | ");
+    if (column.nullable) {
+      return `${enumType} | null`;
+    }
+    return enumType;
+  }
+  if (pgType.startsWith("_")) {
+    const enumName = pgType.slice(1);
+    const enumValues = enums[enumName];
+    if (enumValues) {
+      const enumType = enumValues.map((v) => `"${v}"`).join(" | ");
+      const arrayType = `(${enumType})[]`;
+      if (column.nullable) {
+        return `${arrayType} | null`;
+      }
+      return arrayType;
+    }
+  }
   const baseType = (() => {
-    switch (column.pgType) {
+    switch (pgType) {
       case "int":
+      case "int2":
+      case "int4":
+      case "int8":
       case "integer":
       case "smallint":
       case "bigint":
       case "decimal":
       case "numeric":
       case "real":
+      case "float4":
+      case "float8":
       case "double precision":
       case "float":
         return "number";
@@ -969,9 +995,16 @@ function postgresTypeToTsType(column) {
         return "string";
       case "text[]":
       case "varchar[]":
+      case "_text":
+      case "_varchar":
         return "string[]";
       case "int[]":
       case "integer[]":
+      case "_int":
+      case "_int2":
+      case "_int4":
+      case "_int8":
+      case "_integer":
         return "number[]";
       default:
         return "string";
@@ -1053,18 +1086,18 @@ function generateExampleValue(column) {
       return `'example value'`;
   }
 }
-function generateQueryParams(table) {
+function generateQueryParams(table, enums) {
   const params = {
     limit: "number - Max records to return (default: 50)",
     offset: "number - Records to skip",
-    order_by: "string - Field to sort by",
-    order_dir: "'asc' | 'desc' - Sort direction"
+    orderBy: "string | string[] - Field(s) to sort by",
+    order: "'asc' | 'desc' | ('asc' | 'desc')[] - Sort direction(s)"
   };
   let filterCount = 0;
   for (const col of table.columns) {
     if (filterCount >= 3)
       break;
-    const type = postgresTypeToJsonType(col.pgType);
+    const type = postgresTypeToJsonType(col.pgType, enums);
     params[col.name] = `${type} - Filter by ${col.name}`;
     if (type === "string") {
       params[`${col.name}_like`] = `string - Search in ${col.name}`;
@@ -1077,15 +1110,27 @@ function generateQueryParams(table) {
   params["..."] = "Additional filters for all fields";
   return params;
 }
-function postgresTypeToJsonType(pgType) {
-  switch (pgType) {
+function postgresTypeToJsonType(pgType, enums) {
+  const t = pgType.toLowerCase();
+  if (enums[t]) {
+    return t;
+  }
+  if (t.startsWith("_") && enums[t.slice(1)]) {
+    return `${t.slice(1)}[]`;
+  }
+  switch (t) {
     case "int":
+    case "int2":
+    case "int4":
+    case "int8":
     case "integer":
     case "smallint":
     case "bigint":
     case "decimal":
     case "numeric":
     case "real":
+    case "float4":
+    case "float8":
     case "double precision":
     case "float":
       return "number";
@@ -1103,9 +1148,16 @@ function postgresTypeToJsonType(pgType) {
       return "uuid";
     case "text[]":
     case "varchar[]":
+    case "_text":
+    case "_varchar":
       return "string[]";
     case "int[]":
     case "integer[]":
+    case "_int":
+    case "_int2":
+    case "_int4":
+    case "_int8":
+    case "_integer":
       return "number[]";
     default:
       return "string";
@@ -1350,6 +1402,64 @@ function generateUnifiedContractMarkdown(contract) {
   lines.push("");
   lines.push("**Note:** The WHERE clause types are fully type-safe. TypeScript will only allow operators that are valid for each field type.");
   lines.push("");
+  lines.push("## Sorting");
+  lines.push("");
+  lines.push("Sort query results using the `orderBy` and `order` parameters. Supports both single and multi-column sorting.");
+  lines.push("");
+  lines.push("### Single Column Sorting");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("// Sort by one column ascending");
+  lines.push("const users = await sdk.users.list({");
+  lines.push("  orderBy: 'created_at',");
+  lines.push("  order: 'asc'");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Sort descending");
+  lines.push("const latest = await sdk.users.list({");
+  lines.push("  orderBy: 'created_at',");
+  lines.push("  order: 'desc'");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Order defaults to 'asc' if not specified");
+  lines.push("const sorted = await sdk.users.list({");
+  lines.push("  orderBy: 'name'");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Multi-Column Sorting");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("// Sort by multiple columns (all same direction)");
+  lines.push("const users = await sdk.users.list({");
+  lines.push("  orderBy: ['status', 'created_at'],");
+  lines.push("  order: 'desc'");
+  lines.push("});");
+  lines.push("");
+  lines.push("// Different direction per column");
+  lines.push("const sorted = await sdk.users.list({");
+  lines.push("  orderBy: ['status', 'created_at'],");
+  lines.push("  order: ['asc', 'desc']  // status ASC, created_at DESC");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Combining Sorting with Filters");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("const results = await sdk.users.list({");
+  lines.push("  where: {");
+  lines.push("    status: 'active',");
+  lines.push("    age: { $gte: 18 }");
+  lines.push("  },");
+  lines.push("  orderBy: 'created_at',");
+  lines.push("  order: 'desc',");
+  lines.push("  limit: 50,");
+  lines.push("  offset: 0");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("**Note:** Column names are validated by Zod schemas. Only valid table columns are accepted, preventing SQL injection.");
+  lines.push("");
   lines.push("## Resources");
   lines.push("");
   for (const resource of contract.resources) {
@@ -1748,23 +1858,28 @@ export const buildWithFor = (t: TableName) =>
 
 // src/emit-zod.ts
 init_utils();
-function emitZod(table, opts) {
+function emitZod(table, opts, enums) {
   const Type = pascal(table.name);
   const zFor = (pg) => {
-    if (pg === "uuid")
+    const t = pg.toLowerCase();
+    if (enums[t]) {
+      const values = enums[t].map((v) => `"${v}"`).join(", ");
+      return `z.enum([${values}])`;
+    }
+    if (t === "uuid")
       return `z.string()`;
-    if (pg === "bool" || pg === "boolean")
+    if (t === "bool" || t === "boolean")
       return `z.boolean()`;
-    if (pg === "int2" || pg === "int4" || pg === "int8")
+    if (t === "int2" || t === "int4" || t === "int8")
       return opts.numericMode === "number" ? `z.number()` : `z.string()`;
-    if (pg === "numeric" || pg === "float4" || pg === "float8")
+    if (t === "numeric" || t === "float4" || t === "float8")
       return opts.numericMode === "number" ? `z.number()` : `z.string()`;
-    if (pg === "jsonb" || pg === "json")
+    if (t === "jsonb" || t === "json")
       return `z.unknown()`;
-    if (pg === "date" || pg.startsWith("timestamp"))
+    if (t === "date" || t.startsWith("timestamp"))
       return `z.string()`;
-    if (pg.startsWith("_"))
-      return `z.array(${zFor(pg.slice(1))})`;
+    if (t.startsWith("_"))
+      return `z.array(${zFor(t.slice(1))})`;
     return `z.string()`;
   };
   const selectFields = table.columns.map((c) => {
@@ -1865,6 +1980,7 @@ function emitHonoRoutes(table, _graph, opts) {
   const hasAuth = opts.authStrategy && opts.authStrategy !== "none";
   const ext = opts.useJsExtensions ? ".js" : "";
   const authImport = hasAuth ? `import { authMiddleware } from "../auth${ext}";` : "";
+  const columnNames = table.columns.map((c) => `"${c.name}"`).join(", ");
   return `/**
  * AUTO-GENERATED FILE - DO NOT EDIT
  *
@@ -1881,12 +1997,15 @@ import { loadIncludes } from "../include-loader${ext}";
 import * as coreOps from "../core/operations${ext}";
 ${authImport}
 
+const columnEnum = z.enum([${columnNames}]);
+
 const listSchema = z.object({
   where: z.any().optional(),
   include: z.any().optional(),
   limit: z.number().int().positive().max(100).optional(),
   offset: z.number().int().min(0).optional(),
-  orderBy: z.any().optional()
+  orderBy: z.union([columnEnum, z.array(columnEnum)]).optional(),
+  order: z.union([z.enum(["asc", "desc"]), z.array(z.enum(["asc", "desc"]))]).optional()
 });
 
 export function register${Type}Routes(app: Hono, deps: { pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> }, onRequest?: (c: Context, pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> }) => Promise<void> }) {
@@ -2075,7 +2194,7 @@ 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; order?: "asc" | "desc"; }, "include">`;
+    const baseParams = isGetByPk ? "" : `params?: Omit<{ limit?: number; offset?: number; where?: Where<Select${Type}>; orderBy?: string | string[]; order?: "asc" | "desc" | ("asc" | "desc")[]; }, "include">`;
     if (isGetByPk) {
       const pkWhere = hasCompositePk ? `{ ${safePk.map((col) => `${col}: pk.${col}`).join(", ")} }` : `{ ${safePk[0] || "id"}: pk }`;
       const baseReturnType = method.returnType.replace(" | null", "");
@@ -2131,8 +2250,8 @@ export class ${Type}Client extends BaseClient {
     limit?: number;
     offset?: number;
     where?: Where<Select${Type}>;
-    orderBy?: string;
-    order?: "asc" | "desc";
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
   }): Promise<Select${Type}[]> {
     return this.post<Select${Type}[]>(\`\${this.resource}/list\`, params ?? {});
   }
@@ -2688,10 +2807,13 @@ export async function loadIncludes(
 }
 
 // src/emit-types.ts
-function tsTypeFor(pgType, opts) {
+function tsTypeFor(pgType, opts, enums) {
   const t = pgType.toLowerCase();
+  if (enums[t]) {
+    return enums[t].map((v) => `"${v}"`).join(" | ");
+  }
   if (t.startsWith("_"))
-    return `${tsTypeFor(t.slice(1), opts)}[]`;
+    return `(${tsTypeFor(t.slice(1), opts, enums)})[]`;
   if (t === "uuid")
     return "string";
   if (t === "bool" || t === "boolean")
@@ -2706,17 +2828,17 @@ function tsTypeFor(pgType, opts) {
   return "string";
 }
 var pascal2 = (s) => s.split(/[_\s-]+/).map((w) => w?.[0] ? w[0].toUpperCase() + w.slice(1) : "").join("");
-function emitTypes(table, opts) {
+function emitTypes(table, opts, enums) {
   const Type = pascal2(table.name);
   const insertFields = table.columns.map((col) => {
-    const base = tsTypeFor(col.pgType, opts);
+    const base = tsTypeFor(col.pgType, opts, enums);
     const optional = col.hasDefault || col.nullable ? "?" : "";
     const valueType = col.nullable ? `${base} | null` : base;
     return `  ${col.name}${optional}: ${valueType};`;
   }).join(`
 `);
   const selectFields = table.columns.map((col) => {
-    const base = tsTypeFor(col.pgType, opts);
+    const base = tsTypeFor(col.pgType, opts, enums);
     const valueType = col.nullable ? `${base} | null` : base;
     return `  ${col.name}: ${valueType};`;
   }).join(`
@@ -3466,10 +3588,10 @@ function buildWhereClause(
  */
 export async function listRecords(
   ctx: OperationContext,
-  params: { where?: any; limit?: number; offset?: number; include?: any }
+  params: { where?: any; limit?: number; offset?: number; include?: any; orderBy?: string | string[]; order?: "asc" | "desc" | ("asc" | "desc")[] }
 ): Promise<{ data?: any; error?: string; issues?: any; needsIncludes?: boolean; includeSpec?: any; status: number }> {
   try {
-    const { where: whereClause, limit = 50, offset = 0, include } = params;
+    const { where: whereClause, limit = 50, offset = 0, include, orderBy, order } = params;
 
     // Build WHERE clause
     let paramIndex = 1;
@@ -3493,12 +3615,26 @@ export async function listRecords(
 
     const whereSQL = whereParts.length > 0 ? \`WHERE \${whereParts.join(" AND ")}\` : "";
 
+    // Build ORDER BY clause
+    let orderBySQL = "";
+    if (orderBy) {
+      const columns = Array.isArray(orderBy) ? orderBy : [orderBy];
+      const directions = Array.isArray(order) ? order : (order ? Array(columns.length).fill(order) : Array(columns.length).fill("asc"));
+
+      const orderParts = columns.map((col, i) => {
+        const dir = (directions[i] || "asc").toUpperCase();
+        return \`"\${col}" \${dir}\`;
+      });
+
+      orderBySQL = \`ORDER BY \${orderParts.join(", ")}\`;
+    }
+
     // Add limit and offset params
     const limitParam = \`$\${paramIndex}\`;
     const offsetParam = \`$\${paramIndex + 1}\`;
     const allParams = [...whereParams, limit, offset];
 
-    const text = \`SELECT * FROM "\${ctx.table}" \${whereSQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
+    const text = \`SELECT * FROM "\${ctx.table}" \${whereSQL} \${orderBySQL} LIMIT \${limitParam} OFFSET \${offsetParam}\`;
     log.debug(\`LIST \${ctx.table} SQL:\`, text, "params:", allParams);
 
     const { rows } = await ctx.pg.query(text, allParams);
@@ -4440,10 +4576,10 @@ async function generate(configPath) {
     console.log(`[Index] About to process ${Object.keys(model.tables || {}).length} tables for generation`);
   }
   for (const table of Object.values(model.tables)) {
-    const typesSrc = emitTypes(table, { numericMode: "string" });
+    const typesSrc = emitTypes(table, { numericMode: "string" }, model.enums);
     files.push({ path: join(serverDir, "types", `${table.name}.ts`), content: typesSrc });
     files.push({ path: join(clientDir, "types", `${table.name}.ts`), content: typesSrc });
-    const zodSrc = emitZod(table, { numericMode: "string" });
+    const zodSrc = emitZod(table, { numericMode: "string" }, model.enums);
     files.push({ path: join(serverDir, "zod", `${table.name}.ts`), content: zodSrc });
     files.push({ path: join(clientDir, "zod", `${table.name}.ts`), content: zodSrc });
     const paramsZodSrc = emitParamsZod(table, graph);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {
@@ -22,11 +22,12 @@
   },
   "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: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: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",
     "test:pull": "bun test/test-pull.ts",
+    "test:enums": "bun test/test-enums.ts",
     "test:typecheck": "bun test/test-typecheck.ts",
     "test:drizzle-e2e": "bun test/test-drizzle-e2e.ts",
     "typecheck": "tsc --noEmit",