postgresdk 0.3.0 → 0.4.0

package/README.md

@@ -493,6 +493,114 @@ const sdk = new SDK({
 });
 ```
 
+## Database Drivers
+
+The generated code works with any PostgreSQL client that implements a simple `query` interface. You can use the standard `pg` driver, Neon's serverless driver, or any other compatible client.
+
+### Node.js `pg` Driver
+
+The standard PostgreSQL driver for Node.js environments. Works everywhere Node.js runs.
+
+Server setup:
+```typescript
+import { Hono } from "hono";
+import { Client } from "pg";
+import { createRouter } from "./generated/server/router";
+
+const app = new Hono();
+
+// Standard pg client
+const pg = new Client({ connectionString: process.env.DATABASE_URL });
+await pg.connect();
+
+// Wire up the generated routes
+const apiRouter = createRouter({ pg });
+app.route("/", apiRouter);
+```
+
+### Neon Serverless Driver (Edge-Compatible)
+
+For edge environments like Vercel Edge Functions or Cloudflare Workers. Uses HTTP/WebSocket instead of TCP connections.
+
+Server setup:
+```typescript
+import { Hono } from "hono";
+import { Pool } from "@neondatabase/serverless";
+import { createRouter } from "./generated/server/router";
+
+const app = new Hono();
+
+// Neon's Pool is compatible with node-postgres
+const pool = new Pool({ connectionString: process.env.DATABASE_URL! });
+
+// Wire up the generated routes (Pool has the same query interface)
+const apiRouter = createRouter({ pg: pool });
+app.route("/", apiRouter);
+
+// Deploy to Vercel Edge
+export const config = { runtime: 'edge' };
+export default app;
+```
+
+### Which Driver Should I Use?
+
+- **Use `pg` (default) when:**
+  - Running on traditional Node.js servers
+  - Using Docker, VPS, or dedicated hosting
+  - Need connection pooling or advanced PostgreSQL features
+  - Running on AWS Lambda, Google Cloud Functions (with Node.js runtime)
+
+- **Use `neon` when:**
+  - Deploying to Vercel Edge Functions
+  - Deploying to Cloudflare Workers
+  - Need globally distributed edge computing
+  - Want to avoid TCP connection overhead
+  - Using Neon as your PostgreSQL provider
+
+### Connection Pooling with `pg`
+
+For production Node.js deployments, use connection pooling:
+
+```typescript
+import { Pool } from "pg";
+import { createRouter } from "./generated/server/router";
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  max: 20,
+  idleTimeoutMillis: 30000,
+  connectionTimeoutMillis: 2000,
+});
+
+// The generated routes work with both Client and Pool
+const apiRouter = createRouter({ pg: pool });
+```
+
+### Custom Database Adapters
+
+You can use any database client as long as it matches the expected interface:
+
+```typescript
+// Any client that implements this interface works
+interface DatabaseAdapter {
+  query(text: string, params?: any[]): Promise<{ rows: any[] }>;
+}
+
+// Both pg and @neondatabase/serverless Pool/Client implement this interface natively
+// For other ORMs, you may need to create an adapter:
+
+// Example with a hypothetical ORM that doesn't match the interface
+const customClient = new SomeORM();
+const pg = {
+  async query(text: string, params?: any[]) {
+    const result = await customClient.raw(text, params);
+    return { rows: result };
+  }
+};
+
+const apiRouter = createRouter({ pg });
+```
+
 ## Server Integration with Hono
 
 The generated code integrates seamlessly with [Hono](https://hono.dev/), a lightweight web framework for the Edge.

package/dist/cli.js

@@ -569,14 +569,6 @@ export default {
    */
   // dateType: "date",
   
-  /**
-   * Database driver to use for connection
-   * - "pg": Node.js pg driver (default, works anywhere Node.js runs)
-   * - "neon": Neon serverless driver (edge-compatible, works on Vercel Edge/Cloudflare Workers)
-   * @default "pg"
-   */
-  // driver: "pg",
-  
   // ========== AUTHENTICATION ==========
   
   /**
@@ -1257,7 +1249,7 @@ export class ${Type}Client extends BaseClient {
 function emitClientIndex(tables) {
   let out = `/* Generated. Do not edit. */
 `;
-  out += `import { BaseClient, AuthConfig } from "./base-client";
+  out += `import { BaseClient, type AuthConfig } from "./base-client";
 `;
   for (const t of tables) {
     out += `import { ${pascal(t.name)}Client } from "./${t.name}";
@@ -1983,7 +1975,7 @@ export async function authMiddleware(c: Context, next: Next) {
 }
 
 // src/emit-router.ts
-function emitRouter(tables, hasAuth, driver = "pg") {
+function emitRouter(tables, hasAuth) {
   const tableNames = tables.map((t) => t.name).sort();
   const imports = tableNames.map((name) => {
     const Type = pascal(name);
@@ -2000,34 +1992,6 @@ function emitRouter(tables, hasAuth, driver = "pg") {
     return `export { register${Type}Routes } from "./routes/${name}";`;
   }).join(`
 `);
-  const pgExample = driver === "pg" ? `
- * import { Client } from "pg";
- * import { createRouter } from "./generated/server/router";
- * 
- * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();
- * 
- * // Mount all generated routes under /api
- * const apiRouter = createRouter({ pg });
- * app.route("/api", apiRouter);` : `
- * import { neon } from "@neondatabase/serverless";
- * import { createRouter } from "./generated/server/router";
- * 
- * const app = new Hono();
- * const sql = neon(process.env.DATABASE_URL!);
- * 
- * // Create pg-compatible adapter for Neon
- * const pg = {
- *   async query(text: string, params?: any[]) {
- *     const rows = await sql(text, params);
- *     return { rows };
- *   }
- * };
- * 
- * // Mount all generated routes under /api
- * const apiRouter = createRouter({ pg });
- * app.route("/api", apiRouter);`;
   return `/* Generated. Do not edit. */
 import { Hono } from "hono";
 import { SDK_MANIFEST } from "./sdk-bundle";
@@ -2038,7 +2002,23 @@ ${hasAuth ? `export { authMiddleware } from "./auth";` : ""}
  * Creates a Hono router with all generated routes that can be mounted into your existing app.
  * 
  * @example
- * import { Hono } from "hono";${pgExample}
+ * import { Hono } from "hono";
+ * import { createRouter } from "./generated/server/router";
+ * 
+ * // Using pg driver (Node.js)
+ * import { Client } from "pg";
+ * const pg = new Client({ connectionString: process.env.DATABASE_URL });
+ * await pg.connect();
+ * 
+ * // OR using Neon driver (Edge-compatible)
+ * import { Pool } from "@neondatabase/serverless";
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL! });
+ * const pg = pool; // Pool already has the compatible query method
+ * 
+ * // Mount all generated routes
+ * const app = new Hono();
+ * const apiRouter = createRouter({ pg });
+ * app.route("/api", apiRouter);
  * 
  * // Or mount directly at root
  * const router = createRouter({ pg });
@@ -2083,24 +2063,13 @@ ${registrations}
  * Register all generated routes directly on an existing Hono app.
  * 
  * @example
- * import { Hono } from "hono";${driver === "pg" ? `
- * import { Client } from "pg";
+ * import { Hono } from "hono";
  * import { registerAllRoutes } from "./generated/server/router";
  * 
  * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();` : `
- * import { neon } from "@neondatabase/serverless";
- * import { registerAllRoutes } from "./generated/server/router";
  * 
- * const app = new Hono();
- * const sql = neon(process.env.DATABASE_URL!);
- * const pg = {
- *   async query(text: string, params?: any[]) {
- *     const rows = await sql(text, params);
- *     return { rows };
- *   }
- * };`}
+ * // Setup database connection (see createRouter example for both pg and Neon options)
+ * const pg = yourDatabaseClient;
  * 
  * // Register all routes at once
  * registerAllRoutes(app, { pg });
@@ -2252,7 +2221,7 @@ async function generate(configPath) {
   });
   files.push({
     path: join(serverDir, "router.ts"),
-    content: emitRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none", cfg.driver || "pg")
+    content: emitRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none")
   });
   const clientFiles = files.filter((f) => {
     return f.path.includes(clientDir);

package/dist/emit-router.d.ts

@@ -2,4 +2,4 @@ import type { Table } from "./introspect";
 /**
  * Emits the server router file that exports helper functions for route registration
  */
-export declare function emitRouter(tables: Table[], hasAuth: boolean, driver?: "pg" | "neon"): string;
+export declare function emitRouter(tables: Table[], hasAuth: boolean): string;

package/dist/index.js

@@ -1012,7 +1012,7 @@ export class ${Type}Client extends BaseClient {
 function emitClientIndex(tables) {
   let out = `/* Generated. Do not edit. */
 `;
-  out += `import { BaseClient, AuthConfig } from "./base-client";
+  out += `import { BaseClient, type AuthConfig } from "./base-client";
 `;
   for (const t of tables) {
     out += `import { ${pascal(t.name)}Client } from "./${t.name}";
@@ -1738,7 +1738,7 @@ export async function authMiddleware(c: Context, next: Next) {
 }
 
 // src/emit-router.ts
-function emitRouter(tables, hasAuth, driver = "pg") {
+function emitRouter(tables, hasAuth) {
   const tableNames = tables.map((t) => t.name).sort();
   const imports = tableNames.map((name) => {
     const Type = pascal(name);
@@ -1755,34 +1755,6 @@ function emitRouter(tables, hasAuth, driver = "pg") {
     return `export { register${Type}Routes } from "./routes/${name}";`;
   }).join(`
 `);
-  const pgExample = driver === "pg" ? `
- * import { Client } from "pg";
- * import { createRouter } from "./generated/server/router";
- * 
- * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();
- * 
- * // Mount all generated routes under /api
- * const apiRouter = createRouter({ pg });
- * app.route("/api", apiRouter);` : `
- * import { neon } from "@neondatabase/serverless";
- * import { createRouter } from "./generated/server/router";
- * 
- * const app = new Hono();
- * const sql = neon(process.env.DATABASE_URL!);
- * 
- * // Create pg-compatible adapter for Neon
- * const pg = {
- *   async query(text: string, params?: any[]) {
- *     const rows = await sql(text, params);
- *     return { rows };
- *   }
- * };
- * 
- * // Mount all generated routes under /api
- * const apiRouter = createRouter({ pg });
- * app.route("/api", apiRouter);`;
   return `/* Generated. Do not edit. */
 import { Hono } from "hono";
 import { SDK_MANIFEST } from "./sdk-bundle";
@@ -1793,7 +1765,23 @@ ${hasAuth ? `export { authMiddleware } from "./auth";` : ""}
  * Creates a Hono router with all generated routes that can be mounted into your existing app.
  * 
  * @example
- * import { Hono } from "hono";${pgExample}
+ * import { Hono } from "hono";
+ * import { createRouter } from "./generated/server/router";
+ * 
+ * // Using pg driver (Node.js)
+ * import { Client } from "pg";
+ * const pg = new Client({ connectionString: process.env.DATABASE_URL });
+ * await pg.connect();
+ * 
+ * // OR using Neon driver (Edge-compatible)
+ * import { Pool } from "@neondatabase/serverless";
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL! });
+ * const pg = pool; // Pool already has the compatible query method
+ * 
+ * // Mount all generated routes
+ * const app = new Hono();
+ * const apiRouter = createRouter({ pg });
+ * app.route("/api", apiRouter);
  * 
  * // Or mount directly at root
  * const router = createRouter({ pg });
@@ -1838,24 +1826,13 @@ ${registrations}
  * Register all generated routes directly on an existing Hono app.
  * 
  * @example
- * import { Hono } from "hono";${driver === "pg" ? `
- * import { Client } from "pg";
+ * import { Hono } from "hono";
  * import { registerAllRoutes } from "./generated/server/router";
  * 
  * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();` : `
- * import { neon } from "@neondatabase/serverless";
- * import { registerAllRoutes } from "./generated/server/router";
  * 
- * const app = new Hono();
- * const sql = neon(process.env.DATABASE_URL!);
- * const pg = {
- *   async query(text: string, params?: any[]) {
- *     const rows = await sql(text, params);
- *     return { rows };
- *   }
- * };`}
+ * // Setup database connection (see createRouter example for both pg and Neon options)
+ * const pg = yourDatabaseClient;
  * 
  * // Register all routes at once
  * registerAllRoutes(app, { pg });
@@ -2007,7 +1984,7 @@ async function generate(configPath) {
   });
   files.push({
     path: join(serverDir, "router.ts"),
-    content: emitRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none", cfg.driver || "pg")
+    content: emitRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none")
   });
   const clientFiles = files.filter((f) => {
     return f.path.includes(clientDir);

package/dist/types.d.ts

@@ -26,7 +26,6 @@ export interface Config {
     softDeleteColumn?: string | null;
     includeDepthLimit?: number;
     dateType?: "date" | "string";
-    driver?: "pg" | "neon";
     auth?: AuthConfigInput;
     pull?: PullConfig;
 }

package/package.json

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