postgresdk 0.18.13 → 0.18.15

package/dist/cli.js

@@ -605,12 +605,16 @@ function generateIncludeMethods(table, graph, opts, allTables) {
       const newIsMany = [...isMany, edge.kind === "many"];
       const newTargets = [...targets, edge.target];
       const methodSuffix = pathToMethodSuffix(newPath);
+      const baseType = buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph);
+      const typeName = `Select${pascal(baseTableName)}${methodSuffix}`;
       methods.push({
         name: `list${methodSuffix}`,
         path: newPath,
         isMany: newIsMany,
         targets: newTargets,
-        returnType: `PaginatedResponse<${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)}>`,
+        returnType: `PaginatedResponse<${baseType}>`,
+        typeName,
+        baseType,
         includeSpec: buildIncludeSpec(newPath)
       });
       methods.push({
@@ -618,7 +622,9 @@ function generateIncludeMethods(table, graph, opts, allTables) {
         path: newPath,
         isMany: newIsMany,
         targets: newTargets,
-        returnType: `${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)} | null`,
+        returnType: `${baseType} | null`,
+        typeName,
+        baseType,
         includeSpec: buildIncludeSpec(newPath)
       });
       explore(edge.target, newPath, newIsMany, newTargets, new Set([...visited, edge.target]), depth + 1);
@@ -645,12 +651,16 @@ function generateIncludeMethods(table, graph, opts, allTables) {
             const combinedSuffix = `With${pascal(key1)}And${pascal(key2)}`;
             const type1 = `${key1}: ${edge1.kind === "many" ? `Select${pascal(edge1.target)}[]` : `Select${pascal(edge1.target)}`}`;
             const type2 = `${key2}: ${edge2.kind === "many" ? `Select${pascal(edge2.target)}[]` : `Select${pascal(edge2.target)}`}`;
+            const combinedBaseType = `Select${pascal(baseTableName)} & { ${type1}; ${type2} }`;
+            const combinedTypeName = `Select${pascal(baseTableName)}${combinedSuffix}`;
             methods.push({
               name: `list${combinedSuffix}`,
               path: combinedPath,
               isMany: [edge1.kind === "many", edge2.kind === "many"],
               targets: [edge1.target, edge2.target],
-              returnType: `PaginatedResponse<Select${pascal(baseTableName)} & { ${type1}; ${type2} }>`,
+              returnType: `PaginatedResponse<${combinedBaseType}>`,
+              typeName: combinedTypeName,
+              baseType: combinedBaseType,
               includeSpec: { [key1]: true, [key2]: true }
             });
             methods.push({
@@ -658,7 +668,9 @@ function generateIncludeMethods(table, graph, opts, allTables) {
               path: combinedPath,
               isMany: [edge1.kind === "many", edge2.kind === "many"],
               targets: [edge1.target, edge2.target],
-              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} }) | null`,
+              returnType: `${combinedBaseType} | null`,
+              typeName: combinedTypeName,
+              baseType: combinedBaseType,
               includeSpec: { [key1]: true, [key2]: true }
             });
           }
@@ -2903,7 +2915,7 @@ function emitIncludeSpec(graph) {
         out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; include?: ${toPascal(edge.target)}IncludeSpec; limit?: number; offset?: number; orderBy?: string; order?: "asc" | "desc"; };
 `;
       } else {
-        out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; } | ${toPascal(edge.target)}IncludeSpec;
+        out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; include?: ${toPascal(edge.target)}IncludeSpec; };
 `;
       }
     }
@@ -3560,6 +3572,15 @@ function emitClient(table, graph, opts, model) {
       otherTableImports.push(`import type { Select${pascal(target)} } from "./types/${target}${ext}";`);
     }
   }
+  const seenTypeNames = new Set;
+  let typeAliasesCode = "";
+  for (const method of includeMethods) {
+    if (!seenTypeNames.has(method.typeName)) {
+      seenTypeNames.add(method.typeName);
+      typeAliasesCode += `export type ${method.typeName} = ${method.baseType};
+`;
+    }
+  }
   let includeMethodsCode = "";
   for (const method of includeMethods) {
     const isGetByPk = method.name.startsWith("getByPk");
@@ -3644,7 +3665,7 @@ function emitClient(table, graph, opts, model) {
     }
     if (isGetByPk) {
       const pkWhere = hasCompositePk ? `{ ${safePk.map((col) => `${col}: pk.${col}`).join(", ")} }` : `{ ${safePk[0] || "id"}: pk }`;
-      const baseReturnType = method.returnType.replace(" | null", "");
+      const baseReturnType = method.typeName;
       let transformCode = "";
       if (includeParamNames.length > 0) {
         const destructure = includeParamNames.map((name) => name).join(", ");
@@ -3665,9 +3686,13 @@ function emitClient(table, graph, opts, model) {
         } else if (pattern.type === "nested" && pattern.nestedKey) {
           const key = pattern.nestedKey;
           const paramName = includeParamNames[0];
+          const nestedValue = pattern.nestedValue;
+          const requiredIncludes = Object.entries(nestedValue).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
           transformCode = `
     const { ${destructure} } = params ?? {};
-    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};`;
+    const includeSpec = { ${key}: ${paramName}
+      ? { ...${paramName}, include: { ${requiredIncludes}, ...${paramName}.include } }
+      : ${JSON.stringify(nestedValue)} };`;
         }
       } else {
         transformCode = `
@@ -3680,7 +3705,7 @@ function emitClient(table, graph, opts, model) {
    * @param params - Optional include options (including select/exclude for base and nested tables)
    * @returns The record with nested ${method.path.join(" and ")} if found, null otherwise
    */
-  async ${method.name}(pk: ${pkType}, params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
+  async ${method.name}(pk: ${pkType}, params?: ${paramsType}): Promise<${method.typeName} | null> {${transformCode}
     const results = await this.post<PaginatedResponse<${baseReturnType}>>(\`\${this.resource}/list\`, {
       where: ${pkWhere},
       select: params?.select,
@@ -3714,9 +3739,13 @@ function emitClient(table, graph, opts, model) {
         } else if (pattern.type === "nested" && pattern.nestedKey) {
           const key = pattern.nestedKey;
           const paramName = includeParamNames[0];
+          const nestedValue = pattern.nestedValue;
+          const requiredIncludes = Object.entries(nestedValue).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
           transformCode = `
     const { ${destructure}, ...baseParams } = params ?? {};
-    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};
+    const includeSpec = { ${key}: ${paramName}
+      ? { ...${paramName}, include: { ${requiredIncludes}, ...${paramName}.include } }
+      : ${JSON.stringify(nestedValue)} };
     return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
         }
       } else {
@@ -3729,7 +3758,7 @@ function emitClient(table, graph, opts, model) {
    * @param params - Query parameters (where, orderBy, order, limit, offset) and include options
    * @returns Paginated results with nested ${method.path.join(" and ")} included
    */
-  async ${method.name}(params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
+  async ${method.name}(params?: ${paramsType}): Promise<PaginatedResponse<${method.typeName}>> {${transformCode}
   }
 `;
     }
@@ -3751,6 +3780,7 @@ ${includeResolverImport}
 ${otherTableImports.join(`
 `)}
 
+${typeAliasesCode}
 /**
  * Client for ${table.name} table operations
  */
@@ -4206,7 +4236,7 @@ ${hasJsonbColumns ? `  /**
 ${includeMethodsCode}}
 `;
 }
-function emitClientIndex(tables, useJsExtensions) {
+function emitClientIndex(tables, useJsExtensions, graph, includeOpts) {
   const ext = useJsExtensions ? ".js" : "";
   let out = `/**
  * AUTO-GENERATED FILE - DO NOT EDIT
@@ -4296,6 +4326,24 @@ export type { AuthConfig, HeaderMap, AuthHeadersProvider } from "./base-client${
 `;
   out += `export type { PaginatedResponse } from "./types/shared${ext}";
 `;
+  if (graph && includeOpts) {
+    const opts = { maxDepth: includeOpts.maxDepth, skipJunctionTables: includeOpts.skipJunctionTables };
+    for (const t of tables) {
+      const methods = generateIncludeMethods(t, graph, opts, tables);
+      const seenTypeNames = new Set;
+      const typeNames = [];
+      for (const method of methods) {
+        if (!seenTypeNames.has(method.typeName)) {
+          seenTypeNames.add(method.typeName);
+          typeNames.push(method.typeName);
+        }
+      }
+      if (typeNames.length > 0) {
+        out += `export type { ${typeNames.join(", ")} } from "./${t.name}${ext}";
+`;
+      }
+    }
+  }
   return out;
 }
 
@@ -4722,9 +4770,15 @@ export async function loadIncludes(
         // Could be belongs-to (current has FK to target) OR has-one (target unique-FK to current)
         const specValue = s[key];
         const options: RelationOptions = {};
+        let childSpec: any = undefined;
+
         if (specValue && typeof specValue === "object" && specValue !== true) {
           if (specValue.select !== undefined) options.select = specValue.select;
           if (specValue.exclude !== undefined) options.exclude = specValue.exclude;
+          // Support { include: TargetIncludeSpec } — mirrors the many/via handler
+          if (specValue.include !== undefined) {
+            childSpec = specValue.include;
+          }
         }
 
         const currFks = (FK_INDEX as any)[table] as Array<{from:string[];toTable:string;to:string[]}>;
@@ -4744,7 +4798,7 @@ export async function loadIncludes(
             for (const r of rows) r[key] = null;
           }
         }
-        const childSpec = s[key] && typeof s[key] === "object" ? s[key] : undefined;
+
         if (childSpec) {
           const children = rows.map(r => r[key]).filter(Boolean);
           try {
@@ -7277,7 +7331,7 @@ async function generate(configPath) {
   }
   files.push({
     path: join(clientDir, "index.ts"),
-    content: emitClientIndex(Object.values(model.tables), cfg.useJsExtensionsClient)
+    content: emitClientIndex(Object.values(model.tables), cfg.useJsExtensionsClient, graph, { maxDepth: cfg.includeMethodsDepth ?? 2, skipJunctionTables: cfg.skipJunctionTables ?? true })
   });
   if (serverFramework === "hono") {
     files.push({

package/dist/emit-client.d.ts

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

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

@@ -6,6 +6,8 @@ export type IncludeMethod = {
     isMany: boolean[];
     targets: string[];
     returnType: string;
+    typeName: string;
+    baseType: string;
     includeSpec: any;
 };
 /**

package/dist/index.js

@@ -604,12 +604,16 @@ function generateIncludeMethods(table, graph, opts, allTables) {
       const newIsMany = [...isMany, edge.kind === "many"];
       const newTargets = [...targets, edge.target];
       const methodSuffix = pathToMethodSuffix(newPath);
+      const baseType = buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph);
+      const typeName = `Select${pascal(baseTableName)}${methodSuffix}`;
       methods.push({
         name: `list${methodSuffix}`,
         path: newPath,
         isMany: newIsMany,
         targets: newTargets,
-        returnType: `PaginatedResponse<${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)}>`,
+        returnType: `PaginatedResponse<${baseType}>`,
+        typeName,
+        baseType,
         includeSpec: buildIncludeSpec(newPath)
       });
       methods.push({
@@ -617,7 +621,9 @@ function generateIncludeMethods(table, graph, opts, allTables) {
         path: newPath,
         isMany: newIsMany,
         targets: newTargets,
-        returnType: `${buildReturnType(baseTableName, newPath, newIsMany, newTargets, graph)} | null`,
+        returnType: `${baseType} | null`,
+        typeName,
+        baseType,
         includeSpec: buildIncludeSpec(newPath)
       });
       explore(edge.target, newPath, newIsMany, newTargets, new Set([...visited, edge.target]), depth + 1);
@@ -644,12 +650,16 @@ function generateIncludeMethods(table, graph, opts, allTables) {
             const combinedSuffix = `With${pascal(key1)}And${pascal(key2)}`;
             const type1 = `${key1}: ${edge1.kind === "many" ? `Select${pascal(edge1.target)}[]` : `Select${pascal(edge1.target)}`}`;
             const type2 = `${key2}: ${edge2.kind === "many" ? `Select${pascal(edge2.target)}[]` : `Select${pascal(edge2.target)}`}`;
+            const combinedBaseType = `Select${pascal(baseTableName)} & { ${type1}; ${type2} }`;
+            const combinedTypeName = `Select${pascal(baseTableName)}${combinedSuffix}`;
             methods.push({
               name: `list${combinedSuffix}`,
               path: combinedPath,
               isMany: [edge1.kind === "many", edge2.kind === "many"],
               targets: [edge1.target, edge2.target],
-              returnType: `PaginatedResponse<Select${pascal(baseTableName)} & { ${type1}; ${type2} }>`,
+              returnType: `PaginatedResponse<${combinedBaseType}>`,
+              typeName: combinedTypeName,
+              baseType: combinedBaseType,
               includeSpec: { [key1]: true, [key2]: true }
             });
             methods.push({
@@ -657,7 +667,9 @@ function generateIncludeMethods(table, graph, opts, allTables) {
               path: combinedPath,
               isMany: [edge1.kind === "many", edge2.kind === "many"],
               targets: [edge1.target, edge2.target],
-              returnType: `(Select${pascal(baseTableName)} & { ${type1}; ${type2} }) | null`,
+              returnType: `${combinedBaseType} | null`,
+              typeName: combinedTypeName,
+              baseType: combinedBaseType,
               includeSpec: { [key1]: true, [key2]: true }
             });
           }
@@ -1942,7 +1954,7 @@ function emitIncludeSpec(graph) {
         out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; include?: ${toPascal(edge.target)}IncludeSpec; limit?: number; offset?: number; orderBy?: string; order?: "asc" | "desc"; };
 `;
       } else {
-        out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; } | ${toPascal(edge.target)}IncludeSpec;
+        out += `  ${relKey}?: boolean | { select?: string[]; exclude?: string[]; include?: ${toPascal(edge.target)}IncludeSpec; };
 `;
       }
     }
@@ -2599,6 +2611,15 @@ function emitClient(table, graph, opts, model) {
       otherTableImports.push(`import type { Select${pascal(target)} } from "./types/${target}${ext}";`);
     }
   }
+  const seenTypeNames = new Set;
+  let typeAliasesCode = "";
+  for (const method of includeMethods) {
+    if (!seenTypeNames.has(method.typeName)) {
+      seenTypeNames.add(method.typeName);
+      typeAliasesCode += `export type ${method.typeName} = ${method.baseType};
+`;
+    }
+  }
   let includeMethodsCode = "";
   for (const method of includeMethods) {
     const isGetByPk = method.name.startsWith("getByPk");
@@ -2683,7 +2704,7 @@ function emitClient(table, graph, opts, model) {
     }
     if (isGetByPk) {
       const pkWhere = hasCompositePk ? `{ ${safePk.map((col) => `${col}: pk.${col}`).join(", ")} }` : `{ ${safePk[0] || "id"}: pk }`;
-      const baseReturnType = method.returnType.replace(" | null", "");
+      const baseReturnType = method.typeName;
       let transformCode = "";
       if (includeParamNames.length > 0) {
         const destructure = includeParamNames.map((name) => name).join(", ");
@@ -2704,9 +2725,13 @@ function emitClient(table, graph, opts, model) {
         } else if (pattern.type === "nested" && pattern.nestedKey) {
           const key = pattern.nestedKey;
           const paramName = includeParamNames[0];
+          const nestedValue = pattern.nestedValue;
+          const requiredIncludes = Object.entries(nestedValue).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
           transformCode = `
     const { ${destructure} } = params ?? {};
-    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};`;
+    const includeSpec = { ${key}: ${paramName}
+      ? { ...${paramName}, include: { ${requiredIncludes}, ...${paramName}.include } }
+      : ${JSON.stringify(nestedValue)} };`;
         }
       } else {
         transformCode = `
@@ -2719,7 +2744,7 @@ function emitClient(table, graph, opts, model) {
    * @param params - Optional include options (including select/exclude for base and nested tables)
    * @returns The record with nested ${method.path.join(" and ")} if found, null otherwise
    */
-  async ${method.name}(pk: ${pkType}, params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
+  async ${method.name}(pk: ${pkType}, params?: ${paramsType}): Promise<${method.typeName} | null> {${transformCode}
     const results = await this.post<PaginatedResponse<${baseReturnType}>>(\`\${this.resource}/list\`, {
       where: ${pkWhere},
       select: params?.select,
@@ -2753,9 +2778,13 @@ function emitClient(table, graph, opts, model) {
         } else if (pattern.type === "nested" && pattern.nestedKey) {
           const key = pattern.nestedKey;
           const paramName = includeParamNames[0];
+          const nestedValue = pattern.nestedValue;
+          const requiredIncludes = Object.entries(nestedValue).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
           transformCode = `
     const { ${destructure}, ...baseParams } = params ?? {};
-    const includeSpec = ${paramName} ? { ${key}: ${paramName} } : ${JSON.stringify(method.includeSpec)};
+    const includeSpec = { ${key}: ${paramName}
+      ? { ...${paramName}, include: { ${requiredIncludes}, ...${paramName}.include } }
+      : ${JSON.stringify(nestedValue)} };
     return this.post<${method.returnType}>(\`\${this.resource}/list\`, { ...baseParams, include: includeSpec });`;
         }
       } else {
@@ -2768,7 +2797,7 @@ function emitClient(table, graph, opts, model) {
    * @param params - Query parameters (where, orderBy, order, limit, offset) and include options
    * @returns Paginated results with nested ${method.path.join(" and ")} included
    */
-  async ${method.name}(params?: ${paramsType}): Promise<${method.returnType}> {${transformCode}
+  async ${method.name}(params?: ${paramsType}): Promise<PaginatedResponse<${method.typeName}>> {${transformCode}
   }
 `;
     }
@@ -2790,6 +2819,7 @@ ${includeResolverImport}
 ${otherTableImports.join(`
 `)}
 
+${typeAliasesCode}
 /**
  * Client for ${table.name} table operations
  */
@@ -3245,7 +3275,7 @@ ${hasJsonbColumns ? `  /**
 ${includeMethodsCode}}
 `;
 }
-function emitClientIndex(tables, useJsExtensions) {
+function emitClientIndex(tables, useJsExtensions, graph, includeOpts) {
   const ext = useJsExtensions ? ".js" : "";
   let out = `/**
  * AUTO-GENERATED FILE - DO NOT EDIT
@@ -3335,6 +3365,24 @@ export type { AuthConfig, HeaderMap, AuthHeadersProvider } from "./base-client${
 `;
   out += `export type { PaginatedResponse } from "./types/shared${ext}";
 `;
+  if (graph && includeOpts) {
+    const opts = { maxDepth: includeOpts.maxDepth, skipJunctionTables: includeOpts.skipJunctionTables };
+    for (const t of tables) {
+      const methods = generateIncludeMethods(t, graph, opts, tables);
+      const seenTypeNames = new Set;
+      const typeNames = [];
+      for (const method of methods) {
+        if (!seenTypeNames.has(method.typeName)) {
+          seenTypeNames.add(method.typeName);
+          typeNames.push(method.typeName);
+        }
+      }
+      if (typeNames.length > 0) {
+        out += `export type { ${typeNames.join(", ")} } from "./${t.name}${ext}";
+`;
+      }
+    }
+  }
   return out;
 }
 
@@ -3761,9 +3809,15 @@ export async function loadIncludes(
         // Could be belongs-to (current has FK to target) OR has-one (target unique-FK to current)
         const specValue = s[key];
         const options: RelationOptions = {};
+        let childSpec: any = undefined;
+
         if (specValue && typeof specValue === "object" && specValue !== true) {
           if (specValue.select !== undefined) options.select = specValue.select;
           if (specValue.exclude !== undefined) options.exclude = specValue.exclude;
+          // Support { include: TargetIncludeSpec } — mirrors the many/via handler
+          if (specValue.include !== undefined) {
+            childSpec = specValue.include;
+          }
         }
 
         const currFks = (FK_INDEX as any)[table] as Array<{from:string[];toTable:string;to:string[]}>;
@@ -3783,7 +3837,7 @@ export async function loadIncludes(
             for (const r of rows) r[key] = null;
           }
         }
-        const childSpec = s[key] && typeof s[key] === "object" ? s[key] : undefined;
+
         if (childSpec) {
           const children = rows.map(r => r[key]).filter(Boolean);
           try {
@@ -6316,7 +6370,7 @@ async function generate(configPath) {
   }
   files.push({
     path: join(clientDir, "index.ts"),
-    content: emitClientIndex(Object.values(model.tables), cfg.useJsExtensionsClient)
+    content: emitClientIndex(Object.values(model.tables), cfg.useJsExtensionsClient, graph, { maxDepth: cfg.includeMethodsDepth ?? 2, skipJunctionTables: cfg.skipJunctionTables ?? true })
   });
   if (serverFramework === "hono") {
     files.push({

package/package.json

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