@framers/sql-storage-adapter 0.7.2 → 0.7.3

package/dist/cjs/adapters/postgresAdapter.js

@@ -0,0 +1,889 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var postgresAdapter_exports = {};
+__export(postgresAdapter_exports, {
+  PostgresAdapter: () => PostgresAdapter,
+  createPostgresAdapter: () => createPostgresAdapter
+});
+module.exports = __toCommonJS(postgresAdapter_exports);
+var import_sqlPlaceholders = require("../shared/sqlPlaceholders.js");
+var import_splitSqlStatements = require("../shared/splitSqlStatements.js");
+var import_segment = require("../shared/segment.js");
+var import_logger = require("../shared/logger.js");
+const __isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+const typeParserOverrides = (parsers) => {
+  const overrides = /* @__PURE__ */ new Map();
+  if (!parsers)
+    return overrides;
+  const choice = (field, allowed) => {
+    const value = parsers[field];
+    if (value === void 0)
+      return void 0;
+    if (!allowed.includes(value)) {
+      throw new Error(`typeParsers.${field} must be ${allowed.map((option) => `'${option}'`).join(" or ")}; got ${JSON.stringify(value)}.`);
+    }
+    return value;
+  };
+  const int8 = choice("int8", ["string", "number", "bigint"]);
+  if (int8 === "string")
+    overrides.set(20, (text) => text);
+  if (int8 === "bigint")
+    overrides.set(20, (text) => BigInt(text));
+  if (int8 === "number") {
+    overrides.set(20, (text) => {
+      const value = Number(text);
+      if (!Number.isSafeInteger(value)) {
+        throw new RangeError(`int8 value ${text} is outside Number's safe integer range; read it with typeParsers.int8 'bigint' or 'string'.`);
+      }
+      return value;
+    });
+  }
+  const numeric = choice("numeric", ["string", "number"]);
+  if (numeric === "string")
+    overrides.set(1700, (text) => text);
+  if (numeric === "number")
+    overrides.set(1700, (text) => Number(text));
+  if (choice("date", ["date", "string"]) === "string")
+    overrides.set(1082, (text) => text);
+  if (choice("json", ["parse", "string"]) === "string") {
+    overrides.set(114, (text) => text);
+    overrides.set(3802, (text) => text);
+  }
+  return overrides;
+};
+const POOL_SETTINGS = [
+  "connectionString",
+  "host",
+  "port",
+  "database",
+  "user",
+  "password",
+  "ssl",
+  "max",
+  "min",
+  "idleTimeoutMillis",
+  "connectionTimeoutMillis",
+  "application_name",
+  "statement_timeout",
+  "query_timeout",
+  "allowExitOnIdle",
+  "typeParsers"
+];
+const ISOLATION_LEVELS = /* @__PURE__ */ new Map([
+  ["read uncommitted", "READ UNCOMMITTED"],
+  ["read committed", "READ COMMITTED"],
+  ["repeatable read", "REPEATABLE READ"],
+  ["serializable", "SERIALIZABLE"]
+]);
+const beginStatement = (options) => {
+  const modes = [];
+  if (options?.isolationLevel !== void 0) {
+    const level = ISOLATION_LEVELS.get(options.isolationLevel);
+    if (!level) {
+      throw new Error(`Unknown isolation level "${String(options.isolationLevel)}". Use 'read uncommitted', 'read committed', 'repeatable read' or 'serializable'.`);
+    }
+    modes.push(`ISOLATION LEVEL ${level}`);
+  }
+  if (options?.readOnly !== void 0)
+    modes.push(options.readOnly ? "READ ONLY" : "READ WRITE");
+  if (options?.deferrable !== void 0)
+    modes.push(options.deferrable ? "DEFERRABLE" : "NOT DEFERRABLE");
+  return modes.length > 0 ? `BEGIN ${modes.join(", ")}` : "BEGIN";
+};
+const transactionStatus = (client) => {
+  const read = client.getTransactionStatus;
+  return typeof read === "function" ? read.call(client) : null;
+};
+const prepareStatement = import_sqlPlaceholders.toPostgresStatement;
+const runWith = async (query, statement, parameters) => {
+  const { text, values } = prepareStatement(statement, parameters);
+  const result = await query(text, values);
+  const firstRow = result.rows?.[0];
+  const lastInsertRowid = firstRow && typeof firstRow === "object" && "id" in firstRow ? firstRow.id : null;
+  return { changes: result.rowCount ?? 0, lastInsertRowid };
+};
+const getWith = async (query, statement, parameters) => {
+  const { text, values } = prepareStatement(statement, parameters);
+  const result = await query(text, values);
+  return result.rows?.[0] ?? null;
+};
+const allWith = async (query, statement, parameters) => {
+  const { text, values } = prepareStatement(statement, parameters);
+  const result = await query(text, values);
+  return result.rows ?? [];
+};
+const execWith = async (query, script) => {
+  const statements = (0, import_splitSqlStatements.splitSqlStatements)(script);
+  for (const text of statements) {
+    await query(text, []);
+  }
+};
+const leadingWords = (statement, limit) => {
+  const words = [];
+  let i = 0;
+  const length = statement.length;
+  while (i < length && words.length < limit) {
+    const char = statement[i];
+    if (/\s/.test(char)) {
+      i += 1;
+    } else if (char === "-" && statement[i + 1] === "-") {
+      const end = statement.indexOf("\n", i);
+      i = end === -1 ? length : end + 1;
+    } else if (char === "/" && statement[i + 1] === "*") {
+      let depth = 1;
+      i += 2;
+      while (i < length && depth > 0) {
+        if (statement[i] === "/" && statement[i + 1] === "*") {
+          depth += 1;
+          i += 2;
+        } else if (statement[i] === "*" && statement[i + 1] === "/") {
+          depth -= 1;
+          i += 2;
+        } else {
+          i += 1;
+        }
+      }
+    } else if (char === "'") {
+      i += 1;
+      while (i < length) {
+        if (statement[i] === "'" && statement[i + 1] === "'")
+          i += 2;
+        else if (statement[i] === "'")
+          break;
+        else
+          i += 1;
+      }
+      i += 1;
+      words.push({ keyword: "'", identifier: "" });
+    } else if (char === '"') {
+      let identifier = "";
+      i += 1;
+      while (i < length) {
+        if (statement[i] === '"' && statement[i + 1] === '"') {
+          identifier += '"';
+          i += 2;
+        } else if (statement[i] === '"') {
+          break;
+        } else {
+          identifier += statement[i];
+          i += 1;
+        }
+      }
+      i += 1;
+      words.push({ keyword: '"', identifier });
+    } else if (char === "$") {
+      const tag = /^\$[A-Za-z_]*\$/.exec(statement.slice(i));
+      if (tag) {
+        const end = statement.indexOf(tag[0], i + tag[0].length);
+        i = end === -1 ? length : end + tag[0].length;
+        words.push({ keyword: "$", identifier: "" });
+      } else {
+        i += 1;
+        words.push({ keyword: "$", identifier: "" });
+      }
+    } else if (/[A-Za-z_]/.test(char)) {
+      const word = /^[A-Za-z_][A-Za-z0-9_$]*/.exec(statement.slice(i))[0];
+      i += word.length;
+      words.push({ keyword: word.toUpperCase(), identifier: word.toLowerCase() });
+    } else {
+      i += 1;
+      words.push({ keyword: char, identifier: "" });
+    }
+  }
+  return words;
+};
+const unqualifiedCreateExtension = (statement) => {
+  const words = leadingWords(statement, 16);
+  if (words[0]?.keyword !== "CREATE" || words[1]?.keyword !== "EXTENSION")
+    return null;
+  let at = 2;
+  if (words[2]?.keyword === "IF" && words[3]?.keyword === "NOT" && words[4]?.keyword === "EXISTS")
+    at = 5;
+  const name = words[at];
+  if (!name || name.keyword !== '"' && !/^[A-Z_]/.test(name.keyword))
+    return null;
+  if (words.slice(at + 1).some((word) => word.keyword === "SCHEMA"))
+    return null;
+  return name.identifier;
+};
+const asError = (value) => value instanceof Error ? value : new Error(String(value));
+const keepRollbackError = (error, rollbackError) => {
+  if (typeof error !== "object" || error === null || !Object.isExtensible(error))
+    return;
+  try {
+    Object.defineProperty(error, "rollbackError", {
+      value: rollbackError,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+  } catch {
+  }
+};
+const watchClient = (client) => {
+  let failure;
+  if (typeof client.on !== "function" || typeof client.removeListener !== "function") {
+    return { failure: () => void 0, stop: () => void 0 };
+  }
+  const onError = (error) => {
+    if (!failure)
+      failure = error;
+  };
+  client.on("error", onError);
+  return {
+    failure: () => failure,
+    stop: () => {
+      client.removeListener?.("error", onError);
+    }
+  };
+};
+const EXTENSION_PLACE = "SELECT n.nspname AS schema, e.extrelocatable AS relocatable FROM pg_extension e JOIN pg_namespace n ON n.oid = e.extnamespace WHERE e.extname = $1";
+class SegmentStatements {
+  constructor(segment) {
+    this.segment = segment;
+    this.reported = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Runs `text` on the pool. The connection that runs a `CREATE EXTENSION`
+   * goes back to the pool unless its BEGIN or ROLLBACK failed or it broke
+   * while held, in which case it is closed.
+   */
+  async onPool(pool, text, values) {
+    const extension = unqualifiedCreateExtension(text);
+    if (extension === null) {
+      return pool.query(text, values);
+    }
+    const client = await pool.connect();
+    const watch = watchClient(client);
+    let brokenBy;
+    try {
+      return await this.inOwnTransaction(client, text, values, extension, (error) => {
+        if (!brokenBy)
+          brokenBy = error;
+      });
+    } finally {
+      watch.stop();
+      client.release(brokenBy ?? watch.failure());
+    }
+  }
+  /** Runs `text` on a transaction's client, inside the caller's transaction. */
+  async inTransaction(client, text, values) {
+    const extension = unqualifiedCreateExtension(text);
+    if (extension === null) {
+      return client.query(text, values);
+    }
+    return this.withinTransaction(client, text, values, extension);
+  }
+  /**
+   * Runs `text` on the connection a `withConnection()` callback holds: inside
+   * the transaction the callback began, as `inTransaction` does, or outside
+   * one in a transaction of its own, as on the pool. On a pg that does not
+   * report a connection's transaction status (before 8.21), the session's
+   * search_path is set to `public` around the statement and set back after it.
+   * `onBroken` hears when the connection cannot be trusted any more, so
+   * `withConnection()` closes it instead of returning it to the pool.
+   */
+  async onConnection(client, text, values, onBroken) {
+    const extension = unqualifiedCreateExtension(text);
+    if (extension === null) {
+      return client.query(text, values);
+    }
+    switch (transactionStatus(client)) {
+      case "T":
+        return this.withinTransaction(client, text, values, extension);
+      case "I":
+        return this.inOwnTransaction(client, text, values, extension, onBroken);
+      case "E":
+        return client.query(text, values);
+      default:
+        return this.aroundSession(client, text, values, extension, onBroken);
+    }
+  }
+  /**
+   * In a transaction of its own on `client`, whose COMMIT or ROLLBACK ends the
+   * setting. A BEGIN or ROLLBACK that fails leaves the connection in a state
+   * nobody knows, so `onBroken` hears of it.
+   */
+  async inOwnTransaction(client, text, values, extension, onBroken) {
+    try {
+      await client.query("BEGIN");
+    } catch (error) {
+      onBroken(asError(error));
+      throw error;
+    }
+    let result;
+    try {
+      await client.query("SELECT set_config('search_path', 'public', true)");
+      result = await client.query(text, values);
+      await client.query("COMMIT");
+    } catch (error) {
+      try {
+        await client.query("ROLLBACK");
+      } catch (rollbackError) {
+        onBroken(asError(rollbackError));
+        keepRollbackError(error, asError(rollbackError));
+      }
+      throw error;
+    }
+    await this.checkReach((t, v) => client.query(t, v), extension);
+    return result;
+  }
+  /** Inside the transaction open on `client`, setting the search_path for the statement and back. */
+  async withinTransaction(client, text, values, extension) {
+    const saved = await client.query("SELECT current_setting('search_path') AS path");
+    const path = saved.rows[0]?.path;
+    await client.query("SELECT set_config('search_path', 'public', true)");
+    const result = await client.query(text, values);
+    await client.query("SELECT set_config($1, $2, true)", ["search_path", typeof path === "string" ? path : `${this.segment}, public`]);
+    await this.checkReach((t, v) => client.query(t, v), extension);
+    return result;
+  }
+  /**
+   * With the session's search_path set to `public` for the statement, and set
+   * back after it. When the statement fails inside a transaction, setting it
+   * back fails too, and that transaction's rollback restores it. Without the
+   * transaction status this cannot tell that case from a connection whose
+   * search_path stays on `public`, so a failed set-back tells `onBroken`, and
+   * the connection is closed rather than returned to the pool outside the
+   * segment.
+   */
+  async aroundSession(client, text, values, extension, onBroken) {
+    const saved = await client.query("SELECT current_setting('search_path') AS path");
+    const savedPath = saved.rows[0]?.path;
+    const path = typeof savedPath === "string" ? savedPath : `${this.segment}, public`;
+    await client.query("SELECT set_config('search_path', 'public', false)");
+    const setBack = async () => {
+      try {
+        await client.query("SELECT set_config($1, $2, false)", ["search_path", path]);
+      } catch (error) {
+        onBroken(asError(error));
+        throw error;
+      }
+    };
+    let result;
+    try {
+      result = await client.query(text, values);
+    } catch (error) {
+      await setBack().catch(() => void 0);
+      throw error;
+    }
+    await setBack();
+    await this.checkReach((t, v) => client.query(t, v), extension);
+    return result;
+  }
+  async checkReach(query, extension) {
+    if (this.reported.has(extension))
+      return;
+    const found = await query(EXTENSION_PLACE, [extension]);
+    const place = found.rows[0];
+    if (!place || place.relocatable !== true)
+      return;
+    if (place.schema === "public" || place.schema === this.segment)
+      return;
+    this.reported.add(extension);
+    (0, import_logger.getStorageLogger)().warn({ adapter: "postgres", segment: this.segment, extension, schema: String(place.schema) }, `PostgreSQL extension "${extension}" is installed in schema "${String(place.schema)}", which segment "${this.segment}" does not reach: its search_path is ${this.segment}, public, so the extension's types and functions do not resolve here. ALTER EXTENSION "${extension}" SET SCHEMA public moves it where every segment finds it.`);
+  }
+}
+const hasEnded = (pool) => pool.ending === true || pool.ended === true;
+const warnOfIdleError = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  (0, import_logger.getStorageLogger)().warn({ adapter: "postgres", error: message }, `PostgreSQL: an idle connection of the pool failed; the pool opens another when one is needed. ${message}`);
+};
+const readEnv = (key) => typeof process !== "undefined" && process.env ? process.env[key] : void 0;
+const refuseOwnStartupOptions = (connectionString) => {
+  if (connectionString && /[?&]options=/i.test(connectionString)) {
+    throw new Error("PostgresAdapter: a segment cannot be used with a connection string that sets its own startup options (options=...): pg sends those in place of the segment's search_path. Move them out of the connection string, into PGOPTIONS.");
+  }
+};
+const createSchema = async (client, segment) => {
+  const found = await client.query("SELECT 1 FROM pg_namespace WHERE nspname = $1", [segment]);
+  if (found.rows.length > 0) {
+    return;
+  }
+  try {
+    await client.query(`CREATE SCHEMA IF NOT EXISTS "${segment}"`);
+  } catch (error) {
+    const code = error?.code;
+    if (code !== "23505" && code !== "42P06") {
+      throw error;
+    }
+  }
+};
+class PostgresTransactionAdapter {
+  constructor(client, capabilities, segment, afterEnd) {
+    this.capabilities = capabilities;
+    this.afterEnd = afterEnd;
+    this.kind = "postgres";
+    this.ended = false;
+    this.query = segment ? (text, values) => segment.inTransaction(client, text, values) : (text, values) => client.query(text, values);
+  }
+  async open() {
+  }
+  async run(statement, parameters) {
+    if (this.ended)
+      return this.afterEnd.run(statement, parameters);
+    return runWith(this.query, statement, parameters);
+  }
+  async get(statement, parameters) {
+    if (this.ended)
+      return this.afterEnd.get(statement, parameters);
+    return getWith(this.query, statement, parameters);
+  }
+  async all(statement, parameters) {
+    if (this.ended)
+      return this.afterEnd.all(statement, parameters);
+    return allWith(this.query, statement, parameters);
+  }
+  async exec(script) {
+    if (this.ended)
+      return this.afterEnd.exec(script);
+    await execWith(this.query, script);
+  }
+  async transaction(fn) {
+    if (this.ended)
+      return this.afterEnd.transaction(fn);
+    return fn(this);
+  }
+  async close() {
+  }
+  /** @internal runTransaction() calls this when the transaction has ended. */
+  end() {
+    this.ended = true;
+  }
+}
+const runTransaction = async (client, begin, fn, capabilities, segment, afterEnd, onBroken) => {
+  try {
+    await client.query(begin);
+  } catch (error) {
+    onBroken(asError(error));
+    throw error;
+  }
+  const handle = new PostgresTransactionAdapter(client, capabilities, segment, afterEnd);
+  try {
+    const result = await fn(handle);
+    await client.query("COMMIT");
+    return result;
+  } catch (error) {
+    try {
+      await client.query("ROLLBACK");
+    } catch (rollbackError) {
+      const failure = asError(rollbackError);
+      onBroken(failure);
+      keepRollbackError(error, failure);
+      (0, import_logger.getStorageLogger)().warn({ adapter: "postgres", error: failure.message }, `PostgreSQL ROLLBACK failed after a transaction error, so the connection was closed; the transaction's own error is rethrown. ${failure.message}`);
+    }
+    throw error;
+  } finally {
+    handle.end();
+  }
+};
+class PostgresConnectionAdapter {
+  constructor(client, capabilities, segment) {
+    this.client = client;
+    this.capabilities = capabilities;
+    this.segment = segment;
+    this.kind = "postgres";
+    this.ended = false;
+    this.transactionOpen = false;
+    this.onBroken = (error) => {
+      if (!this.brokenBy)
+        this.brokenBy = error;
+    };
+    this.query = (text, values) => {
+      const live = this.live();
+      return segment ? segment.onConnection(live, text, values, this.onBroken) : live.query(text, values);
+    };
+  }
+  async open() {
+  }
+  async run(statement, parameters) {
+    return runWith(this.query, statement, parameters);
+  }
+  async get(statement, parameters) {
+    return getWith(this.query, statement, parameters);
+  }
+  async all(statement, parameters) {
+    return allWith(this.query, statement, parameters);
+  }
+  async exec(script) {
+    await execWith(this.query, script);
+  }
+  async transaction(fn, options) {
+    const begin = beginStatement(options);
+    const client = this.live();
+    if (this.transactionOpen) {
+      throw new Error("A transaction is already open on this connection. Run its statements through the handle its callback receives.");
+    }
+    this.transactionOpen = true;
+    try {
+      return await runTransaction(client, begin, fn, this.capabilities, this.segment, this, this.onBroken);
+    } finally {
+      this.transactionOpen = false;
+    }
+  }
+  async close() {
+  }
+  /** @internal withConnection() calls this when the callback ends. */
+  end() {
+    this.ended = true;
+  }
+  live() {
+    if (this.ended) {
+      throw new Error("This connection was handed back when its withConnection() callback ended.");
+    }
+    return this.client;
+  }
+}
+class PostgresAdapter {
+  constructor(options) {
+    this.kind = "postgres";
+    this.capabilities = /* @__PURE__ */ new Set([
+      "transactions",
+      // Full ACID transaction support
+      "locks",
+      // Row-level and advisory locks
+      "persistence",
+      // Data persisted to disk
+      "concurrent",
+      // Excellent concurrent access
+      "json",
+      // Native JSON/JSONB support
+      "arrays",
+      // Native array data types
+      "prepared"
+      // Prepared statements for security/performance
+    ]);
+    this.pool = null;
+    this.pgModule = null;
+    this.listening = null;
+    this.opening = null;
+    this.closing = null;
+    this.query = (text, values) => {
+      const pool = this.requirePool();
+      return this.segmentStatements ? this.segmentStatements.onPool(pool, text, values) : pool.query(text, values);
+    };
+    this.options = typeof options === "string" ? { connectionString: options } : { ...options };
+    const segment = this.options.segment === void 0 ? void 0 : (0, import_segment.validateSegment)(this.options.segment);
+    this.segmentStatements = segment === void 0 ? null : new SegmentStatements(segment);
+    const given = this.options.pool;
+    if (given) {
+      if (segment !== void 0) {
+        throw new Error("PostgresAdapter: a segment cannot run on a pool its caller made: the segment's search_path is set when each connection of the pool starts, and the adapter does not start the connections of a pool it did not make. Give the connection settings and the segment instead of the pool.");
+      }
+      const settings = POOL_SETTINGS.filter((key) => this.options[key] !== void 0);
+      if (settings.length > 0) {
+        throw new Error(`PostgresAdapter: ${settings.join(", ")} cannot be given with pool: they configure a pool when one is made, and the pool given was made by its caller. Set them on that pool` + (settings.includes("typeParsers") ? " (typeParsers through the pool's own types option)." : "."));
+      }
+      this.givenPool = given;
+      this.ownsPool = this.options.ownsPool === true;
+      this.pool = given;
+      this.listenOn(given);
+    } else {
+      this.givenPool = null;
+      this.ownsPool = true;
+      if (segment !== void 0) {
+        refuseOwnStartupOptions(this.options.connectionString);
+      }
+    }
+  }
+  /**
+   * The pool the adapter runs on: the pool it was given, or the pool it made
+   * while it is open. Null while the adapter is closed.
+   */
+  getPool() {
+    return this.pool;
+  }
+  /**
+   * Lazy loader for pg module to keep the dependency optional and prevent bundling in browser builds.
+   */
+  async loadPgModule() {
+    if (this.pgModule) {
+      return this.pgModule;
+    }
+    if (__isBrowser) {
+      throw new Error("[StorageAdapter] PostgreSQL adapter cannot be used in a browser environment.");
+    }
+    try {
+      this.pgModule = await Promise.resolve().then(() => __toESM(require("pg")));
+      return this.pgModule;
+    } catch (error) {
+      throw new Error(`[StorageAdapter] Failed to load pg module. Install it with: npm install pg. Error: ${error}`);
+    }
+  }
+  /**
+   * Opens the adapter: makes its pool and checks that a connection can be
+   * made (and with a segment, creates the segment's schema when it is
+   * missing), or takes up the pool it was given. A failure ends the pool it
+   * made, so a later `open()` starts again. Two calls at once open once.
+   */
+  open(openOptions) {
+    if (this.pool) {
+      return Promise.resolve();
+    }
+    if (!this.opening) {
+      this.opening = this.openNow(openOptions).finally(() => {
+        this.opening = null;
+      });
+    }
+    return this.opening;
+  }
+  async openNow(openOptions) {
+    if (__isBrowser) {
+      throw new Error("[StorageAdapter] PostgreSQL adapter cannot be opened in a browser environment.");
+    }
+    if (this.givenPool) {
+      if (hasEnded(this.givenPool)) {
+        throw new Error("PostgresAdapter: the pool it was given has ended, so the adapter cannot open on it again.");
+      }
+      this.pool = this.givenPool;
+      this.listenOn(this.givenPool);
+      return;
+    }
+    const connectionString = openOptions?.connectionString ?? this.options.connectionString;
+    if (this.segmentStatements) {
+      refuseOwnStartupOptions(connectionString);
+    }
+    const pg = await this.loadPgModule();
+    const pool = new pg.Pool(this.poolConfig(pg, connectionString));
+    this.listenOn(pool);
+    try {
+      const client = await pool.connect();
+      try {
+        if (this.segmentStatements) {
+          await createSchema(client, this.segmentStatements.segment);
+        }
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      this.listening = null;
+      await pool.end().catch(() => void 0);
+      throw error;
+    }
+    this.pool = pool;
+  }
+  /** The configuration of the pool the adapter makes. */
+  poolConfig(pg, connectionString) {
+    const poolConfig = {};
+    if (connectionString) {
+      poolConfig.connectionString = connectionString;
+    } else {
+      poolConfig.host = this.options.host ?? "localhost";
+      poolConfig.port = this.options.port ?? 5432;
+      poolConfig.database = this.options.database;
+      poolConfig.user = this.options.user;
+      poolConfig.password = this.options.password;
+    }
+    if (this.options.max !== void 0)
+      poolConfig.max = this.options.max;
+    if (this.options.min !== void 0)
+      poolConfig.min = this.options.min;
+    if (this.options.idleTimeoutMillis !== void 0) {
+      poolConfig.idleTimeoutMillis = this.options.idleTimeoutMillis;
+    }
+    if (this.options.connectionTimeoutMillis !== void 0) {
+      poolConfig.connectionTimeoutMillis = this.options.connectionTimeoutMillis;
+    }
+    if (this.options.application_name !== void 0) {
+      poolConfig.application_name = this.options.application_name;
+    }
+    if (this.options.statement_timeout !== void 0) {
+      poolConfig.statement_timeout = this.options.statement_timeout;
+    }
+    if (this.options.query_timeout !== void 0) {
+      poolConfig.query_timeout = this.options.query_timeout;
+    }
+    if (this.options.allowExitOnIdle !== void 0) {
+      poolConfig.allowExitOnIdle = this.options.allowExitOnIdle;
+    }
+    const overrides = typeParserOverrides(this.options.typeParsers);
+    if (overrides.size > 0) {
+      const defaults = pg.types;
+      poolConfig.types = {
+        getTypeParser: (oid, format) => (format === void 0 || format === "text") && overrides.has(oid) ? overrides.get(oid) : defaults.getTypeParser(oid, format)
+      };
+    }
+    if (this.options.ssl !== void 0) {
+      poolConfig.ssl = this.options.ssl;
+    }
+    if (this.segmentStatements) {
+      const searchPath = `-c search_path=${this.segmentStatements.segment},public`;
+      const inherited = readEnv("PGOPTIONS")?.trim();
+      poolConfig.options = inherited ? `${inherited} ${searchPath}` : searchPath;
+    }
+    return poolConfig;
+  }
+  /** Puts the adapter's error listener on `pool`: `onError`, or the warning on a pool it owns. */
+  listenOn(pool) {
+    const listener = this.options.onError ?? (this.ownsPool ? warnOfIdleError : null);
+    if (!listener || typeof pool.on !== "function" || this.listening?.pool === pool)
+      return;
+    pool.on("error", listener);
+    this.listening = { pool, listener };
+  }
+  async run(statement, parameters) {
+    return runWith(this.query, statement, parameters);
+  }
+  async get(statement, parameters) {
+    return getWith(this.query, statement, parameters);
+  }
+  async all(statement, parameters) {
+    return allWith(this.query, statement, parameters);
+  }
+  async exec(script) {
+    await execWith(this.query, script);
+  }
+  /**
+   * Runs `fn` in a transaction on one pooled connection: COMMIT when it
+   * resolves, ROLLBACK when it or COMMIT throws, and that error is rethrown.
+   * `options` sets the isolation level and the read-only and deferrable modes;
+   * an unknown isolation level is refused before a connection is checked out.
+   *
+   * When ROLLBACK fails too (the connection broke), the error thrown is still
+   * the transaction's own, with the ROLLBACK error on it as `rollbackError`,
+   * and the connection is closed instead of returned to the pool. The handle
+   * `fn` receives runs on the pool once the transaction has ended.
+   */
+  async transaction(fn, options) {
+    const begin = beginStatement(options);
+    const client = await this.requirePool().connect();
+    const watch = watchClient(client);
+    let brokenBy;
+    try {
+      return await runTransaction(client, begin, fn, this.capabilities, this.segmentStatements, this, (error) => {
+        if (!brokenBy)
+          brokenBy = error;
+      });
+    } finally {
+      watch.stop();
+      client.release(brokenBy ?? watch.failure());
+    }
+  }
+  /**
+   * Holds one pooled connection for `fn`, for work that needs one session:
+   * `SET` and other session settings, session advisory locks
+   * (`pg_advisory_lock`), temporary tables, or statements that must not run
+   * inside a transaction. Its statements run outside a transaction unless
+   * `fn` opens one with `connection.transaction()` or `BEGIN`.
+   *
+   * When `fn` resolves, the connection goes back to the pool with its session
+   * state, so undo what `fn` set (or use `SET LOCAL` inside a transaction).
+   * When `fn` throws, the connection is closed instead, which ends its session
+   * state and any transaction it left open, and `fn`'s error is rethrown.
+   * When `fn` resolves inside a transaction it began and did not end, the
+   * connection is closed, which rolls the transaction back, and the call
+   * rejects (pg 8.21 and later report the transaction status). The connection
+   * refuses statements once `fn` has ended. A connection that broke while `fn`
+   * held it (the server ended the session) is closed, not returned. On a
+   * segmented adapter the connection starts in the segment, as every
+   * connection of its pool does.
+   */
+  async withConnection(fn) {
+    const client = await this.requirePool().connect();
+    const watch = watchClient(client);
+    const connection = new PostgresConnectionAdapter(client, this.capabilities, this.segmentStatements);
+    let releaseError;
+    try {
+      const result = await fn(connection);
+      const status = transactionStatus(client);
+      if (status === "T" || status === "E") {
+        releaseError = new Error("withConnection(): the callback returned inside an open transaction. The connection was closed, which rolled the transaction back. End each transaction the callback begins, or run it through connection.transaction().");
+        throw releaseError;
+      }
+      return result;
+    } catch (error) {
+      if (!releaseError) {
+        releaseError = error instanceof Error ? error : new Error(String(error));
+      }
+      throw error;
+    } finally {
+      connection.end();
+      watch.stop();
+      client.release(releaseError ?? connection.brokenBy ?? watch.failure());
+    }
+  }
+  /**
+   * The pool's counts, or null when the adapter is not open. A pool of the
+   * caller's that does not count its connections, as pg's Pool does, reads 0.
+   */
+  getPoolStats() {
+    const pool = this.pool;
+    if (!pool) {
+      return null;
+    }
+    return { total: pool.totalCount ?? 0, idle: pool.idleCount ?? 0, waiting: pool.waitingCount ?? 0 };
+  }
+  /**
+   * Closes the adapter. A pool the adapter made or owns is ended, once; a pool
+   * of its caller's that it does not own is left open, with the adapter's
+   * listener taken off it. A call made while a close is running waits for it.
+   */
+  close() {
+    if (!this.closing) {
+      this.closing = this.closeNow().finally(() => {
+        this.closing = null;
+      });
+    }
+    return this.closing;
+  }
+  async closeNow() {
+    if (this.opening) {
+      await this.opening.catch(() => void 0);
+    }
+    const pool = this.pool;
+    this.pool = null;
+    if (!pool) {
+      return;
+    }
+    const listening = this.listening?.pool === pool ? this.listening : null;
+    this.listening = null;
+    if (this.ownsPool) {
+      if (!hasEnded(pool)) {
+        await pool.end();
+      }
+      return;
+    }
+    if (listening && typeof pool.removeListener === "function") {
+      pool.removeListener("error", listening.listener);
+    }
+  }
+  requirePool() {
+    if (!this.pool) {
+      throw new Error("Postgres adapter not opened.");
+    }
+    return this.pool;
+  }
+}
+function createPostgresAdapter(optionsOrString) {
+  return new PostgresAdapter(optionsOrString);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresAdapter,
+  createPostgresAdapter
+});