postgresdk 0.14.2 → 0.14.4

package/README.md

@@ -4,7 +4,7 @@
 
 Generate a typed server/client SDK from your PostgreSQL database schema.
 
-## See It In Action
+## What It Does
 
 **Your database:**
 ```sql
@@ -58,7 +58,11 @@ const filtered = await sdk.users.list({
 - 🎯 **Zero Config** - Works out of the box with sensible defaults
 - 📦 **Lightweight** - Minimal dependencies, optimized bundle size
 
-## Installation
+---
+
+## Getting Started
+
+### Installation
 
 ```bash
 npm install -g postgresdk
@@ -73,7 +77,7 @@ bunx postgresdk generate
 
 > **Note:** Currently only generates **Hono** server code. See [Supported Frameworks](#supported-frameworks) for details.
 
-## Quick Start
+### Quick Start
 
 1. Initialize your project:
 
@@ -107,7 +111,7 @@ bunx postgresdk generate
 ```typescript
 import { Hono } from "hono";
 import { Client } from "pg";
-import { createRouter } from "./api/server/router";
+import { createRouter } from "./api/server/router"; // Path depends on your outDir config
 
 const app = new Hono();
 const pg = new Client({ connectionString: "..." });
@@ -120,7 +124,7 @@ app.route("/", api);
 5. Use the client SDK:
 
 ```typescript
-import { SDK } from "./api/client";
+import { SDK } from "./api/client"; // Path depends on your outDir config
 
 const sdk = new SDK({ baseUrl: "http://localhost:3000" });
 
@@ -131,7 +135,13 @@ await sdk.users.update(user.id, { name: "Alice Smith" });
 await sdk.users.delete(user.id);
 ```
 
-## Configuration
+---
+
+## API Server Setup
+
+> **Note:** Code examples in this section use default output paths (`./api/server/`, `./api/client/`). If you configure a custom `outDir`, adjust import paths accordingly.
+
+### Configuration
 
 Create a `postgresdk.config.ts` file in your project root:
 
@@ -148,7 +158,7 @@ export default {
   dateType: "date",                    // "date" | "string" - How to handle timestamps
   serverFramework: "hono",             // Currently only hono is supported
   useJsExtensions: false,              // Add .js to imports (for Vercel Edge, Deno)
-  
+
   // Authentication (optional)
   auth: {
     apiKey: process.env.API_KEY,        // Simple API key auth
@@ -159,7 +169,7 @@ export default {
       ]
     }
   },
-  
+
   // Test generation (optional)
   tests: {
     generate: true,                      // Generate test files
@@ -169,155 +179,96 @@ export default {
 };
 ```
 
-## Generated SDK Usage
+### Database Drivers
 
-### CRUD Operations
+The generated code works with any PostgreSQL client that implements a simple `query` interface:
 
-Every table gets a complete set of CRUD operations:
+#### Node.js `pg` Driver
 
 ```typescript
-// Create
-const user = await sdk.users.create({ name: "Bob", email: "bob@example.com" });
-
-// Read
-const user = await sdk.users.getByPk(123);
-const result = await sdk.users.list();
-const users = result.data;  // Array of users
+import { Client } from "pg";
+import { createRouter } from "./api/server/router";
 
-// Update  
-const updated = await sdk.users.update(123, { name: "Robert" });
+const pg = new Client({ connectionString: process.env.DATABASE_URL });
+await pg.connect();
 
-// Delete
-const deleted = await sdk.users.delete(123);
+const apiRouter = createRouter({ pg });
 ```
 
-### Relationships & Eager Loading
-
-Automatically handles relationships with the `include` parameter:
+#### Neon Serverless Driver (Edge-Compatible)
 
 ```typescript
-// 1:N relationship - Get authors with their books
-const authorsResult = await sdk.authors.list({
-  include: { books: true }
-});
-const authors = authorsResult.data;
-
-// M:N relationship - Get books with their tags
-const booksResult = await sdk.books.list({
-  include: { tags: true }
-});
-const books = booksResult.data;
+import { Pool } from "@neondatabase/serverless";
+import { createRouter } from "./api/server/router";
 
-// Nested includes - Get authors with books and their tags
-const nestedResult = await sdk.authors.list({
-  include: {
-    books: {
-      include: {
-        tags: true
-      }
-    }
-  }
-});
-const authorsWithBooksAndTags = nestedResult.data;
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const apiRouter = createRouter({ pg: pool });
 ```
 
-### Filtering & Pagination
+### Server Integration
 
-All `list()` methods return pagination metadata:
+postgresdk generates Hono-compatible routes:
 
 ```typescript
-const result = await sdk.users.list({
-  where: { status: "active" },
-  orderBy: "created_at",
-  order: "desc",
-  limit: 20,
-  offset: 40
-});
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { Client } from "pg";
+import { createRouter } from "./api/server/router";
 
-// Access results
-result.data;       // User[] - array of records
-result.total;      // number - total matching records
-result.limit;      // number - page size used
-result.offset;     // number - offset used
-result.hasMore;    // boolean - more pages available
+const app = new Hono();
 
-// Calculate pagination info
-const totalPages = Math.ceil(result.total / result.limit);
-const currentPage = Math.floor(result.offset / result.limit) + 1;
+// Database connection
+const pg = new Client({ connectionString: process.env.DATABASE_URL });
+await pg.connect();
 
-// Multi-column sorting
-const sorted = await sdk.users.list({
-  orderBy: ["status", "created_at"],
-  order: ["asc", "desc"]  // or use single direction: order: "asc"
-});
+// Mount all generated routes
+const apiRouter = createRouter({ pg });
+app.route("/", apiRouter);
 
-// Advanced WHERE operators
-const filtered = await sdk.users.list({
-  where: {
-    age: { $gte: 18, $lt: 65 },           // Range queries
-    email: { $ilike: '%@company.com' },   // Pattern matching
-    status: { $in: ['active', 'pending'] }, // Array matching
-    deleted_at: { $is: null }              // NULL checks
-  }
-});
-// filtered.total respects WHERE clause for accurate counts
+// Start server
+serve({ fetch: app.fetch, port: 3000 });
+```
 
-// OR logic - match any condition
-const results = await sdk.users.list({
-  where: {
-    $or: [
-      { email: { $ilike: '%@gmail.com' } },
-      { email: { $ilike: '%@yahoo.com' } },
-      { status: 'premium' }
-    ]
-  }
-});
+#### Request-Level Middleware (onRequest Hook)
 
-// Complex queries with AND/OR
-const complex = await sdk.users.list({
-  where: {
-    status: 'active',  // Implicit AND at root level
-    $or: [
-      { age: { $lt: 18 } },
-      { age: { $gt: 65 } }
-    ]
-  }
-});
+The `onRequest` hook executes before every endpoint operation, enabling:
+- Setting PostgreSQL session variables for audit logging
+- Configuring Row-Level Security (RLS) based on authenticated user
+- Request-level logging or monitoring
 
-// Nested logic (2 levels)
-const nested = await sdk.users.list({
-  where: {
-    $and: [
-      {
-        $or: [
-          { firstName: { $ilike: '%john%' } },
-          { lastName: { $ilike: '%john%' } }
-        ]
-      },
-      { status: 'active' }
-    ]
+```typescript
+import { createRouter } from "./api/server/router";
+
+const apiRouter = createRouter({
+  pg,
+  onRequest: async (c, pg) => {
+    // Access Hono context - fully type-safe
+    const auth = c.get('auth');
+
+    // Set PostgreSQL session variable for audit triggers
+    if (auth?.kind === 'jwt' && auth.claims?.sub) {
+      await pg.query(`SET LOCAL app.user_id = '${auth.claims.sub}'`);
+    }
+
+    // Or configure RLS policies
+    if (auth?.tenant_id) {
+      await pg.query(`SET LOCAL app.tenant_id = '${auth.tenant_id}'`);
+    }
   }
 });
-
-// Pagination with filtered results
-let allResults = [];
-let offset = 0;
-const limit = 50;
-do {
-  const page = await sdk.users.list({ where: { status: 'active' }, limit, offset });
-  allResults = allResults.concat(page.data);
-  offset += limit;
-  if (!page.hasMore) break;
-} while (true);
 ```
 
-See the generated SDK documentation for all available operators: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$like`, `$ilike`, `$is`, `$isNot`, `$or`, `$and`.
+The hook receives:
+- `c` - Hono Context object with full type safety and IDE autocomplete
+- `pg` - PostgreSQL client for setting session variables
+
+**Note:** The router works with or without the `onRequest` hook - fully backward compatible.
 
-## Authentication
+### Authentication
 
 postgresdk supports API key and JWT authentication:
 
-### API Key Authentication
+#### API Key Authentication
 
 ```typescript
 // postgresdk.config.ts
@@ -335,7 +286,7 @@ const sdk = new SDK({
 });
 ```
 
-### JWT Authentication (HS256)
+#### JWT Authentication (HS256)
 
 ```typescript
 // postgresdk.config.ts
@@ -374,94 +325,127 @@ const sdk = new SDK({
 });
 ```
 
-## Database Drivers
+#### Service-to-Service Authorization
 
-The generated code works with any PostgreSQL client that implements a simple `query` interface:
+For service-to-service authorization (controlling which services can access which tables/actions), use JWT claims with the `onRequest` hook instead of built-in config scopes:
 
-### Node.js `pg` Driver
+**Why this approach?**
+- **Standard**: Follows OAuth2/OIDC conventions (authorization in token claims, not API config)
+- **Dynamic**: Different tokens can have different permissions (service accounts vs user sessions)
+- **Flexible**: Supports table-level, row-level, and field-level authorization in one place
 
 ```typescript
-import { Client } from "pg";
-import { createRouter } from "./api/server/router";
+// 1. Your auth service issues JWTs with scopes in claims
+import { sign } from "jsonwebtoken";
 
-const pg = new Client({ connectionString: process.env.DATABASE_URL });
-await pg.connect();
-
-const apiRouter = createRouter({ pg });
-```
+const token = sign({
+  iss: "analytics-service",
+  sub: "service-123",
+  aud: "my-api",
+  scopes: ["users:read", "posts:read", "analytics:*"]  // ← Authorization here
+}, process.env.ANALYTICS_SECRET);
 
-### Neon Serverless Driver (Edge-Compatible)
+// 2. API config remains simple (authentication only)
+export default {
+  connectionString: process.env.DATABASE_URL,
+  auth: {
+    strategy: "jwt-hs256",
+    jwt: {
+      services: [
+        { issuer: "web-app", secret: process.env.WEB_SECRET },
+        { issuer: "analytics-service", secret: process.env.ANALYTICS_SECRET }
+      ],
+      audience: "my-api"
+    }
+  }
+};
 
-```typescript
-import { Pool } from "@neondatabase/serverless";
+// 3. Enforce scopes in onRequest hook
 import { createRouter } from "./api/server/router";
 
-const pool = new Pool({ connectionString: process.env.DATABASE_URL });
-const apiRouter = createRouter({ pg: pool });
-```
+function hasPermission(scopes: string[], table: string, method: string): boolean {
+  const action = { POST: "create", GET: "read", PUT: "update", DELETE: "delete" }[method];
 
-### Request-Level Middleware (onRequest Hook)
+  return scopes.some(scope => {
+    const [scopeTable, scopeAction] = scope.split(":");
+    return (scopeTable === "*" || scopeTable === table) &&
+           (scopeAction === "*" || scopeAction === action);
+  });
+}
 
-The `onRequest` hook executes before every endpoint operation, enabling:
-- Setting PostgreSQL session variables for audit logging
-- Configuring Row-Level Security (RLS) based on authenticated user
-- Request-level logging or monitoring
-
-```typescript
-import { createRouter } from "./api/server/router";
+function getTableFromPath(path: string): string {
+  // Extract table from path like "/v1/users" or "/v1/posts/123"
+  return path.split("/")[2];
+}
 
 const apiRouter = createRouter({
   pg,
   onRequest: async (c, pg) => {
-    // Access Hono context - fully type-safe
-    const auth = c.get('auth');
+    const auth = c.get("auth");
 
-    // Set PostgreSQL session variable for audit triggers
-    if (auth?.kind === 'jwt' && auth.claims?.sub) {
-      await pg.query(`SET LOCAL app.user_id = '${auth.claims.sub}'`);
+    // Extract scopes from JWT claims
+    const scopes = auth?.claims?.scopes || [];
+    const table = getTableFromPath(c.req.path);
+    const method = c.req.method;
+
+    // Enforce permission
+    if (!hasPermission(scopes, table, method)) {
+      throw new Error(`Forbidden: ${auth?.claims?.iss} lacks ${table}:${method}`);
     }
 
-    // Or configure RLS policies
-    if (auth?.tenant_id) {
-      await pg.query(`SET LOCAL app.tenant_id = '${auth.tenant_id}'`);
+    // Optional: Set session variables for audit logging
+    if (auth?.claims?.sub) {
+      await pg.query(`SET LOCAL app.service_id = $1`, [auth.claims.sub]);
     }
   }
 });
 ```
 
-The hook receives:
-- `c` - Hono Context object with full type safety and IDE autocomplete
-- `pg` - PostgreSQL client for setting session variables
-
-**Note:** The router works with or without the `onRequest` hook - fully backward compatible.
-
-## Server Integration
-
-postgresdk generates Hono-compatible routes:
+**Advanced patterns:**
 
 ```typescript
-import { Hono } from "hono";
-import { serve } from "@hono/node-server";
-import { Client } from "pg";
-import { createRouter } from "./api/server/router";
-
-const app = new Hono();
-
-// Database connection
-const pg = new Client({ connectionString: process.env.DATABASE_URL });
-await pg.connect();
-
-// Mount all generated routes
-const apiRouter = createRouter({ pg });
-app.route("/", apiRouter);
+// Row-level security (RLS)
+onRequest: async (c, pg) => {
+  const auth = c.get("auth");
+  const userId = auth?.claims?.sub;
+
+  // Enable RLS for this session
+  await pg.query(`SET LOCAL app.user_id = $1`, [userId]);
+  // Now your RLS policies automatically filter rows
+}
+
+// Field-level restrictions
+onRequest: async (c, pg) => {
+  const auth = c.get("auth");
+  const scopes = auth?.claims?.scopes || [];
+
+  // Store scopes in session for use in SELECT queries
+  await pg.query(`SET LOCAL app.scopes = $1`, [JSON.stringify(scopes)]);
+
+  // Your stored procedures/views can read app.scopes to hide sensitive fields
+}
+
+// Complex business logic
+onRequest: async (c, pg) => {
+  const auth = c.get("auth");
+  const table = getTableFromPath(c.req.path);
+
+  // Custom rules per service
+  if (auth?.claims?.iss === "analytics-service" && c.req.method !== "GET") {
+    throw new Error("Analytics service is read-only");
+  }
 
-// Start server
-serve({ fetch: app.fetch, port: 3000 });
+  // Time-based restrictions
+  const hour = new Date().getHours();
+  if (auth?.claims?.iss === "batch-processor" && hour >= 8 && hour <= 17) {
+    throw new Error("Batch jobs only run outside business hours");
+  }
+}
 ```
 
-## Deployment
+### Deployment
 
-### Serverless (Vercel, Netlify, Cloudflare Workers)
+#### Serverless (Vercel, Netlify, Cloudflare Workers)
 
 Use `max: 1` - each serverless instance should hold one connection:
 
@@ -478,7 +462,7 @@ const apiRouter = createRouter({ pg: pool });
 
 **Why `max: 1`?** Serverless functions are ephemeral and isolated. Each instance handles one request at a time, so connection pooling provides no benefit and wastes database connections.
 
-### Traditional Servers (Railway, Render, VPS)
+#### Traditional Servers (Railway, Render, VPS)
 
 Use connection pooling to reuse connections across requests:
 
@@ -495,16 +479,51 @@ const apiRouter = createRouter({ pg: pool });
 
 **Why `max: 10`?** Long-running servers handle many concurrent requests. Pooling prevents opening/closing connections for every request, significantly improving performance.
 
-## SDK Distribution
+---
+
+## Client SDK
+
+### SDK Distribution
+
+When you run `postgresdk generate`, the client SDK is automatically bundled into your server code and exposed via HTTP endpoints. This allows client applications to pull the SDK directly from your running API.
+
+#### How It Works
 
-Your generated SDK can be pulled by client applications:
+**On the API server:**
+- SDK files are bundled into your server output directory as `sdk-bundle.ts` (embedded as strings)
+- Auto-generated endpoints serve the SDK:
+  - `GET /_psdk/sdk/manifest` - Lists available files and metadata
+  - `GET /_psdk/sdk/download` - Returns complete SDK bundle
+  - `GET /_psdk/sdk/files/:path` - Individual file access
+
+**On client applications:**
+
+1. Install postgresdk in your client project:
+
+```bash
+npm install -D postgresdk
+# or
+bun install -D postgresdk
+```
+
+2. Pull the SDK from your API:
 
 ```bash
-# In your client app
-postgresdk pull --from=https://api.myapp.com --output=./src/sdk
+npx postgresdk pull --from=https://api.myapp.com --output=./src/sdk
+# or with Bun
+bunx postgresdk pull --from=https://api.myapp.com --output=./src/sdk
 ```
 
-Or with configuration:
+3. Use the generated SDK with full TypeScript types:
+
+```typescript
+import { SDK } from "./src/sdk";
+
+const sdk = new SDK({ baseUrl: "https://api.myapp.com" });
+const users = await sdk.users.list();
+```
+
+**Using a config file (recommended):**
 
 ```typescript
 // postgresdk.config.ts in client app
@@ -512,37 +531,169 @@ export default {
   pull: {
     from: "https://api.myapp.com",
     output: "./src/sdk",
-    token: process.env.API_TOKEN  // Optional auth
+    token: process.env.API_TOKEN  // Optional auth for protected APIs
   }
 };
 ```
 
-## Generated Tests
+Then run:
+```bash
+npx postgresdk pull
+# or
+bunx postgresdk pull
+```
 
-Enable test generation in your config:
+The SDK files are written directly to your client project, giving you full TypeScript autocomplete and type safety.
+
+### Using the SDK
+
+#### CRUD Operations
+
+Every table gets a complete set of CRUD operations:
 
 ```typescript
-export default {
-  connectionString: process.env.DATABASE_URL,
-  tests: {
-    generate: true,
-    output: "./api/tests",
-    framework: "vitest"
+// Create
+const user = await sdk.users.create({ name: "Bob", email: "bob@example.com" });
+
+// Read
+const user = await sdk.users.getByPk(123);
+const result = await sdk.users.list();
+const users = result.data;  // Array of users
+
+// Update
+const updated = await sdk.users.update(123, { name: "Robert" });
+
+// Delete
+const deleted = await sdk.users.delete(123);
+```
+
+#### Relationships & Eager Loading
+
+Automatically handles relationships with the `include` parameter:
+
+```typescript
+// 1:N relationship - Get authors with their books
+const authorsResult = await sdk.authors.list({
+  include: { books: true }
+});
+const authors = authorsResult.data;
+
+// M:N relationship - Get books with their tags
+const booksResult = await sdk.books.list({
+  include: { tags: true }
+});
+const books = booksResult.data;
+
+// Nested includes - Get authors with books and their tags
+const nestedResult = await sdk.authors.list({
+  include: {
+    books: {
+      include: {
+        tags: true
+      }
+    }
   }
-};
+});
+const authorsWithBooksAndTags = nestedResult.data;
 ```
 
-Run tests with the included Docker setup:
+#### Filtering & Pagination
 
-```bash
-chmod +x api/tests/run-tests.sh
-./api/tests/run-tests.sh
+All `list()` methods return pagination metadata:
 
-# Or with Bun's built-in test runner (if framework: "bun")
-bun test
+```typescript
+const result = await sdk.users.list({
+  where: { status: "active" },
+  orderBy: "created_at",
+  order: "desc",
+  limit: 20,
+  offset: 40
+});
+
+// Access results
+result.data;       // User[] - array of records
+result.total;      // number - total matching records
+result.limit;      // number - page size used
+result.offset;     // number - offset used
+result.hasMore;    // boolean - more pages available
+
+// Calculate pagination info
+const totalPages = Math.ceil(result.total / result.limit);
+const currentPage = Math.floor(result.offset / result.limit) + 1;
+
+// Multi-column sorting
+const sorted = await sdk.users.list({
+  orderBy: ["status", "created_at"],
+  order: ["asc", "desc"]  // or use single direction: order: "asc"
+});
+
+// Advanced WHERE operators
+const filtered = await sdk.users.list({
+  where: {
+    age: { $gte: 18, $lt: 65 },           // Range queries
+    email: { $ilike: '%@company.com' },   // Pattern matching
+    status: { $in: ['active', 'pending'] }, // Array matching
+    deleted_at: { $is: null }              // NULL checks
+  }
+});
+// filtered.total respects WHERE clause for accurate counts
+
+// OR logic - match any condition
+const results = await sdk.users.list({
+  where: {
+    $or: [
+      { email: { $ilike: '%@gmail.com' } },
+      { email: { $ilike: '%@yahoo.com' } },
+      { status: 'premium' }
+    ]
+  }
+});
+
+// Complex queries with AND/OR
+const complex = await sdk.users.list({
+  where: {
+    status: 'active',  // Implicit AND at root level
+    $or: [
+      { age: { $lt: 18 } },
+      { age: { $gt: 65 } }
+    ]
+  }
+});
+
+// Nested logic (2 levels)
+const nested = await sdk.users.list({
+  where: {
+    $and: [
+      {
+        $or: [
+          { firstName: { $ilike: '%john%' } },
+          { lastName: { $ilike: '%john%' } }
+        ]
+      },
+      { status: 'active' }
+    ]
+  }
+});
+
+// Pagination with filtered results
+let allResults = [];
+let offset = 0;
+const limit = 50;
+do {
+  const page = await sdk.users.list({ where: { status: 'active' }, limit, offset });
+  allResults = allResults.concat(page.data);
+  offset += limit;
+  if (!page.hasMore) break;
+} while (true);
 ```
 
-## CLI Commands
+See the generated SDK documentation for all available operators: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$like`, `$ilike`, `$is`, `$isNot`, `$or`, `$and`.
+
+---
+
+## Reference
+
+### CLI Commands
 
 ```bash
 postgresdk <command> [options]
@@ -570,19 +721,44 @@ Examples:
   postgresdk pull --from=https://api.com --output=./src/sdk
 ```
 
-## Requirements
+### Generated Tests
+
+Enable test generation in your config:
+
+```typescript
+export default {
+  connectionString: process.env.DATABASE_URL,
+  tests: {
+    generate: true,
+    output: "./api/tests",
+    framework: "vitest"
+  }
+};
+```
+
+Run tests with the included Docker setup:
+
+```bash
+chmod +x api/tests/run-tests.sh
+./api/tests/run-tests.sh
+
+# Or with Bun's built-in test runner (if framework: "bun")
+bun test
+```
+
+### Requirements
 
 - Node.js 18+
 - PostgreSQL 12+
 - TypeScript project (for using generated code)
 
-## Supported Frameworks
+### Supported Frameworks
 
 **Currently, postgresdk only generates server code for Hono.**
 
 While the configuration accepts `serverFramework: "hono" | "express" | "fastify"`, only Hono is implemented at this time. Attempting to generate code with `express` or `fastify` will result in an error.
 
-### Why Hono?
+#### Why Hono?
 
 Hono was chosen as the initial framework because:
 - **Edge-first design** - Works seamlessly in serverless and edge environments (Cloudflare Workers, Vercel Edge, Deno Deploy)
@@ -590,7 +766,7 @@ Hono was chosen as the initial framework because:
 - **Modern patterns** - Web Standard APIs (Request/Response), TypeScript-first
 - **Framework compatibility** - Works across Node.js, Bun, Deno, and edge runtimes
 
-### Future Framework Support
+#### Future Framework Support
 
 The codebase architecture is designed to support multiple frameworks. Adding Express or Fastify support would require:
 - Implementing framework-specific route emitters (`emit-routes-express.ts`, etc.)
@@ -600,4 +776,4 @@ Contributions to add additional framework support are welcome.
 
 ## License
 
-MIT
+MIT

package/dist/cli.js

@@ -635,7 +635,15 @@ function generateIncludeMethods(table, graph, opts, allTables) {
     }
   }
   explore(baseTableName, [], [], [], new Set([baseTableName]), 1);
-  return methods;
+  const seen = new Set;
+  const dedupedMethods = [];
+  for (const method of methods) {
+    if (!seen.has(method.name)) {
+      seen.add(method.name);
+      dedupedMethods.push(method);
+    }
+  }
+  return dedupedMethods;
 }
 var init_emit_include_methods = __esm(() => {
   init_utils();
@@ -1978,7 +1986,7 @@ var exports_cli_init = {};
 __export(exports_cli_init, {
   initCommand: () => initCommand
 });
-import { existsSync, writeFileSync, readFileSync, copyFileSync } from "fs";
+import { existsSync as existsSync2, writeFileSync, readFileSync, copyFileSync } from "fs";
 import { resolve } from "path";
 import prompts from "prompts";
 async function initCommand(args) {
@@ -1988,7 +1996,7 @@ async function initCommand(args) {
   const isApiSide = args.includes("--api");
   const isSdkSide = args.includes("--sdk");
   const configPath = resolve(process.cwd(), "postgresdk.config.ts");
-  if (existsSync(configPath)) {
+  if (existsSync2(configPath)) {
     if (forceError) {
       console.error("❌ Error: postgresdk.config.ts already exists");
       console.log("   To reinitialize, please remove or rename the existing file first.");
@@ -2142,7 +2150,7 @@ async function initCommand(args) {
   }
   const template = projectType === "api" ? CONFIG_TEMPLATE_API : CONFIG_TEMPLATE_SDK;
   const envPath = resolve(process.cwd(), ".env");
-  const hasEnv = existsSync(envPath);
+  const hasEnv = existsSync2(envPath);
   try {
     writeFileSync(configPath, template, "utf-8");
     console.log("✅ Created postgresdk.config.ts");
@@ -2350,7 +2358,7 @@ __export(exports_cli_pull, {
 });
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join2, dirname as dirname2, resolve as resolve2 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function pullCommand(args) {
   let configPath = "postgresdk.config.ts";
@@ -2360,7 +2368,7 @@ async function pullCommand(args) {
   }
   let fileConfig = {};
   const fullConfigPath = resolve2(process.cwd(), configPath);
-  if (existsSync2(fullConfigPath)) {
+  if (existsSync3(fullConfigPath)) {
     console.log(`\uD83D\uDCCB Loading ${configPath}`);
     try {
       const configUrl = pathToFileURL2(fullConfigPath).href;
@@ -2436,6 +2444,7 @@ var init_cli_pull = () => {};
 var import_config = __toESM(require_config(), 1);
 import { join, relative } from "node:path";
 import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
 
 // src/introspect.ts
 import { Client } from "pg";
@@ -3953,7 +3962,7 @@ const STRATEGY = ${STRATEGY} as "none" | "api-key" | "jwt-hs256";
 const API_KEY_HEADER = ${API_KEY_HEADER} as string;
 const RAW_API_KEYS = ${RAW_API_KEYS} as readonly string[];
 
-const JWT_SERVICES = ${JWT_SERVICES} as ReadonlyArray<{ issuer: string; secret: string }>;
+const JWT_SERVICES = ${JWT_SERVICES} as ReadonlyArray<{ issuer: string; secret?: string }>;
 const JWT_AUDIENCE = ${JWT_AUDIENCE} as string | undefined;
 // -------------------------------------
 
@@ -5509,6 +5518,12 @@ function normalizeAuthConfig(input) {
 
 // src/index.ts
 async function generate(configPath) {
+  if (!existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}
+
+` + `Run 'postgresdk init' to create a config file, or specify a custom path with:
+` + `  postgresdk generate --config <path>`);
+  }
   const configUrl = pathToFileURL(configPath).href;
   const module = await import(configUrl);
   const rawCfg = module.default || module;

package/dist/index.js

@@ -634,7 +634,15 @@ function generateIncludeMethods(table, graph, opts, allTables) {
     }
   }
   explore(baseTableName, [], [], [], new Set([baseTableName]), 1);
-  return methods;
+  const seen = new Set;
+  const dedupedMethods = [];
+  for (const method of methods) {
+    if (!seen.has(method.name)) {
+      seen.add(method.name);
+      dedupedMethods.push(method);
+    }
+  }
+  return dedupedMethods;
 }
 var init_emit_include_methods = __esm(() => {
   init_utils();
@@ -1610,6 +1618,7 @@ var init_emit_sdk_contract = __esm(() => {
 var import_config = __toESM(require_config(), 1);
 import { join, relative } from "node:path";
 import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
 
 // src/introspect.ts
 import { Client } from "pg";
@@ -3127,7 +3136,7 @@ const STRATEGY = ${STRATEGY} as "none" | "api-key" | "jwt-hs256";
 const API_KEY_HEADER = ${API_KEY_HEADER} as string;
 const RAW_API_KEYS = ${RAW_API_KEYS} as readonly string[];
 
-const JWT_SERVICES = ${JWT_SERVICES} as ReadonlyArray<{ issuer: string; secret: string }>;
+const JWT_SERVICES = ${JWT_SERVICES} as ReadonlyArray<{ issuer: string; secret?: string }>;
 const JWT_AUDIENCE = ${JWT_AUDIENCE} as string | undefined;
 // -------------------------------------
 
@@ -4683,6 +4692,12 @@ function normalizeAuthConfig(input) {
 
 // src/index.ts
 async function generate(configPath) {
+  if (!existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}
+
+` + `Run 'postgresdk init' to create a config file, or specify a custom path with:
+` + `  postgresdk generate --config <path>`);
+  }
   const configUrl = pathToFileURL(configPath).href;
   const module = await import(configUrl);
   const rawCfg = module.default || module;

package/package.json

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