@prisma-next/driver-postgres 0.0.1

package/README.md

@@ -0,0 +1,113 @@
+# @prisma-next/driver-postgres
+
+PostgreSQL driver for Prisma Next.
+
+## Package Classification
+
+- **Domain**: targets
+- **Layer**: drivers
+- **Plane**: multi-plane (migration, runtime)
+
+## Overview
+
+The PostgreSQL driver provides transport and connection management for PostgreSQL databases. It implements the `SqlDriver` interface for executing SQL statements, explaining queries, and managing connections.
+
+Drivers are transport-agnostic: they own pooling, connection management, and transport protocol (TCP, HTTP, etc.), but contain no dialect-specific logic. All dialect behavior lives in adapters.
+
+This package spans multiple planes:
+- **Migration plane** (`src/exports/control.ts`): Control plane entry point for driver descriptors
+- **Runtime plane** (`src/exports/runtime.ts`): Runtime entry point for driver implementation
+
+## Purpose
+
+Provide PostgreSQL transport and connection management. Execute SQL statements and manage connections without dialect-specific logic.
+
+## Responsibilities
+
+- **Connection Management**: Acquire and release database connections
+- **Statement Execution**: Execute SQL statements with parameters
+- **Query Explanation**: Execute EXPLAIN queries for query analysis
+- **Connection Pooling**: Manage connection pools (when applicable)
+- **Transport Protocol**: Handle PostgreSQL protocol (TCP, HTTP, etc.)
+
+**Non-goals:**
+- Dialect-specific SQL lowering (adapters)
+- Query compilation (sql-query)
+- Runtime execution (runtime)
+
+## Architecture
+
+```mermaid
+flowchart TD
+    subgraph "Runtime"
+        RT[Runtime]
+        ADAPTER[Adapter]
+    end
+
+    subgraph "Postgres Driver"
+        DRIVER[Driver]
+        POOL[Connection Pool]
+        CONN[Connection]
+    end
+
+    subgraph "PostgreSQL"
+        PG[(PostgreSQL)]
+    end
+
+    RT --> ADAPTER
+    ADAPTER --> DRIVER
+    DRIVER --> POOL
+    POOL --> CONN
+    CONN --> PG
+    PG --> CONN
+    CONN --> DRIVER
+    DRIVER --> RT
+```
+
+## Components
+
+### Driver (`postgres-driver.ts`)
+- Main driver implementation
+- Implements `SqlDriver` interface
+- Manages connections and executes statements
+- Handles PostgreSQL protocol
+
+## Dependencies
+
+- **`@prisma-next/sql-target`**: Driver SPI and SQL types
+
+## Related Subsystems
+
+- **[Adapters & Targets](../../docs/architecture%20docs/subsystems/5.%20Adapters%20&%20Targets.md)**: Driver specification
+
+## Related ADRs
+
+- [ADR 005 - Thin Core Fat Targets](../../docs/architecture%20docs/adrs/ADR%20005%20-%20Thin%20Core%20Fat%20Targets.md)
+- [ADR 016 - Adapter SPI for Lowering](../../docs/architecture%20docs/adrs/ADR%20016%20-%20Adapter%20SPI%20for%20Lowering.md)
+
+## Usage
+
+```typescript
+import { createPostgresDriver } from '@prisma-next/driver-postgres/runtime';
+import { createRuntime } from '@prisma-next/sql-runtime';
+
+const driver = createPostgresDriver({
+  connectionString: process.env.DATABASE_URL,
+});
+
+const runtime = createRuntime({
+  contract,
+  adapter: postgresAdapter,
+  driver,
+});
+```
+
+## Exports
+
+- `./runtime`: Runtime entry point for driver implementation
+  - `createPostgresDriver(connectionString, options?)`: Create driver from connection string
+  - `createPostgresDriverFromOptions(options)`: Create driver from options object
+  - Types: `PostgresDriverOptions`, `QueryResult`
+- `./control`: Control plane entry point for driver descriptors
+  - Default export: `DriverDescriptor` for use in `prisma-next.config.ts`
+

package/dist/exports/control.d.ts

@@ -0,0 +1,26 @@
+import { ControlDriverDescriptor, ControlDriverInstance } from '@prisma-next/core-control-plane/types';
+import { Client } from 'pg';
+
+/**
+ * Postgres control driver instance for control-plane operations.
+ * Implements ControlDriverInstance<'postgres'> for database queries.
+ */
+declare class PostgresControlDriver implements ControlDriverInstance<'postgres'> {
+    private readonly client;
+    readonly targetId: "postgres";
+    /**
+     * @deprecated Use targetId instead
+     */
+    readonly target: "postgres";
+    constructor(client: Client);
+    query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<{
+        readonly rows: Row[];
+    }>;
+    close(): Promise<void>;
+}
+/**
+ * Postgres driver descriptor for CLI config.
+ */
+declare const postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', PostgresControlDriver>;
+
+export { PostgresControlDriver, postgresDriverDescriptor as default };

package/dist/exports/control.js

@@ -0,0 +1,73 @@
+// src/exports/control.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { type } from "arktype";
+import { Client } from "pg";
+var PostgresControlDriver = class {
+  constructor(client) {
+    this.client = client;
+  }
+  targetId = "postgres";
+  /**
+   * @deprecated Use targetId instead
+   */
+  target = "postgres";
+  async query(sql, params) {
+    const result = await this.client.query(sql, params);
+    return { rows: result.rows };
+  }
+  async close() {
+    await this.client.end();
+  }
+};
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var TypesImportSpecSchema = type({
+  package: "string",
+  named: "string",
+  alias: "string"
+});
+var ExtensionPackManifestSchema = type({
+  id: "string",
+  version: "string",
+  "targets?": type({ "[string]": type({ "minVersion?": "string" }) }),
+  "capabilities?": "Record<string, unknown>",
+  "types?": type({
+    "codecTypes?": type({
+      import: TypesImportSpecSchema
+    }),
+    "operationTypes?": type({
+      import: TypesImportSpecSchema
+    })
+  }),
+  "operations?": "unknown[]"
+});
+function loadDriverManifest() {
+  const manifestPath = join(__dirname, "../../packs/manifest.json");
+  const manifestJson = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  const result = ExtensionPackManifestSchema(manifestJson);
+  if (result instanceof type.errors) {
+    const messages = result.map((p) => p.message).join("; ");
+    throw new Error(`Invalid driver manifest structure at ${manifestPath}: ${messages}`);
+  }
+  return result;
+}
+var postgresDriverDescriptor = {
+  kind: "driver",
+  id: "postgres",
+  familyId: "sql",
+  targetId: "postgres",
+  manifest: loadDriverManifest(),
+  async create(url) {
+    const client = new Client({ connectionString: url });
+    await client.connect();
+    return new PostgresControlDriver(client);
+  }
+};
+var control_default = postgresDriverDescriptor;
+export {
+  PostgresControlDriver,
+  control_default as default
+};
+//# sourceMappingURL=control.js.map

package/dist/exports/control.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/control.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { ExtensionPackManifest } from '@prisma-next/contract/pack-manifest-types';\nimport type {\n  ControlDriverDescriptor,\n  ControlDriverInstance,\n} from '@prisma-next/core-control-plane/types';\nimport { type } from 'arktype';\nimport { Client } from 'pg';\n\n/**\n * Postgres control driver instance for control-plane operations.\n * Implements ControlDriverInstance<'postgres'> for database queries.\n */\nexport class PostgresControlDriver implements ControlDriverInstance<'postgres'> {\n  readonly targetId = 'postgres' as const;\n  /**\n   * @deprecated Use targetId instead\n   */\n  readonly target = 'postgres' as const;\n\n  constructor(private readonly client: Client) {}\n\n  async query<Row = Record<string, unknown>>(\n    sql: string,\n    params?: readonly unknown[],\n  ): Promise<{ readonly rows: Row[] }> {\n    const result = await this.client.query(sql, params as unknown[] | undefined);\n    return { rows: result.rows as Row[] };\n  }\n\n  async close(): Promise<void> {\n    await this.client.end();\n  }\n}\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\nconst TypesImportSpecSchema = type({\n  package: 'string',\n  named: 'string',\n  alias: 'string',\n});\n\nconst ExtensionPackManifestSchema = type({\n  id: 'string',\n  version: 'string',\n  'targets?': type({ '[string]': type({ 'minVersion?': 'string' }) }),\n  'capabilities?': 'Record<string, unknown>',\n  'types?': type({\n    'codecTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n    'operationTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n  }),\n  'operations?': 'unknown[]',\n});\n\n/**\n * Loads the driver manifest from packs/manifest.json.\n */\nfunction loadDriverManifest(): ExtensionPackManifest {\n  const manifestPath = join(__dirname, '../../packs/manifest.json');\n  const manifestJson = JSON.parse(readFileSync(manifestPath, 'utf-8'));\n\n  const result = ExtensionPackManifestSchema(manifestJson);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid driver manifest structure at ${manifestPath}: ${messages}`);\n  }\n\n  return result as ExtensionPackManifest;\n}\n\n/**\n * Postgres driver descriptor for CLI config.\n */\nconst postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', PostgresControlDriver> =\n  {\n    kind: 'driver',\n    id: 'postgres',\n    familyId: 'sql',\n    targetId: 'postgres',\n    manifest: loadDriverManifest(),\n    async create(url: string): Promise<PostgresControlDriver> {\n      const client = new Client({ connectionString: url });\n      await client.connect();\n      return new PostgresControlDriver(client);\n    },\n  };\n\nexport default postgresDriverDescriptor;\n"],"mappings":";AAAA,SAAS,oBAAoB;AAC7B,SAAS,SAAS,YAAY;AAC9B,SAAS,qBAAqB;AAM9B,SAAS,YAAY;AACrB,SAAS,cAAc;AAMhB,IAAM,wBAAN,MAAyE;AAAA,EAO9E,YAA6B,QAAgB;AAAhB;AAAA,EAAiB;AAAA,EANrC,WAAW;AAAA;AAAA;AAAA;AAAA,EAIX,SAAS;AAAA,EAIlB,MAAM,MACJ,KACA,QACmC;AACnC,UAAM,SAAS,MAAM,KAAK,OAAO,MAAM,KAAK,MAA+B;AAC3E,WAAO,EAAE,MAAM,OAAO,KAAc;AAAA,EACtC;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,OAAO,IAAI;AAAA,EACxB;AACF;AAEA,IAAM,aAAa,cAAc,YAAY,GAAG;AAChD,IAAM,YAAY,QAAQ,UAAU;AAEpC,IAAM,wBAAwB,KAAK;AAAA,EACjC,SAAS;AAAA,EACT,OAAO;AAAA,EACP,OAAO;AACT,CAAC;AAED,IAAM,8BAA8B,KAAK;AAAA,EACvC,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,YAAY,KAAK,EAAE,YAAY,KAAK,EAAE,eAAe,SAAS,CAAC,EAAE,CAAC;AAAA,EAClE,iBAAiB;AAAA,EACjB,UAAU,KAAK;AAAA,IACb,eAAe,KAAK;AAAA,MAClB,QAAQ;AAAA,IACV,CAAC;AAAA,IACD,mBAAmB,KAAK;AAAA,MACtB,QAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AAAA,EACD,eAAe;AACjB,CAAC;AAKD,SAAS,qBAA4C;AACnD,QAAM,eAAe,KAAK,WAAW,2BAA2B;AAChE,QAAM,eAAe,KAAK,MAAM,aAAa,cAAc,OAAO,CAAC;AAEnE,QAAM,SAAS,4BAA4B,YAAY;AACvD,MAAI,kBAAkB,KAAK,QAAQ;AACjC,UAAM,WAAW,OAAO,IAAI,CAAC,MAA2B,EAAE,OAAO,EAAE,KAAK,IAAI;AAC5E,UAAM,IAAI,MAAM,wCAAwC,YAAY,KAAK,QAAQ,EAAE;AAAA,EACrF;AAEA,SAAO;AACT;AAKA,IAAM,2BACJ;AAAA,EACE,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,UAAU;AAAA,EACV,UAAU,mBAAmB;AAAA,EAC7B,MAAM,OAAO,KAA6C;AACxD,UAAM,SAAS,IAAI,OAAO,EAAE,kBAAkB,IAAI,CAAC;AACnD,UAAM,OAAO,QAAQ;AACrB,WAAO,IAAI,sBAAsB,MAAM;AAAA,EACzC;AACF;AAEF,IAAO,kBAAQ;","names":[]}

package/dist/exports/runtime.d.ts

@@ -0,0 +1,55 @@
+import { RuntimeDriverDescriptor, RuntimeDriverInstance } from '@prisma-next/core-execution-plane/types';
+import { Client, Pool, QueryResultRow, QueryResult as QueryResult$1 } from 'pg';
+
+interface SqlExecuteRequest {
+    readonly sql: string;
+    readonly params?: readonly unknown[];
+}
+interface SqlQueryResult<Row = Record<string, unknown>> {
+    readonly rows: ReadonlyArray<Row>;
+    readonly rowCount?: number | null;
+    readonly [key: string]: unknown;
+}
+interface SqlExplainResult<Row = Record<string, unknown>> {
+    readonly rows: ReadonlyArray<Row>;
+}
+interface SqlDriver {
+    connect(): Promise<void>;
+    execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row>;
+    explain?(request: SqlExecuteRequest): Promise<SqlExplainResult>;
+    query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<SqlQueryResult<Row>>;
+    close(): Promise<void>;
+}
+
+type QueryResult<T extends QueryResultRow = QueryResultRow> = QueryResult$1<T>;
+interface PostgresDriverOptions {
+    readonly connect: {
+        client: Client;
+    } | {
+        pool: Pool;
+    };
+    readonly cursor?: {
+        readonly batchSize?: number;
+        readonly disabled?: boolean;
+    } | undefined;
+}
+interface CreatePostgresDriverOptions {
+    readonly cursor?: PostgresDriverOptions['cursor'];
+    readonly poolFactory?: typeof Pool;
+}
+declare function createPostgresDriver(connectionString: string, options?: CreatePostgresDriverOptions): SqlDriver;
+declare function createPostgresDriverFromOptions(options: PostgresDriverOptions): SqlDriver;
+
+/**
+ * Postgres runtime driver instance interface.
+ * SqlDriver provides SQL-specific methods (execute, explain, close).
+ * RuntimeDriverInstance provides target identification (targetId).
+ * We use intersection type to combine both interfaces.
+ */
+type PostgresRuntimeDriver = RuntimeDriverInstance<'postgres'> & SqlDriver;
+/**
+ * Postgres driver descriptor for runtime plane.
+ */
+declare const postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<'sql', 'postgres', PostgresRuntimeDriver>;
+
+export { type CreatePostgresDriverOptions, type PostgresDriverOptions, type PostgresRuntimeDriver, type QueryResult, createPostgresDriver, createPostgresDriverFromOptions, postgresRuntimeDriverDescriptor as default };

package/dist/exports/runtime.js

@@ -0,0 +1,209 @@
+// src/exports/runtime.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { type } from "arktype";
+
+// src/postgres-driver.ts
+import { Pool } from "pg";
+import Cursor from "pg-cursor";
+var DEFAULT_BATCH_SIZE = 100;
+var PostgresDriverImpl = class {
+  pool;
+  directClient;
+  cursorBatchSize;
+  cursorDisabled;
+  constructor(options) {
+    if ("client" in options.connect) {
+      this.directClient = options.connect.client;
+    } else if ("pool" in options.connect) {
+      this.pool = options.connect.pool;
+    } else {
+      throw new Error("PostgresDriver requires a pool or client");
+    }
+    this.cursorBatchSize = options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.cursorDisabled = options.cursor?.disabled ?? false;
+  }
+  async connect() {
+  }
+  async *execute(request) {
+    const client = await this.acquireClient();
+    try {
+      if (!this.cursorDisabled) {
+        try {
+          for await (const row of this.executeWithCursor(client, request.sql, request.params)) {
+            yield row;
+          }
+          return;
+        } catch (cursorError) {
+          if (!(cursorError instanceof Error)) {
+            throw cursorError;
+          }
+        }
+      }
+      for await (const row of this.executeBuffered(client, request.sql, request.params)) {
+        yield row;
+      }
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+  async explain(request) {
+    const text = `EXPLAIN (FORMAT JSON) ${request.sql}`;
+    const client = await this.acquireClient();
+    try {
+      const result = await client.query(text, request.params);
+      return { rows: result.rows };
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+  async query(sql, params) {
+    const client = await this.acquireClient();
+    try {
+      const result = await client.query(sql, params);
+      return result;
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+  async close() {
+    if (this.pool) {
+      if (!this.pool.ended) {
+        await this.pool.end();
+      }
+    }
+  }
+  async acquireClient() {
+    if (this.pool) {
+      return this.pool.connect();
+    }
+    if (this.directClient) {
+      try {
+        await this.directClient.connect();
+      } catch (error) {
+        if (error instanceof Error) {
+          const message = error.message.toLowerCase();
+          if (!message.includes("already") && !message.includes("connected")) {
+            throw error;
+          }
+        } else {
+          throw error;
+        }
+      }
+      return this.directClient;
+    }
+    throw new Error("PostgresDriver requires a pool or client");
+  }
+  async releaseClient(client) {
+    if (this.pool) {
+      client.release();
+    }
+  }
+  async *executeWithCursor(client, sql, params) {
+    const cursor = client.query(new Cursor(sql, params));
+    try {
+      while (true) {
+        const rows = await readCursor(cursor, this.cursorBatchSize);
+        if (rows.length === 0) {
+          break;
+        }
+        for (const row of rows) {
+          yield row;
+        }
+      }
+    } finally {
+      await closeCursor(cursor);
+    }
+  }
+  async *executeBuffered(client, sql, params) {
+    const result = await client.query(sql, params);
+    for (const row of result.rows) {
+      yield row;
+    }
+  }
+};
+function createPostgresDriver(connectionString, options) {
+  const PoolImpl = options?.poolFactory ?? Pool;
+  const pool = new PoolImpl({ connectionString });
+  return new PostgresDriverImpl({
+    connect: { pool },
+    cursor: options?.cursor
+  });
+}
+function createPostgresDriverFromOptions(options) {
+  return new PostgresDriverImpl(options);
+}
+function readCursor(cursor, size) {
+  return new Promise((resolve, reject) => {
+    cursor.read(size, (err, rows) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(rows ?? []);
+    });
+  });
+}
+function closeCursor(cursor) {
+  return new Promise((resolve, reject) => {
+    cursor.close((err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+// src/exports/runtime.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var TypesImportSpecSchema = type({
+  package: "string",
+  named: "string",
+  alias: "string"
+});
+var ExtensionPackManifestSchema = type({
+  id: "string",
+  version: "string",
+  "targets?": type({ "[string]": type({ "minVersion?": "string" }) }),
+  "capabilities?": "Record<string, unknown>",
+  "types?": type({
+    "codecTypes?": type({
+      import: TypesImportSpecSchema
+    }),
+    "operationTypes?": type({
+      import: TypesImportSpecSchema
+    })
+  }),
+  "operations?": "unknown[]"
+});
+function loadDriverManifest() {
+  const manifestPath = join(__dirname, "../../packs/manifest.json");
+  const manifestJson = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  const result = ExtensionPackManifestSchema(manifestJson);
+  if (result instanceof type.errors) {
+    const messages = result.map((p) => p.message).join("; ");
+    throw new Error(`Invalid driver manifest structure at ${manifestPath}: ${messages}`);
+  }
+  return result;
+}
+var postgresRuntimeDriverDescriptor = {
+  kind: "driver",
+  familyId: "sql",
+  targetId: "postgres",
+  id: "postgres",
+  manifest: loadDriverManifest(),
+  create(options) {
+    return createPostgresDriverFromOptions(options);
+  }
+};
+var runtime_default = postgresRuntimeDriverDescriptor;
+export {
+  createPostgresDriver,
+  createPostgresDriverFromOptions,
+  runtime_default as default
+};
+//# sourceMappingURL=runtime.js.map

package/dist/exports/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/runtime.ts","../../src/postgres-driver.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { ExtensionPackManifest } from '@prisma-next/contract/pack-manifest-types';\nimport type {\n  RuntimeDriverDescriptor,\n  RuntimeDriverInstance,\n} from '@prisma-next/core-execution-plane/types';\nimport type { SqlDriver } from '@prisma-next/sql-relational-core/ast';\nimport { type } from 'arktype';\nimport type { PostgresDriverOptions } from '../postgres-driver';\nimport { createPostgresDriverFromOptions } from '../postgres-driver';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\nconst TypesImportSpecSchema = type({\n  package: 'string',\n  named: 'string',\n  alias: 'string',\n});\n\nconst ExtensionPackManifestSchema = type({\n  id: 'string',\n  version: 'string',\n  'targets?': type({ '[string]': type({ 'minVersion?': 'string' }) }),\n  'capabilities?': 'Record<string, unknown>',\n  'types?': type({\n    'codecTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n    'operationTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n  }),\n  'operations?': 'unknown[]',\n});\n\n/**\n * Loads the driver manifest from packs/manifest.json.\n */\nfunction loadDriverManifest(): ExtensionPackManifest {\n  const manifestPath = join(__dirname, '../../packs/manifest.json');\n  const manifestJson = JSON.parse(readFileSync(manifestPath, 'utf-8'));\n\n  const result = ExtensionPackManifestSchema(manifestJson);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid driver manifest structure at ${manifestPath}: ${messages}`);\n  }\n\n  return result as ExtensionPackManifest;\n}\n\n/**\n * Postgres runtime driver instance interface.\n * SqlDriver provides SQL-specific methods (execute, explain, close).\n * RuntimeDriverInstance provides target identification (targetId).\n * We use intersection type to combine both interfaces.\n */\nexport type PostgresRuntimeDriver = RuntimeDriverInstance<'postgres'> & SqlDriver;\n\n/**\n * Postgres driver descriptor for runtime plane.\n */\nconst postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<\n  'sql',\n  'postgres',\n  PostgresRuntimeDriver\n> = {\n  kind: 'driver',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  manifest: loadDriverManifest(),\n  create(options: PostgresDriverOptions): PostgresRuntimeDriver {\n    return createPostgresDriverFromOptions(options) as PostgresRuntimeDriver;\n  },\n};\n\nexport default postgresRuntimeDriverDescriptor;\nexport type {\n  CreatePostgresDriverOptions,\n  PostgresDriverOptions,\n  QueryResult,\n} from '../postgres-driver';\nexport { createPostgresDriver, createPostgresDriverFromOptions } from '../postgres-driver';\n","import type {\n  SqlDriver,\n  SqlExecuteRequest,\n  SqlExplainResult,\n  SqlQueryResult,\n} from '@prisma-next/sql-relational-core/ast';\nimport type {\n  Client,\n  QueryResult as PgQueryResult,\n  PoolClient,\n  Pool as PoolType,\n  QueryResultRow,\n} from 'pg';\nimport { Pool } from 'pg';\nimport Cursor from 'pg-cursor';\n\nexport type QueryResult<T extends QueryResultRow = QueryResultRow> = PgQueryResult<T>;\n\nexport interface PostgresDriverOptions {\n  readonly connect: { client: Client } | { pool: PoolType };\n  readonly cursor?:\n    | {\n        readonly batchSize?: number;\n        readonly disabled?: boolean;\n      }\n    | undefined;\n}\n\nconst DEFAULT_BATCH_SIZE = 100;\n\nclass PostgresDriverImpl implements SqlDriver {\n  private readonly pool: PoolType | undefined;\n  private readonly directClient: Client | undefined;\n  private readonly cursorBatchSize: number;\n  private readonly cursorDisabled: boolean;\n\n  constructor(options: PostgresDriverOptions) {\n    if ('client' in options.connect) {\n      this.directClient = options.connect.client;\n    } else if ('pool' in options.connect) {\n      this.pool = options.connect.pool;\n    } else {\n      throw new Error('PostgresDriver requires a pool or client');\n    }\n\n    this.cursorBatchSize = options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE;\n    this.cursorDisabled = options.cursor?.disabled ?? false;\n  }\n\n  async connect(): Promise<void> {\n    // No-op: caller controls connecting the underlying client or pool\n  }\n\n  async *execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row> {\n    const client = await this.acquireClient();\n    try {\n      if (!this.cursorDisabled) {\n        try {\n          for await (const row of this.executeWithCursor(client, request.sql, request.params)) {\n            yield row as Row;\n          }\n          return;\n        } catch (cursorError) {\n          if (!(cursorError instanceof Error)) {\n            throw cursorError;\n          }\n        }\n      }\n\n      for await (const row of this.executeBuffered(client, request.sql, request.params)) {\n        yield row as Row;\n      }\n    } finally {\n      await this.releaseClient(client);\n    }\n  }\n\n  async explain(request: SqlExecuteRequest): Promise<SqlExplainResult> {\n    const text = `EXPLAIN (FORMAT JSON) ${request.sql}`;\n    const client = await this.acquireClient();\n    try {\n      const result = await client.query(text, request.params as unknown[] | undefined);\n      return { rows: result.rows as ReadonlyArray<Record<string, unknown>> };\n    } finally {\n      await this.releaseClient(client);\n    }\n  }\n\n  async query<Row = Record<string, unknown>>(\n    sql: string,\n    params?: readonly unknown[],\n  ): Promise<SqlQueryResult<Row>> {\n    const client = await this.acquireClient();\n    try {\n      const result = await client.query(sql, params as unknown[] | undefined);\n      return result as unknown as SqlQueryResult<Row>;\n    } finally {\n      await this.releaseClient(client);\n    }\n  }\n\n  async close(): Promise<void> {\n    if (this.pool) {\n      // Check if pool is already closed to avoid \"Called end on pool more than once\" error\n      // pg Pool has an 'ended' property that indicates if the pool has been closed\n      if (!(this.pool as { ended?: boolean }).ended) {\n        await this.pool.end();\n      }\n    }\n  }\n\n  private async acquireClient(): Promise<PoolClient | Client> {\n    if (this.pool) {\n      return this.pool.connect();\n    }\n    if (this.directClient) {\n      // Lazy connection: connect if not already connected\n      // This allows tests to manage their own connections while still supporting lazy connection\n      // pg's Client.connect() will throw if already connected, so we catch and ignore that case\n      try {\n        await this.directClient.connect();\n      } catch (error: unknown) {\n        // If already connected, pg throws an error - ignore it and proceed\n        // Re-throw other errors (actual connection failures)\n        if (error instanceof Error) {\n          const message = error.message.toLowerCase();\n          if (!message.includes('already') && !message.includes('connected')) {\n            throw error;\n          }\n        } else {\n          throw error;\n        }\n      }\n      return this.directClient;\n    }\n    throw new Error('PostgresDriver requires a pool or client');\n  }\n\n  private async releaseClient(client: PoolClient | Client): Promise<void> {\n    if (this.pool) {\n      (client as PoolClient).release();\n    }\n  }\n\n  private async *executeWithCursor(\n    client: PoolClient | Client,\n    sql: string,\n    params: readonly unknown[] | undefined,\n  ): AsyncIterable<Record<string, unknown>> {\n    const cursor = client.query(new Cursor(sql, params as unknown[] | undefined));\n\n    try {\n      while (true) {\n        const rows = await readCursor(cursor, this.cursorBatchSize);\n        if (rows.length === 0) {\n          break;\n        }\n\n        for (const row of rows) {\n          yield row;\n        }\n      }\n    } finally {\n      await closeCursor(cursor);\n    }\n  }\n\n  private async *executeBuffered(\n    client: PoolClient | Client,\n    sql: string,\n    params: readonly unknown[] | undefined,\n  ): AsyncIterable<Record<string, unknown>> {\n    const result = await client.query(sql, params as unknown[] | undefined);\n    for (const row of result.rows as Record<string, unknown>[]) {\n      yield row;\n    }\n  }\n}\n\nexport interface CreatePostgresDriverOptions {\n  readonly cursor?: PostgresDriverOptions['cursor'];\n  readonly poolFactory?: typeof Pool;\n}\n\nexport function createPostgresDriver(\n  connectionString: string,\n  options?: CreatePostgresDriverOptions,\n): SqlDriver {\n  const PoolImpl: typeof Pool = options?.poolFactory ?? Pool;\n  const pool = new PoolImpl({ connectionString });\n  return new PostgresDriverImpl({\n    connect: { pool },\n    cursor: options?.cursor,\n  });\n}\n\nexport function createPostgresDriverFromOptions(options: PostgresDriverOptions): SqlDriver {\n  return new PostgresDriverImpl(options);\n}\n\nfunction readCursor<Row>(cursor: Cursor<Row>, size: number): Promise<Row[]> {\n  return new Promise<Row[]>((resolve, reject) => {\n    cursor.read(size, (err, rows) => {\n      if (err) {\n        reject(err);\n        return;\n      }\n\n      resolve(rows ?? []);\n    });\n  });\n}\n\nfunction closeCursor(cursor: Cursor<unknown>): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    cursor.close((err) => {\n      if (err) {\n        reject(err);\n        return;\n      }\n\n      resolve();\n    });\n  });\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@prisma-next/driver-postgres",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "dependencies": {
+    "arktype": "^2.0.0",
+    "pg": "^8.11.5",
+    "pg-cursor": "^2.10.5",
+    "@prisma-next/core-control-plane": "0.0.1",
+    "@prisma-next/core-execution-plane": "0.0.1",
+    "@prisma-next/sql-operations": "0.0.1",
+    "@prisma-next/sql-contract": "0.0.1"
+  },
+  "devDependencies": {
+    "pg-mem": "^3.0.5",
+    "tsup": "^8.3.0",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.1",
+    "@types/pg": "^8.11.10",
+    "@types/pg-cursor": "^2.4.6",
+    "@prisma-next/test-utils": "0.0.1"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./control": {
+      "types": "./dist/exports/control.d.ts",
+      "import": "./dist/exports/control.js"
+    },
+    "./runtime": {
+      "types": "./dist/exports/runtime.d.ts",
+      "import": "./dist/exports/runtime.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "lint": "biome check . --config-path ../../../biome.json --error-on-warnings",
+    "clean": "node ../../../scripts/clean.mjs"
+  }
+}