@prisma-next/driver-postgres 0.3.0-dev.4 → 0.3.0-dev.41

package/src/postgres-driver.ts

@@ -0,0 +1,403 @@
+import type {
+  SqlConnection,
+  SqlDriver,
+  SqlDriverState,
+  SqlExecuteRequest,
+  SqlExplainResult,
+  SqlQueryable,
+  SqlQueryResult,
+  SqlTransaction,
+} from '@prisma-next/sql-relational-core/ast';
+import type {
+  Client,
+  QueryResult as PgQueryResult,
+  PoolClient,
+  Pool as PoolType,
+  QueryResultRow,
+} from 'pg';
+import { Pool } from 'pg';
+import Cursor from 'pg-cursor';
+import { callbackToPromise } from './callback-to-promise';
+import { isAlreadyConnectedError, isPostgresError, normalizePgError } from './normalize-error';
+
+export type QueryResult<T extends QueryResultRow = QueryResultRow> = PgQueryResult<T>;
+
+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?: PostgresCursorOptions | undefined;
+}
+
+export type PostgresDriverCreateOptions = Omit<PostgresDriverOptions, 'connect'>;
+
+const DEFAULT_BATCH_SIZE = 100;
+
+type ConnectionOptions =
+  | { readonly cursorDisabled: true }
+  | { readonly cursorBatchSize: number; readonly cursorDisabled: false };
+
+class AsyncMutex {
+  #queue = Promise.resolve();
+
+  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>;
+
+  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.options.cursorDisabled) {
+        try {
+          for await (const row of this.executeWithCursor(
+            client,
+            request.sql,
+            request.params,
+            this.options.cursorBatchSize,
+          )) {
+            yield row as Row;
+          }
+          return;
+        } catch (cursorError) {
+          if (!(cursorError instanceof Error)) {
+            throw cursorError;
+          }
+          // Check if this is a pg error - if so, normalize and throw
+          // Otherwise, fall back to buffered mode for cursor-specific errors
+          if (isPostgresError(cursorError)) {
+            throw normalizePgError(cursorError);
+          }
+          // Not a pg error - cursor-specific error, fall back to buffered mode
+        }
+      }
+
+      for await (const row of this.executeBuffered(client, request.sql, request.params)) {
+        yield row as Row;
+      }
+    } catch (error) {
+      throw normalizePgError(error);
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+
+  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)
+        .catch(rethrowNormalizedError);
+      return { rows: result.rows as ReadonlyArray<Record<string, unknown>> };
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+
+  async query<Row = Record<string, unknown>>(
+    sql: string,
+    params?: readonly unknown[],
+  ): Promise<SqlQueryResult<Row>> {
+    const client = await this.acquireClient();
+    try {
+      const result = await client
+        .query(sql, params as unknown[] | undefined)
+        .catch(rethrowNormalizedError);
+      return result as unknown as SqlQueryResult<Row>;
+    } finally {
+      await this.releaseClient(client);
+    }
+  }
+
+  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, cursorBatchSize);
+        if (rows.length === 0) {
+          break;
+        }
+
+        for (const row of rows) {
+          yield row;
+        }
+      }
+    } finally {
+      await closeCursor(cursor);
+    }
+  }
+
+  private async *executeBuffered(
+    client: PoolClient | Client,
+    sql: string,
+    params: readonly unknown[] | undefined,
+  ): AsyncIterable<Record<string, unknown>> {
+    const result = await client.query(sql, params as unknown[] | undefined);
+    for (const row of result.rows as Record<string, unknown>[]) {
+      yield row;
+    }
+  }
+}
+
+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;
+  }
+}
+
+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);
+  }
+}
+
+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[]> {
+  return callbackToPromise<Row[]>((cb) => {
+    cursor.read(size, (err, rows) => cb(err, rows));
+  });
+}
+
+function closeCursor(cursor: Cursor<unknown>): Promise<void> {
+  return callbackToPromise((cb) => cursor.close(cb));
+}
+
+function rethrowNormalizedError(error: unknown): never {
+  throw normalizePgError(error);
+}

package/dist/exports/chunk-GGJ2L556.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-GGJ2L556.js.map

package/dist/exports/chunk-GGJ2L556.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/exports/control.d.ts

@@ -1,27 +0,0 @@
-import { 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.
- */
-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 { PostgresControlDriver, postgresDriverDescriptor as default };

package/dist/exports/control.js

@@ -1,66 +0,0 @@
-import {
-  normalizePgError,
-  postgresDriverDescriptorMeta
-} from "./chunk-GGJ2L556.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

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

@@ -1,36 +0,0 @@
-import { RuntimeDriverDescriptor, RuntimeDriverInstance } from '@prisma-next/core-execution-plane/types';
-import { SqlDriver } from '@prisma-next/sql-relational-core/ast';
-import { Client, Pool, QueryResultRow, QueryResult as QueryResult$1 } from 'pg';
-
-type QueryResult<T extends QueryResultRow = QueryResultRow> = QueryResult$1<T>;
-interface PostgresDriverOptions {
-    readonly connect: {
-        client: Client;
-    } | {
-        pool: Pool;
-    };
-    readonly cursor?: {
-        readonly batchSize?: number;
-        readonly disabled?: boolean;
-    } | undefined;
-}
-interface CreatePostgresDriverOptions {
-    readonly cursor?: PostgresDriverOptions['cursor'];
-    readonly poolFactory?: typeof Pool;
-}
-declare function createPostgresDriver(connectionString: string, options?: CreatePostgresDriverOptions): SqlDriver;
-declare function createPostgresDriverFromOptions(options: PostgresDriverOptions): SqlDriver;
-
-/**
- * Postgres runtime driver instance interface.
- * SqlDriver provides SQL-specific methods (execute, explain, close).
- * RuntimeDriverInstance provides target identification (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>;
-
-export { type CreatePostgresDriverOptions, type PostgresDriverOptions, type PostgresRuntimeDriver, type QueryResult, createPostgresDriver, createPostgresDriverFromOptions, postgresRuntimeDriverDescriptor as default };