@juit/pgproxy-pool 1.0.0

package/dist/pool.mjs

@@ -0,0 +1,451 @@
+// pool.ts
+import assert from "node:assert";
+import { Connection, convertOptions } from "./connection.mjs";
+import { Emitter } from "./events.mjs";
+function parseEnvNumber(variable, defaultValue) {
+  const string = process.env[variable];
+  if (string == null)
+    return defaultValue;
+  const value = parseFloat(string);
+  if (isNaN(value))
+    throw new Error(`Invalid value "${string}" for environment variable "${variable}"`);
+  return value;
+}
+function parseEnvBoolean(variable, defaultValue) {
+  const string = process.env[variable];
+  if (string == null)
+    return defaultValue;
+  const value = string.toLowerCase();
+  if (value === "false")
+    return false;
+  if (value === "true")
+    return true;
+  throw new Error(`Invalid value "${string}" for environment variable "${variable}"`);
+}
+var ConnectionRequest = class {
+  _resolve;
+  _reject;
+  _promise;
+  _timeout;
+  _pending = true;
+  /**
+   * Create a new {@link ConnectionRequest} with a timeout, after which the
+   * request will be automatically rejected.
+   */
+  constructor(timeout) {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+    this._timeout = setTimeout(() => {
+      this.reject(new Error(`Timeout of ${timeout} ms reached acquiring connection`));
+    }, timeout).unref();
+  }
+  /** Return the {@link Promise} to the {@link Connection} */
+  get promise() {
+    return this._promise;
+  }
+  /** Determine whether this request is still pending or not */
+  get pending() {
+    return this._pending;
+  }
+  /** Resolve this instance's {@link Promise} with a {@link Connection} */
+  resolve(connection) {
+    clearTimeout(this._timeout);
+    if (this._pending)
+      this._resolve(connection);
+    this._pending = false;
+  }
+  /** Reject this instance's {@link Promise} with an {@link Error} */
+  reject(error) {
+    clearTimeout(this._timeout);
+    if (this._pending)
+      this._reject(error);
+    this._pending = false;
+  }
+};
+var ConnectionPool = class extends Emitter {
+  /** Borrowed connections mapped to their borrow timeout */
+  _borrowed = /* @__PURE__ */ new Map();
+  /** Array of all _available_ connections (that is, not borrowed out) */
+  _available = [];
+  /** Array of all pending {@link ConnectionRequest}s */
+  _pending = [];
+  /** All connections mapped to their evictor callback handler */
+  _connections = /* @__PURE__ */ new Map();
+  /** A {@link WeakMap} of connections already evicted by this pool */
+  _evicted = /* @__PURE__ */ new WeakSet();
+  /** The minimum number of connections to keep in the pool */
+  _minimumPoolSize;
+  /** The maximum number of connections to keep in the pool */
+  _maximumPoolSize;
+  /** The maximum number of idle connections that can be sitting in the pool */
+  _maximumIdleConnections;
+  /** The number of *milliseconds* after which an `acquire()` call will fail */
+  _acquireTimeoutMs;
+  /** The maximum number of *milliseconds* a connection can be borrowed for */
+  _borrowTimeoutMs;
+  /** The number of *milliseconds* to wait after the creation of a connection failed */
+  _retryIntervalMs;
+  /** Whether to validate connections on borrow or not */
+  _validateOnBorrow;
+  /** The {@link ConnectionOptions} converted into a string for `LibPQ` */
+  _connectionOptions;
+  /** Indicator on whether this {@link ConnectionPool} was started or not */
+  _started = false;
+  /** Indicator on whether this {@link ConnectionPool} is starting or not */
+  _starting = false;
+  constructor(logger, options = {}) {
+    super(logger);
+    const {
+      minimumPoolSize = parseEnvNumber("PGPOOLMINSIZE", 0),
+      maximumPoolSize = parseEnvNumber("PGPOOLMAXSIZE", minimumPoolSize + 20),
+      maximumIdleConnections = parseEnvNumber("PGPOOLIDLECONN", (maximumPoolSize + minimumPoolSize) / 2),
+      acquireTimeout = parseEnvNumber("PGPOOLACQUIRETIMEOUT", 30),
+      borrowTimeout = parseEnvNumber("PGPOOLBORROWTIMEOUT", 120),
+      retryInterval = parseEnvNumber("PGPOOLRETRYINTERVAL", 5),
+      validateOnBorrow = parseEnvBoolean("PGPOOLVALIDATEONBORROW", true),
+      ...connectionOptions
+    } = options;
+    this._minimumPoolSize = Math.round(minimumPoolSize);
+    this._maximumPoolSize = Math.round(maximumPoolSize);
+    this._maximumIdleConnections = Math.ceil(maximumIdleConnections);
+    this._acquireTimeoutMs = Math.round(acquireTimeout * 1e3);
+    this._borrowTimeoutMs = Math.round(borrowTimeout * 1e3);
+    this._retryIntervalMs = Math.round(retryInterval * 1e3);
+    this._validateOnBorrow = validateOnBorrow;
+    assert(this._minimumPoolSize >= 0, `Invalid minimum pool size: ${this._minimumPoolSize}`);
+    assert(this._maximumPoolSize >= 1, `Invalid maximum pool size: ${this._maximumPoolSize}`);
+    assert(this._maximumIdleConnections >= 0, `Invalid maximum idle connections: ${this._maximumIdleConnections}`);
+    assert(this._acquireTimeoutMs > 0, `Invalid acquire timeout: ${this._acquireTimeoutMs} ms`);
+    assert(this._borrowTimeoutMs > 0, `Invalid borrow timeout: ${this._borrowTimeoutMs} ms`);
+    assert(this._retryIntervalMs > 0, `Invalid retry interval: ${this._retryIntervalMs} ms`);
+    assert(
+      this._minimumPoolSize <= this._maximumPoolSize,
+      `The minimum pool size ${this._minimumPoolSize} must less or equal to the maximum pool size ${this._maximumPoolSize}`
+    );
+    assert(
+      this._minimumPoolSize <= this._maximumIdleConnections,
+      `The minimum pool size ${this._minimumPoolSize} must less or equal to the maximum number of idle connections ${this._maximumIdleConnections}`
+    );
+    assert(
+      this._maximumIdleConnections <= this._maximumPoolSize,
+      `The maximum number of idle connections ${this._maximumIdleConnections} must less or equal to the maximum pool size ${this._maximumPoolSize}`
+    );
+    this._connectionOptions = convertOptions(connectionOptions);
+    this._logger = logger;
+  }
+  /** Statistical informations about a {@link ConnectionPool} */
+  get stats() {
+    const available = this._available.length;
+    const borrowed = this._borrowed.size;
+    const total = this._connections.size;
+    const connecting = total - (available + borrowed);
+    return { available, borrowed, connecting, total };
+  }
+  /** Returns a flag indicating whether this pool is running or not */
+  get running() {
+    return this._started || this._starting;
+  }
+  /** Returns the running configuration of this instance */
+  get configuration() {
+    return {
+      minimumPoolSize: this._minimumPoolSize,
+      maximumPoolSize: this._maximumPoolSize,
+      maximumIdleConnections: this._maximumIdleConnections,
+      acquireTimeout: this._acquireTimeoutMs / 1e3,
+      borrowTimeout: this._borrowTimeoutMs / 1e3,
+      retryInterval: this._retryIntervalMs / 1e3,
+      validateOnBorrow: this._validateOnBorrow
+    };
+  }
+  /* ===== CONNECTION MANAGEMENT ============================================ */
+  /* These methods are protected, as they can be overridden to provide more
+   * specialized versions of connections */
+  /** Create a connection */
+  _create(logger, params) {
+    return new Connection(logger, params);
+  }
+  /** Validate a connection by issuing a super-simple statement */
+  async _validate(connection) {
+    if (!connection.connected)
+      return false;
+    if (!this._validateOnBorrow)
+      return true;
+    const start = process.hrtime.bigint();
+    try {
+      this._logger.debug(`Validating connection "${connection.id}"`);
+      const result = await connection.query("SELECT now()");
+      return result.rowCount === 1;
+    } catch (error) {
+      this._logger.error(`Error validating connection "${connection.id}":`, error);
+      return false;
+    } finally {
+      const time = process.hrtime.bigint() - start;
+      const ms = Math.floor(Number(time) / 1e4) / 100;
+      this._logger.debug(`Connection "${connection.id}" validated in ${ms} ms`);
+    }
+  }
+  /** Recycle a connection rolling back any running transaction */
+  async _recycle(connection) {
+    if (!connection.connected)
+      return false;
+    try {
+      const result = await connection.query("SELECT pg_current_xact_id_if_assigned() IS NOT NULL");
+      if (result.rows[0]?.[0] === "t") {
+        this._logger.warn(`Rolling back transaction recycling connection "${connection.id}"`);
+        await connection.query("ROLLBACK");
+      }
+      return true;
+    } catch (error) {
+      this._logger.error(`Error recycling connection "${connection.id}":`, error);
+      return false;
+    }
+  }
+  /* ===== CONNECTION / POOL INTERACTION ==================================== */
+  /** Adopt a connection tying it to our events */
+  _adopt(connection) {
+    const destroyer = () => {
+      connection.off("destroyed", evictor);
+      this._evict(connection);
+    };
+    this.once("stopped", destroyer);
+    const evictor = (forced) => {
+      this.off("stopped", destroyer);
+      if (forced)
+        return;
+      this._evict(connection);
+      this._runCreateLoop();
+    };
+    connection.once("destroyed", evictor);
+    this._connections.set(connection, evictor);
+    return connection;
+  }
+  /** Destroy a connection, it will be wiped from this pool */
+  _evict(connection, aborted = false) {
+    const evictor = this._connections.get(connection);
+    if (!evictor) {
+      this._logger.warn(`Attempting to evict non adopted connection ${connection.id}`);
+      return;
+    }
+    this._connections.delete(connection);
+    connection.off("destroyed", evictor);
+    evictor(true);
+    try {
+      this._logger.debug(`Destroying connection "${connection.id}"`);
+      clearTimeout(this._borrowed.get(connection));
+      this._borrowed.delete(connection);
+      const index = this._available.indexOf(connection);
+      if (index >= 0)
+        this._available.splice(index);
+      connection.destroy();
+      this._emit(aborted ? "connection_aborted" : "connection_destroyed", connection);
+    } catch (error) {
+      this._logger.error(`Error destroying connection "${connection.id}"`);
+    } finally {
+      this._evicted.add(connection);
+    }
+  }
+  /* ===== RUN LOOPS ======================================================== */
+  /**
+   * Run the create connection loop.
+   *
+   * This loop simply creates connections, connects them, sets up the various
+   * event handler (on disconnect) and simply adds them to the available array.
+   */
+  _runCreateLoop() {
+    if (!this._started)
+      return;
+    Promise.resolve().then(async () => {
+      while (this._started) {
+        const connections = this._connections.size;
+        const available = this._available.length;
+        const pending = this._pending.length;
+        if (available && connections >= this._minimumPoolSize || // enough available for minimum pool size
+        !pending && available >= this._maximumIdleConnections || // enough maximum idle connections
+        connections >= this._maximumPoolSize) {
+          break;
+        }
+        let connection;
+        try {
+          connection = this._create(this._logger, this._connectionOptions);
+          this._adopt(connection);
+        } catch (error) {
+          const retry = `retrying in ${this._retryIntervalMs} ms`;
+          this._logger.error(`Error creating pooled connection, ${retry}:`, error);
+          await new Promise((resolve) => setTimeout(resolve, this._retryIntervalMs));
+          continue;
+        }
+        try {
+          await connection.connect();
+        } catch (error) {
+          const retry = `retrying in ${this._retryIntervalMs} ms`;
+          this._logger.error(`Error connecting "${connection.id}", ${retry}:`, error);
+          this._evict(connection, true);
+          await new Promise((resolve) => setTimeout(resolve, this._retryIntervalMs));
+          continue;
+        }
+        if (this._started)
+          this._available.push(connection);
+        else
+          this._evict(connection, true);
+        this._runBorrowLoop();
+        this._emit("connection_created", connection);
+      }
+    }).catch(
+      /* coverage ignore next */
+      (error) => {
+        const retry = `retrying in ${this._retryIntervalMs} ms`;
+        this._logger.error(`Error in create loop, ${retry}:`, error);
+        setTimeout(() => this._runCreateLoop(), this._retryIntervalMs);
+      }
+    );
+  }
+  /**
+   * Run the borrow connection loop.
+   *
+   * This loop looks at all the pending connection requests, and fullfills them
+   * with a connection from the available array. If no connections are available
+   * then it simply triggers the create loop.
+   */
+  _runBorrowLoop() {
+    if (!this._started)
+      return;
+    Promise.resolve().then(async () => {
+      let request;
+      while (this._started && (request = this._pending.splice(0, 1)[0])) {
+        const connection = this._available.splice(0, 1)[0];
+        if (!connection) {
+          if (request.pending)
+            this._pending.unshift(request);
+          return this._runCreateLoop();
+        }
+        if (!request.pending) {
+          if (this._available.length >= this._maximumIdleConnections) {
+            this._evict(connection);
+          } else {
+            this._available.push(connection);
+          }
+          continue;
+        }
+        const valid = await this._validate(connection);
+        if (!this._started) {
+          request.reject(new Error(`Pool stopped while validatin connection ${connection.id}`));
+          return;
+        }
+        if (!valid) {
+          if (request.pending)
+            this._pending.unshift(request);
+          this._evict(connection);
+          continue;
+        }
+        if (!request.pending) {
+          this.release(connection);
+          continue;
+        }
+        const timeout = setTimeout(() => {
+          this._logger.error(`Connection "${connection.id}" borrowed for too long`);
+          this._evict(connection);
+        }, this._borrowTimeoutMs).unref();
+        this._borrowed.set(connection, timeout);
+        this._emit("connection_acquired", connection);
+        request.resolve(connection);
+      }
+    }).catch(
+      /* coverage ignore next */
+      (error) => {
+        const retry = `retrying in ${this._retryIntervalMs} ms`;
+        this._logger.error(`Error in borrow loop, ${retry}:`, error);
+        setTimeout(() => this._runBorrowLoop(), this._retryIntervalMs);
+      }
+    );
+  }
+  /* ===== CONNECTION LIFECYCLE ============================================= */
+  /** Acquire a {@link Connection} from this {@link ConnectionPool} */
+  acquire() {
+    assert(this._started, "Connection pool not started");
+    const deferred = new ConnectionRequest(this._acquireTimeoutMs);
+    this._pending.push(deferred);
+    this._runBorrowLoop();
+    return deferred.promise;
+  }
+  /** Release a {@link Connection} back to this {@link ConnectionPool} */
+  release(connection) {
+    if (this._evicted.has(connection))
+      return;
+    assert(this._connections.has(connection), `Connection "${connection.id}" not owned by this pool`);
+    Promise.resolve().then(async () => {
+      this._logger.debug(`Releasing connection "${connection.id}"`);
+      clearTimeout(this._borrowed.get(connection));
+      if (!connection.connected) {
+        this._logger.info(`Disconnected connection "${connection.id}" discarded`);
+        this._evict(connection);
+      } else if (this._available.length >= this._maximumIdleConnections) {
+        this._logger.info(`Extra connection "${connection.id}" discarded`);
+        this._evict(connection);
+      } else if (!await this._recycle(connection)) {
+        this._logger.info(`Non-validated connection "${connection.id}" discarded`);
+        this._evict(connection);
+      } else {
+        this._logger.debug(`Connection "${connection.id}" released`);
+        this._borrowed.delete(connection);
+        this._available.push(connection);
+        this._emit("connection_released", connection);
+      }
+    }).catch((error) => {
+      this._logger.error(`Error releasing connection "${connection.id}":`, error);
+      this._evict(connection);
+    }).finally(() => this._runBorrowLoop());
+  }
+  /* ===== POOL LIFECYCLE =================================================== */
+  /** Start this {@link ConnectionPool} validating an initial connection */
+  async start() {
+    if (this._started || this._starting)
+      return this;
+    this._logger.debug("Starting connection pool");
+    this._starting = true;
+    try {
+      const connection = this._create(this._logger, this._connectionOptions);
+      await connection.connect();
+      const valid = await this._validate(connection);
+      assert(valid, `Unable to validate initial connection "${connection.id}"`);
+      this._logger.debug(`Initial connection "${connection.id}" validated`);
+      this._adopt(connection);
+      this._started = true;
+      this._emit("started");
+      this._emit("connection_created", connection);
+      if (this._maximumIdleConnections > 0) {
+        this._available.push(connection);
+      } else {
+        this._evict(connection);
+      }
+      this._runCreateLoop();
+      return this;
+    } finally {
+      this._starting = false;
+    }
+  }
+  /** Stop this {@link ConnectionPool} and disconnect all connections. */
+  stop() {
+    if (!this._started)
+      return;
+    this._started = false;
+    const connections = `${this._connections.size} connections`;
+    const requests = `${this._pending.length} pending requests`;
+    this._logger.info(`Stopping connection pool with ${connections} and ${requests}`);
+    for (const pending of this._pending) {
+      pending.reject(new Error("Connection pool stopped"));
+    }
+    this._available.splice(0, Number.MAX_SAFE_INTEGER);
+    this._borrowed.clear();
+    try {
+      this._emit("stopped");
+    } finally {
+      this._connections.clear();
+    }
+  }
+};
+export {
+  ConnectionPool
+};
+//# sourceMappingURL=pool.mjs.map

package/dist/pool.mjs.map

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

package/dist/queue.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// queue.ts
+var queue_exports = {};
+__export(queue_exports, {
+  Queue: () => Queue
+});
+module.exports = __toCommonJS(queue_exports);
+var Executor = class {
+  constructor(_task, _resolve, _reject) {
+    this._task = _task;
+    this._resolve = _resolve;
+    this._reject = _reject;
+  }
+  execute() {
+    return Promise.resolve().then(async () => {
+      try {
+        const result = await this._task();
+        this._resolve(result);
+      } catch (error) {
+        this._reject(error);
+      }
+    });
+  }
+};
+var Queue = class {
+  _queue = [];
+  _running = false;
+  _run() {
+    if (this._running)
+      return;
+    const next = this._queue.splice(0, 1)[0];
+    if (!next)
+      return;
+    this._running = true;
+    void next.execute().finally(() => {
+      this._running = false;
+      this._run();
+    });
+  }
+  enqueue(task) {
+    return new Promise((resolve, reject) => {
+      const executor = new Executor(task, resolve, reject);
+      this._queue.push(executor);
+      process.nextTick(() => this._run());
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Queue
+});
+//# sourceMappingURL=queue.cjs.map

package/dist/queue.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/queue.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,IAAM,WAAN,MAAkB;AAAA,EAChB,YACY,OACA,UACA,SACV;AAHU;AACA;AACA;AAAA,EACT;AAAA,EAEH,UAAyB;AACvB,WAAO,QAAQ,QAAQ,EAAE,KAAK,YAAY;AACxC,UAAI;AACF,cAAM,SAAS,MAAM,KAAK,MAAM;AAChC,aAAK,SAAS,MAAM;AAAA,MACtB,SAAS,OAAO;AACd,aAAK,QAAQ,KAAK;AAAA,MACpB;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEO,IAAM,QAAN,MAAY;AAAA,EACT,SAA0B,CAAC;AAAA,EAC3B,WAAoB;AAAA,EAEpB,OAAa;AACnB,QAAI,KAAK;AAAU;AAEnB,UAAM,OAAO,KAAK,OAAO,OAAO,GAAG,CAAC,EAAE,CAAC;AACvC,QAAI,CAAE;AAAM;AAEZ,SAAK,WAAW;AAEhB,SAAK,KAAK,QAAQ,EAAE,QAAQ,MAAM;AAChC,WAAK,WAAW;AAChB,WAAK,KAAK;AAAA,IACZ,CAAC;AAAA,EACH;AAAA,EAEA,QAAW,MAA2B;AACpC,WAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACzC,YAAM,WAAW,IAAI,SAAS,MAAM,SAAS,MAAM;AACnD,WAAK,OAAO,KAAK,QAAQ;AACzB,cAAQ,SAAS,MAAM,KAAK,KAAK,CAAC;AAAA,IACpC,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/queue.d.ts

@@ -0,0 +1,7 @@
+export type Task<T> = () => T | PromiseLike<T>;
+export declare class Queue {
+    private _queue;
+    private _running;
+    private _run;
+    enqueue<T>(task: Task<T>): Promise<T>;
+}

package/dist/queue.mjs

@@ -0,0 +1,45 @@
+// queue.ts
+var Executor = class {
+  constructor(_task, _resolve, _reject) {
+    this._task = _task;
+    this._resolve = _resolve;
+    this._reject = _reject;
+  }
+  execute() {
+    return Promise.resolve().then(async () => {
+      try {
+        const result = await this._task();
+        this._resolve(result);
+      } catch (error) {
+        this._reject(error);
+      }
+    });
+  }
+};
+var Queue = class {
+  _queue = [];
+  _running = false;
+  _run() {
+    if (this._running)
+      return;
+    const next = this._queue.splice(0, 1)[0];
+    if (!next)
+      return;
+    this._running = true;
+    void next.execute().finally(() => {
+      this._running = false;
+      this._run();
+    });
+  }
+  enqueue(task) {
+    return new Promise((resolve, reject) => {
+      const executor = new Executor(task, resolve, reject);
+      this._queue.push(executor);
+      process.nextTick(() => this._run());
+    });
+  }
+};
+export {
+  Queue
+};
+//# sourceMappingURL=queue.mjs.map

package/dist/queue.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/queue.ts"],
+  "mappings": ";AAEA,IAAM,WAAN,MAAkB;AAAA,EAChB,YACY,OACA,UACA,SACV;AAHU;AACA;AACA;AAAA,EACT;AAAA,EAEH,UAAyB;AACvB,WAAO,QAAQ,QAAQ,EAAE,KAAK,YAAY;AACxC,UAAI;AACF,cAAM,SAAS,MAAM,KAAK,MAAM;AAChC,aAAK,SAAS,MAAM;AAAA,MACtB,SAAS,OAAO;AACd,aAAK,QAAQ,KAAK;AAAA,MACpB;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEO,IAAM,QAAN,MAAY;AAAA,EACT,SAA0B,CAAC;AAAA,EAC3B,WAAoB;AAAA,EAEpB,OAAa;AACnB,QAAI,KAAK;AAAU;AAEnB,UAAM,OAAO,KAAK,OAAO,OAAO,GAAG,CAAC,EAAE,CAAC;AACvC,QAAI,CAAE;AAAM;AAEZ,SAAK,WAAW;AAEhB,SAAK,KAAK,QAAQ,EAAE,QAAQ,MAAM;AAChC,WAAK,WAAW;AAChB,WAAK,KAAK;AAAA,IACZ,CAAC;AAAA,EACH;AAAA,EAEA,QAAW,MAA2B;AACpC,WAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACzC,YAAM,WAAW,IAAI,SAAS,MAAM,SAAS,MAAM;AACnD,WAAK,OAAO,KAAK,QAAQ;AACzB,cAAQ,SAAS,MAAM,KAAK,KAAK,CAAC;AAAA,IACpC,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@juit/pgproxy-pool",
+  "version": "1.0.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "author": "Juit Developers <developers@juit.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/juitnow/juit-pgproxy.git"
+  },
+  "keywords": [
+    "database",
+    "pg",
+    "pool",
+    "postgres",
+    "proxy"
+  ],
+  "bugs": {
+    "url": "https://github.com/juitnow/juit-pgproxy/issues"
+  },
+  "homepage": "https://github.com/juitnow/juit-pgproxy#readme",
+  "dependencies": {
+    "libpq": "^1.8.12"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "*.md",
+    "dist/",
+    "src/"
+  ]
+}