@prisma-next/driver-postgres 0.3.0-pr.94.3 → 0.3.0-pr.95.2

package/dist/callback-to-promise.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Wraps a Node-style callback function into a Promise.
+ * Supports both (err) => void and (err, result) => void patterns.
+ */
+export declare function callbackToPromise(fn: (callback: (err: Error | null | undefined) => void) => void): Promise<void>;
+export declare function callbackToPromise<T>(fn: (callback: (err: Error | null | undefined, result: T) => void) => void): Promise<T>;
+//# sourceMappingURL=callback-to-promise.d.ts.map

package/dist/callback-to-promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback-to-promise.d.ts","sourceRoot":"","sources":["../src/callback-to-promise.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,KAAK,IAAI,KAAK,IAAI,GAC9D,OAAO,CAAC,IAAI,CAAC,CAAC;AACjB,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,EAAE,MAAM,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,GACzE,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/dist/chunk-M4WUUVS5.js

@@ -0,0 +1,116 @@
+// src/core/descriptor-meta.ts
+var postgresDriverDescriptorMeta = {
+  kind: "driver",
+  familyId: "sql",
+  targetId: "postgres",
+  id: "postgres",
+  version: "0.0.1",
+  capabilities: {}
+};
+
+// src/normalize-error.ts
+import { SqlConnectionError, SqlQueryError } from "@prisma-next/sql-errors";
+function isConnectionError(error) {
+  const code = error.code;
+  if (code) {
+    if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EHOSTUNREACH") {
+      return true;
+    }
+  }
+  const message = error.message.toLowerCase();
+  if (message.includes("connection terminated") || message.includes("connection closed") || message.includes("connection refused") || message.includes("connection timeout") || message.includes("connection reset")) {
+    return true;
+  }
+  return false;
+}
+function isTransientConnectionError(error) {
+  const code = error.code;
+  if (code) {
+    if (code === "ETIMEDOUT" || code === "ECONNRESET") {
+      return true;
+    }
+    if (code === "ECONNREFUSED") {
+      return false;
+    }
+  }
+  const message = error.message.toLowerCase();
+  if (message.includes("timeout") || message.includes("connection reset")) {
+    return true;
+  }
+  return false;
+}
+var PG_ERROR_PROPERTIES = [
+  "constraint",
+  "table",
+  "column",
+  "hint",
+  "internalPosition",
+  "internalQuery",
+  "where",
+  "schema",
+  "routine"
+];
+function isPostgresError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const pgError = error;
+  if (pgError.code && isPostgresSqlState(pgError.code)) {
+    return true;
+  }
+  return PG_ERROR_PROPERTIES.some((prop) => pgError[prop] !== void 0);
+}
+function isAlreadyConnectedError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("already") && message.includes("connected");
+}
+function isPostgresSqlState(code) {
+  if (!code) {
+    return false;
+  }
+  return /^[A-Z0-9]{5}$/.test(code);
+}
+function normalizePgError(error) {
+  if (!(error instanceof Error)) {
+    return new Error(String(error));
+  }
+  const pgError = error;
+  if (isPostgresSqlState(pgError.code)) {
+    const sqlState = pgError.code;
+    const options = {
+      cause: error,
+      sqlState
+    };
+    if (pgError.constraint !== void 0) {
+      options.constraint = pgError.constraint;
+    }
+    if (pgError.table !== void 0) {
+      options.table = pgError.table;
+    }
+    if (pgError.column !== void 0) {
+      options.column = pgError.column;
+    }
+    if (pgError.detail !== void 0) {
+      options.detail = pgError.detail;
+    }
+    return new SqlQueryError(error.message, options);
+  }
+  if (isConnectionError(error)) {
+    return new SqlConnectionError(error.message, {
+      cause: error,
+      transient: isTransientConnectionError(error)
+    });
+  }
+  return error;
+}
+
+export {
+  postgresDriverDescriptorMeta,
+  isPostgresError,
+  isAlreadyConnectedError,
+  normalizePgError
+};
+//# sourceMappingURL=chunk-M4WUUVS5.js.map

package/dist/chunk-M4WUUVS5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/descriptor-meta.ts","../src/normalize-error.ts"],"sourcesContent":["export const postgresDriverDescriptorMeta = {\n  kind: 'driver',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n","import { SqlConnectionError, SqlQueryError } from '@prisma-next/sql-errors';\n\n/**\n * Postgres error shape from the pg library.\n *\n * Note: The pg library doesn't export a DatabaseError type or interface, but errors\n * thrown by pg.query() and pg.Client have this shape at runtime. We define this\n * interface to match the actual runtime structure documented in the pg library\n * (https://github.com/brianc/node-postgres/blob/master/packages/pg/lib/errors.js).\n *\n * The @types/pg package also doesn't provide comprehensive error type definitions,\n * so we define our own interface based on the runtime error properties.\n */\ninterface PostgresError extends Error {\n  readonly code?: string;\n  readonly constraint?: string;\n  readonly table?: string;\n  readonly column?: string;\n  readonly detail?: string;\n  readonly hint?: string;\n  readonly position?: string;\n  readonly internalPosition?: string;\n  readonly internalQuery?: string;\n  readonly where?: string;\n  readonly schema?: string;\n  readonly file?: string;\n  readonly line?: string;\n  readonly routine?: string;\n}\n\n/**\n * Checks if an error is a connection-related error.\n */\nfunction isConnectionError(error: Error): boolean {\n  const code = (error as { code?: string }).code;\n  if (code) {\n    // Node.js error codes for connection issues\n    if (\n      code === 'ECONNRESET' ||\n      code === 'ETIMEDOUT' ||\n      code === 'ECONNREFUSED' ||\n      code === 'ENOTFOUND' ||\n      code === 'EHOSTUNREACH'\n    ) {\n      return true;\n    }\n  }\n\n  // Check error message for connection-related strings\n  const message = error.message.toLowerCase();\n  if (\n    message.includes('connection terminated') ||\n    message.includes('connection closed') ||\n    message.includes('connection refused') ||\n    message.includes('connection timeout') ||\n    message.includes('connection reset')\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Checks if a connection error is transient (might succeed on retry).\n */\nfunction isTransientConnectionError(error: Error): boolean {\n  const code = (error as { code?: string }).code;\n  if (code) {\n    // Timeouts and connection resets are often transient\n    if (code === 'ETIMEDOUT' || code === 'ECONNRESET') {\n      return true;\n    }\n    // Connection refused is usually not transient (server is down)\n    if (code === 'ECONNREFUSED') {\n      return false;\n    }\n  }\n\n  const message = error.message.toLowerCase();\n  if (message.includes('timeout') || message.includes('connection reset')) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * PostgreSQL-specific error properties that indicate an error originated from pg library.\n * These properties are not present on Node.js system errors.\n * Excludes generic properties like 'detail', 'file', 'line', and 'position' that could appear on any error.\n */\nconst PG_ERROR_PROPERTIES = [\n  'constraint',\n  'table',\n  'column',\n  'hint',\n  'internalPosition',\n  'internalQuery',\n  'where',\n  'schema',\n  'routine',\n] as const;\n\n/**\n * Type predicate to check if an error is a Postgres error from the pg library.\n *\n * Distinguishes pg library errors from Node.js system errors by checking for:\n * - SQLSTATE codes (5-character alphanumeric codes like '23505', '42601')\n * - pg-specific properties (constraint, table, column, hint, etc.) that Node.js errors don't have\n *\n * Node.js system errors (ECONNREFUSED, ETIMEDOUT, etc.) are excluded to prevent false positives.\n */\nexport function isPostgresError(error: unknown): error is PostgresError {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n\n  const pgError = error as PostgresError;\n\n  // Check for SQLSTATE code (5-character alphanumeric) - primary indicator of pg errors\n  if (pgError.code && isPostgresSqlState(pgError.code)) {\n    return true;\n  }\n\n  // Check for pg-specific properties that Node.js system errors don't have\n  // These properties indicate the error originated from pg library query execution\n  return PG_ERROR_PROPERTIES.some((prop) => pgError[prop] !== undefined);\n}\n\n/**\n * Checks if an error is an \"already connected\" error from pg.Client.connect().\n * When calling connect() on an already-connected client, pg throws an error that can be safely ignored.\n */\nexport function isAlreadyConnectedError(error: unknown): error is Error {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n  const message = error.message.toLowerCase();\n  return message.includes('already') && message.includes('connected');\n}\n\n/**\n * Checks if an error code is a Postgres SQLSTATE (5-character alphanumeric code).\n * SQLSTATE codes are standardized SQL error codes (e.g., '23505' for unique violation).\n */\nfunction isPostgresSqlState(code: string | undefined): boolean {\n  if (!code) {\n    return false;\n  }\n  // Postgres SQLSTATE codes are 5-character alphanumeric strings\n  // Examples: '23505' (unique violation), '42501' (insufficient privilege), '42601' (syntax error)\n  return /^[A-Z0-9]{5}$/.test(code);\n}\n\n/**\n * Normalizes a Postgres error into a SQL-shared error type.\n *\n * - Postgres SQLSTATE errors (5-char codes like '23505') → SqlQueryError\n * - Connection errors (ECONNRESET, ETIMEDOUT, etc.) → SqlConnectionError\n * - Unknown errors → returns the original error as-is\n *\n * The original error is preserved via Error.cause to maintain stack traces.\n *\n * @param error - The error to normalize (typically from pg library)\n * @returns SqlQueryError for query-related failures\n * @returns SqlConnectionError for connection-related failures\n * @returns The original error if it cannot be normalized\n */\nexport function normalizePgError(error: unknown): SqlQueryError | SqlConnectionError | Error {\n  if (!(error instanceof Error)) {\n    // Wrap non-Error values in an Error object\n    return new Error(String(error));\n  }\n\n  const pgError = error as PostgresError;\n\n  // Check for Postgres SQLSTATE (query errors)\n  if (isPostgresSqlState(pgError.code)) {\n    // isPostgresSqlState ensures code is defined and is a valid SQLSTATE\n    // biome-ignore lint/style/noNonNullAssertion: isPostgresSqlState guarantees code is defined\n    const sqlState = pgError.code!;\n    const options: {\n      cause: Error;\n      sqlState: string;\n      constraint?: string;\n      table?: string;\n      column?: string;\n      detail?: string;\n    } = {\n      cause: error,\n      sqlState,\n    };\n    if (pgError.constraint !== undefined) {\n      options.constraint = pgError.constraint;\n    }\n    if (pgError.table !== undefined) {\n      options.table = pgError.table;\n    }\n    if (pgError.column !== undefined) {\n      options.column = pgError.column;\n    }\n    if (pgError.detail !== undefined) {\n      options.detail = pgError.detail;\n    }\n    return new SqlQueryError(error.message, options);\n  }\n\n  // Check for connection errors\n  if (isConnectionError(error)) {\n    return new SqlConnectionError(error.message, {\n      cause: error,\n      transient: isTransientConnectionError(error),\n    });\n  }\n\n  // Unknown error - return as-is to preserve original error and stack trace\n  return error;\n}\n"],"mappings":";AAAO,IAAM,+BAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AAAA,EACV,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,cAAc,CAAC;AACjB;;;ACPA,SAAS,oBAAoB,qBAAqB;AAiClD,SAAS,kBAAkB,OAAuB;AAChD,QAAM,OAAQ,MAA4B;AAC1C,MAAI,MAAM;AAER,QACE,SAAS,gBACT,SAAS,eACT,SAAS,kBACT,SAAS,eACT,SAAS,gBACT;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAGA,QAAM,UAAU,MAAM,QAAQ,YAAY;AAC1C,MACE,QAAQ,SAAS,uBAAuB,KACxC,QAAQ,SAAS,mBAAmB,KACpC,QAAQ,SAAS,oBAAoB,KACrC,QAAQ,SAAS,oBAAoB,KACrC,QAAQ,SAAS,kBAAkB,GACnC;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAKA,SAAS,2BAA2B,OAAuB;AACzD,QAAM,OAAQ,MAA4B;AAC1C,MAAI,MAAM;AAER,QAAI,SAAS,eAAe,SAAS,cAAc;AACjD,aAAO;AAAA,IACT;AAEA,QAAI,SAAS,gBAAgB;AAC3B,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,UAAU,MAAM,QAAQ,YAAY;AAC1C,MAAI,QAAQ,SAAS,SAAS,KAAK,QAAQ,SAAS,kBAAkB,GAAG;AACvE,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAOA,IAAM,sBAAsB;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAWO,SAAS,gBAAgB,OAAwC;AACtE,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO;AAAA,EACT;AAEA,QAAM,UAAU;AAGhB,MAAI,QAAQ,QAAQ,mBAAmB,QAAQ,IAAI,GAAG;AACpD,WAAO;AAAA,EACT;AAIA,SAAO,oBAAoB,KAAK,CAAC,SAAS,QAAQ,IAAI,MAAM,MAAS;AACvE;AAMO,SAAS,wBAAwB,OAAgC;AACtE,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO;AAAA,EACT;AACA,QAAM,UAAU,MAAM,QAAQ,YAAY;AAC1C,SAAO,QAAQ,SAAS,SAAS,KAAK,QAAQ,SAAS,WAAW;AACpE;AAMA,SAAS,mBAAmB,MAAmC;AAC7D,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAGA,SAAO,gBAAgB,KAAK,IAAI;AAClC;AAgBO,SAAS,iBAAiB,OAA4D;AAC3F,MAAI,EAAE,iBAAiB,QAAQ;AAE7B,WAAO,IAAI,MAAM,OAAO,KAAK,CAAC;AAAA,EAChC;AAEA,QAAM,UAAU;AAGhB,MAAI,mBAAmB,QAAQ,IAAI,GAAG;AAGpC,UAAM,WAAW,QAAQ;AACzB,UAAM,UAOF;AAAA,MACF,OAAO;AAAA,MACP;AAAA,IACF;AACA,QAAI,QAAQ,eAAe,QAAW;AACpC,cAAQ,aAAa,QAAQ;AAAA,IAC/B;AACA,QAAI,QAAQ,UAAU,QAAW;AAC/B,cAAQ,QAAQ,QAAQ;AAAA,IAC1B;AACA,QAAI,QAAQ,WAAW,QAAW;AAChC,cAAQ,SAAS,QAAQ;AAAA,IAC3B;AACA,QAAI,QAAQ,WAAW,QAAW;AAChC,cAAQ,SAAS,QAAQ;AAAA,IAC3B;AACA,WAAO,IAAI,cAAc,MAAM,SAAS,OAAO;AAAA,EACjD;AAGA,MAAI,kBAAkB,KAAK,GAAG;AAC5B,WAAO,IAAI,mBAAmB,MAAM,SAAS;AAAA,MAC3C,OAAO;AAAA,MACP,WAAW,2BAA2B,KAAK;AAAA,IAC7C,CAAC;AAAA,EACH;AAGA,SAAO;AACT;","names":[]}

package/dist/core/descriptor-meta.d.ts

@@ -0,0 +1,9 @@
+export declare const postgresDriverDescriptorMeta: {
+    readonly kind: "driver";
+    readonly familyId: "sql";
+    readonly targetId: "postgres";
+    readonly id: "postgres";
+    readonly version: "0.0.1";
+    readonly capabilities: {};
+};
+//# sourceMappingURL=descriptor-meta.d.ts.map

package/dist/core/descriptor-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta.d.ts","sourceRoot":"","sources":["../../src/core/descriptor-meta.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B;;;;;;;CAO/B,CAAC"}

package/dist/exports/control.d.ts

@@ -0,0 +1,26 @@
+import type { ControlDriverDescriptor, ControlDriverInstance } from '@prisma-next/core-control-plane/types';
+import { Client } from 'pg';
+/**
+ * Postgres control driver instance for control-plane operations.
+ * Implements ControlDriverInstance<'sql', 'postgres'> for database queries.
+ */
+export declare class PostgresControlDriver implements ControlDriverInstance<'sql', 'postgres'> {
+    private readonly client;
+    readonly familyId: "sql";
+    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 default postgresDriverDescriptor;
+//# sourceMappingURL=control.d.ts.map

package/dist/exports/control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/exports/control.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,uCAAuC,CAAC;AAG/C,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAI5B;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,qBAAqB,CAAC,KAAK,EAAE,UAAU,CAAC;IAQxE,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPnC,QAAQ,CAAC,QAAQ,EAAG,KAAK,CAAU;IACnC,QAAQ,CAAC,QAAQ,EAAG,UAAU,CAAU;IACxC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAG,UAAU,CAAU;gBAET,MAAM,EAAE,MAAM;IAErC,KAAK,CAAC,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,GAC1B,OAAO,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IAS9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B;AAED;;GAEG;AACH,QAAA,MAAM,wBAAwB,EAAE,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,qBAAqB,CAkC7F,CAAC;AAEJ,eAAe,wBAAwB,CAAC"}

package/dist/exports/control.js

@@ -0,0 +1,66 @@
+import {
+  normalizePgError,
+  postgresDriverDescriptorMeta
+} from "../chunk-M4WUUVS5.js";
+
+// src/exports/control.ts
+import { errorRuntime } from "@prisma-next/core-control-plane/errors";
+import { SqlQueryError } from "@prisma-next/sql-errors";
+import { redactDatabaseUrl } from "@prisma-next/utils/redact-db-url";
+import { Client } from "pg";
+var PostgresControlDriver = class {
+  constructor(client) {
+    this.client = client;
+  }
+  familyId = "sql";
+  targetId = "postgres";
+  /**
+   * @deprecated Use targetId instead
+   */
+  target = "postgres";
+  async query(sql, params) {
+    try {
+      const result = await this.client.query(sql, params);
+      return { rows: result.rows };
+    } catch (error) {
+      throw normalizePgError(error);
+    }
+  }
+  async close() {
+    await this.client.end();
+  }
+};
+var postgresDriverDescriptor = {
+  ...postgresDriverDescriptorMeta,
+  async create(url) {
+    const client = new Client({ connectionString: url });
+    try {
+      await client.connect();
+      return new PostgresControlDriver(client);
+    } catch (error) {
+      const normalized = normalizePgError(error);
+      const redacted = redactDatabaseUrl(url);
+      try {
+        await client.end();
+      } catch {
+      }
+      const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : void 0;
+      const causeCode = "cause" in normalized && normalized.cause ? normalized.cause.code : void 0;
+      const code = codeFromSqlState ?? causeCode;
+      throw errorRuntime("Database connection failed", {
+        why: normalized.message,
+        fix: "Verify the database URL, ensure the database is reachable, and confirm credentials/permissions",
+        meta: {
+          ...typeof code !== "undefined" ? { code } : {},
+          ...redacted
+        }
+      });
+    }
+  }
+};
+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 { errorRuntime } from '@prisma-next/core-control-plane/errors';\nimport type {\n  ControlDriverDescriptor,\n  ControlDriverInstance,\n} from '@prisma-next/core-control-plane/types';\nimport { SqlQueryError } from '@prisma-next/sql-errors';\nimport { redactDatabaseUrl } from '@prisma-next/utils/redact-db-url';\nimport { Client } from 'pg';\nimport { postgresDriverDescriptorMeta } from '../core/descriptor-meta';\nimport { normalizePgError } from '../normalize-error';\n\n/**\n * Postgres control driver instance for control-plane operations.\n * Implements ControlDriverInstance<'sql', 'postgres'> for database queries.\n */\nexport class PostgresControlDriver implements ControlDriverInstance<'sql', 'postgres'> {\n  readonly familyId = 'sql' as const;\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    try {\n      const result = await this.client.query(sql, params as unknown[] | undefined);\n      return { rows: result.rows as Row[] };\n    } catch (error) {\n      throw normalizePgError(error);\n    }\n  }\n\n  async close(): Promise<void> {\n    await this.client.end();\n  }\n}\n\n/**\n * Postgres driver descriptor for CLI config.\n */\nconst postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', PostgresControlDriver> =\n  {\n    ...postgresDriverDescriptorMeta,\n    async create(url: string): Promise<PostgresControlDriver> {\n      const client = new Client({ connectionString: url });\n      try {\n        await client.connect();\n        return new PostgresControlDriver(client);\n      } catch (error) {\n        const normalized = normalizePgError(error);\n        const redacted = redactDatabaseUrl(url);\n        try {\n          await client.end();\n        } catch {\n          // ignore\n        }\n\n        const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : undefined;\n        const causeCode =\n          'cause' in normalized && normalized.cause\n            ? (normalized.cause as { code?: unknown }).code\n            : undefined;\n        const code = codeFromSqlState ?? causeCode;\n\n        throw errorRuntime('Database connection failed', {\n          why: normalized.message,\n          fix: 'Verify the database URL, ensure the database is reachable, and confirm credentials/permissions',\n          meta: {\n            ...(typeof code !== 'undefined' ? { code } : {}),\n            ...redacted,\n          },\n        });\n      }\n    },\n  };\n\nexport default postgresDriverDescriptor;\n"],"mappings":";;;;;;AAAA,SAAS,oBAAoB;AAK7B,SAAS,qBAAqB;AAC9B,SAAS,yBAAyB;AAClC,SAAS,cAAc;AAQhB,IAAM,wBAAN,MAAgF;AAAA,EAQrF,YAA6B,QAAgB;AAAhB;AAAA,EAAiB;AAAA,EAPrC,WAAW;AAAA,EACX,WAAW;AAAA;AAAA;AAAA;AAAA,EAIX,SAAS;AAAA,EAIlB,MAAM,MACJ,KACA,QACmC;AACnC,QAAI;AACF,YAAM,SAAS,MAAM,KAAK,OAAO,MAAM,KAAK,MAA+B;AAC3E,aAAO,EAAE,MAAM,OAAO,KAAc;AAAA,IACtC,SAAS,OAAO;AACd,YAAM,iBAAiB,KAAK;AAAA,IAC9B;AAAA,EACF;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,OAAO,IAAI;AAAA,EACxB;AACF;AAKA,IAAM,2BACJ;AAAA,EACE,GAAG;AAAA,EACH,MAAM,OAAO,KAA6C;AACxD,UAAM,SAAS,IAAI,OAAO,EAAE,kBAAkB,IAAI,CAAC;AACnD,QAAI;AACF,YAAM,OAAO,QAAQ;AACrB,aAAO,IAAI,sBAAsB,MAAM;AAAA,IACzC,SAAS,OAAO;AACd,YAAM,aAAa,iBAAiB,KAAK;AACzC,YAAM,WAAW,kBAAkB,GAAG;AACtC,UAAI;AACF,cAAM,OAAO,IAAI;AAAA,MACnB,QAAQ;AAAA,MAER;AAEA,YAAM,mBAAmB,cAAc,GAAG,UAAU,IAAI,WAAW,WAAW;AAC9E,YAAM,YACJ,WAAW,cAAc,WAAW,QAC/B,WAAW,MAA6B,OACzC;AACN,YAAM,OAAO,oBAAoB;AAEjC,YAAM,aAAa,8BAA8B;AAAA,QAC/C,KAAK,WAAW;AAAA,QAChB,KAAK;AAAA,QACL,MAAM;AAAA,UACJ,GAAI,OAAO,SAAS,cAAc,EAAE,KAAK,IAAI,CAAC;AAAA,UAC9C,GAAG;AAAA,QACL;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEF,IAAO,kBAAQ;","names":[]}

package/dist/exports/runtime.d.ts

@@ -0,0 +1,17 @@
+import type { RuntimeDriverDescriptor, RuntimeDriverInstance } from '@prisma-next/core-execution-plane/types';
+import type { SqlDriver } from '@prisma-next/sql-relational-core/ast';
+/**
+ * Postgres runtime driver instance interface.
+ * SqlDriver provides SQL-specific methods (execute, explain, close).
+ * RuntimeDriverInstance provides target identification (familyId, targetId).
+ * We use intersection type to combine both interfaces.
+ */
+export type PostgresRuntimeDriver = RuntimeDriverInstance<'sql', 'postgres'> & SqlDriver;
+/**
+ * Postgres driver descriptor for runtime plane.
+ */
+declare const postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<'sql', 'postgres', PostgresRuntimeDriver>;
+export default postgresRuntimeDriverDescriptor;
+export type { CreatePostgresDriverOptions, PostgresDriverOptions, QueryResult, } from '../postgres-driver';
+export { createPostgresDriver, createPostgresDriverFromOptions } from '../postgres-driver';
+//# sourceMappingURL=runtime.d.ts.map

package/dist/exports/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/exports/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAKtE;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,qBAAqB,CAAC,KAAK,EAAE,UAAU,CAAC,GAAG,SAAS,CAAC;AAEzF;;GAEG;AACH,QAAA,MAAM,+BAA+B,EAAE,uBAAuB,CAC5D,KAAK,EACL,UAAU,EACV,qBAAqB,CAMtB,CAAC;AAEF,eAAe,+BAA+B,CAAC;AAC/C,YAAY,EACV,2BAA2B,EAC3B,qBAAqB,EACrB,WAAW,GACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,oBAAoB,EAAE,+BAA+B,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/exports/runtime.js

@@ -0,0 +1,189 @@
+import {
+  isAlreadyConnectedError,
+  isPostgresError,
+  normalizePgError,
+  postgresDriverDescriptorMeta
+} from "../chunk-M4WUUVS5.js";
+
+// src/postgres-driver.ts
+import { Pool } from "pg";
+import Cursor from "pg-cursor";
+
+// src/callback-to-promise.ts
+function callbackToPromise(fn) {
+  return new Promise((resolve, reject) => {
+    fn((err, result) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+
+// src/postgres-driver.ts
+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;
+          }
+          if (isPostgresError(cursorError)) {
+            throw normalizePgError(cursorError);
+          }
+        }
+      }
+      for await (const row of this.executeBuffered(client, request.sql, request.params)) {
+        yield row;
+      }
+    } catch (error) {
+      throw normalizePgError(error);
+    } 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 };
+    } catch (error) {
+      throw normalizePgError(error);
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+  async query(sql, params) {
+    const client = await this.acquireClient();
+    try {
+      const result = await client.query(sql, params);
+      return result;
+    } catch (error) {
+      throw normalizePgError(error);
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+  async close() {
+    if (this.pool) {
+      if (!this.pool.ended) {
+        await this.pool.end();
+      }
+    }
+    if (this.directClient) {
+      const client = this.directClient;
+      if (!client._ending) {
+        await client.end();
+      }
+    }
+  }
+  async acquireClient() {
+    if (this.pool) {
+      return this.pool.connect();
+    }
+    if (this.directClient) {
+      const client = this.directClient;
+      const isConnected = client._connection !== void 0 && client._connection !== null && !client._ending;
+      if (!isConnected) {
+        try {
+          await this.directClient.connect();
+        } catch (error) {
+          if (!isAlreadyConnectedError(error)) {
+            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 callbackToPromise((cb) => {
+    cursor.read(size, (err, rows) => cb(err, rows));
+  });
+}
+function closeCursor(cursor) {
+  return callbackToPromise((cb) => cursor.close(cb));
+}
+
+// src/exports/runtime.ts
+var postgresRuntimeDriverDescriptor = {
+  ...postgresDriverDescriptorMeta,
+  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/postgres-driver.ts","../../src/callback-to-promise.ts","../../src/exports/runtime.ts"],"sourcesContent":["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';\nimport { callbackToPromise } from './callback-to-promise';\nimport { isAlreadyConnectedError, isPostgresError, normalizePgError } from './normalize-error';\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          // Check if this is a pg error - if so, normalize and throw\n          // Otherwise, fall back to buffered mode for cursor-specific errors\n          if (isPostgresError(cursorError)) {\n            throw normalizePgError(cursorError);\n          }\n          // Not a pg error - cursor-specific error, fall back to buffered mode\n        }\n      }\n\n      for await (const row of this.executeBuffered(client, request.sql, request.params)) {\n        yield row as Row;\n      }\n    } catch (error) {\n      throw normalizePgError(error);\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    } catch (error) {\n      throw normalizePgError(error);\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    } catch (error) {\n      throw normalizePgError(error);\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    if (this.directClient) {\n      const client = this.directClient as Client & { _ending?: boolean };\n      if (!client._ending) {\n        await client.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      // Check if client is already connected before attempting to connect\n      // This prevents hanging when the database only supports a single connection\n      // pg's Client has internal connection state that we can check\n      const client = this.directClient as Client & {\n        _ending?: boolean;\n        _connection?: unknown;\n      };\n      const isConnected =\n        client._connection !== undefined && client._connection !== null && !client._ending;\n\n      // Only connect if not already connected\n      // If caller provided a connected client (e.g., in tests), use it as-is\n      if (!isConnected) {\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 (!isAlreadyConnectedError(error)) {\n            throw error;\n          }\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 callbackToPromise<Row[]>((cb) => {\n    cursor.read(size, (err, rows) => cb(err, rows));\n  });\n}\n\nfunction closeCursor(cursor: Cursor<unknown>): Promise<void> {\n  return callbackToPromise((cb) => cursor.close(cb));\n}\n","/**\n * Wraps a Node-style callback function into a Promise.\n * Supports both (err) => void and (err, result) => void patterns.\n */\nexport function callbackToPromise(\n  fn: (callback: (err: Error | null | undefined) => void) => void,\n): Promise<void>;\nexport function callbackToPromise<T>(\n  fn: (callback: (err: Error | null | undefined, result: T) => void) => void,\n): Promise<T>;\nexport function callbackToPromise<T = void>(\n  fn: (callback: (err: Error | null | undefined, result?: T) => void) => void,\n): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    fn((err, result) => {\n      if (err) {\n        reject(err);\n        return;\n      }\n      resolve(result as T);\n    });\n  });\n}\n","import type {\n  RuntimeDriverDescriptor,\n  RuntimeDriverInstance,\n} from '@prisma-next/core-execution-plane/types';\nimport type { SqlDriver } from '@prisma-next/sql-relational-core/ast';\nimport { postgresDriverDescriptorMeta } from '../core/descriptor-meta';\nimport type { PostgresDriverOptions } from '../postgres-driver';\nimport { createPostgresDriverFromOptions } from '../postgres-driver';\n\n/**\n * Postgres runtime driver instance interface.\n * SqlDriver provides SQL-specific methods (execute, explain, close).\n * RuntimeDriverInstance provides target identification (familyId, targetId).\n * We use intersection type to combine both interfaces.\n */\nexport type PostgresRuntimeDriver = RuntimeDriverInstance<'sql', 'postgres'> & SqlDriver;\n\n/**\n * Postgres driver descriptor for runtime plane.\n */\nconst postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<\n  'sql',\n  'postgres',\n  PostgresRuntimeDriver\n> = {\n  ...postgresDriverDescriptorMeta,\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"],"mappings":"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","names":[]}

package/dist/normalize-error.d.ts

@@ -0,0 +1,60 @@
+import { SqlConnectionError, SqlQueryError } from '@prisma-next/sql-errors';
+/**
+ * Postgres error shape from the pg library.
+ *
+ * Note: The pg library doesn't export a DatabaseError type or interface, but errors
+ * thrown by pg.query() and pg.Client have this shape at runtime. We define this
+ * interface to match the actual runtime structure documented in the pg library
+ * (https://github.com/brianc/node-postgres/blob/master/packages/pg/lib/errors.js).
+ *
+ * The @types/pg package also doesn't provide comprehensive error type definitions,
+ * so we define our own interface based on the runtime error properties.
+ */
+interface PostgresError extends Error {
+    readonly code?: string;
+    readonly constraint?: string;
+    readonly table?: string;
+    readonly column?: string;
+    readonly detail?: string;
+    readonly hint?: string;
+    readonly position?: string;
+    readonly internalPosition?: string;
+    readonly internalQuery?: string;
+    readonly where?: string;
+    readonly schema?: string;
+    readonly file?: string;
+    readonly line?: string;
+    readonly routine?: string;
+}
+/**
+ * Type predicate to check if an error is a Postgres error from the pg library.
+ *
+ * Distinguishes pg library errors from Node.js system errors by checking for:
+ * - SQLSTATE codes (5-character alphanumeric codes like '23505', '42601')
+ * - pg-specific properties (constraint, table, column, hint, etc.) that Node.js errors don't have
+ *
+ * Node.js system errors (ECONNREFUSED, ETIMEDOUT, etc.) are excluded to prevent false positives.
+ */
+export declare function isPostgresError(error: unknown): error is PostgresError;
+/**
+ * Checks if an error is an "already connected" error from pg.Client.connect().
+ * When calling connect() on an already-connected client, pg throws an error that can be safely ignored.
+ */
+export declare function isAlreadyConnectedError(error: unknown): error is Error;
+/**
+ * Normalizes a Postgres error into a SQL-shared error type.
+ *
+ * - Postgres SQLSTATE errors (5-char codes like '23505') → SqlQueryError
+ * - Connection errors (ECONNRESET, ETIMEDOUT, etc.) → SqlConnectionError
+ * - Unknown errors → returns the original error as-is
+ *
+ * The original error is preserved via Error.cause to maintain stack traces.
+ *
+ * @param error - The error to normalize (typically from pg library)
+ * @returns SqlQueryError for query-related failures
+ * @returns SqlConnectionError for connection-related failures
+ * @returns The original error if it cannot be normalized
+ */
+export declare function normalizePgError(error: unknown): SqlQueryError | SqlConnectionError | Error;
+export {};
+//# sourceMappingURL=normalize-error.d.ts.map

package/dist/normalize-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-error.d.ts","sourceRoot":"","sources":["../src/normalize-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE5E;;;;;;;;;;GAUG;AACH,UAAU,aAAc,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AA4ED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAetE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAMtE;AAeD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,GAAG,kBAAkB,GAAG,KAAK,CAiD3F"}

package/dist/postgres-driver.d.ts

@@ -0,0 +1,22 @@
+import type { SqlDriver } from '@prisma-next/sql-relational-core/ast';
+import type { Client, QueryResult as PgQueryResult, Pool as PoolType, QueryResultRow } from 'pg';
+import { Pool } from 'pg';
+export type QueryResult<T extends QueryResultRow = QueryResultRow> = PgQueryResult<T>;
+export interface PostgresDriverOptions {
+    readonly connect: {
+        client: Client;
+    } | {
+        pool: PoolType;
+    };
+    readonly cursor?: {
+        readonly batchSize?: number;
+        readonly disabled?: boolean;
+    } | undefined;
+}
+export interface CreatePostgresDriverOptions {
+    readonly cursor?: PostgresDriverOptions['cursor'];
+    readonly poolFactory?: typeof Pool;
+}
+export declare function createPostgresDriver(connectionString: string, options?: CreatePostgresDriverOptions): SqlDriver;
+export declare function createPostgresDriverFromOptions(options: PostgresDriverOptions): SqlDriver;
+//# sourceMappingURL=postgres-driver.d.ts.map

package/dist/postgres-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-driver.d.ts","sourceRoot":"","sources":["../src/postgres-driver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAIV,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EACV,MAAM,EACN,WAAW,IAAI,aAAa,EAE5B,IAAI,IAAI,QAAQ,EAChB,cAAc,EACf,MAAM,IAAI,CAAC;AACZ,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAK1B,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;AAEtF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC;IAC1D,QAAQ,CAAC,MAAM,CAAC,EACZ;QACE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;KAC7B,GACD,SAAS,CAAC;CACf;AAiLD,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAClD,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,IAAI,CAAC;CACpC;AAED,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,EACxB,OAAO,CAAC,EAAE,2BAA2B,GACpC,SAAS,CAOX;AAED,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,qBAAqB,GAAG,SAAS,CAEzF"}

package/package.json

@@ -1,49 +1,50 @@
 {
   "name": "@prisma-next/driver-postgres",
-  "version": "0.3.0-pr.94.3",
+  "version": "0.3.0-pr.95.2",
   "type": "module",
   "sideEffects": false,
-  "engines": {
-    "node": ">=20"
-  },
   "dependencies": {
     "arktype": "^2.0.0",
     "pg": "8.16.3",
     "pg-cursor": "^2.10.5",
-    "@prisma-next/contract": "0.3.0-pr.94.3",
-    "@prisma-next/core-control-plane": "0.3.0-pr.94.3",
-    "@prisma-next/core-execution-plane": "0.3.0-pr.94.3",
-    "@prisma-next/sql-contract": "0.3.0-pr.94.3",
-    "@prisma-next/sql-errors": "0.3.0-pr.94.3",
-    "@prisma-next/sql-relational-core": "0.3.0-pr.94.3",
-    "@prisma-next/sql-operations": "0.3.0-pr.94.3",
-    "@prisma-next/utils": "0.3.0-pr.94.3"
+    "@prisma-next/contract": "0.3.0-pr.95.2",
+    "@prisma-next/core-control-plane": "0.3.0-pr.95.2",
+    "@prisma-next/core-execution-plane": "0.3.0-pr.95.2",
+    "@prisma-next/sql-contract": "0.3.0-pr.95.2",
+    "@prisma-next/sql-errors": "0.3.0-pr.95.2",
+    "@prisma-next/sql-operations": "0.3.0-pr.95.2",
+    "@prisma-next/sql-relational-core": "0.3.0-pr.95.2",
+    "@prisma-next/utils": "0.3.0-pr.95.2"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
     "@types/pg-cursor": "^2.4.6",
     "pg-mem": "^3.0.5",
-    "tsdown": "0.18.4",
+    "tsup": "8.5.1",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",
     "src"
   ],
   "exports": {
-    "./control": "./dist/control.mjs",
-    "./runtime": "./dist/runtime.mjs",
-    "./package.json": "./package.json"
+    "./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": "tsdown",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
     "lint": "biome check . --error-on-warnings",
     "lint:fix": "biome check --write .",
     "lint:fix:unsafe": "biome check --write --unsafe .",

package/dist/control.d.mts

@@ -1,30 +0,0 @@
-import { Client } from "pg";
-import { ControlDriverDescriptor, ControlDriverInstance } from "@prisma-next/core-control-plane/types";
-
-//#region src/exports/control.d.ts
-
-/**
- * Postgres control driver instance for control-plane operations.
- * Implements ControlDriverInstance<'sql', 'postgres'> for database queries.
- */
-declare class PostgresControlDriver implements ControlDriverInstance<'sql', 'postgres'> {
-  private readonly client;
-  readonly familyId: "sql";
-  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>;
-//#endregion
-export { PostgresControlDriver, postgresDriverDescriptor as default };
-//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;;AAUoB,cAVP,qBAAA,YAAiC,qBAU1B,CAAA,KAAA,EAAA,UAAA,CAAA,CAAA;EAGU,iBAAA,MAAA;EAAzB,SAAA,QAAA,EAAA,KAAA;EASY,SAAA,QAAA,EAAA,UAAA;EAtB6B;;AAyB7C;;sBAjBsC;cAEnB,oEAGf;mBAAyB;;WASb;;;;;cAQX,0BAA0B,2CAA2C"}

package/dist/control.mjs

@@ -1,67 +0,0 @@
-import { i as postgresDriverDescriptorMeta, r as normalizePgError } from "./normalize-error-BU6yV-XB.mjs";
-import { errorRuntime } from "@prisma-next/core-control-plane/errors";
-import { SqlQueryError } from "@prisma-next/sql-errors";
-import { redactDatabaseUrl } from "@prisma-next/utils/redact-db-url";
-import { Client } from "pg";
-
-//#region src/exports/control.ts
-/**
-* Postgres control driver instance for control-plane operations.
-* Implements ControlDriverInstance<'sql', 'postgres'> for database queries.
-*/
-var PostgresControlDriver = class {
-	familyId = "sql";
-	targetId = "postgres";
-	/**
-	* @deprecated Use targetId instead
-	*/
-	target = "postgres";
-	constructor(client) {
-		this.client = client;
-	}
-	async query(sql, params) {
-		try {
-			return { rows: (await this.client.query(sql, params)).rows };
-		} catch (error) {
-			throw normalizePgError(error);
-		}
-	}
-	async close() {
-		await this.client.end();
-	}
-};
-/**
-* Postgres driver descriptor for CLI config.
-*/
-const postgresDriverDescriptor = {
-	...postgresDriverDescriptorMeta,
-	async create(url) {
-		const client = new Client({ connectionString: url });
-		try {
-			await client.connect();
-			return new PostgresControlDriver(client);
-		} catch (error) {
-			const normalized = normalizePgError(error);
-			const redacted = redactDatabaseUrl(url);
-			try {
-				await client.end();
-			} catch {}
-			const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : void 0;
-			const causeCode = "cause" in normalized && normalized.cause ? normalized.cause.code : void 0;
-			const code = codeFromSqlState ?? causeCode;
-			throw errorRuntime("Database connection failed", {
-				why: normalized.message,
-				fix: "Verify the database URL, ensure the database is reachable, and confirm credentials/permissions",
-				meta: {
-					...typeof code !== "undefined" ? { code } : {},
-					...redacted
-				}
-			});
-		}
-	}
-};
-var control_default = postgresDriverDescriptor;
-
-//#endregion
-export { PostgresControlDriver, control_default as default };
-//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"control.mjs","names":["client: Client","postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', PostgresControlDriver>"],"sources":["../src/exports/control.ts"],"sourcesContent":["import { errorRuntime } from '@prisma-next/core-control-plane/errors';\nimport type {\n  ControlDriverDescriptor,\n  ControlDriverInstance,\n} from '@prisma-next/core-control-plane/types';\nimport { SqlQueryError } from '@prisma-next/sql-errors';\nimport { redactDatabaseUrl } from '@prisma-next/utils/redact-db-url';\nimport { Client } from 'pg';\nimport { postgresDriverDescriptorMeta } from '../core/descriptor-meta';\nimport { normalizePgError } from '../normalize-error';\n\n/**\n * Postgres control driver instance for control-plane operations.\n * Implements ControlDriverInstance<'sql', 'postgres'> for database queries.\n */\nexport class PostgresControlDriver implements ControlDriverInstance<'sql', 'postgres'> {\n  readonly familyId = 'sql' as const;\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    try {\n      const result = await this.client.query(sql, params as unknown[] | undefined);\n      return { rows: result.rows as Row[] };\n    } catch (error) {\n      throw normalizePgError(error);\n    }\n  }\n\n  async close(): Promise<void> {\n    await this.client.end();\n  }\n}\n\n/**\n * Postgres driver descriptor for CLI config.\n */\nconst postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', PostgresControlDriver> =\n  {\n    ...postgresDriverDescriptorMeta,\n    async create(url: string): Promise<PostgresControlDriver> {\n      const client = new Client({ connectionString: url });\n      try {\n        await client.connect();\n        return new PostgresControlDriver(client);\n      } catch (error) {\n        const normalized = normalizePgError(error);\n        const redacted = redactDatabaseUrl(url);\n        try {\n          await client.end();\n        } catch {\n          // ignore\n        }\n\n        const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : undefined;\n        const causeCode =\n          'cause' in normalized && normalized.cause\n            ? (normalized.cause as { code?: unknown }).code\n            : undefined;\n        const code = codeFromSqlState ?? causeCode;\n\n        throw errorRuntime('Database connection failed', {\n          why: normalized.message,\n          fix: 'Verify the database URL, ensure the database is reachable, and confirm credentials/permissions',\n          meta: {\n            ...(typeof code !== 'undefined' ? { code } : {}),\n            ...redacted,\n          },\n        });\n      }\n    },\n  };\n\nexport default postgresDriverDescriptor;\n"],"mappings":";;;;;;;;;;;AAeA,IAAa,wBAAb,MAAuF;CACrF,AAAS,WAAW;CACpB,AAAS,WAAW;;;;CAIpB,AAAS,SAAS;CAElB,YAAY,AAAiBA,QAAgB;EAAhB;;CAE7B,MAAM,MACJ,KACA,QACmC;AACnC,MAAI;AAEF,UAAO,EAAE,OADM,MAAM,KAAK,OAAO,MAAM,KAAK,OAAgC,EACtD,MAAe;WAC9B,OAAO;AACd,SAAM,iBAAiB,MAAM;;;CAIjC,MAAM,QAAuB;AAC3B,QAAM,KAAK,OAAO,KAAK;;;;;;AAO3B,MAAMC,2BACJ;CACE,GAAG;CACH,MAAM,OAAO,KAA6C;EACxD,MAAM,SAAS,IAAI,OAAO,EAAE,kBAAkB,KAAK,CAAC;AACpD,MAAI;AACF,SAAM,OAAO,SAAS;AACtB,UAAO,IAAI,sBAAsB,OAAO;WACjC,OAAO;GACd,MAAM,aAAa,iBAAiB,MAAM;GAC1C,MAAM,WAAW,kBAAkB,IAAI;AACvC,OAAI;AACF,UAAM,OAAO,KAAK;WACZ;GAIR,MAAM,mBAAmB,cAAc,GAAG,WAAW,GAAG,WAAW,WAAW;GAC9E,MAAM,YACJ,WAAW,cAAc,WAAW,QAC/B,WAAW,MAA6B,OACzC;GACN,MAAM,OAAO,oBAAoB;AAEjC,SAAM,aAAa,8BAA8B;IAC/C,KAAK,WAAW;IAChB,KAAK;IACL,MAAM;KACJ,GAAI,OAAO,SAAS,cAAc,EAAE,MAAM,GAAG,EAAE;KAC/C,GAAG;KACJ;IACF,CAAC;;;CAGP;AAEH,sBAAe"}

package/dist/normalize-error-BU6yV-XB.mjs

@@ -1,125 +0,0 @@
-import { SqlConnectionError, SqlQueryError } from "@prisma-next/sql-errors";
-
-//#region src/core/descriptor-meta.ts
-const postgresDriverDescriptorMeta = {
-	kind: "driver",
-	familyId: "sql",
-	targetId: "postgres",
-	id: "postgres",
-	version: "0.0.1",
-	capabilities: {}
-};
-
-//#endregion
-//#region src/normalize-error.ts
-/**
-* Checks if an error is a connection-related error.
-*/
-function isConnectionError(error) {
-	const code = error.code;
-	if (code) {
-		if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EHOSTUNREACH") return true;
-	}
-	const message = error.message.toLowerCase();
-	if (message.includes("connection terminated") || message.includes("connection closed") || message.includes("connection refused") || message.includes("connection timeout") || message.includes("connection reset")) return true;
-	return false;
-}
-/**
-* Checks if a connection error is transient (might succeed on retry).
-*/
-function isTransientConnectionError(error) {
-	const code = error.code;
-	if (code) {
-		if (code === "ETIMEDOUT" || code === "ECONNRESET") return true;
-		if (code === "ECONNREFUSED") return false;
-	}
-	const message = error.message.toLowerCase();
-	if (message.includes("timeout") || message.includes("connection reset")) return true;
-	return false;
-}
-/**
-* PostgreSQL-specific error properties that indicate an error originated from pg library.
-* These properties are not present on Node.js system errors.
-* Excludes generic properties like 'detail', 'file', 'line', and 'position' that could appear on any error.
-*/
-const PG_ERROR_PROPERTIES = [
-	"constraint",
-	"table",
-	"column",
-	"hint",
-	"internalPosition",
-	"internalQuery",
-	"where",
-	"schema",
-	"routine"
-];
-/**
-* Type predicate to check if an error is a Postgres error from the pg library.
-*
-* Distinguishes pg library errors from Node.js system errors by checking for:
-* - SQLSTATE codes (5-character alphanumeric codes like '23505', '42601')
-* - pg-specific properties (constraint, table, column, hint, etc.) that Node.js errors don't have
-*
-* Node.js system errors (ECONNREFUSED, ETIMEDOUT, etc.) are excluded to prevent false positives.
-*/
-function isPostgresError(error) {
-	if (!(error instanceof Error)) return false;
-	const pgError = error;
-	if (pgError.code && isPostgresSqlState(pgError.code)) return true;
-	return PG_ERROR_PROPERTIES.some((prop) => pgError[prop] !== void 0);
-}
-/**
-* Checks if an error is an "already connected" error from pg.Client.connect().
-* When calling connect() on an already-connected client, pg throws an error that can be safely ignored.
-*/
-function isAlreadyConnectedError(error) {
-	if (!(error instanceof Error)) return false;
-	const message = error.message.toLowerCase();
-	return message.includes("already") && message.includes("connected");
-}
-/**
-* Checks if an error code is a Postgres SQLSTATE (5-character alphanumeric code).
-* SQLSTATE codes are standardized SQL error codes (e.g., '23505' for unique violation).
-*/
-function isPostgresSqlState(code) {
-	if (!code) return false;
-	return /^[A-Z0-9]{5}$/.test(code);
-}
-/**
-* Normalizes a Postgres error into a SQL-shared error type.
-*
-* - Postgres SQLSTATE errors (5-char codes like '23505') → SqlQueryError
-* - Connection errors (ECONNRESET, ETIMEDOUT, etc.) → SqlConnectionError
-* - Unknown errors → returns the original error as-is
-*
-* The original error is preserved via Error.cause to maintain stack traces.
-*
-* @param error - The error to normalize (typically from pg library)
-* @returns SqlQueryError for query-related failures
-* @returns SqlConnectionError for connection-related failures
-* @returns The original error if it cannot be normalized
-*/
-function normalizePgError(error) {
-	if (!(error instanceof Error)) return new Error(String(error));
-	const pgError = error;
-	if (isPostgresSqlState(pgError.code)) {
-		const options = {
-			cause: error,
-			sqlState: pgError.code
-		};
-		if (pgError.constraint !== void 0) options.constraint = pgError.constraint;
-		if (pgError.table !== void 0) options.table = pgError.table;
-		if (pgError.column !== void 0) options.column = pgError.column;
-		if (pgError.detail !== void 0) options.detail = pgError.detail;
-		return new SqlQueryError(error.message, options);
-	}
-	if (isConnectionError(error)) return new SqlConnectionError(error.message, {
-		cause: error,
-		transient: isTransientConnectionError(error)
-	});
-	return error;
-}
-
-//#endregion
-export { postgresDriverDescriptorMeta as i, isPostgresError as n, normalizePgError as r, isAlreadyConnectedError as t };
-//# sourceMappingURL=normalize-error-BU6yV-XB.mjs.map

package/dist/normalize-error-BU6yV-XB.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize-error-BU6yV-XB.mjs","names":["options: {\n      cause: Error;\n      sqlState: string;\n      constraint?: string;\n      table?: string;\n      column?: string;\n      detail?: string;\n    }"],"sources":["../src/core/descriptor-meta.ts","../src/normalize-error.ts"],"sourcesContent":["export const postgresDriverDescriptorMeta = {\n  kind: 'driver',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n","import { SqlConnectionError, SqlQueryError } from '@prisma-next/sql-errors';\n\n/**\n * Postgres error shape from the pg library.\n *\n * Note: The pg library doesn't export a DatabaseError type or interface, but errors\n * thrown by pg.query() and pg.Client have this shape at runtime. We define this\n * interface to match the actual runtime structure documented in the pg library\n * (https://github.com/brianc/node-postgres/blob/master/packages/pg/lib/errors.js).\n *\n * The @types/pg package also doesn't provide comprehensive error type definitions,\n * so we define our own interface based on the runtime error properties.\n */\ninterface PostgresError extends Error {\n  readonly code?: string;\n  readonly constraint?: string;\n  readonly table?: string;\n  readonly column?: string;\n  readonly detail?: string;\n  readonly hint?: string;\n  readonly position?: string;\n  readonly internalPosition?: string;\n  readonly internalQuery?: string;\n  readonly where?: string;\n  readonly schema?: string;\n  readonly file?: string;\n  readonly line?: string;\n  readonly routine?: string;\n}\n\n/**\n * Checks if an error is a connection-related error.\n */\nfunction isConnectionError(error: Error): boolean {\n  const code = (error as { code?: string }).code;\n  if (code) {\n    // Node.js error codes for connection issues\n    if (\n      code === 'ECONNRESET' ||\n      code === 'ETIMEDOUT' ||\n      code === 'ECONNREFUSED' ||\n      code === 'ENOTFOUND' ||\n      code === 'EHOSTUNREACH'\n    ) {\n      return true;\n    }\n  }\n\n  // Check error message for connection-related strings\n  const message = error.message.toLowerCase();\n  if (\n    message.includes('connection terminated') ||\n    message.includes('connection closed') ||\n    message.includes('connection refused') ||\n    message.includes('connection timeout') ||\n    message.includes('connection reset')\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Checks if a connection error is transient (might succeed on retry).\n */\nfunction isTransientConnectionError(error: Error): boolean {\n  const code = (error as { code?: string }).code;\n  if (code) {\n    // Timeouts and connection resets are often transient\n    if (code === 'ETIMEDOUT' || code === 'ECONNRESET') {\n      return true;\n    }\n    // Connection refused is usually not transient (server is down)\n    if (code === 'ECONNREFUSED') {\n      return false;\n    }\n  }\n\n  const message = error.message.toLowerCase();\n  if (message.includes('timeout') || message.includes('connection reset')) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * PostgreSQL-specific error properties that indicate an error originated from pg library.\n * These properties are not present on Node.js system errors.\n * Excludes generic properties like 'detail', 'file', 'line', and 'position' that could appear on any error.\n */\nconst PG_ERROR_PROPERTIES = [\n  'constraint',\n  'table',\n  'column',\n  'hint',\n  'internalPosition',\n  'internalQuery',\n  'where',\n  'schema',\n  'routine',\n] as const;\n\n/**\n * Type predicate to check if an error is a Postgres error from the pg library.\n *\n * Distinguishes pg library errors from Node.js system errors by checking for:\n * - SQLSTATE codes (5-character alphanumeric codes like '23505', '42601')\n * - pg-specific properties (constraint, table, column, hint, etc.) that Node.js errors don't have\n *\n * Node.js system errors (ECONNREFUSED, ETIMEDOUT, etc.) are excluded to prevent false positives.\n */\nexport function isPostgresError(error: unknown): error is PostgresError {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n\n  const pgError = error as PostgresError;\n\n  // Check for SQLSTATE code (5-character alphanumeric) - primary indicator of pg errors\n  if (pgError.code && isPostgresSqlState(pgError.code)) {\n    return true;\n  }\n\n  // Check for pg-specific properties that Node.js system errors don't have\n  // These properties indicate the error originated from pg library query execution\n  return PG_ERROR_PROPERTIES.some((prop) => pgError[prop] !== undefined);\n}\n\n/**\n * Checks if an error is an \"already connected\" error from pg.Client.connect().\n * When calling connect() on an already-connected client, pg throws an error that can be safely ignored.\n */\nexport function isAlreadyConnectedError(error: unknown): error is Error {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n  const message = error.message.toLowerCase();\n  return message.includes('already') && message.includes('connected');\n}\n\n/**\n * Checks if an error code is a Postgres SQLSTATE (5-character alphanumeric code).\n * SQLSTATE codes are standardized SQL error codes (e.g., '23505' for unique violation).\n */\nfunction isPostgresSqlState(code: string | undefined): boolean {\n  if (!code) {\n    return false;\n  }\n  // Postgres SQLSTATE codes are 5-character alphanumeric strings\n  // Examples: '23505' (unique violation), '42501' (insufficient privilege), '42601' (syntax error)\n  return /^[A-Z0-9]{5}$/.test(code);\n}\n\n/**\n * Normalizes a Postgres error into a SQL-shared error type.\n *\n * - Postgres SQLSTATE errors (5-char codes like '23505') → SqlQueryError\n * - Connection errors (ECONNRESET, ETIMEDOUT, etc.) → SqlConnectionError\n * - Unknown errors → returns the original error as-is\n *\n * The original error is preserved via Error.cause to maintain stack traces.\n *\n * @param error - The error to normalize (typically from pg library)\n * @returns SqlQueryError for query-related failures\n * @returns SqlConnectionError for connection-related failures\n * @returns The original error if it cannot be normalized\n */\nexport function normalizePgError(error: unknown): SqlQueryError | SqlConnectionError | Error {\n  if (!(error instanceof Error)) {\n    // Wrap non-Error values in an Error object\n    return new Error(String(error));\n  }\n\n  const pgError = error as PostgresError;\n\n  // Check for Postgres SQLSTATE (query errors)\n  if (isPostgresSqlState(pgError.code)) {\n    // isPostgresSqlState ensures code is defined and is a valid SQLSTATE\n    // biome-ignore lint/style/noNonNullAssertion: isPostgresSqlState guarantees code is defined\n    const sqlState = pgError.code!;\n    const options: {\n      cause: Error;\n      sqlState: string;\n      constraint?: string;\n      table?: string;\n      column?: string;\n      detail?: string;\n    } = {\n      cause: error,\n      sqlState,\n    };\n    if (pgError.constraint !== undefined) {\n      options.constraint = pgError.constraint;\n    }\n    if (pgError.table !== undefined) {\n      options.table = pgError.table;\n    }\n    if (pgError.column !== undefined) {\n      options.column = pgError.column;\n    }\n    if (pgError.detail !== undefined) {\n      options.detail = pgError.detail;\n    }\n    return new SqlQueryError(error.message, options);\n  }\n\n  // Check for connection errors\n  if (isConnectionError(error)) {\n    return new SqlConnectionError(error.message, {\n      cause: error,\n      transient: isTransientConnectionError(error),\n    });\n  }\n\n  // Unknown error - return as-is to preserve original error and stack trace\n  return error;\n}\n"],"mappings":";;;AAAA,MAAa,+BAA+B;CAC1C,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CACjB;;;;;;;AC0BD,SAAS,kBAAkB,OAAuB;CAChD,MAAM,OAAQ,MAA4B;AAC1C,KAAI,MAEF;MACE,SAAS,gBACT,SAAS,eACT,SAAS,kBACT,SAAS,eACT,SAAS,eAET,QAAO;;CAKX,MAAM,UAAU,MAAM,QAAQ,aAAa;AAC3C,KACE,QAAQ,SAAS,wBAAwB,IACzC,QAAQ,SAAS,oBAAoB,IACrC,QAAQ,SAAS,qBAAqB,IACtC,QAAQ,SAAS,qBAAqB,IACtC,QAAQ,SAAS,mBAAmB,CAEpC,QAAO;AAGT,QAAO;;;;;AAMT,SAAS,2BAA2B,OAAuB;CACzD,MAAM,OAAQ,MAA4B;AAC1C,KAAI,MAAM;AAER,MAAI,SAAS,eAAe,SAAS,aACnC,QAAO;AAGT,MAAI,SAAS,eACX,QAAO;;CAIX,MAAM,UAAU,MAAM,QAAQ,aAAa;AAC3C,KAAI,QAAQ,SAAS,UAAU,IAAI,QAAQ,SAAS,mBAAmB,CACrE,QAAO;AAGT,QAAO;;;;;;;AAQT,MAAM,sBAAsB;CAC1B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;;;;;;;AAWD,SAAgB,gBAAgB,OAAwC;AACtE,KAAI,EAAE,iBAAiB,OACrB,QAAO;CAGT,MAAM,UAAU;AAGhB,KAAI,QAAQ,QAAQ,mBAAmB,QAAQ,KAAK,CAClD,QAAO;AAKT,QAAO,oBAAoB,MAAM,SAAS,QAAQ,UAAU,OAAU;;;;;;AAOxE,SAAgB,wBAAwB,OAAgC;AACtE,KAAI,EAAE,iBAAiB,OACrB,QAAO;CAET,MAAM,UAAU,MAAM,QAAQ,aAAa;AAC3C,QAAO,QAAQ,SAAS,UAAU,IAAI,QAAQ,SAAS,YAAY;;;;;;AAOrE,SAAS,mBAAmB,MAAmC;AAC7D,KAAI,CAAC,KACH,QAAO;AAIT,QAAO,gBAAgB,KAAK,KAAK;;;;;;;;;;;;;;;;AAiBnC,SAAgB,iBAAiB,OAA4D;AAC3F,KAAI,EAAE,iBAAiB,OAErB,QAAO,IAAI,MAAM,OAAO,MAAM,CAAC;CAGjC,MAAM,UAAU;AAGhB,KAAI,mBAAmB,QAAQ,KAAK,EAAE;EAIpC,MAAMA,UAOF;GACF,OAAO;GACP,UAVe,QAAQ;GAWxB;AACD,MAAI,QAAQ,eAAe,OACzB,SAAQ,aAAa,QAAQ;AAE/B,MAAI,QAAQ,UAAU,OACpB,SAAQ,QAAQ,QAAQ;AAE1B,MAAI,QAAQ,WAAW,OACrB,SAAQ,SAAS,QAAQ;AAE3B,MAAI,QAAQ,WAAW,OACrB,SAAQ,SAAS,QAAQ;AAE3B,SAAO,IAAI,cAAc,MAAM,SAAS,QAAQ;;AAIlD,KAAI,kBAAkB,MAAM,CAC1B,QAAO,IAAI,mBAAmB,MAAM,SAAS;EAC3C,OAAO;EACP,WAAW,2BAA2B,MAAM;EAC7C,CAAC;AAIJ,QAAO"}

package/dist/runtime.d.mts

@@ -1,39 +0,0 @@
-import { Client, Pool, QueryResult as QueryResult$1, QueryResultRow } from "pg";
-import { RuntimeDriverDescriptor, RuntimeDriverInstance } from "@prisma-next/core-execution-plane/types";
-import { SqlDriver } from "@prisma-next/sql-relational-core/ast";
-
-//#region src/postgres-driver.d.ts
-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;
-//#endregion
-//#region src/exports/runtime.d.ts
-/**
- * Postgres runtime driver instance interface.
- * SqlDriver provides SQL-specific methods (execute, explain, close).
- * RuntimeDriverInstance provides target identification (familyId, targetId).
- * We use intersection type to combine both interfaces.
- */
-type PostgresRuntimeDriver = RuntimeDriverInstance<'sql', 'postgres'> & SqlDriver;
-/**
- * Postgres driver descriptor for runtime plane.
- */
-declare const postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<'sql', 'postgres', PostgresRuntimeDriver>;
-//#endregion
-export { type CreatePostgresDriverOptions, type PostgresDriverOptions, PostgresRuntimeDriver, type QueryResult, createPostgresDriver, createPostgresDriverFromOptions, postgresRuntimeDriverDescriptor as default };
-//# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/postgres-driver.ts","../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;;KAkBY,sBAAsB,iBAAiB,kBAAkB,cAAc;UAElE,qBAAA;EAFL,SAAA,OAAW,EAAA;IAAW,MAAA,EAGJ,MAHI;EAAiB,CAAA,GAAA;IAAgC,IAAA,EAGlC,IAHkC;EAAd,CAAA;EAAa,SAAA,MAAA,CAAA,EAAA;IAEjE,SAAA,SAAA,CAAA,EAAqB,MAAA;IAyLrB,SAAA,QAAA,CAAA,EAAA,OAA2B;EAK5B,CAAA,GAAA,SAAA;AAYhB;UAjBiB,2BAAA;oBACG;gCACY;AChMhC;AAKM,iBD8LU,oBAAA,CCrLf,gBANC,EAAA,MAAA,EAAA,OAH4D,CAAvB,EDgM3B,2BChMkD,CAAA,EDiM3D,SCjM2D;iBD0M9C,+BAAA,UAAyC,wBAAwB;;;;;;AA5MjF;;;AAAmF,KCHvE,qBAAA,GAAwB,qBDG+C,CAAA,KAAA,EAAA,UAAA,CAAA,GCHJ,SDGI;;;AAEnF;AAyLA,cCzLM,+BD0Lc,EC1LmB,uBD2LP,CAAA,KAAI,EAAA,UAAA,ECxLlC,qBDwLkC,CAAA"}

package/dist/runtime.mjs

@@ -1,147 +0,0 @@
-import { i as postgresDriverDescriptorMeta, n as isPostgresError, r as normalizePgError, t as isAlreadyConnectedError } from "./normalize-error-BU6yV-XB.mjs";
-import { Pool } from "pg";
-import Cursor from "pg-cursor";
-
-//#region src/callback-to-promise.ts
-function callbackToPromise(fn) {
-	return new Promise((resolve, reject) => {
-		fn((err, result) => {
-			if (err) {
-				reject(err);
-				return;
-			}
-			resolve(result);
-		});
-	});
-}
-
-//#endregion
-//#region src/postgres-driver.ts
-const 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;
-				if (isPostgresError(cursorError)) throw normalizePgError(cursorError);
-			}
-			for await (const row of this.executeBuffered(client, request.sql, request.params)) yield row;
-		} catch (error) {
-			throw normalizePgError(error);
-		} finally {
-			await this.releaseClient(client);
-		}
-	}
-	async explain(request) {
-		const text = `EXPLAIN (FORMAT JSON) ${request.sql}`;
-		const client = await this.acquireClient();
-		try {
-			return { rows: (await client.query(text, request.params)).rows };
-		} catch (error) {
-			throw normalizePgError(error);
-		} finally {
-			await this.releaseClient(client);
-		}
-	}
-	async query(sql, params) {
-		const client = await this.acquireClient();
-		try {
-			return await client.query(sql, params);
-		} catch (error) {
-			throw normalizePgError(error);
-		} finally {
-			await this.releaseClient(client);
-		}
-	}
-	async close() {
-		if (this.pool) {
-			if (!this.pool.ended) await this.pool.end();
-		}
-		if (this.directClient) {
-			const client = this.directClient;
-			if (!client._ending) await client.end();
-		}
-	}
-	async acquireClient() {
-		if (this.pool) return this.pool.connect();
-		if (this.directClient) {
-			const client = this.directClient;
-			if (!(client._connection !== void 0 && client._connection !== null && !client._ending)) try {
-				await this.directClient.connect();
-			} catch (error) {
-				if (!isAlreadyConnectedError(error)) 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) {
-	return new PostgresDriverImpl({
-		connect: { pool: new (options?.poolFactory ?? Pool)({ connectionString }) },
-		cursor: options?.cursor
-	});
-}
-function createPostgresDriverFromOptions(options) {
-	return new PostgresDriverImpl(options);
-}
-function readCursor(cursor, size) {
-	return callbackToPromise((cb) => {
-		cursor.read(size, (err, rows) => cb(err, rows));
-	});
-}
-function closeCursor(cursor) {
-	return callbackToPromise((cb) => cursor.close(cb));
-}
-
-//#endregion
-//#region src/exports/runtime.ts
-/**
-* Postgres driver descriptor for runtime plane.
-*/
-const postgresRuntimeDriverDescriptor = {
-	...postgresDriverDescriptorMeta,
-	create(options) {
-		return createPostgresDriverFromOptions(options);
-	}
-};
-var runtime_default = postgresRuntimeDriverDescriptor;
-
-//#endregion
-export { createPostgresDriver, createPostgresDriverFromOptions, runtime_default as default };
-//# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.mjs","names":["error: unknown","postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<\n  'sql',\n  'postgres',\n  PostgresRuntimeDriver\n>"],"sources":["../src/callback-to-promise.ts","../src/postgres-driver.ts","../src/exports/runtime.ts"],"sourcesContent":["/**\n * Wraps a Node-style callback function into a Promise.\n * Supports both (err) => void and (err, result) => void patterns.\n */\nexport function callbackToPromise(\n  fn: (callback: (err: Error | null | undefined) => void) => void,\n): Promise<void>;\nexport function callbackToPromise<T>(\n  fn: (callback: (err: Error | null | undefined, result: T) => void) => void,\n): Promise<T>;\nexport function callbackToPromise<T = void>(\n  fn: (callback: (err: Error | null | undefined, result?: T) => void) => void,\n): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    fn((err, result) => {\n      if (err) {\n        reject(err);\n        return;\n      }\n      resolve(result as T);\n    });\n  });\n}\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';\nimport { callbackToPromise } from './callback-to-promise';\nimport { isAlreadyConnectedError, isPostgresError, normalizePgError } from './normalize-error';\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          // Check if this is a pg error - if so, normalize and throw\n          // Otherwise, fall back to buffered mode for cursor-specific errors\n          if (isPostgresError(cursorError)) {\n            throw normalizePgError(cursorError);\n          }\n          // Not a pg error - cursor-specific error, fall back to buffered mode\n        }\n      }\n\n      for await (const row of this.executeBuffered(client, request.sql, request.params)) {\n        yield row as Row;\n      }\n    } catch (error) {\n      throw normalizePgError(error);\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    } catch (error) {\n      throw normalizePgError(error);\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    } catch (error) {\n      throw normalizePgError(error);\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    if (this.directClient) {\n      const client = this.directClient as Client & { _ending?: boolean };\n      if (!client._ending) {\n        await client.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      // Check if client is already connected before attempting to connect\n      // This prevents hanging when the database only supports a single connection\n      // pg's Client has internal connection state that we can check\n      const client = this.directClient as Client & {\n        _ending?: boolean;\n        _connection?: unknown;\n      };\n      const isConnected =\n        client._connection !== undefined && client._connection !== null && !client._ending;\n\n      // Only connect if not already connected\n      // If caller provided a connected client (e.g., in tests), use it as-is\n      if (!isConnected) {\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 (!isAlreadyConnectedError(error)) {\n            throw error;\n          }\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 callbackToPromise<Row[]>((cb) => {\n    cursor.read(size, (err, rows) => cb(err, rows));\n  });\n}\n\nfunction closeCursor(cursor: Cursor<unknown>): Promise<void> {\n  return callbackToPromise((cb) => cursor.close(cb));\n}\n","import type {\n  RuntimeDriverDescriptor,\n  RuntimeDriverInstance,\n} from '@prisma-next/core-execution-plane/types';\nimport type { SqlDriver } from '@prisma-next/sql-relational-core/ast';\nimport { postgresDriverDescriptorMeta } from '../core/descriptor-meta';\nimport type { PostgresDriverOptions } from '../postgres-driver';\nimport { createPostgresDriverFromOptions } from '../postgres-driver';\n\n/**\n * Postgres runtime driver instance interface.\n * SqlDriver provides SQL-specific methods (execute, explain, close).\n * RuntimeDriverInstance provides target identification (familyId, targetId).\n * We use intersection type to combine both interfaces.\n */\nexport type PostgresRuntimeDriver = RuntimeDriverInstance<'sql', 'postgres'> & SqlDriver;\n\n/**\n * Postgres driver descriptor for runtime plane.\n */\nconst postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<\n  'sql',\n  'postgres',\n  PostgresRuntimeDriver\n> = {\n  ...postgresDriverDescriptorMeta,\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"],"mappings":"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"}