postgresdk 0.8.0 → 0.9.1

package/dist/cli.js

@@ -486,6 +486,157 @@ async function ensureDirs(dirs) {
 var pascal = (s) => s.split(/[_\s-]+/).map((w) => w?.[0] ? w[0].toUpperCase() + w.slice(1) : "").join("");
 var init_utils = () => {};
 
+// src/emit-include-methods.ts
+function isJunctionTable(table) {
+  if (!table.name.includes("_"))
+    return false;
+  const fkColumns = new Set(table.fks.flatMap((fk) => fk.from));
+  const nonPkColumns = table.columns.filter((c) => !table.pk.includes(c.name));
+  return nonPkColumns.every((c) => fkColumns.has(c.name));
+}
+function pathToMethodSuffix(path) {
+  return "With" + path.map((p) => pascal(p)).join("And");
+}
+function buildReturnType(baseTable, path, isMany, targets, graph) {
+  const BaseType = `Select${pascal(baseTable)}`;
+  if (path.length === 0)
+    return BaseType;
+  let type = BaseType;
+  let currentTable = baseTable;
+  const parts = [];
+  for (let i = 0;i < path.length; i++) {
+    const key = path[i];
+    const target = targets[i];
+    if (!key || !target)
+      continue;
+    const targetType = `Select${pascal(target)}`;
+    if (i === 0) {
+      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : targetType}`);
+    } else {
+      let nestedType = targetType;
+      for (let j = i;j < path.length; j++) {
+        if (j > i) {
+          const nestedKey = path[j];
+          const nestedTarget = targets[j];
+          if (!nestedKey || !nestedTarget)
+            continue;
+          const nestedTargetType = `Select${pascal(nestedTarget)}`;
+          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : nestedTargetType} }`;
+        }
+      }
+      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} }`}`;
+      }
+      break;
+    }
+  }
+  return `${type} & { ${parts.join("; ")} }`;
+}
+function buildIncludeSpec(path) {
+  if (path.length === 0)
+    return {};
+  if (path.length === 1)
+    return { [path[0]]: true };
+  let spec = true;
+  for (let i = path.length - 1;i > 0; i--) {
+    const key = path[i];
+    if (!key)
+      continue;
+    spec = { [key]: spec };
+  }
+  const rootKey = path[0];
+  return rootKey ? { [rootKey]: spec } : {};
+}
+function generateIncludeMethods(table, graph, opts, allTables) {
+  const methods = [];
+  const baseTableName = table.name;
+  if (opts.skipJunctionTables && isJunctionTable(table)) {
+    return methods;
+  }
+  const edges = graph[baseTableName] || {};
+  function explore(currentTable, path, isMany, targets, visited, depth) {
+    if (depth > opts.maxDepth)
+      return;
+    const currentEdges = graph[currentTable] || {};
+    for (const [key, edge] of Object.entries(currentEdges)) {
+      if (visited.has(edge.target))
+        continue;
+      if (opts.skipJunctionTables && allTables) {
+        const targetTable = allTables.find((t) => t.name === edge.target);
+        if (targetTable && isJunctionTable(targetTable)) {
+          continue;
+        }
+      }
+      const newPath = [...path, key];
+      const newIsMany = [...isMany, edge.kind === "many"];
+      const newTargets = [...targets, edge.target];
+      const methodSuffix = pathToMethodSuffix(newPath);
+      methods.push({
+        name: `list${methodSuffix}`,
+        path: newPath,
+        isMany: newIsMany,
+        targets: newTargets,
+        returnType: `(${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)})[]`,
+        includeSpec: buildIncludeSpec(newPath)
+      });
+      methods.push({
+        name: `getByPk${methodSuffix}`,
+        path: newPath,
+        isMany: newIsMany,
+        targets: newTargets,
+        returnType: `${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)} | null`,
+        includeSpec: buildIncludeSpec(newPath)
+      });
+      explore(edge.target, newPath, newIsMany, newTargets, new Set([...visited, edge.target]), depth + 1);
+    }
+    if (depth === 1 && Object.keys(currentEdges).length > 1 && Object.keys(currentEdges).length <= 3) {
+      const edgeEntries = Object.entries(currentEdges);
+      if (edgeEntries.length >= 2) {
+        for (let i = 0;i < edgeEntries.length - 1; i++) {
+          for (let j = i + 1;j < edgeEntries.length; j++) {
+            const entry1 = edgeEntries[i];
+            const entry2 = edgeEntries[j];
+            if (!entry1 || !entry2)
+              continue;
+            const [key1, edge1] = entry1;
+            const [key2, edge2] = entry2;
+            if (opts.skipJunctionTables && (edge1.target.includes("_") || edge2.target.includes("_"))) {
+              continue;
+            }
+            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)}`}`;
+            methods.push({
+              name: `list${combinedSuffix}`,
+              path: combinedPath,
+              isMany: [edge1.kind === "many", edge2.kind === "many"],
+              targets: [edge1.target, edge2.target],
+              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} })[]`,
+              includeSpec: { [key1]: true, [key2]: true }
+            });
+            methods.push({
+              name: `getByPk${combinedSuffix}`,
+              path: combinedPath,
+              isMany: [edge1.kind === "many", edge2.kind === "many"],
+              targets: [edge1.target, edge2.target],
+              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} }) | null`,
+              includeSpec: { [key1]: true, [key2]: true }
+            });
+          }
+        }
+      }
+    }
+  }
+  explore(baseTableName, [], [], [], new Set([baseTableName]), 1);
+  return methods;
+}
+var init_emit_include_methods = __esm(() => {
+  init_utils();
+});
+
 // src/emit-sdk-contract.ts
 var exports_emit_sdk_contract = {};
 __export(exports_emit_sdk_contract, {
@@ -493,7 +644,7 @@ __export(exports_emit_sdk_contract, {
   generateUnifiedContract: () => generateUnifiedContract,
   emitUnifiedContract: () => emitUnifiedContract
 });
-function generateUnifiedContract(model, config) {
+function generateUnifiedContract(model, config, graph) {
   const resources = [];
   const relationships = [];
   const tables = model && model.tables ? Object.values(model.tables) : [];
@@ -501,7 +652,7 @@ function generateUnifiedContract(model, config) {
     console.log(`[SDK Contract] Processing ${tables.length} tables`);
   }
   for (const table of tables) {
-    resources.push(generateResourceWithSDK(table, model));
+    resources.push(generateResourceWithSDK(table, model, graph, config));
     for (const fk of table.fks) {
       relationships.push({
         from: table.name,
@@ -619,7 +770,7 @@ function generateSDKAuthExamples(auth) {
   });
   return examples;
 }
-function generateResourceWithSDK(table, model) {
+function generateResourceWithSDK(table, model, graph, config) {
   const Type = pascal(table.name);
   const tableName = table.name;
   const basePath = `/v1/${tableName}`;
@@ -641,11 +792,6 @@ const filtered = await sdk.${tableName}.list({
   ${table.columns[0]?.name || "field"}_like: 'search',
   order_by: '${table.columns[0]?.name || "created_at"}',
   order_dir: 'desc'
-});
-
-// With related data
-const withRelations = await sdk.${tableName}.list({
-  include: '${table.fks[0]?.toTable || "related_table"}'
 });`,
     correspondsTo: `GET ${basePath}`
   });
@@ -659,16 +805,11 @@ const withRelations = await sdk.${tableName}.list({
   if (hasSinglePK) {
     sdkMethods.push({
       name: "getByPk",
-      signature: `getByPk(${pkField}: string, params?: GetParams): Promise<${Type} | null>`,
+      signature: `getByPk(${pkField}: string): Promise<${Type} | null>`,
       description: `Get a single ${tableName} by primary key`,
       example: `// Get by ID
 const item = await sdk.${tableName}.getByPk('123e4567-e89b-12d3-a456-426614174000');
 
-// With related data
-const withRelations = await sdk.${tableName}.getByPk('123', {
-  include: '${table.fks[0]?.toTable || "related_table"}'
-});
-
 // Check if exists
 if (item === null) {
   console.log('Not found');
@@ -679,9 +820,6 @@ if (item === null) {
       method: "GET",
       path: `${basePath}/:${pkField}`,
       description: `Get ${tableName} by ID`,
-      queryParameters: {
-        include: "string - Comma-separated list of related resources"
-      },
       responseBody: `${Type}`
     });
   }
@@ -744,6 +882,31 @@ console.log('Deleted:', deleted);`,
       responseBody: `${Type}`
     });
   }
+  if (graph && config) {
+    const allTables = model && model.tables ? Object.values(model.tables) : undefined;
+    const includeMethods = generateIncludeMethods(table, graph, {
+      maxDepth: config.includeMethodsDepth ?? 2,
+      skipJunctionTables: config.skipJunctionTables ?? true
+    }, allTables);
+    for (const method of includeMethods) {
+      const isGetByPk = method.name.startsWith("getByPk");
+      const exampleCall = isGetByPk ? `const result = await sdk.${tableName}.${method.name}('123e4567-e89b-12d3-a456-426614174000');` : `const results = await sdk.${tableName}.${method.name}();
+
+// With filters and pagination
+const filtered = await sdk.${tableName}.${method.name}({
+  limit: 20,
+  offset: 0,
+  where: { /* filter conditions */ }
+});`;
+      sdkMethods.push({
+        name: method.name,
+        signature: `${method.name}(${isGetByPk ? `${pkField}: string` : "params?: ListParams"}): ${method.returnType}`,
+        description: `Get ${tableName} with included ${method.path.join(", ")} data`,
+        example: exampleCall,
+        correspondsTo: `POST ${basePath}/list`
+      });
+    }
+  }
   const fields = table.columns.map((col) => generateFieldContract(col, table));
   return {
     name: Type,
@@ -892,8 +1055,7 @@ function generateQueryParams(table) {
     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",
-    include: "string - Related resources to include"
+    order_dir: "'asc' | 'desc' - Sort direction"
   };
   let filterCount = 0;
   for (const col of table.columns) {
@@ -1080,8 +1242,8 @@ function generateUnifiedContractMarkdown(contract) {
   return lines.join(`
 `);
 }
-function emitUnifiedContract(model, config) {
-  const contract = generateUnifiedContract(model, config);
+function emitUnifiedContract(model, config, graph) {
+  const contract = generateUnifiedContract(model, config, graph);
   const contractJson = JSON.stringify(contract, null, 2);
   return `/**
  * Unified API & SDK Contract
@@ -1137,6 +1299,7 @@ import type * as Types from './client/types';
 }
 var init_emit_sdk_contract = __esm(() => {
   init_utils();
+  init_emit_include_methods();
 });
 
 // src/cli-init.ts
@@ -1914,156 +2077,8 @@ ${hasAuth ? `
 
 // src/emit-client.ts
 init_utils();
-
-// src/emit-include-methods.ts
-init_utils();
-function isJunctionTable(table) {
-  if (!table.name.includes("_"))
-    return false;
-  const fkColumns = new Set(table.fks.flatMap((fk) => fk.from));
-  const nonPkColumns = table.columns.filter((c) => !table.pk.includes(c.name));
-  return nonPkColumns.every((c) => fkColumns.has(c.name));
-}
-function pathToMethodSuffix(path) {
-  return "With" + path.map((p) => pascal(p)).join("And");
-}
-function buildReturnType(baseTable, path, isMany, targets, graph) {
-  const BaseType = `Select${pascal(baseTable)}`;
-  if (path.length === 0)
-    return BaseType;
-  let type = BaseType;
-  let currentTable = baseTable;
-  const parts = [];
-  for (let i = 0;i < path.length; i++) {
-    const key = path[i];
-    const target = targets[i];
-    if (!key || !target)
-      continue;
-    const targetType = `Select${pascal(target)}`;
-    if (i === 0) {
-      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : targetType}`);
-    } else {
-      let nestedType = targetType;
-      for (let j = i;j < path.length; j++) {
-        if (j > i) {
-          const nestedKey = path[j];
-          const nestedTarget = targets[j];
-          if (!nestedKey || !nestedTarget)
-            continue;
-          const nestedTargetType = `Select${pascal(nestedTarget)}`;
-          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : nestedTargetType} }`;
-        }
-      }
-      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} }`}`;
-      }
-      break;
-    }
-  }
-  return `${type} & { ${parts.join("; ")} }`;
-}
-function buildIncludeSpec(path) {
-  if (path.length === 0)
-    return {};
-  if (path.length === 1)
-    return { [path[0]]: true };
-  let spec = true;
-  for (let i = path.length - 1;i > 0; i--) {
-    const key = path[i];
-    if (!key)
-      continue;
-    spec = { [key]: spec };
-  }
-  const rootKey = path[0];
-  return rootKey ? { [rootKey]: spec } : {};
-}
-function generateIncludeMethods(table, graph, opts) {
-  const methods = [];
-  const baseTableName = table.name;
-  if (opts.skipJunctionTables && isJunctionTable(table)) {
-    return methods;
-  }
-  const edges = graph[baseTableName] || {};
-  function explore(currentTable, path, isMany, targets, visited, depth) {
-    if (depth > opts.maxDepth)
-      return;
-    const currentEdges = graph[currentTable] || {};
-    for (const [key, edge] of Object.entries(currentEdges)) {
-      if (visited.has(edge.target))
-        continue;
-      const targetTable = Object.values(graph).find((t) => Object.values(t).some((e) => e.target === edge.target));
-      if (opts.skipJunctionTables && edge.target.includes("_")) {
-        continue;
-      }
-      const newPath = [...path, key];
-      const newIsMany = [...isMany, edge.kind === "many"];
-      const newTargets = [...targets, edge.target];
-      const methodSuffix = pathToMethodSuffix(newPath);
-      methods.push({
-        name: `list${methodSuffix}`,
-        path: newPath,
-        isMany: newIsMany,
-        targets: newTargets,
-        returnType: `(${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)})[]`,
-        includeSpec: buildIncludeSpec(newPath)
-      });
-      methods.push({
-        name: `getByPk${methodSuffix}`,
-        path: newPath,
-        isMany: newIsMany,
-        targets: newTargets,
-        returnType: `${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)} | null`,
-        includeSpec: buildIncludeSpec(newPath)
-      });
-      explore(edge.target, newPath, newIsMany, newTargets, new Set([...visited, edge.target]), depth + 1);
-    }
-    if (depth === 1 && Object.keys(currentEdges).length > 1 && Object.keys(currentEdges).length <= 3) {
-      const edgeEntries = Object.entries(currentEdges);
-      if (edgeEntries.length >= 2) {
-        for (let i = 0;i < edgeEntries.length - 1; i++) {
-          for (let j = i + 1;j < edgeEntries.length; j++) {
-            const entry1 = edgeEntries[i];
-            const entry2 = edgeEntries[j];
-            if (!entry1 || !entry2)
-              continue;
-            const [key1, edge1] = entry1;
-            const [key2, edge2] = entry2;
-            if (opts.skipJunctionTables && (edge1.target.includes("_") || edge2.target.includes("_"))) {
-              continue;
-            }
-            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)}`}`;
-            methods.push({
-              name: `list${combinedSuffix}`,
-              path: combinedPath,
-              isMany: [edge1.kind === "many", edge2.kind === "many"],
-              targets: [edge1.target, edge2.target],
-              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} })[]`,
-              includeSpec: { [key1]: true, [key2]: true }
-            });
-            methods.push({
-              name: `getByPk${combinedSuffix}`,
-              path: combinedPath,
-              isMany: [edge1.kind === "many", edge2.kind === "many"],
-              targets: [edge1.target, edge2.target],
-              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} }) | null`,
-              includeSpec: { [key1]: true, [key2]: true }
-            });
-          }
-        }
-      }
-    }
-  }
-  explore(baseTableName, [], [], [], new Set([baseTableName]), 1);
-  return methods;
-}
-
-// src/emit-client.ts
-function emitClient(table, graph, opts) {
+init_emit_include_methods();
+function emitClient(table, graph, opts, model) {
   const Type = pascal(table.name);
   const ext = opts.useJsExtensions ? ".js" : "";
   const pkCols = Array.isArray(table.pk) ? table.pk : table.pk ? [table.pk] : [];
@@ -2071,10 +2086,11 @@ function emitClient(table, graph, opts) {
   const hasCompositePk = safePk.length > 1;
   const pkType = hasCompositePk ? `{ ${safePk.map((c) => `${c}: string`).join("; ")} }` : `string`;
   const pkPathExpr = hasCompositePk ? safePk.map((c) => `pk.${c}`).join(` + "/" + `) : `pk`;
+  const allTables = model ? Object.values(model.tables) : undefined;
   const includeMethods = generateIncludeMethods(table, graph, {
     maxDepth: opts.includeMethodsDepth ?? 2,
     skipJunctionTables: opts.skipJunctionTables ?? true
-  });
+  }, allTables);
   const importedTypes = new Set;
   importedTypes.add(table.name);
   for (const method of includeMethods) {
@@ -2084,7 +2100,7 @@ function emitClient(table, graph, opts) {
   }
   const typeImports = `import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}${ext}";`;
   const otherTableImports = [];
-  for (const target of importedTypes) {
+  for (const target of Array.from(importedTypes)) {
     if (target !== table.name) {
       otherTableImports.push(`import type { Select${pascal(target)} } from "./types/${target}${ext}";`);
     }
@@ -4083,11 +4099,11 @@ async function generate(configPath) {
   files.push({ path: join(clientDir, "base-client.ts"), content: emitBaseClient() });
   files.push({
     path: join(serverDir, "include-builder.ts"),
-    content: emitIncludeBuilder(graph, cfg.includeDepthLimit || 3)
+    content: emitIncludeBuilder(graph, cfg.includeMethodsDepth || 2)
   });
   files.push({
     path: join(serverDir, "include-loader.ts"),
-    content: emitIncludeLoader(graph, model, cfg.includeDepthLimit || 3, cfg.useJsExtensions)
+    content: emitIncludeLoader(graph, model, cfg.includeMethodsDepth || 2, cfg.useJsExtensions)
   });
   files.push({ path: join(serverDir, "logger.ts"), content: emitLogger() });
   if (normalizedAuth?.strategy && normalizedAuth.strategy !== "none") {
@@ -4113,7 +4129,7 @@ async function generate(configPath) {
     if (serverFramework === "hono") {
       routeContent = emitHonoRoutes(table, graph, {
         softDeleteColumn: cfg.softDeleteColumn || null,
-        includeDepthLimit: cfg.includeDepthLimit || 3,
+        includeDepthLimit: cfg.includeMethodsDepth || 2,
         authStrategy: normalizedAuth?.strategy,
         useJsExtensions: cfg.useJsExtensions
       });
@@ -4130,7 +4146,7 @@ async function generate(configPath) {
         useJsExtensions: cfg.useJsExtensionsClient,
         includeMethodsDepth: cfg.includeMethodsDepth ?? 2,
         skipJunctionTables: cfg.skipJunctionTables ?? true
-      })
+      }, model)
     });
   }
   files.push({
@@ -4159,7 +4175,7 @@ async function generate(configPath) {
   if (process.env.SDK_DEBUG) {
     console.log(`[Index] Model has ${Object.keys(model.tables || {}).length} tables before contract generation`);
   }
-  const contract = generateUnifiedContract2(model, cfg);
+  const contract = generateUnifiedContract2(model, cfg, graph);
   files.push({
     path: join(serverDir, "CONTRACT.md"),
     content: generateUnifiedContractMarkdown2(contract)

package/dist/emit-client.d.ts

@@ -1,8 +1,8 @@
-import type { Table } from "./introspect";
+import type { Table, Model } from "./introspect";
 import type { Graph } from "./rel-classify";
 export declare function emitClient(table: Table, graph: Graph, opts: {
     useJsExtensions?: boolean;
     includeMethodsDepth?: number;
     skipJunctionTables?: boolean;
-}): string;
+}, model?: Model): string;
 export declare function emitClientIndex(tables: Table[], useJsExtensions?: boolean): string;

package/dist/emit-include-methods.d.ts

@@ -14,4 +14,4 @@ export type IncludeMethod = {
 export declare function generateIncludeMethods(table: Table, graph: Graph, opts: {
     maxDepth: number;
     skipJunctionTables: boolean;
-}): IncludeMethod[];
+}, allTables?: Table[]): IncludeMethod[];

package/dist/emit-sdk-contract.d.ts

@@ -1,5 +1,6 @@
 import type { Model } from "./introspect";
 import type { Config, AuthConfig } from "./types";
+import type { Graph } from "./rel-classify";
 export interface UnifiedContract {
     version: string;
     generatedAt: string;
@@ -70,7 +71,7 @@ export interface RelationshipContract {
  */
 export declare function generateUnifiedContract(model: Model, config: Config & {
     auth?: AuthConfig;
-}): UnifiedContract;
+}, graph?: Graph): UnifiedContract;
 /**
  * Generate markdown documentation for the unified contract
  */
@@ -80,4 +81,4 @@ export declare function generateUnifiedContractMarkdown(contract: UnifiedContrac
  */
 export declare function emitUnifiedContract(model: Model, config: Config & {
     auth?: AuthConfig;
-}): string;
+}, graph?: Graph): string;

package/dist/index.js

@@ -485,6 +485,157 @@ async function ensureDirs(dirs) {
 var pascal = (s) => s.split(/[_\s-]+/).map((w) => w?.[0] ? w[0].toUpperCase() + w.slice(1) : "").join("");
 var init_utils = () => {};
 
+// src/emit-include-methods.ts
+function isJunctionTable(table) {
+  if (!table.name.includes("_"))
+    return false;
+  const fkColumns = new Set(table.fks.flatMap((fk) => fk.from));
+  const nonPkColumns = table.columns.filter((c) => !table.pk.includes(c.name));
+  return nonPkColumns.every((c) => fkColumns.has(c.name));
+}
+function pathToMethodSuffix(path) {
+  return "With" + path.map((p) => pascal(p)).join("And");
+}
+function buildReturnType(baseTable, path, isMany, targets, graph) {
+  const BaseType = `Select${pascal(baseTable)}`;
+  if (path.length === 0)
+    return BaseType;
+  let type = BaseType;
+  let currentTable = baseTable;
+  const parts = [];
+  for (let i = 0;i < path.length; i++) {
+    const key = path[i];
+    const target = targets[i];
+    if (!key || !target)
+      continue;
+    const targetType = `Select${pascal(target)}`;
+    if (i === 0) {
+      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : targetType}`);
+    } else {
+      let nestedType = targetType;
+      for (let j = i;j < path.length; j++) {
+        if (j > i) {
+          const nestedKey = path[j];
+          const nestedTarget = targets[j];
+          if (!nestedKey || !nestedTarget)
+            continue;
+          const nestedTargetType = `Select${pascal(nestedTarget)}`;
+          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : nestedTargetType} }`;
+        }
+      }
+      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} }`}`;
+      }
+      break;
+    }
+  }
+  return `${type} & { ${parts.join("; ")} }`;
+}
+function buildIncludeSpec(path) {
+  if (path.length === 0)
+    return {};
+  if (path.length === 1)
+    return { [path[0]]: true };
+  let spec = true;
+  for (let i = path.length - 1;i > 0; i--) {
+    const key = path[i];
+    if (!key)
+      continue;
+    spec = { [key]: spec };
+  }
+  const rootKey = path[0];
+  return rootKey ? { [rootKey]: spec } : {};
+}
+function generateIncludeMethods(table, graph, opts, allTables) {
+  const methods = [];
+  const baseTableName = table.name;
+  if (opts.skipJunctionTables && isJunctionTable(table)) {
+    return methods;
+  }
+  const edges = graph[baseTableName] || {};
+  function explore(currentTable, path, isMany, targets, visited, depth) {
+    if (depth > opts.maxDepth)
+      return;
+    const currentEdges = graph[currentTable] || {};
+    for (const [key, edge] of Object.entries(currentEdges)) {
+      if (visited.has(edge.target))
+        continue;
+      if (opts.skipJunctionTables && allTables) {
+        const targetTable = allTables.find((t) => t.name === edge.target);
+        if (targetTable && isJunctionTable(targetTable)) {
+          continue;
+        }
+      }
+      const newPath = [...path, key];
+      const newIsMany = [...isMany, edge.kind === "many"];
+      const newTargets = [...targets, edge.target];
+      const methodSuffix = pathToMethodSuffix(newPath);
+      methods.push({
+        name: `list${methodSuffix}`,
+        path: newPath,
+        isMany: newIsMany,
+        targets: newTargets,
+        returnType: `(${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)})[]`,
+        includeSpec: buildIncludeSpec(newPath)
+      });
+      methods.push({
+        name: `getByPk${methodSuffix}`,
+        path: newPath,
+        isMany: newIsMany,
+        targets: newTargets,
+        returnType: `${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)} | null`,
+        includeSpec: buildIncludeSpec(newPath)
+      });
+      explore(edge.target, newPath, newIsMany, newTargets, new Set([...visited, edge.target]), depth + 1);
+    }
+    if (depth === 1 && Object.keys(currentEdges).length > 1 && Object.keys(currentEdges).length <= 3) {
+      const edgeEntries = Object.entries(currentEdges);
+      if (edgeEntries.length >= 2) {
+        for (let i = 0;i < edgeEntries.length - 1; i++) {
+          for (let j = i + 1;j < edgeEntries.length; j++) {
+            const entry1 = edgeEntries[i];
+            const entry2 = edgeEntries[j];
+            if (!entry1 || !entry2)
+              continue;
+            const [key1, edge1] = entry1;
+            const [key2, edge2] = entry2;
+            if (opts.skipJunctionTables && (edge1.target.includes("_") || edge2.target.includes("_"))) {
+              continue;
+            }
+            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)}`}`;
+            methods.push({
+              name: `list${combinedSuffix}`,
+              path: combinedPath,
+              isMany: [edge1.kind === "many", edge2.kind === "many"],
+              targets: [edge1.target, edge2.target],
+              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} })[]`,
+              includeSpec: { [key1]: true, [key2]: true }
+            });
+            methods.push({
+              name: `getByPk${combinedSuffix}`,
+              path: combinedPath,
+              isMany: [edge1.kind === "many", edge2.kind === "many"],
+              targets: [edge1.target, edge2.target],
+              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} }) | null`,
+              includeSpec: { [key1]: true, [key2]: true }
+            });
+          }
+        }
+      }
+    }
+  }
+  explore(baseTableName, [], [], [], new Set([baseTableName]), 1);
+  return methods;
+}
+var init_emit_include_methods = __esm(() => {
+  init_utils();
+});
+
 // src/emit-sdk-contract.ts
 var exports_emit_sdk_contract = {};
 __export(exports_emit_sdk_contract, {
@@ -492,7 +643,7 @@ __export(exports_emit_sdk_contract, {
   generateUnifiedContract: () => generateUnifiedContract,
   emitUnifiedContract: () => emitUnifiedContract
 });
-function generateUnifiedContract(model, config) {
+function generateUnifiedContract(model, config, graph) {
   const resources = [];
   const relationships = [];
   const tables = model && model.tables ? Object.values(model.tables) : [];
@@ -500,7 +651,7 @@ function generateUnifiedContract(model, config) {
     console.log(`[SDK Contract] Processing ${tables.length} tables`);
   }
   for (const table of tables) {
-    resources.push(generateResourceWithSDK(table, model));
+    resources.push(generateResourceWithSDK(table, model, graph, config));
     for (const fk of table.fks) {
       relationships.push({
         from: table.name,
@@ -618,7 +769,7 @@ function generateSDKAuthExamples(auth) {
   });
   return examples;
 }
-function generateResourceWithSDK(table, model) {
+function generateResourceWithSDK(table, model, graph, config) {
   const Type = pascal(table.name);
   const tableName = table.name;
   const basePath = `/v1/${tableName}`;
@@ -640,11 +791,6 @@ const filtered = await sdk.${tableName}.list({
   ${table.columns[0]?.name || "field"}_like: 'search',
   order_by: '${table.columns[0]?.name || "created_at"}',
   order_dir: 'desc'
-});
-
-// With related data
-const withRelations = await sdk.${tableName}.list({
-  include: '${table.fks[0]?.toTable || "related_table"}'
 });`,
     correspondsTo: `GET ${basePath}`
   });
@@ -658,16 +804,11 @@ const withRelations = await sdk.${tableName}.list({
   if (hasSinglePK) {
     sdkMethods.push({
       name: "getByPk",
-      signature: `getByPk(${pkField}: string, params?: GetParams): Promise<${Type} | null>`,
+      signature: `getByPk(${pkField}: string): Promise<${Type} | null>`,
       description: `Get a single ${tableName} by primary key`,
       example: `// Get by ID
 const item = await sdk.${tableName}.getByPk('123e4567-e89b-12d3-a456-426614174000');
 
-// With related data
-const withRelations = await sdk.${tableName}.getByPk('123', {
-  include: '${table.fks[0]?.toTable || "related_table"}'
-});
-
 // Check if exists
 if (item === null) {
   console.log('Not found');
@@ -678,9 +819,6 @@ if (item === null) {
       method: "GET",
       path: `${basePath}/:${pkField}`,
       description: `Get ${tableName} by ID`,
-      queryParameters: {
-        include: "string - Comma-separated list of related resources"
-      },
       responseBody: `${Type}`
     });
   }
@@ -743,6 +881,31 @@ console.log('Deleted:', deleted);`,
       responseBody: `${Type}`
     });
   }
+  if (graph && config) {
+    const allTables = model && model.tables ? Object.values(model.tables) : undefined;
+    const includeMethods = generateIncludeMethods(table, graph, {
+      maxDepth: config.includeMethodsDepth ?? 2,
+      skipJunctionTables: config.skipJunctionTables ?? true
+    }, allTables);
+    for (const method of includeMethods) {
+      const isGetByPk = method.name.startsWith("getByPk");
+      const exampleCall = isGetByPk ? `const result = await sdk.${tableName}.${method.name}('123e4567-e89b-12d3-a456-426614174000');` : `const results = await sdk.${tableName}.${method.name}();
+
+// With filters and pagination
+const filtered = await sdk.${tableName}.${method.name}({
+  limit: 20,
+  offset: 0,
+  where: { /* filter conditions */ }
+});`;
+      sdkMethods.push({
+        name: method.name,
+        signature: `${method.name}(${isGetByPk ? `${pkField}: string` : "params?: ListParams"}): ${method.returnType}`,
+        description: `Get ${tableName} with included ${method.path.join(", ")} data`,
+        example: exampleCall,
+        correspondsTo: `POST ${basePath}/list`
+      });
+    }
+  }
   const fields = table.columns.map((col) => generateFieldContract(col, table));
   return {
     name: Type,
@@ -891,8 +1054,7 @@ function generateQueryParams(table) {
     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",
-    include: "string - Related resources to include"
+    order_dir: "'asc' | 'desc' - Sort direction"
   };
   let filterCount = 0;
   for (const col of table.columns) {
@@ -1079,8 +1241,8 @@ function generateUnifiedContractMarkdown(contract) {
   return lines.join(`
 `);
 }
-function emitUnifiedContract(model, config) {
-  const contract = generateUnifiedContract(model, config);
+function emitUnifiedContract(model, config, graph) {
+  const contract = generateUnifiedContract(model, config, graph);
   const contractJson = JSON.stringify(contract, null, 2);
   return `/**
  * Unified API & SDK Contract
@@ -1136,6 +1298,7 @@ import type * as Types from './client/types';
 }
 var init_emit_sdk_contract = __esm(() => {
   init_utils();
+  init_emit_include_methods();
 });
 
 // src/index.ts
@@ -1651,156 +1814,8 @@ ${hasAuth ? `
 
 // src/emit-client.ts
 init_utils();
-
-// src/emit-include-methods.ts
-init_utils();
-function isJunctionTable(table) {
-  if (!table.name.includes("_"))
-    return false;
-  const fkColumns = new Set(table.fks.flatMap((fk) => fk.from));
-  const nonPkColumns = table.columns.filter((c) => !table.pk.includes(c.name));
-  return nonPkColumns.every((c) => fkColumns.has(c.name));
-}
-function pathToMethodSuffix(path) {
-  return "With" + path.map((p) => pascal(p)).join("And");
-}
-function buildReturnType(baseTable, path, isMany, targets, graph) {
-  const BaseType = `Select${pascal(baseTable)}`;
-  if (path.length === 0)
-    return BaseType;
-  let type = BaseType;
-  let currentTable = baseTable;
-  const parts = [];
-  for (let i = 0;i < path.length; i++) {
-    const key = path[i];
-    const target = targets[i];
-    if (!key || !target)
-      continue;
-    const targetType = `Select${pascal(target)}`;
-    if (i === 0) {
-      parts.push(`${key}: ${isMany[i] ? `${targetType}[]` : targetType}`);
-    } else {
-      let nestedType = targetType;
-      for (let j = i;j < path.length; j++) {
-        if (j > i) {
-          const nestedKey = path[j];
-          const nestedTarget = targets[j];
-          if (!nestedKey || !nestedTarget)
-            continue;
-          const nestedTargetType = `Select${pascal(nestedTarget)}`;
-          nestedType = `${nestedType} & { ${nestedKey}: ${isMany[j] ? `${nestedTargetType}[]` : nestedTargetType} }`;
-        }
-      }
-      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} }`}`;
-      }
-      break;
-    }
-  }
-  return `${type} & { ${parts.join("; ")} }`;
-}
-function buildIncludeSpec(path) {
-  if (path.length === 0)
-    return {};
-  if (path.length === 1)
-    return { [path[0]]: true };
-  let spec = true;
-  for (let i = path.length - 1;i > 0; i--) {
-    const key = path[i];
-    if (!key)
-      continue;
-    spec = { [key]: spec };
-  }
-  const rootKey = path[0];
-  return rootKey ? { [rootKey]: spec } : {};
-}
-function generateIncludeMethods(table, graph, opts) {
-  const methods = [];
-  const baseTableName = table.name;
-  if (opts.skipJunctionTables && isJunctionTable(table)) {
-    return methods;
-  }
-  const edges = graph[baseTableName] || {};
-  function explore(currentTable, path, isMany, targets, visited, depth) {
-    if (depth > opts.maxDepth)
-      return;
-    const currentEdges = graph[currentTable] || {};
-    for (const [key, edge] of Object.entries(currentEdges)) {
-      if (visited.has(edge.target))
-        continue;
-      const targetTable = Object.values(graph).find((t) => Object.values(t).some((e) => e.target === edge.target));
-      if (opts.skipJunctionTables && edge.target.includes("_")) {
-        continue;
-      }
-      const newPath = [...path, key];
-      const newIsMany = [...isMany, edge.kind === "many"];
-      const newTargets = [...targets, edge.target];
-      const methodSuffix = pathToMethodSuffix(newPath);
-      methods.push({
-        name: `list${methodSuffix}`,
-        path: newPath,
-        isMany: newIsMany,
-        targets: newTargets,
-        returnType: `(${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)})[]`,
-        includeSpec: buildIncludeSpec(newPath)
-      });
-      methods.push({
-        name: `getByPk${methodSuffix}`,
-        path: newPath,
-        isMany: newIsMany,
-        targets: newTargets,
-        returnType: `${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)} | null`,
-        includeSpec: buildIncludeSpec(newPath)
-      });
-      explore(edge.target, newPath, newIsMany, newTargets, new Set([...visited, edge.target]), depth + 1);
-    }
-    if (depth === 1 && Object.keys(currentEdges).length > 1 && Object.keys(currentEdges).length <= 3) {
-      const edgeEntries = Object.entries(currentEdges);
-      if (edgeEntries.length >= 2) {
-        for (let i = 0;i < edgeEntries.length - 1; i++) {
-          for (let j = i + 1;j < edgeEntries.length; j++) {
-            const entry1 = edgeEntries[i];
-            const entry2 = edgeEntries[j];
-            if (!entry1 || !entry2)
-              continue;
-            const [key1, edge1] = entry1;
-            const [key2, edge2] = entry2;
-            if (opts.skipJunctionTables && (edge1.target.includes("_") || edge2.target.includes("_"))) {
-              continue;
-            }
-            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)}`}`;
-            methods.push({
-              name: `list${combinedSuffix}`,
-              path: combinedPath,
-              isMany: [edge1.kind === "many", edge2.kind === "many"],
-              targets: [edge1.target, edge2.target],
-              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} })[]`,
-              includeSpec: { [key1]: true, [key2]: true }
-            });
-            methods.push({
-              name: `getByPk${combinedSuffix}`,
-              path: combinedPath,
-              isMany: [edge1.kind === "many", edge2.kind === "many"],
-              targets: [edge1.target, edge2.target],
-              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} }) | null`,
-              includeSpec: { [key1]: true, [key2]: true }
-            });
-          }
-        }
-      }
-    }
-  }
-  explore(baseTableName, [], [], [], new Set([baseTableName]), 1);
-  return methods;
-}
-
-// src/emit-client.ts
-function emitClient(table, graph, opts) {
+init_emit_include_methods();
+function emitClient(table, graph, opts, model) {
   const Type = pascal(table.name);
   const ext = opts.useJsExtensions ? ".js" : "";
   const pkCols = Array.isArray(table.pk) ? table.pk : table.pk ? [table.pk] : [];
@@ -1808,10 +1823,11 @@ function emitClient(table, graph, opts) {
   const hasCompositePk = safePk.length > 1;
   const pkType = hasCompositePk ? `{ ${safePk.map((c) => `${c}: string`).join("; ")} }` : `string`;
   const pkPathExpr = hasCompositePk ? safePk.map((c) => `pk.${c}`).join(` + "/" + `) : `pk`;
+  const allTables = model ? Object.values(model.tables) : undefined;
   const includeMethods = generateIncludeMethods(table, graph, {
     maxDepth: opts.includeMethodsDepth ?? 2,
     skipJunctionTables: opts.skipJunctionTables ?? true
-  });
+  }, allTables);
   const importedTypes = new Set;
   importedTypes.add(table.name);
   for (const method of includeMethods) {
@@ -1821,7 +1837,7 @@ function emitClient(table, graph, opts) {
   }
   const typeImports = `import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}${ext}";`;
   const otherTableImports = [];
-  for (const target of importedTypes) {
+  for (const target of Array.from(importedTypes)) {
     if (target !== table.name) {
       otherTableImports.push(`import type { Select${pascal(target)} } from "./types/${target}${ext}";`);
     }
@@ -3820,11 +3836,11 @@ async function generate(configPath) {
   files.push({ path: join(clientDir, "base-client.ts"), content: emitBaseClient() });
   files.push({
     path: join(serverDir, "include-builder.ts"),
-    content: emitIncludeBuilder(graph, cfg.includeDepthLimit || 3)
+    content: emitIncludeBuilder(graph, cfg.includeMethodsDepth || 2)
   });
   files.push({
     path: join(serverDir, "include-loader.ts"),
-    content: emitIncludeLoader(graph, model, cfg.includeDepthLimit || 3, cfg.useJsExtensions)
+    content: emitIncludeLoader(graph, model, cfg.includeMethodsDepth || 2, cfg.useJsExtensions)
   });
   files.push({ path: join(serverDir, "logger.ts"), content: emitLogger() });
   if (normalizedAuth?.strategy && normalizedAuth.strategy !== "none") {
@@ -3850,7 +3866,7 @@ async function generate(configPath) {
     if (serverFramework === "hono") {
       routeContent = emitHonoRoutes(table, graph, {
         softDeleteColumn: cfg.softDeleteColumn || null,
-        includeDepthLimit: cfg.includeDepthLimit || 3,
+        includeDepthLimit: cfg.includeMethodsDepth || 2,
         authStrategy: normalizedAuth?.strategy,
         useJsExtensions: cfg.useJsExtensions
       });
@@ -3867,7 +3883,7 @@ async function generate(configPath) {
         useJsExtensions: cfg.useJsExtensionsClient,
         includeMethodsDepth: cfg.includeMethodsDepth ?? 2,
         skipJunctionTables: cfg.skipJunctionTables ?? true
-      })
+      }, model)
     });
   }
   files.push({
@@ -3896,7 +3912,7 @@ async function generate(configPath) {
   if (process.env.SDK_DEBUG) {
     console.log(`[Index] Model has ${Object.keys(model.tables || {}).length} tables before contract generation`);
   }
-  const contract = generateUnifiedContract2(model, cfg);
+  const contract = generateUnifiedContract2(model, cfg, graph);
   files.push({
     path: join(serverDir, "CONTRACT.md"),
     content: generateUnifiedContractMarkdown2(contract)

package/dist/types.d.ts

@@ -24,7 +24,7 @@ export interface Config {
     outServer?: string;
     outClient?: string;
     softDeleteColumn?: string | null;
-    includeDepthLimit?: number;
+    dateType?: "date" | "string";
     includeMethodsDepth?: number;
     skipJunctionTables?: boolean;
     serverFramework?: "hono" | "express" | "fastify";

package/package.json

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