@prisma-next/driver-postgres 0.3.0-dev.7 → 0.3.0-dev.70

package/dist/runtime.mjs

@@ -0,0 +1,339 @@
+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 AsyncMutex = class {
+	#queue = Promise.resolve();
+	async lock() {
+		const previous = this.#queue;
+		let releaseLock;
+		this.#queue = new Promise((resolve) => {
+			releaseLock = resolve;
+		});
+		await previous;
+		return () => {
+			releaseLock?.();
+			releaseLock = void 0;
+		};
+	}
+};
+var PostgresQueryable = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async *execute(request) {
+		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;
+				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).catch(rethrowNormalizedError)).rows };
+		} finally {
+			await this.releaseClient(client);
+		}
+	}
+	async query(sql, params) {
+		const client = await this.acquireClient();
+		try {
+			return await client.query(sql, params).catch(rethrowNormalizedError);
+		} finally {
+			await this.releaseClient(client);
+		}
+	}
+	async *executeWithCursor(client, sql, params, cursorBatchSize) {
+		const cursor = client.query(new Cursor(sql, params));
+		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);
+		}
+	}
+	async *executeBuffered(client, sql, params) {
+		const result = await client.query(sql, params);
+		for (const row of result.rows) yield row;
+	}
+};
+var PostgresConnectionImpl = class extends PostgresQueryable {
+	#connection;
+	#onRelease;
+	constructor(connection, options, onRelease) {
+		super(options);
+		this.#connection = connection;
+		this.#onRelease = onRelease;
+	}
+	acquireClient() {
+		return Promise.resolve(this.#connection);
+	}
+	releaseClient(_client) {
+		return Promise.resolve();
+	}
+	async beginTransaction() {
+		await this.#connection.query("BEGIN").catch(rethrowNormalizedError);
+		return new PostgresTransactionImpl(this.#connection, this.options);
+	}
+	async release() {
+		if ("release" in this.#connection) this.#connection.release();
+		this.#onRelease?.();
+		this.#onRelease = void 0;
+	}
+};
+var PostgresTransactionImpl = class extends PostgresQueryable {
+	#connection;
+	constructor(connection, options) {
+		super(options);
+		this.#connection = connection;
+	}
+	acquireClient() {
+		return Promise.resolve(this.#connection);
+	}
+	releaseClient(_client) {
+		return Promise.resolve();
+	}
+	async commit() {
+		await this.#connection.query("COMMIT").catch(rethrowNormalizedError);
+	}
+	async rollback() {
+		await this.#connection.query("ROLLBACK").catch(rethrowNormalizedError);
+	}
+};
+var PostgresPoolDriverImpl = class extends PostgresQueryable {
+	pool;
+	#closed = false;
+	constructor(options) {
+		super({
+			cursorBatchSize: options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE,
+			cursorDisabled: options.cursor?.disabled ?? false
+		});
+		this.pool = options.connect.pool;
+	}
+	get state() {
+		return this.#closed ? "closed" : "connected";
+	}
+	async connect(_binding) {}
+	async acquireConnection() {
+		return new PostgresConnectionImpl(await this.acquireClient(), this.options);
+	}
+	async close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		await this.pool.end();
+	}
+	async acquireClient() {
+		return this.pool.connect();
+	}
+	async releaseClient(client) {
+		client.release();
+	}
+};
+var PostgresDirectDriverImpl = class extends PostgresQueryable {
+	directClient;
+	#connectionMutex = new AsyncMutex();
+	#closed = false;
+	#connected = false;
+	#connectPromise;
+	constructor(options) {
+		super({
+			cursorBatchSize: options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE,
+			cursorDisabled: options.cursor?.disabled ?? false
+		});
+		this.directClient = options.connect.client;
+	}
+	get state() {
+		return this.#closed ? "closed" : "connected";
+	}
+	async connect(_binding) {}
+	async acquireConnection() {
+		const releaseLease = await this.#connectionMutex.lock();
+		try {
+			return new PostgresConnectionImpl(await this.acquireClient(), this.options, releaseLease);
+		} catch (error) {
+			releaseLease();
+			throw error;
+		}
+	}
+	async close() {
+		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() {
+		if (this.#connected) return this.directClient;
+		if (this.#connectPromise !== void 0) {
+			await this.#connectPromise;
+			return this.directClient;
+		}
+		this.#connectPromise = (async () => {
+			try {
+				await this.directClient.connect();
+			} catch (error) {
+				if (!isAlreadyConnectedError(error)) throw error;
+			} finally {
+				this.#connectPromise = void 0;
+			}
+			this.#connected = true;
+		})();
+		await this.#connectPromise;
+		return this.directClient;
+	}
+	async releaseClient(_client) {}
+};
+function createBoundDriverFromBinding(binding, cursorOpts) {
+	switch (binding.kind) {
+		case "url": return new PostgresPoolDriverImpl({
+			connect: { pool: new Pool({
+				connectionString: binding.url,
+				connectionTimeoutMillis: 2e4,
+				idleTimeoutMillis: 3e4
+			}) },
+			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(cursor, size) {
+	return callbackToPromise((cb) => {
+		cursor.read(size, (err, rows) => cb(err, rows));
+	});
+}
+function closeCursor(cursor) {
+	return callbackToPromise((cb) => cursor.close(cb));
+}
+function rethrowNormalizedError(error) {
+	throw normalizePgError(error);
+}
+
+//#endregion
+//#region src/exports/runtime.ts
+const USE_BEFORE_CONNECT_MESSAGE = "Postgres driver not connected. Call connect(binding) before acquireConnection or execute.";
+const ALREADY_CONNECTED_MESSAGE = "Postgres driver already connected. Call close() before reconnecting with a new binding.";
+function driverError(code, message, details) {
+	const error = new Error(message);
+	Object.defineProperty(error, "name", {
+		value: "RuntimeError",
+		configurable: true
+	});
+	return Object.assign(error, {
+		code,
+		category: "RUNTIME",
+		severity: "error",
+		message,
+		details
+	});
+}
+function unboundExecute() {
+	return { [Symbol.asyncIterator]() {
+		return { async next() {
+			throw driverError("DRIVER.NOT_CONNECTED", USE_BEFORE_CONNECT_MESSAGE);
+		} };
+	} };
+}
+var PostgresUnboundDriverImpl = class {
+	familyId = "sql";
+	targetId = "postgres";
+	#delegate = null;
+	#closed = false;
+	#cursorOpts;
+	constructor(cursorOpts) {
+		this.#cursorOpts = cursorOpts;
+	}
+	get state() {
+		if (this.#delegate !== null) return "connected";
+		if (this.#closed) return "closed";
+		return "unbound";
+	}
+	#requireDelegate() {
+		const delegate = this.#delegate;
+		if (delegate === null) throw driverError("DRIVER.NOT_CONNECTED", USE_BEFORE_CONNECT_MESSAGE);
+		return delegate;
+	}
+	async connect(binding) {
+		if (this.#delegate !== null) throw driverError("DRIVER.ALREADY_CONNECTED", ALREADY_CONNECTED_MESSAGE, { bindingKind: binding.kind });
+		this.#delegate = createBoundDriverFromBinding(binding, this.#cursorOpts);
+		this.#closed = false;
+	}
+	async acquireConnection() {
+		return this.#requireDelegate().acquireConnection();
+	}
+	async close() {
+		const delegate = this.#delegate;
+		if (delegate !== null) {
+			this.#delegate = null;
+			await delegate.close();
+		}
+		this.#closed = true;
+	}
+	execute(request) {
+		const delegate = this.#delegate;
+		if (delegate === null) return unboundExecute();
+		return delegate.execute(request);
+	}
+	async explain(request) {
+		const delegate = this.#requireDelegate();
+		const explain = delegate.explain;
+		if (explain === void 0) throw driverError("DRIVER.NOT_CONNECTED", USE_BEFORE_CONNECT_MESSAGE);
+		return explain.call(delegate, request);
+	}
+	async query(sql, params) {
+		return this.#requireDelegate().query(sql, params);
+	}
+};
+const postgresRuntimeDriverDescriptor = {
+	...postgresDriverDescriptorMeta,
+	create(options) {
+		return new PostgresUnboundDriverImpl(options?.cursor);
+	}
+};
+var runtime_default = postgresRuntimeDriverDescriptor;
+
+//#endregion
+export { runtime_default as default };
+//# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":["#queue","releaseLock: (() => void) | undefined","#connection","#onRelease","#closed","#connectionMutex","#connected","#connectPromise","error: unknown","#cursorOpts","#delegate","#closed","#requireDelegate","postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<\n  'sql',\n  'postgres',\n  PostgresDriverCreateOptions,\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  SqlConnection,\n  SqlDriver,\n  SqlDriverState,\n  SqlExecuteRequest,\n  SqlExplainResult,\n  SqlQueryable,\n  SqlQueryResult,\n  SqlTransaction,\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 type PostgresBinding =\n  | { readonly kind: 'url'; readonly url: string }\n  | { readonly kind: 'pgPool'; readonly pool: PoolType }\n  | { readonly kind: 'pgClient'; readonly client: Client };\n\nexport interface PostgresCursorOptions {\n  readonly batchSize?: number;\n  readonly disabled?: boolean;\n}\n\ninterface PostgresDriverOptions {\n  readonly connect: { client: Client } | { pool: PoolType };\n  readonly cursor?: PostgresCursorOptions | undefined;\n}\n\nexport type PostgresDriverCreateOptions = Omit<PostgresDriverOptions, 'connect'>;\n\nconst DEFAULT_BATCH_SIZE = 100;\n\ntype ConnectionOptions =\n  | { readonly cursorDisabled: true }\n  | { readonly cursorBatchSize: number; readonly cursorDisabled: false };\n\nclass AsyncMutex {\n  #queue = Promise.resolve();\n\n  async lock(): Promise<() => void> {\n    const previous = this.#queue;\n    let releaseLock: (() => void) | undefined;\n    this.#queue = new Promise<void>((resolve) => {\n      releaseLock = resolve;\n    });\n    await previous;\n    return () => {\n      releaseLock?.();\n      releaseLock = undefined;\n    };\n  }\n}\n\nabstract class PostgresQueryable<C extends PoolClient | Client = PoolClient | Client>\n  implements SqlQueryable\n{\n  abstract acquireClient(): Promise<C>;\n  abstract releaseClient(client: C): Promise<void>;\n\n  protected readonly options: ConnectionOptions;\n\n  constructor(options: ConnectionOptions) {\n    this.options = options;\n  }\n\n  async *execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row> {\n    const client = await this.acquireClient();\n    try {\n      if (!this.options.cursorDisabled) {\n        try {\n          for await (const row of this.executeWithCursor(\n            client,\n            request.sql,\n            request.params,\n            this.options.cursorBatchSize,\n          )) {\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    // SQL is generated by Prisma Next planners (or validated raw paths), so\n    // EXPLAIN prefixing preserves the same statement semantics.\n    const text = `EXPLAIN (FORMAT JSON) ${request.sql}`;\n    const client = await this.acquireClient();\n    try {\n      const result = await client\n        .query(text, request.params as unknown[] | undefined)\n        .catch(rethrowNormalizedError);\n      return { rows: result.rows as ReadonlyArray<Record<string, unknown>> };\n    } finally {\n      await this.releaseClient(client);\n    }\n  }\n\n  async query<Row = Record<string, unknown>>(\n    sql: string,\n    params?: readonly unknown[],\n  ): Promise<SqlQueryResult<Row>> {\n    const client = await this.acquireClient();\n    try {\n      const result = await client\n        .query(sql, params as unknown[] | undefined)\n        .catch(rethrowNormalizedError);\n      return result as unknown as SqlQueryResult<Row>;\n    } finally {\n      await this.releaseClient(client);\n    }\n  }\n\n  private async *executeWithCursor(\n    client: PoolClient | Client,\n    sql: string,\n    params: readonly unknown[] | undefined,\n    cursorBatchSize: number,\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, 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\nclass PostgresConnectionImpl extends PostgresQueryable implements SqlConnection {\n  #connection: PoolClient | Client;\n  #onRelease: (() => void) | undefined;\n\n  constructor(connection: PoolClient | Client, options: ConnectionOptions, onRelease?: () => void) {\n    super(options);\n    this.#connection = connection;\n    this.#onRelease = onRelease;\n  }\n\n  override acquireClient(): Promise<PoolClient | Client> {\n    return Promise.resolve(this.#connection);\n  }\n\n  override releaseClient(_client: PoolClient | Client): Promise<void> {\n    return Promise.resolve();\n  }\n\n  async beginTransaction(): Promise<SqlTransaction> {\n    await this.#connection.query('BEGIN').catch(rethrowNormalizedError);\n    return new PostgresTransactionImpl(this.#connection, this.options);\n  }\n\n  async release(): Promise<void> {\n    if ('release' in this.#connection) {\n      this.#connection.release();\n    }\n    this.#onRelease?.();\n    this.#onRelease = undefined;\n  }\n}\n\nclass PostgresTransactionImpl extends PostgresQueryable implements SqlTransaction {\n  #connection: PoolClient | Client;\n\n  constructor(connection: PoolClient | Client, options: ConnectionOptions) {\n    super(options);\n    this.#connection = connection;\n  }\n\n  override acquireClient(): Promise<PoolClient | Client> {\n    return Promise.resolve(this.#connection);\n  }\n\n  override releaseClient(_client: PoolClient | Client): Promise<void> {\n    return Promise.resolve();\n  }\n\n  async commit(): Promise<void> {\n    await this.#connection.query('COMMIT').catch(rethrowNormalizedError);\n  }\n\n  async rollback(): Promise<void> {\n    await this.#connection.query('ROLLBACK').catch(rethrowNormalizedError);\n  }\n}\n\nclass PostgresPoolDriverImpl\n  extends PostgresQueryable<PoolClient>\n  implements SqlDriver<PostgresBinding>\n{\n  private readonly pool: PoolType;\n  #closed = false;\n\n  constructor(options: PostgresDriverOptions & { connect: { pool: PoolType } }) {\n    super({\n      cursorBatchSize: options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE,\n      cursorDisabled: options.cursor?.disabled ?? false,\n    });\n    this.pool = options.connect.pool;\n  }\n\n  get state(): SqlDriverState {\n    return this.#closed ? 'closed' : 'connected';\n  }\n\n  // Bound drivers are created via createBoundDriverFromBinding with pool already\n  // configured; connect is intentionally no-op.\n  async connect(_binding: PostgresBinding): Promise<void> {}\n\n  async acquireConnection(): Promise<SqlConnection> {\n    const client = await this.acquireClient();\n    return new PostgresConnectionImpl(client, this.options);\n  }\n\n  async close(): Promise<void> {\n    if (this.#closed) {\n      return;\n    }\n    this.#closed = true;\n    await this.pool.end();\n  }\n\n  async acquireClient(): Promise<PoolClient> {\n    return this.pool.connect();\n  }\n\n  async releaseClient(client: PoolClient): Promise<void> {\n    client.release();\n  }\n}\n\nclass PostgresDirectDriverImpl\n  extends PostgresQueryable<Client>\n  implements SqlDriver<PostgresBinding>\n{\n  private readonly directClient: Client;\n  readonly #connectionMutex = new AsyncMutex();\n  #closed = false;\n  #connected = false;\n  #connectPromise: Promise<void> | undefined;\n\n  constructor(options: PostgresDriverOptions & { connect: { client: Client } }) {\n    super({\n      cursorBatchSize: options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE,\n      cursorDisabled: options.cursor?.disabled ?? false,\n    });\n    this.directClient = options.connect.client;\n  }\n\n  get state(): SqlDriverState {\n    return this.#closed ? 'closed' : 'connected';\n  }\n\n  // Bound drivers are created via createBoundDriverFromBinding with client already\n  // configured; connect is intentionally no-op.\n  async connect(_binding: PostgresBinding): Promise<void> {}\n\n  async acquireConnection(): Promise<SqlConnection> {\n    const releaseLease = await this.#connectionMutex.lock();\n    try {\n      const client = await this.acquireClient();\n      return new PostgresConnectionImpl(client, this.options, releaseLease);\n    } catch (error) {\n      releaseLease();\n      throw error;\n    }\n  }\n\n  async close(): Promise<void> {\n    const releaseLease = await this.#connectionMutex.lock();\n    try {\n      if (this.#closed) {\n        return;\n      }\n      this.#closed = true;\n      await this.directClient.end();\n      this.#connected = false;\n    } finally {\n      releaseLease();\n    }\n  }\n\n  async acquireClient(): Promise<Client> {\n    if (this.#connected) {\n      return this.directClient;\n    }\n    if (this.#connectPromise !== undefined) {\n      await this.#connectPromise;\n      return this.directClient;\n    }\n\n    this.#connectPromise = (async () => {\n      try {\n        await this.directClient.connect();\n      } catch (error: unknown) {\n        if (!isAlreadyConnectedError(error)) {\n          throw error;\n        }\n      } finally {\n        this.#connectPromise = undefined;\n      }\n      this.#connected = true;\n    })();\n    await this.#connectPromise;\n\n    return this.directClient;\n  }\n\n  async releaseClient(_client: Client): Promise<void> {}\n}\n\nexport function createBoundDriverFromBinding(\n  binding: PostgresBinding,\n  cursorOpts: PostgresDriverCreateOptions['cursor'],\n): SqlDriver<PostgresBinding> {\n  switch (binding.kind) {\n    case 'url': {\n      const pool = new Pool({\n        connectionString: binding.url,\n        connectionTimeoutMillis: 20_000,\n        idleTimeoutMillis: 30_000,\n      });\n      return new PostgresPoolDriverImpl({\n        connect: { pool },\n        cursor: cursorOpts,\n      });\n    }\n    case 'pgPool':\n      return new PostgresPoolDriverImpl({\n        connect: { pool: binding.pool },\n        cursor: cursorOpts,\n      });\n    case 'pgClient':\n      return new PostgresDirectDriverImpl({\n        connect: { client: binding.client },\n        cursor: cursorOpts,\n      });\n  }\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\nfunction rethrowNormalizedError(error: unknown): never {\n  throw normalizePgError(error);\n}\n","import type {\n  RuntimeDriverDescriptor,\n  RuntimeDriverInstance,\n} from '@prisma-next/core-execution-plane/types';\nimport type {\n  SqlConnection,\n  SqlDriver,\n  SqlExecuteRequest,\n  SqlExplainResult,\n  SqlQueryResult,\n} from '@prisma-next/sql-relational-core/ast';\nimport { postgresDriverDescriptorMeta } from '../core/descriptor-meta';\nimport {\n  createBoundDriverFromBinding,\n  type PostgresBinding,\n  type PostgresDriverCreateOptions,\n} from '../postgres-driver';\n\nexport type PostgresRuntimeDriver = RuntimeDriverInstance<'sql', 'postgres'> &\n  SqlDriver<PostgresBinding>;\n\nconst USE_BEFORE_CONNECT_MESSAGE =\n  'Postgres driver not connected. Call connect(binding) before acquireConnection or execute.';\nconst ALREADY_CONNECTED_MESSAGE =\n  'Postgres driver already connected. Call close() before reconnecting with a new binding.';\n\ninterface DriverRuntimeError extends Error {\n  readonly code: 'DRIVER.NOT_CONNECTED' | 'DRIVER.ALREADY_CONNECTED';\n  readonly category: 'RUNTIME';\n  readonly severity: 'error';\n  readonly details?: Record<string, unknown>;\n}\n\nfunction driverError(\n  code: DriverRuntimeError['code'],\n  message: string,\n  details?: Record<string, unknown>,\n): DriverRuntimeError {\n  const error = new Error(message) as DriverRuntimeError;\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n  return Object.assign(error, {\n    code,\n    category: 'RUNTIME' as const,\n    severity: 'error' as const,\n    message,\n    details,\n  });\n}\n\nfunction unboundExecute<Row>(): AsyncIterable<Row> {\n  return {\n    [Symbol.asyncIterator]() {\n      return {\n        async next() {\n          throw driverError('DRIVER.NOT_CONNECTED', USE_BEFORE_CONNECT_MESSAGE);\n        },\n      };\n    },\n  };\n}\n\nclass PostgresUnboundDriverImpl implements PostgresRuntimeDriver {\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  #delegate: SqlDriver<PostgresBinding> | null = null;\n  #closed = false;\n  #cursorOpts: PostgresDriverCreateOptions['cursor'];\n\n  constructor(cursorOpts?: PostgresDriverCreateOptions['cursor']) {\n    this.#cursorOpts = cursorOpts;\n  }\n\n  get state(): 'unbound' | 'connected' | 'closed' {\n    if (this.#delegate !== null) {\n      return 'connected';\n    }\n    if (this.#closed) {\n      return 'closed';\n    }\n    return 'unbound';\n  }\n\n  #requireDelegate(): SqlDriver<PostgresBinding> {\n    const delegate = this.#delegate;\n    if (delegate === null) {\n      throw driverError('DRIVER.NOT_CONNECTED', USE_BEFORE_CONNECT_MESSAGE);\n    }\n    return delegate;\n  }\n\n  async connect(binding: PostgresBinding): Promise<void> {\n    if (this.#delegate !== null) {\n      throw driverError('DRIVER.ALREADY_CONNECTED', ALREADY_CONNECTED_MESSAGE, {\n        bindingKind: binding.kind,\n      });\n    }\n    this.#delegate = createBoundDriverFromBinding(binding, this.#cursorOpts);\n    this.#closed = false;\n  }\n\n  async acquireConnection(): Promise<SqlConnection> {\n    const delegate = this.#requireDelegate();\n    return delegate.acquireConnection();\n  }\n\n  async close(): Promise<void> {\n    const delegate = this.#delegate;\n    if (delegate !== null) {\n      this.#delegate = null;\n      await delegate.close();\n    }\n    this.#closed = true;\n  }\n\n  execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row> {\n    const delegate = this.#delegate;\n    if (delegate === null) {\n      return unboundExecute<Row>();\n    }\n    return delegate.execute<Row>(request);\n  }\n\n  async explain(request: SqlExecuteRequest): Promise<SqlExplainResult> {\n    const delegate = this.#requireDelegate();\n    const explain = delegate.explain;\n    if (explain === undefined) {\n      throw driverError('DRIVER.NOT_CONNECTED', USE_BEFORE_CONNECT_MESSAGE);\n    }\n    return explain.call(delegate, request);\n  }\n\n  async query<Row = Record<string, unknown>>(\n    sql: string,\n    params?: readonly unknown[],\n  ): Promise<SqlQueryResult<Row>> {\n    const delegate = this.#requireDelegate();\n    return delegate.query<Row>(sql, params);\n  }\n}\n\nconst postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<\n  'sql',\n  'postgres',\n  PostgresDriverCreateOptions,\n  PostgresRuntimeDriver\n> = {\n  ...postgresDriverDescriptorMeta,\n  create(options?: PostgresDriverCreateOptions): PostgresRuntimeDriver {\n    return new PostgresUnboundDriverImpl(options?.cursor);\n  },\n};\n\nexport default postgresRuntimeDriverDescriptor;\nexport type {\n  PostgresBinding,\n  PostgresDriverCreateOptions,\n  QueryResult,\n} from '../postgres-driver';\n"],"mappings":"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"}

package/package.json

@@ -1,53 +1,54 @@
 {
   "name": "@prisma-next/driver-postgres",
-  "version": "0.3.0-dev.7",
+  "version": "0.3.0-dev.70",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
     "arktype": "^2.0.0",
     "pg": "8.16.3",
     "pg-cursor": "^2.10.5",
-    "@prisma-next/core-control-plane": "0.3.0-dev.7",
-    "@prisma-next/core-execution-plane": "0.3.0-dev.7",
-    "@prisma-next/sql-contract": "0.3.0-dev.7",
-    "@prisma-next/sql-errors": "0.3.0-dev.7",
-    "@prisma-next/sql-operations": "0.3.0-dev.7",
-    "@prisma-next/sql-relational-core": "0.3.0-dev.7",
-    "@prisma-next/utils": "0.3.0-dev.7",
-    "@prisma-next/contract": "0.3.0-dev.7"
+    "@prisma-next/contract": "0.3.0-dev.70",
+    "@prisma-next/core-control-plane": "0.3.0-dev.70",
+    "@prisma-next/core-execution-plane": "0.3.0-dev.70",
+    "@prisma-next/sql-contract": "0.3.0-dev.70",
+    "@prisma-next/sql-errors": "0.3.0-dev.70",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.70",
+    "@prisma-next/sql-operations": "0.3.0-dev.70",
+    "@prisma-next/utils": "0.3.0-dev.70"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
-    "pg-mem": "^3.0.5",
-    "tsup": "8.5.1",
-    "typescript": "5.9.3",
-    "vitest": "4.0.16",
     "@types/pg": "8.16.0",
     "@types/pg-cursor": "^2.4.6",
-    "@prisma-next/test-utils": "0.0.1"
+    "pg-mem": "^3.0.5",
+    "tsdown": "0.18.4",
+    "typescript": "5.9.3",
+    "vitest": "4.0.17",
+    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
     "src"
   ],
   "exports": {
-    "./control": {
-      "types": "./dist/exports/control.d.ts",
-      "import": "./dist/exports/control.js"
-    },
-    "./runtime": {
-      "types": "./dist/exports/runtime.d.ts",
-      "import": "./dist/exports/runtime.js"
-    }
+    "./control": "./dist/control.mjs",
+    "./runtime": "./dist/runtime.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/3-targets/7-drivers/postgres"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../../biome.json --error-on-warnings",
-    "lint:fix": "biome check --write . --config-path ../../../biome.json",
-    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../biome.json",
-    "clean": "node ../../../../scripts/clean.mjs"
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/exports/control.ts

@@ -4,6 +4,7 @@ import type {
   ControlDriverInstance,
 } from '@prisma-next/core-control-plane/types';
 import { SqlQueryError } from '@prisma-next/sql-errors';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { redactDatabaseUrl } from '@prisma-next/utils/redact-db-url';
 import { Client } from 'pg';
 import { postgresDriverDescriptorMeta } from '../core/descriptor-meta';
@@ -71,7 +72,7 @@ const postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', Postg
           why: normalized.message,
           fix: 'Verify the database URL, ensure the database is reachable, and confirm credentials/permissions',
           meta: {
-            ...(typeof code !== 'undefined' ? { code } : {}),
+            ...ifDefined('code', code),
             ...redacted,
           },
         });

package/src/exports/runtime.ts

@@ -2,37 +2,161 @@ import type {
   RuntimeDriverDescriptor,
   RuntimeDriverInstance,
 } from '@prisma-next/core-execution-plane/types';
-import type { SqlDriver } from '@prisma-next/sql-relational-core/ast';
+import type {
+  SqlConnection,
+  SqlDriver,
+  SqlExecuteRequest,
+  SqlExplainResult,
+  SqlQueryResult,
+} from '@prisma-next/sql-relational-core/ast';
 import { postgresDriverDescriptorMeta } from '../core/descriptor-meta';
-import type { PostgresDriverOptions } from '../postgres-driver';
-import { createPostgresDriverFromOptions } from '../postgres-driver';
-
-/**
- * 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.
- */
+import {
+  createBoundDriverFromBinding,
+  type PostgresBinding,
+  type PostgresDriverCreateOptions,
+} from '../postgres-driver';
+
+export type PostgresRuntimeDriver = RuntimeDriverInstance<'sql', 'postgres'> &
+  SqlDriver<PostgresBinding>;
+
+const USE_BEFORE_CONNECT_MESSAGE =
+  'Postgres driver not connected. Call connect(binding) before acquireConnection or execute.';
+const ALREADY_CONNECTED_MESSAGE =
+  'Postgres driver already connected. Call close() before reconnecting with a new binding.';
+
+interface DriverRuntimeError extends Error {
+  readonly code: 'DRIVER.NOT_CONNECTED' | 'DRIVER.ALREADY_CONNECTED';
+  readonly category: 'RUNTIME';
+  readonly severity: 'error';
+  readonly details?: Record<string, unknown>;
+}
+
+function driverError(
+  code: DriverRuntimeError['code'],
+  message: string,
+  details?: Record<string, unknown>,
+): DriverRuntimeError {
+  const error = new Error(message) as DriverRuntimeError;
+  Object.defineProperty(error, 'name', {
+    value: 'RuntimeError',
+    configurable: true,
+  });
+  return Object.assign(error, {
+    code,
+    category: 'RUNTIME' as const,
+    severity: 'error' as const,
+    message,
+    details,
+  });
+}
+
+function unboundExecute<Row>(): AsyncIterable<Row> {
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        async next() {
+          throw driverError('DRIVER.NOT_CONNECTED', USE_BEFORE_CONNECT_MESSAGE);
+        },
+      };
+    },
+  };
+}
+
+class PostgresUnboundDriverImpl implements PostgresRuntimeDriver {
+  readonly familyId = 'sql' as const;
+  readonly targetId = 'postgres' as const;
+
+  #delegate: SqlDriver<PostgresBinding> | null = null;
+  #closed = false;
+  #cursorOpts: PostgresDriverCreateOptions['cursor'];
+
+  constructor(cursorOpts?: PostgresDriverCreateOptions['cursor']) {
+    this.#cursorOpts = cursorOpts;
+  }
+
+  get state(): 'unbound' | 'connected' | 'closed' {
+    if (this.#delegate !== null) {
+      return 'connected';
+    }
+    if (this.#closed) {
+      return 'closed';
+    }
+    return 'unbound';
+  }
+
+  #requireDelegate(): SqlDriver<PostgresBinding> {
+    const delegate = this.#delegate;
+    if (delegate === null) {
+      throw driverError('DRIVER.NOT_CONNECTED', USE_BEFORE_CONNECT_MESSAGE);
+    }
+    return delegate;
+  }
+
+  async connect(binding: PostgresBinding): Promise<void> {
+    if (this.#delegate !== null) {
+      throw driverError('DRIVER.ALREADY_CONNECTED', ALREADY_CONNECTED_MESSAGE, {
+        bindingKind: binding.kind,
+      });
+    }
+    this.#delegate = createBoundDriverFromBinding(binding, this.#cursorOpts);
+    this.#closed = false;
+  }
+
+  async acquireConnection(): Promise<SqlConnection> {
+    const delegate = this.#requireDelegate();
+    return delegate.acquireConnection();
+  }
+
+  async close(): Promise<void> {
+    const delegate = this.#delegate;
+    if (delegate !== null) {
+      this.#delegate = null;
+      await delegate.close();
+    }
+    this.#closed = true;
+  }
+
+  execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row> {
+    const delegate = this.#delegate;
+    if (delegate === null) {
+      return unboundExecute<Row>();
+    }
+    return delegate.execute<Row>(request);
+  }
+
+  async explain(request: SqlExecuteRequest): Promise<SqlExplainResult> {
+    const delegate = this.#requireDelegate();
+    const explain = delegate.explain;
+    if (explain === undefined) {
+      throw driverError('DRIVER.NOT_CONNECTED', USE_BEFORE_CONNECT_MESSAGE);
+    }
+    return explain.call(delegate, request);
+  }
+
+  async query<Row = Record<string, unknown>>(
+    sql: string,
+    params?: readonly unknown[],
+  ): Promise<SqlQueryResult<Row>> {
+    const delegate = this.#requireDelegate();
+    return delegate.query<Row>(sql, params);
+  }
+}
+
 const postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<
   'sql',
   'postgres',
+  PostgresDriverCreateOptions,
   PostgresRuntimeDriver
 > = {
   ...postgresDriverDescriptorMeta,
-  create(options: PostgresDriverOptions): PostgresRuntimeDriver {
-    return createPostgresDriverFromOptions(options) as PostgresRuntimeDriver;
+  create(options?: PostgresDriverCreateOptions): PostgresRuntimeDriver {
+    return new PostgresUnboundDriverImpl(options?.cursor);
   },
 };
 
 export default postgresRuntimeDriverDescriptor;
 export type {
-  CreatePostgresDriverOptions,
-  PostgresDriverOptions,
+  PostgresBinding,
+  PostgresDriverCreateOptions,
   QueryResult,
 } from '../postgres-driver';
-export { createPostgresDriver, createPostgresDriverFromOptions } from '../postgres-driver';