@prisma-next/driver-postgres 0.3.0-dev.6 → 0.3.0-dev.64

package/src/postgres-driver.ts

@@ -1,8 +1,12 @@
 import type {
+  SqlConnection,
   SqlDriver,
+  SqlDriverState,
   SqlExecuteRequest,
   SqlExplainResult,
+  SqlQueryable,
   SqlQueryResult,
+  SqlTransaction,
 } from '@prisma-next/sql-relational-core/ast';
 import type {
   Client,
@@ -18,47 +22,69 @@ import { isAlreadyConnectedError, isPostgresError, normalizePgError } from './no
 
 export type QueryResult<T extends QueryResultRow = QueryResultRow> = PgQueryResult<T>;
 
-export interface PostgresDriverOptions {
+export type PostgresBinding =
+  | { readonly kind: 'url'; readonly url: string }
+  | { readonly kind: 'pgPool'; readonly pool: PoolType }
+  | { readonly kind: 'pgClient'; readonly client: Client };
+
+export interface PostgresCursorOptions {
+  readonly batchSize?: number;
+  readonly disabled?: boolean;
+}
+
+interface PostgresDriverOptions {
   readonly connect: { client: Client } | { pool: PoolType };
-  readonly cursor?:
-    | {
-        readonly batchSize?: number;
-        readonly disabled?: boolean;
-      }
-    | undefined;
+  readonly cursor?: PostgresCursorOptions | undefined;
 }
 
+export type PostgresDriverCreateOptions = Omit<PostgresDriverOptions, 'connect'>;
+
 const DEFAULT_BATCH_SIZE = 100;
 
-class PostgresDriverImpl implements SqlDriver {
-  private readonly pool: PoolType | undefined;
-  private readonly directClient: Client | undefined;
-  private readonly cursorBatchSize: number;
-  private readonly cursorDisabled: boolean;
-
-  constructor(options: PostgresDriverOptions) {
-    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');
-    }
+type ConnectionOptions =
+  | { readonly cursorDisabled: true }
+  | { readonly cursorBatchSize: number; readonly cursorDisabled: false };
+
+class AsyncMutex {
+  #queue = Promise.resolve();
 
-    this.cursorBatchSize = options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE;
-    this.cursorDisabled = options.cursor?.disabled ?? false;
+  async lock(): Promise<() => void> {
+    const previous = this.#queue;
+    let releaseLock: (() => void) | undefined;
+    this.#queue = new Promise<void>((resolve) => {
+      releaseLock = resolve;
+    });
+    await previous;
+    return () => {
+      releaseLock?.();
+      releaseLock = undefined;
+    };
   }
+}
+
+abstract class PostgresQueryable<C extends PoolClient | Client = PoolClient | Client>
+  implements SqlQueryable
+{
+  abstract acquireClient(): Promise<C>;
+  abstract releaseClient(client: C): Promise<void>;
 
-  async connect(): Promise<void> {
-    // No-op: caller controls connecting the underlying client or pool
+  protected readonly options: ConnectionOptions;
+
+  constructor(options: ConnectionOptions) {
+    this.options = options;
   }
 
   async *execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row> {
     const client = await this.acquireClient();
     try {
-      if (!this.cursorDisabled) {
+      if (!this.options.cursorDisabled) {
         try {
-          for await (const row of this.executeWithCursor(client, request.sql, request.params)) {
+          for await (const row of this.executeWithCursor(
+            client,
+            request.sql,
+            request.params,
+            this.options.cursorBatchSize,
+          )) {
             yield row as Row;
           }
           return;
@@ -86,13 +112,15 @@ class PostgresDriverImpl implements SqlDriver {
   }
 
   async explain(request: SqlExecuteRequest): Promise<SqlExplainResult> {
+    // SQL is generated by Prisma Next planners (or validated raw paths), so
+    // EXPLAIN prefixing preserves the same statement semantics.
     const text = `EXPLAIN (FORMAT JSON) ${request.sql}`;
     const client = await this.acquireClient();
     try {
-      const result = await client.query(text, request.params as unknown[] | undefined);
+      const result = await client
+        .query(text, request.params as unknown[] | undefined)
+        .catch(rethrowNormalizedError);
       return { rows: result.rows as ReadonlyArray<Record<string, unknown>> };
-    } catch (error) {
-      throw normalizePgError(error);
     } finally {
       await this.releaseClient(client);
     }
@@ -104,80 +132,26 @@ class PostgresDriverImpl implements SqlDriver {
   ): Promise<SqlQueryResult<Row>> {
     const client = await this.acquireClient();
     try {
-      const result = await client.query(sql, params as unknown[] | undefined);
+      const result = await client
+        .query(sql, params as unknown[] | undefined)
+        .catch(rethrowNormalizedError);
       return result as unknown as SqlQueryResult<Row>;
-    } catch (error) {
-      throw normalizePgError(error);
     } finally {
       await this.releaseClient(client);
     }
   }
 
-  async close(): Promise<void> {
-    if (this.pool) {
-      // Check if pool is already closed to avoid "Called end on pool more than once" error
-      // pg Pool has an 'ended' property that indicates if the pool has been closed
-      if (!(this.pool as { ended?: boolean }).ended) {
-        await this.pool.end();
-      }
-    }
-    if (this.directClient) {
-      const client = this.directClient as Client & { _ending?: boolean };
-      if (!client._ending) {
-        await client.end();
-      }
-    }
-  }
-
-  private async acquireClient(): Promise<PoolClient | Client> {
-    if (this.pool) {
-      return this.pool.connect();
-    }
-    if (this.directClient) {
-      // Check if client is already connected before attempting to connect
-      // This prevents hanging when the database only supports a single connection
-      // pg's Client has internal connection state that we can check
-      const client = this.directClient as Client & {
-        _ending?: boolean;
-        _connection?: unknown;
-      };
-      const isConnected =
-        client._connection !== undefined && client._connection !== null && !client._ending;
-
-      // Only connect if not already connected
-      // If caller provided a connected client (e.g., in tests), use it as-is
-      if (!isConnected) {
-        try {
-          await this.directClient.connect();
-        } catch (error: unknown) {
-          // If already connected, pg throws an error - ignore it and proceed
-          // Re-throw other errors (actual connection failures)
-          if (!isAlreadyConnectedError(error)) {
-            throw error;
-          }
-        }
-      }
-      return this.directClient;
-    }
-    throw new Error('PostgresDriver requires a pool or client');
-  }
-
-  private async releaseClient(client: PoolClient | Client): Promise<void> {
-    if (this.pool) {
-      (client as PoolClient).release();
-    }
-  }
-
   private async *executeWithCursor(
     client: PoolClient | Client,
     sql: string,
     params: readonly unknown[] | undefined,
+    cursorBatchSize: number,
   ): AsyncIterable<Record<string, unknown>> {
     const cursor = client.query(new Cursor(sql, params as unknown[] | undefined));
 
     try {
       while (true) {
-        const rows = await readCursor(cursor, this.cursorBatchSize);
+        const rows = await readCursor(cursor, cursorBatchSize);
         if (rows.length === 0) {
           break;
         }
@@ -203,25 +177,215 @@ class PostgresDriverImpl implements SqlDriver {
   }
 }
 
-export interface CreatePostgresDriverOptions {
-  readonly cursor?: PostgresDriverOptions['cursor'];
-  readonly poolFactory?: typeof Pool;
+class PostgresConnectionImpl extends PostgresQueryable implements SqlConnection {
+  #connection: PoolClient | Client;
+  #onRelease: (() => void) | undefined;
+
+  constructor(connection: PoolClient | Client, options: ConnectionOptions, onRelease?: () => void) {
+    super(options);
+    this.#connection = connection;
+    this.#onRelease = onRelease;
+  }
+
+  override acquireClient(): Promise<PoolClient | Client> {
+    return Promise.resolve(this.#connection);
+  }
+
+  override releaseClient(_client: PoolClient | Client): Promise<void> {
+    return Promise.resolve();
+  }
+
+  async beginTransaction(): Promise<SqlTransaction> {
+    await this.#connection.query('BEGIN').catch(rethrowNormalizedError);
+    return new PostgresTransactionImpl(this.#connection, this.options);
+  }
+
+  async release(): Promise<void> {
+    if ('release' in this.#connection) {
+      this.#connection.release();
+    }
+    this.#onRelease?.();
+    this.#onRelease = undefined;
+  }
 }
 
-export function createPostgresDriver(
-  connectionString: string,
-  options?: CreatePostgresDriverOptions,
-): SqlDriver {
-  const PoolImpl: typeof Pool = options?.poolFactory ?? Pool;
-  const pool = new PoolImpl({ connectionString });
-  return new PostgresDriverImpl({
-    connect: { pool },
-    cursor: options?.cursor,
-  });
+class PostgresTransactionImpl extends PostgresQueryable implements SqlTransaction {
+  #connection: PoolClient | Client;
+
+  constructor(connection: PoolClient | Client, options: ConnectionOptions) {
+    super(options);
+    this.#connection = connection;
+  }
+
+  override acquireClient(): Promise<PoolClient | Client> {
+    return Promise.resolve(this.#connection);
+  }
+
+  override releaseClient(_client: PoolClient | Client): Promise<void> {
+    return Promise.resolve();
+  }
+
+  async commit(): Promise<void> {
+    await this.#connection.query('COMMIT').catch(rethrowNormalizedError);
+  }
+
+  async rollback(): Promise<void> {
+    await this.#connection.query('ROLLBACK').catch(rethrowNormalizedError);
+  }
 }
 
-export function createPostgresDriverFromOptions(options: PostgresDriverOptions): SqlDriver {
-  return new PostgresDriverImpl(options);
+class PostgresPoolDriverImpl
+  extends PostgresQueryable<PoolClient>
+  implements SqlDriver<PostgresBinding>
+{
+  private readonly pool: PoolType;
+  #closed = false;
+
+  constructor(options: PostgresDriverOptions & { connect: { pool: PoolType } }) {
+    super({
+      cursorBatchSize: options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE,
+      cursorDisabled: options.cursor?.disabled ?? false,
+    });
+    this.pool = options.connect.pool;
+  }
+
+  get state(): SqlDriverState {
+    return this.#closed ? 'closed' : 'connected';
+  }
+
+  // Bound drivers are created via createBoundDriverFromBinding with pool already
+  // configured; connect is intentionally no-op.
+  async connect(_binding: PostgresBinding): Promise<void> {}
+
+  async acquireConnection(): Promise<SqlConnection> {
+    const client = await this.acquireClient();
+    return new PostgresConnectionImpl(client, this.options);
+  }
+
+  async close(): Promise<void> {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    await this.pool.end();
+  }
+
+  async acquireClient(): Promise<PoolClient> {
+    return this.pool.connect();
+  }
+
+  async releaseClient(client: PoolClient): Promise<void> {
+    client.release();
+  }
+}
+
+class PostgresDirectDriverImpl
+  extends PostgresQueryable<Client>
+  implements SqlDriver<PostgresBinding>
+{
+  private readonly directClient: Client;
+  readonly #connectionMutex = new AsyncMutex();
+  #closed = false;
+  #connected = false;
+  #connectPromise: Promise<void> | undefined;
+
+  constructor(options: PostgresDriverOptions & { connect: { client: Client } }) {
+    super({
+      cursorBatchSize: options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE,
+      cursorDisabled: options.cursor?.disabled ?? false,
+    });
+    this.directClient = options.connect.client;
+  }
+
+  get state(): SqlDriverState {
+    return this.#closed ? 'closed' : 'connected';
+  }
+
+  // Bound drivers are created via createBoundDriverFromBinding with client already
+  // configured; connect is intentionally no-op.
+  async connect(_binding: PostgresBinding): Promise<void> {}
+
+  async acquireConnection(): Promise<SqlConnection> {
+    const releaseLease = await this.#connectionMutex.lock();
+    try {
+      const client = await this.acquireClient();
+      return new PostgresConnectionImpl(client, this.options, releaseLease);
+    } catch (error) {
+      releaseLease();
+      throw error;
+    }
+  }
+
+  async close(): Promise<void> {
+    const releaseLease = await this.#connectionMutex.lock();
+    try {
+      if (this.#closed) {
+        return;
+      }
+      this.#closed = true;
+      await this.directClient.end();
+      this.#connected = false;
+    } finally {
+      releaseLease();
+    }
+  }
+
+  async acquireClient(): Promise<Client> {
+    if (this.#connected) {
+      return this.directClient;
+    }
+    if (this.#connectPromise !== undefined) {
+      await this.#connectPromise;
+      return this.directClient;
+    }
+
+    this.#connectPromise = (async () => {
+      try {
+        await this.directClient.connect();
+      } catch (error: unknown) {
+        if (!isAlreadyConnectedError(error)) {
+          throw error;
+        }
+      } finally {
+        this.#connectPromise = undefined;
+      }
+      this.#connected = true;
+    })();
+    await this.#connectPromise;
+
+    return this.directClient;
+  }
+
+  async releaseClient(_client: Client): Promise<void> {}
+}
+
+export function createBoundDriverFromBinding(
+  binding: PostgresBinding,
+  cursorOpts: PostgresDriverCreateOptions['cursor'],
+): SqlDriver<PostgresBinding> {
+  switch (binding.kind) {
+    case 'url': {
+      const pool = new Pool({
+        connectionString: binding.url,
+        connectionTimeoutMillis: 20_000,
+        idleTimeoutMillis: 30_000,
+      });
+      return new PostgresPoolDriverImpl({
+        connect: { pool },
+        cursor: cursorOpts,
+      });
+    }
+    case 'pgPool':
+      return new PostgresPoolDriverImpl({
+        connect: { pool: binding.pool },
+        cursor: cursorOpts,
+      });
+    case 'pgClient':
+      return new PostgresDirectDriverImpl({
+        connect: { client: binding.client },
+        cursor: cursorOpts,
+      });
+  }
 }
 
 function readCursor<Row>(cursor: Cursor<Row>, size: number): Promise<Row[]> {
@@ -233,3 +397,7 @@ function readCursor<Row>(cursor: Cursor<Row>, size: number): Promise<Row[]> {
 function closeCursor(cursor: Cursor<unknown>): Promise<void> {
   return callbackToPromise((cb) => cursor.close(cb));
 }
+
+function rethrowNormalizedError(error: unknown): never {
+  throw normalizePgError(error);
+}

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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,116 +0,0 @@
-// 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

@@ -1 +0,0 @@
-{"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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}