postgresdk 0.9.0 → 0.9.2

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,157 +2077,7 @@ ${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, 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;
-}
-
-// src/emit-client.ts
+init_emit_include_methods();
 function emitClient(table, graph, opts, model) {
   const Type = pascal(table.name);
   const ext = opts.useJsExtensions ? ".js" : "";
@@ -4146,26 +4159,30 @@ async function generate(configPath) {
       content: emitHonoRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none", cfg.useJsExtensions)
     });
   }
-  const clientFiles = files.filter((f) => {
-    return f.path.includes(clientDir);
+  const { generateUnifiedContract: generateUnifiedContract2, generateUnifiedContractMarkdown: generateUnifiedContractMarkdown2 } = await Promise.resolve().then(() => (init_emit_sdk_contract(), exports_emit_sdk_contract));
+  if (process.env.SDK_DEBUG) {
+    console.log(`[Index] Model has ${Object.keys(model.tables || {}).length} tables before contract generation`);
+  }
+  const contract = generateUnifiedContract2(model, cfg, graph);
+  files.push({
+    path: join(serverDir, "CONTRACT.md"),
+    content: generateUnifiedContractMarkdown2(contract)
   });
   files.push({
-    path: join(serverDir, "sdk-bundle.ts"),
-    content: emitSdkBundle(clientFiles, clientDir)
+    path: join(clientDir, "CONTRACT.md"),
+    content: generateUnifiedContractMarkdown2(contract)
   });
-  const contractCode = emitUnifiedContract(model, cfg);
+  const contractCode = emitUnifiedContract(model, cfg, graph);
   files.push({
     path: join(serverDir, "contract.ts"),
     content: contractCode
   });
-  const { generateUnifiedContract: generateUnifiedContract2, generateUnifiedContractMarkdown: generateUnifiedContractMarkdown2 } = await Promise.resolve().then(() => (init_emit_sdk_contract(), exports_emit_sdk_contract));
-  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 clientFiles = files.filter((f) => {
+    return f.path.includes(clientDir);
+  });
   files.push({
-    path: join(serverDir, "CONTRACT.md"),
-    content: generateUnifiedContractMarkdown2(contract)
+    path: join(serverDir, "sdk-bundle.ts"),
+    content: emitSdkBundle(clientFiles, clientDir)
   });
   if (generateTests) {
     console.log("\uD83E\uDDEA Generating tests...");

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,157 +1814,7 @@ ${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, 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;
-}
-
-// src/emit-client.ts
+init_emit_include_methods();
 function emitClient(table, graph, opts, model) {
   const Type = pascal(table.name);
   const ext = opts.useJsExtensions ? ".js" : "";
@@ -3883,26 +3896,30 @@ async function generate(configPath) {
       content: emitHonoRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none", cfg.useJsExtensions)
     });
   }
-  const clientFiles = files.filter((f) => {
-    return f.path.includes(clientDir);
+  const { generateUnifiedContract: generateUnifiedContract2, generateUnifiedContractMarkdown: generateUnifiedContractMarkdown2 } = await Promise.resolve().then(() => (init_emit_sdk_contract(), exports_emit_sdk_contract));
+  if (process.env.SDK_DEBUG) {
+    console.log(`[Index] Model has ${Object.keys(model.tables || {}).length} tables before contract generation`);
+  }
+  const contract = generateUnifiedContract2(model, cfg, graph);
+  files.push({
+    path: join(serverDir, "CONTRACT.md"),
+    content: generateUnifiedContractMarkdown2(contract)
   });
   files.push({
-    path: join(serverDir, "sdk-bundle.ts"),
-    content: emitSdkBundle(clientFiles, clientDir)
+    path: join(clientDir, "CONTRACT.md"),
+    content: generateUnifiedContractMarkdown2(contract)
   });
-  const contractCode = emitUnifiedContract(model, cfg);
+  const contractCode = emitUnifiedContract(model, cfg, graph);
   files.push({
     path: join(serverDir, "contract.ts"),
     content: contractCode
   });
-  const { generateUnifiedContract: generateUnifiedContract2, generateUnifiedContractMarkdown: generateUnifiedContractMarkdown2 } = await Promise.resolve().then(() => (init_emit_sdk_contract(), exports_emit_sdk_contract));
-  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 clientFiles = files.filter((f) => {
+    return f.path.includes(clientDir);
+  });
   files.push({
-    path: join(serverDir, "CONTRACT.md"),
-    content: generateUnifiedContractMarkdown2(contract)
+    path: join(serverDir, "sdk-bundle.ts"),
+    content: emitSdkBundle(clientFiles, clientDir)
   });
   if (generateTests) {
     console.log("\uD83E\uDDEA Generating tests...");

package/package.json

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