postgresdk 0.2.1-alpha.1 → 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

@@ -1249,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}";
@@ -2003,14 +2003,20 @@ ${hasAuth ? `export { authMiddleware } from "./auth";` : ""}
  * 
  * @example
  * import { Hono } from "hono";
- * import { Client } from "pg";
  * import { createRouter } from "./generated/server/router";
  * 
- * const app = new Hono();
+ * // Using pg driver (Node.js)
+ * import { Client } from "pg";
  * const pg = new Client({ connectionString: process.env.DATABASE_URL });
  * await pg.connect();
  * 
- * // Mount all generated routes under /api
+ * // 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);
  * 
@@ -2058,12 +2064,12 @@ ${registrations}
  * 
  * @example
  * import { Hono } from "hono";
- * import { Client } from "pg";
  * import { registerAllRoutes } from "./generated/server/router";
  * 
  * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();
+ * 
+ * // Setup database connection (see createRouter example for both pg and Neon options)
+ * const pg = yourDatabaseClient;
  * 
  * // Register all routes at once
  * registerAllRoutes(app, { pg });

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}";
@@ -1766,14 +1766,20 @@ ${hasAuth ? `export { authMiddleware } from "./auth";` : ""}
  * 
  * @example
  * import { Hono } from "hono";
- * import { Client } from "pg";
  * import { createRouter } from "./generated/server/router";
  * 
- * const app = new Hono();
+ * // Using pg driver (Node.js)
+ * import { Client } from "pg";
  * const pg = new Client({ connectionString: process.env.DATABASE_URL });
  * await pg.connect();
  * 
- * // Mount all generated routes under /api
+ * // 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);
  * 
@@ -1821,12 +1827,12 @@ ${registrations}
  * 
  * @example
  * import { Hono } from "hono";
- * import { Client } from "pg";
  * import { registerAllRoutes } from "./generated/server/router";
  * 
  * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();
+ * 
+ * // Setup database connection (see createRouter example for both pg and Neon options)
+ * const pg = yourDatabaseClient;
  * 
  * // Register all routes at once
  * registerAllRoutes(app, { pg });

package/package.json

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