@juit/pgproxy-pool 1.0.0

package/README.md

@@ -0,0 +1,8 @@
+# PostgreSQL Proxy Connection Pool
+
+This package provides low-level connectivity and a connection pool
+implementation to connect to PosgreSQL databases using `libpq`.
+
+* [PGProxy](https://github.com/juitnow/juit-pgproxy/blob/main/README.md)
+* [Copyright Notice](https://github.com/juitnow/juit-pgproxy/blob/main/NOTICE.md)
+* [License](https://github.com/juitnow/juit-pgproxy/blob/main/NOTICE.md)

package/dist/connection.cjs

@@ -0,0 +1,309 @@
+"use strict";
+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);
+
+// connection.ts
+var connection_exports = {};
+__export(connection_exports, {
+  Connection: () => Connection,
+  convertOptions: () => convertOptions
+});
+module.exports = __toCommonJS(connection_exports);
+var import_node_assert = __toESM(require("node:assert"));
+var import_node_crypto = require("node:crypto");
+var import_events = require("./events.cjs");
+var import_libpq = require("./libpq.cjs");
+var import_queue = require("./queue.cjs");
+var optionKeys = {
+  address: "hostaddr",
+  applicationName: "application_name",
+  connectTimeout: "connect_timeout",
+  database: "dbname",
+  gssLibrary: "gsslib",
+  host: "host",
+  keepalives: "keepalives",
+  keepalivesCount: "keepalives_count",
+  keepalivesIdle: "keepalives_idle",
+  keepalivesInterval: "keepalives_interval",
+  kerberosServiceName: "krbsrvname",
+  password: "password",
+  port: "port",
+  sslCertFile: "sslcert",
+  sslCompression: "sslcompression",
+  sslCrlFile: "sslcrl",
+  sslKeyFile: "sslkey",
+  sslMode: "sslmode",
+  sslRootCertFile: "sslrootcert",
+  user: "user"
+};
+function quoteParamValue(value) {
+  value = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return `'${value}'`;
+}
+var finalizer = new FinalizationRegistry(
+  /* coverage ignore next */
+  (pq) => {
+    pq.finish();
+  }
+);
+function convertOptions(options) {
+  const params = [];
+  for (const [option, value] of Object.entries(options)) {
+    if (value == null)
+      continue;
+    const key = optionKeys[option];
+    if (!key)
+      continue;
+    const string = typeof value === "boolean" ? value ? "1" : "0" : typeof value === "number" ? value.toString() : typeof value === "string" ? value : (
+      /* coverage ignore next */
+      import_node_assert.default.fail(`Invalid type for option ${option}`)
+    );
+    if (string.length === 0)
+      continue;
+    params.push(`${key}=${quoteParamValue(string)}`);
+  }
+  return params.join(" ");
+}
+var Connection = class extends import_events.Emitter {
+  /** The unique ID of this connection */
+  id;
+  /** Queue for serializing queries to the database */
+  _queue = new import_queue.Queue();
+  /** Option string to use when calling `connect` */
+  _options;
+  /** Current instance of `libpq` */
+  _pq;
+  /** A flag indicating that `destroy()` has been invoked... */
+  _destroyed = false;
+  /* Overloaded constructor */
+  constructor(logger, options = {}) {
+    super(logger);
+    this.id = (0, import_node_crypto.randomUUID)();
+    this._logger = logger;
+    const params = typeof options === "string" ? options : convertOptions(options);
+    this._options = `fallback_application_name='pool:${this.id}' ${params}`;
+    this._pq = new import_libpq.LibPQ();
+    finalizer.register(this, this._pq, this._pq);
+    this.on("error", () => {
+      finalizer.unregister(this._pq);
+      this._pq.finish();
+      this._destroyed = true;
+    });
+    logger.debug(`Connection "${this.id}" created`);
+  }
+  /* ===== GETTERS ========================================================== */
+  /** Check whether this {@link Connection} is connected or not */
+  get connected() {
+    return !!this._pq.connected;
+  }
+  /** Check whether this {@link Connection} is destroyed or not */
+  get destroyed() {
+    return this._destroyed;
+  }
+  /** Return the version of the server we're connected to */
+  get serverVersion() {
+    (0, import_node_assert.default)(this._pq.connected, "Not connected");
+    const version = this._pq.serverVersion();
+    return `${Math.floor(version / 1e4)}.${version % 1e4}`;
+  }
+  /* ===== PUBLIC =========================================================== */
+  /** Connect this {@link Connection} (fails if connected already) */
+  async connect() {
+    (0, import_node_assert.default)(!this._pq.connected, `Connection "${this.id}" already connected`);
+    (0, import_node_assert.default)(!this._destroyed, `Connection "${this.id}" already destroyed`);
+    this._logger.debug(`Connection "${this.id}" connecting`);
+    const promise = new Promise((resolve, reject) => {
+      this._pq.connect(this._options, (error) => {
+        if (error) {
+          return reject(new Error(error.message.trim() || "Unknown connection error"));
+        }
+        if (!this._pq.setNonBlocking(true)) {
+          return reject(new Error(`Unable to set connection "${this.id}" as non-blocking`));
+        }
+        return resolve(this._pq.connected);
+      });
+    });
+    try {
+      const connected = await promise;
+      if (this._destroyed)
+        throw new Error(`Connection "${this.id}" aborted`);
+      if (!connected)
+        throw new Error(`Connection "${this.id}" not connected`);
+      this._logger.info(`Connection "${this.id}" connected (server version ${this.serverVersion})`);
+      this._emit("connected");
+      return this;
+    } catch (error) {
+      if (error instanceof Error)
+        Error.captureStackTrace(error);
+      finalizer.unregister(this._pq);
+      this._pq.finish();
+      this._destroyed = true;
+      this._emit("error", error);
+      throw error;
+    }
+  }
+  /** Destroy this {@link Connection} releasing all related resources */
+  destroy() {
+    if (this._destroyed)
+      return;
+    finalizer.unregister(this._pq);
+    this._pq.finish();
+    this._destroyed = true;
+    this._emit("destroyed");
+  }
+  /** ===== QUERY INTERFACE ================================================= */
+  /** Execute a (possibly parameterised) query with this {@link Connection} */
+  async query(text, params) {
+    const promise = this._queue.enqueue(() => {
+      (0, import_node_assert.default)(this._pq.connected, `Connection "${this.id}" not connected`);
+      return new Query(this._pq, this._logger).on("error", (error) => this._emit("error", error)).run(text, params);
+    });
+    try {
+      return await promise;
+    } catch (error) {
+      if (error instanceof Error)
+        Error.captureStackTrace(error);
+      throw error;
+    } finally {
+      if (!this._pq.connected)
+        this.destroy();
+    }
+  }
+  /** Cancel (if possible) the currently running query */
+  cancel() {
+    (0, import_node_assert.default)(this._pq.connected, `Connection "${this.id}" not connected`);
+    const cancel = this._pq.cancel();
+    if (cancel === true)
+      return;
+    throw new Error(cancel || "Unknown error canceling");
+  }
+};
+var Query = class extends import_events.Emitter {
+  constructor(_pq, logger) {
+    super(logger);
+    this._pq = _pq;
+  }
+  /** Run a query, sending it and flushing it, then reading results */
+  run(text, params = []) {
+    return new Promise((resolve, reject) => {
+      const sent = params.length > 0 ? this._pq.sendQueryParams(text, params) : this._pq.sendQuery(text);
+      if (!sent)
+        throw this._fail("sendQuery", "Unable to send query");
+      this._flushQuery((error) => {
+        if (error)
+          return reject(error);
+        const readableCallback = () => this._read(onResult);
+        const onResult = (error2) => {
+          this._pq.stopReader();
+          this._pq.off("readable", readableCallback);
+          if (error2) {
+            this._pq.clear();
+            return reject(error2);
+          }
+          const result = this._createResult();
+          this._pq.clear();
+          resolve(result);
+        };
+        this._pq.on("readable", readableCallback);
+        this._pq.startReader();
+      });
+    });
+  }
+  /* === ERRORS ============================================================= */
+  _fail(syscall, message) {
+    const text = (this._pq.errorMessage() || "").trim() || message;
+    const error = Object.assign(new Error(`${text} (${syscall})`), { syscall });
+    this._pq.finish();
+    this._emit("error", error);
+    return error;
+  }
+  /* === INTERNALS ========================================================== */
+  _error;
+  _flushQuery(cb) {
+    const result = this._pq.flush();
+    if (result === 0)
+      return cb();
+    if (result === -1)
+      cb(this._fail("flush", "Unable to flush query"));
+    this._pq.writable(
+      /* coverage ignore next */
+      () => this._flushQuery(cb)
+    );
+  }
+  _read(onResult) {
+    if (!this._pq.consumeInput()) {
+      return onResult(this._fail("consumeInput", "Unable to consume input"));
+    }
+    if (this._pq.isBusy())
+      return;
+    while (this._pq.getResult()) {
+      const status = this._pq.resultStatus();
+      switch (status) {
+        case "PGRES_FATAL_ERROR":
+          this._error = new Error(`SQL Fatal Error: ${this._pq.resultErrorMessage().trim()}`);
+          break;
+        case "PGRES_TUPLES_OK":
+        case "PGRES_COMMAND_OK":
+        case "PGRES_EMPTY_QUERY":
+          break;
+        default:
+          return onResult(this._fail("resultStatus", `Unrecognized status ${status}`));
+      }
+      if (this._pq.isBusy())
+        return;
+    }
+    onResult(this._error);
+  }
+  /* === RESULT ============================================================= */
+  /** Create a {@link ConnectionQueryResult} from the data currently held by `libpq` */
+  _createResult() {
+    const command = this._pq.cmdStatus().split(" ")[0];
+    const rowCount = parseInt(this._pq.cmdTuples() || "0");
+    const nfields = this._pq.nfields();
+    const ntuples = this._pq.ntuples();
+    const fields = new Array(nfields);
+    const rows = new Array(ntuples);
+    for (let i = 0; i < nfields; i++) {
+      fields[i] = [this._pq.fname(i), this._pq.ftype(i)];
+    }
+    for (let i = 0; i < ntuples; i++) {
+      const row = rows[i] = new Array(nfields);
+      for (let j = 0; j < nfields; j++) {
+        const value = this._pq.getvalue(i, j);
+        row[j] = value === "" && this._pq.getisnull(i, j) ? null : value;
+      }
+    }
+    return { command, rowCount, fields, rows };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Connection,
+  convertOptions
+});
+//# sourceMappingURL=connection.cjs.map

package/dist/connection.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/connection.ts"],
+  "mappings": "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",
+  "names": ["assert", "error"]
+}

package/dist/connection.d.ts

@@ -0,0 +1,112 @@
+import { Emitter } from './events';
+import type { Logger } from './index';
+/**
+ * Connection options
+ *
+ * See https://www.postgresql.org/docs/9.3/libpq-connect.html#LIBPQ-PARAMKEYWORDS
+ */
+export interface ConnectionOptions {
+    /** The database name. */
+    database?: string;
+    /** Name of host to connect to. */
+    host?: string;
+    /** IPv4 or IPv6 numeric IP address of host to connect to. */
+    address?: string;
+    /** Port number to connect to at the server host. */
+    port?: number;
+    /** PostgreSQL user name to connect as. */
+    user?: string;
+    /** Password to be used if the server demands password authentication. */
+    password?: string;
+    /** Maximum wait for connection, in seconds. */
+    connectTimeout?: number;
+    /** The `application_name` as it will appear in `pg_stat_activity`. */
+    applicationName?: string;
+    /** Controls whether client-side TCP keepalives are used. */
+    keepalives?: boolean;
+    /** The number of seconds of inactivity after which TCP should send a keepalive message to the server. */
+    keepalivesIdle?: number;
+    /** The number of seconds after which a TCP keepalive message that is not acknowledged by the server should be retransmitted. */
+    keepalivesInterval?: number;
+    /** The number of TCP keepalives that can be lost before the client's connection to the server is considered dead. */
+    keepalivesCount?: number;
+    /**
+     * This option determines whether or with what priority a secure SSL TCP/IP
+     * connection will be negotiated with the server. There are six modes:
+     * * `disable`: only try a non-SSL connection
+     * * `allow`: first try a non-SSL connection; if that fails, try an SSL connection
+     * * `prefer` _(default)_: first try an SSL connection; if that fails, try a non-SSL connection
+     * * `require`: only try an SSL connection. If a root CA file is present, verify the certificate in the same way as if verify-ca was specified
+     * * `verify-ca`: only try an SSL connection, and verify that the server certificate is issued by a trusted certificate authority (CA)
+     * * `verify-full`: only try an SSL connection, verify that the server certificate is issued by a trusted CA and that the server host name matches that in the certificate
+     */
+    sslMode?: 'disable' | 'allow' | 'prefer' | 'require' | 'verify-ca' | 'verify-full';
+    /** If set to `true` (default), data sent over SSL connections will be compressed */
+    sslCompression?: boolean;
+    /** The file name of the client SSL certificate */
+    sslCertFile?: string;
+    /** The location for the secret key used for the client certificate. */
+    sslKeyFile?: string;
+    /** The name of a file containing SSL certificate authority (CA) certificate(s). */
+    sslRootCertFile?: string;
+    /** The file name of the SSL certificate revocation list (CRL). */
+    sslCrlFile?: string;
+    /** Kerberos service name to use when authenticating with Kerberos 5 or GSSAPI. */
+    kerberosServiceName?: string;
+    /** GSS library to use for GSSAPI authentication. Only used on Windows. */
+    gssLibrary?: 'gssapi';
+}
+/** Describes the result of a PostgreSQL query */
+export interface ConnectionQueryResult {
+    /** Command executed (normally `SELECT`, or `INSERT`, ...) */
+    command: string;
+    /** Number of rows affected by this query (e.g. added rows in `INSERT`) */
+    rowCount: number;
+    /** Fields description with `name` (column name) and `oid` (type) */
+    fields: [name: string, oid: number][];
+    /** Result rows, as an array of unparsed `string` results from `libpq` */
+    rows: (string | null)[][];
+}
+/** The type identifying  */
+export type ConnectionQueryParams = (string | number | bigint | null)[];
+/** Events generated by our {@link Connection} */
+interface ConnectionEvents {
+    error: (error: Error) => unknown;
+    connected: () => unknown;
+    destroyed: () => unknown;
+}
+/** Convert our options into a string suitable for LibPQ */
+export declare function convertOptions(options: ConnectionOptions): string;
+/** Our *minimalistic* PostgreSQL connection wrapping `libpq`. */
+export declare class Connection extends Emitter<ConnectionEvents> {
+    /** The unique ID of this connection */
+    id: string;
+    /** Queue for serializing queries to the database */
+    private readonly _queue;
+    /** Option string to use when calling `connect` */
+    private readonly _options;
+    /** Current instance of `libpq` */
+    private _pq;
+    /** A flag indicating that `destroy()` has been invoked... */
+    private _destroyed;
+    /** Create a connection with the specified `LibPQ` parameters string */
+    constructor(logger: Logger, params?: string);
+    /** Create a connection with the specified configuration options */
+    constructor(logger: Logger, options?: ConnectionOptions);
+    /** Check whether this {@link Connection} is connected or not */
+    get connected(): boolean;
+    /** Check whether this {@link Connection} is destroyed or not */
+    get destroyed(): boolean;
+    /** Return the version of the server we're connected to */
+    get serverVersion(): string;
+    /** Connect this {@link Connection} (fails if connected already) */
+    connect(): Promise<Connection>;
+    /** Destroy this {@link Connection} releasing all related resources */
+    destroy(): void;
+    /** ===== QUERY INTERFACE ================================================= */
+    /** Execute a (possibly parameterised) query with this {@link Connection} */
+    query(text: string, params?: ConnectionQueryParams): Promise<ConnectionQueryResult>;
+    /** Cancel (if possible) the currently running query */
+    cancel(): void;
+}
+export {};