postgresdk 0.18.13 → 0.18.14

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 }
             });
           }
@@ -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(", ");
@@ -3680,7 +3701,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,
@@ -3729,7 +3750,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 +3772,7 @@ ${includeResolverImport}
 ${otherTableImports.join(`
 `)}
 
+${typeAliasesCode}
 /**
  * Client for ${table.name} table operations
  */
@@ -4206,7 +4228,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 +4318,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;
 }
 
@@ -7277,7 +7317,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 }
             });
           }
@@ -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(", ");
@@ -2719,7 +2740,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,
@@ -2768,7 +2789,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 +2811,7 @@ ${includeResolverImport}
 ${otherTableImports.join(`
 `)}
 
+${typeAliasesCode}
 /**
  * Client for ${table.name} table operations
  */
@@ -3245,7 +3267,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 +3357,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;
 }
 
@@ -6316,7 +6356,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.14",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {