postgresdk 0.7.6 → 0.8.0

package/dist/cli.js

@@ -1914,18 +1914,211 @@ ${hasAuth ? `
 
 // src/emit-client.ts
 init_utils();
-function emitClient(table, useJsExtensions) {
+
+// 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) {
   const Type = pascal(table.name);
-  const ext = useJsExtensions ? ".js" : "";
+  const ext = opts.useJsExtensions ? ".js" : "";
   const pkCols = Array.isArray(table.pk) ? table.pk : table.pk ? [table.pk] : [];
   const safePk = pkCols.length ? pkCols : ["id"];
   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 includeMethods = generateIncludeMethods(table, graph, {
+    maxDepth: opts.includeMethodsDepth ?? 2,
+    skipJunctionTables: opts.skipJunctionTables ?? true
+  });
+  const importedTypes = new Set;
+  importedTypes.add(table.name);
+  for (const method of includeMethods) {
+    for (const target of method.targets) {
+      importedTypes.add(target);
+    }
+  }
+  const typeImports = `import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}${ext}";`;
+  const otherTableImports = [];
+  for (const target of importedTypes) {
+    if (target !== table.name) {
+      otherTableImports.push(`import type { Select${pascal(target)} } from "./types/${target}${ext}";`);
+    }
+  }
+  let includeMethodsCode = "";
+  for (const method of includeMethods) {
+    const isGetByPk = method.name.startsWith("getByPk");
+    const baseParams = isGetByPk ? "" : `params?: Omit<{ limit?: number; offset?: number; where?: any; orderBy?: string; order?: "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", "");
+      includeMethodsCode += `
+  async ${method.name}(pk: ${pkType}): Promise<${method.returnType}> {
+    const results = await this.post<${baseReturnType}[]>(\`\${this.resource}/list\`, { 
+      where: ${pkWhere},
+      include: ${JSON.stringify(method.includeSpec)},
+      limit: 1 
+    });
+    return (results[0] as ${baseReturnType}) ?? null;
+  }
+`;
+    } else {
+      includeMethodsCode += `
+  async ${method.name}(${baseParams}): Promise<${method.returnType}> {
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...params, include: ${JSON.stringify(method.includeSpec)} });
+  }
+`;
+    }
+  }
   return `/* Generated. Do not edit. */
 import { BaseClient } from "./base-client${ext}";
-import type { ${Type}IncludeSpec } from "./include-spec${ext}";
-import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}${ext}";
+${typeImports}
+${otherTableImports.join(`
+`)}
 
 /**
  * Client for ${table.name} table operations
@@ -1943,7 +2136,6 @@ export class ${Type}Client extends BaseClient {
   }
 
   async list(params?: { 
-    include?: ${Type}IncludeSpec; 
     limit?: number; 
     offset?: number;
     where?: any;
@@ -1962,7 +2154,7 @@ export class ${Type}Client extends BaseClient {
     const path = ${pkPathExpr};
     return this.del<Select${Type} | null>(\`\${this.resource}/\${path}\`);
   }
-}
+${includeMethodsCode}}
 `;
 }
 function emitClientIndex(tables, useJsExtensions) {
@@ -2006,8 +2198,6 @@ export type { AuthConfig, HeaderMap, AuthHeadersProvider } from "./base-client${
 
 `;
   out += `export { BaseClient } from "./base-client${ext}";
-`;
-  out += `export * from "./include-spec${ext}";
 `;
   out += `
 // Zod schemas for form validation
@@ -3084,12 +3274,12 @@ function emitTableTest(table, model, clientPath, framework = "vitest") {
   const Type = pascal(table.name);
   const tableName = table.name;
   const imports = getFrameworkImports(framework);
-  const isJunctionTable = table.pk.length > 1;
+  const isJunctionTable2 = table.pk.length > 1;
   const hasForeignKeys = table.fks.length > 0;
   const foreignKeySetup = hasForeignKeys ? generateForeignKeySetup(table, model, clientPath) : null;
   const sampleData = generateSampleDataFromSchema(table, hasForeignKeys);
   const updateData = generateUpdateDataFromSchema(table);
-  if (isJunctionTable) {
+  if (isJunctionTable2) {
     return `${imports}
 import { SDK } from '${clientPath}';
 import type { Insert${Type}, Update${Type}, Select${Type} } from '${clientPath}/types/${tableName}';
@@ -3936,7 +4126,11 @@ async function generate(configPath) {
     });
     files.push({
       path: join(clientDir, `${table.name}.ts`),
-      content: emitClient(table, cfg.useJsExtensionsClient)
+      content: emitClient(table, graph, {
+        useJsExtensions: cfg.useJsExtensionsClient,
+        includeMethodsDepth: cfg.includeMethodsDepth ?? 2,
+        skipJunctionTables: cfg.skipJunctionTables ?? true
+      })
     });
   }
   files.push({

package/dist/emit-client.d.ts

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

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

@@ -0,0 +1,17 @@
+import type { Table } from "./introspect";
+import type { Graph } from "./rel-classify";
+export type IncludeMethod = {
+    name: string;
+    path: string[];
+    isMany: boolean[];
+    targets: string[];
+    returnType: string;
+    includeSpec: any;
+};
+/**
+ * Generate all include methods for a table
+ */
+export declare function generateIncludeMethods(table: Table, graph: Graph, opts: {
+    maxDepth: number;
+    skipJunctionTables: boolean;
+}): IncludeMethod[];

package/dist/index.js

@@ -1651,18 +1651,211 @@ ${hasAuth ? `
 
 // src/emit-client.ts
 init_utils();
-function emitClient(table, useJsExtensions) {
+
+// 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) {
   const Type = pascal(table.name);
-  const ext = useJsExtensions ? ".js" : "";
+  const ext = opts.useJsExtensions ? ".js" : "";
   const pkCols = Array.isArray(table.pk) ? table.pk : table.pk ? [table.pk] : [];
   const safePk = pkCols.length ? pkCols : ["id"];
   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 includeMethods = generateIncludeMethods(table, graph, {
+    maxDepth: opts.includeMethodsDepth ?? 2,
+    skipJunctionTables: opts.skipJunctionTables ?? true
+  });
+  const importedTypes = new Set;
+  importedTypes.add(table.name);
+  for (const method of includeMethods) {
+    for (const target of method.targets) {
+      importedTypes.add(target);
+    }
+  }
+  const typeImports = `import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}${ext}";`;
+  const otherTableImports = [];
+  for (const target of importedTypes) {
+    if (target !== table.name) {
+      otherTableImports.push(`import type { Select${pascal(target)} } from "./types/${target}${ext}";`);
+    }
+  }
+  let includeMethodsCode = "";
+  for (const method of includeMethods) {
+    const isGetByPk = method.name.startsWith("getByPk");
+    const baseParams = isGetByPk ? "" : `params?: Omit<{ limit?: number; offset?: number; where?: any; orderBy?: string; order?: "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", "");
+      includeMethodsCode += `
+  async ${method.name}(pk: ${pkType}): Promise<${method.returnType}> {
+    const results = await this.post<${baseReturnType}[]>(\`\${this.resource}/list\`, { 
+      where: ${pkWhere},
+      include: ${JSON.stringify(method.includeSpec)},
+      limit: 1 
+    });
+    return (results[0] as ${baseReturnType}) ?? null;
+  }
+`;
+    } else {
+      includeMethodsCode += `
+  async ${method.name}(${baseParams}): Promise<${method.returnType}> {
+    return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...params, include: ${JSON.stringify(method.includeSpec)} });
+  }
+`;
+    }
+  }
   return `/* Generated. Do not edit. */
 import { BaseClient } from "./base-client${ext}";
-import type { ${Type}IncludeSpec } from "./include-spec${ext}";
-import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}${ext}";
+${typeImports}
+${otherTableImports.join(`
+`)}
 
 /**
  * Client for ${table.name} table operations
@@ -1680,7 +1873,6 @@ export class ${Type}Client extends BaseClient {
   }
 
   async list(params?: { 
-    include?: ${Type}IncludeSpec; 
     limit?: number; 
     offset?: number;
     where?: any;
@@ -1699,7 +1891,7 @@ export class ${Type}Client extends BaseClient {
     const path = ${pkPathExpr};
     return this.del<Select${Type} | null>(\`\${this.resource}/\${path}\`);
   }
-}
+${includeMethodsCode}}
 `;
 }
 function emitClientIndex(tables, useJsExtensions) {
@@ -1743,8 +1935,6 @@ export type { AuthConfig, HeaderMap, AuthHeadersProvider } from "./base-client${
 
 `;
   out += `export { BaseClient } from "./base-client${ext}";
-`;
-  out += `export * from "./include-spec${ext}";
 `;
   out += `
 // Zod schemas for form validation
@@ -2821,12 +3011,12 @@ function emitTableTest(table, model, clientPath, framework = "vitest") {
   const Type = pascal(table.name);
   const tableName = table.name;
   const imports = getFrameworkImports(framework);
-  const isJunctionTable = table.pk.length > 1;
+  const isJunctionTable2 = table.pk.length > 1;
   const hasForeignKeys = table.fks.length > 0;
   const foreignKeySetup = hasForeignKeys ? generateForeignKeySetup(table, model, clientPath) : null;
   const sampleData = generateSampleDataFromSchema(table, hasForeignKeys);
   const updateData = generateUpdateDataFromSchema(table);
-  if (isJunctionTable) {
+  if (isJunctionTable2) {
     return `${imports}
 import { SDK } from '${clientPath}';
 import type { Insert${Type}, Update${Type}, Select${Type} } from '${clientPath}/types/${tableName}';
@@ -3673,7 +3863,11 @@ async function generate(configPath) {
     });
     files.push({
       path: join(clientDir, `${table.name}.ts`),
-      content: emitClient(table, cfg.useJsExtensionsClient)
+      content: emitClient(table, graph, {
+        useJsExtensions: cfg.useJsExtensionsClient,
+        includeMethodsDepth: cfg.includeMethodsDepth ?? 2,
+        skipJunctionTables: cfg.skipJunctionTables ?? true
+      })
     });
   }
   files.push({

package/dist/types.d.ts

@@ -25,6 +25,8 @@ export interface Config {
     outClient?: string;
     softDeleteColumn?: string | null;
     includeDepthLimit?: number;
+    includeMethodsDepth?: number;
+    skipJunctionTables?: boolean;
     serverFramework?: "hono" | "express" | "fastify";
     auth?: AuthConfigInput;
     pull?: PullConfig;

package/package.json

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