pg-cache 3.10.1 → 3.11.1

package/esm/index.js

@@ -1,3 +1,3 @@
 // Main exports from pg-cache package
-export { close, pgCache, PgPoolCacheManager, teardownPgPools } from './lru';
-export { buildConnectionString, getPgPool } from './pg';
+export { close, getPgCacheConfig, pgCache, PgPoolCacheManager, teardownPgPools } from './lru';
+export { buildConnectionString, getPgPool, getPgPoolConfig } from './pg';

package/esm/lru.js

@@ -6,6 +6,25 @@ const ONE_DAY = ONE_HOUR_IN_MS * 24;
 const ONE_YEAR = ONE_DAY * 366;
 // Kubernetes sends only SIGTERM on pod shutdown
 const SYS_EVENTS = ['SIGTERM'];
+const parseEnvInt = (val, fallback) => {
+    if (!val)
+        return fallback;
+    const n = parseInt(val, 10);
+    return isNaN(n) ? fallback : n;
+};
+/**
+ * Read cache configuration from environment variables.
+ *
+ * Supports:
+ * - PG_CACHE_MAX: Maximum number of pools (default: 50)
+ * - PG_CACHE_TTL_MS: TTL in milliseconds (default: ONE_YEAR)
+ */
+export function getPgCacheConfig() {
+    return {
+        max: parseEnvInt(process.env.PG_CACHE_MAX, 50),
+        ttl: parseEnvInt(process.env.PG_CACHE_TTL_MS, ONE_YEAR),
+    };
+}
 class ManagedPgPool {
     pool;
     key;
@@ -41,16 +60,22 @@ export class PgPoolCacheManager {
     cleanupTasks = [];
     closed = false;
     cleanupCallbacks = new Set();
-    pgCache = new LRUCache({
-        max: 10,
-        ttl: ONE_YEAR,
-        updateAgeOnGet: true,
-        dispose: (managedPool, key, reason) => {
-            log.debug(`Disposing pg pool [${key}] (${reason})`);
-            this.notifyCleanup(key);
-            this.disposePool(managedPool);
-        }
-    });
+    config;
+    pgCache;
+    constructor(config) {
+        const defaults = getPgCacheConfig();
+        this.config = { ...defaults, ...config };
+        this.pgCache = new LRUCache({
+            max: this.config.max,
+            ttl: this.config.ttl,
+            updateAgeOnGet: true,
+            dispose: (managedPool, key, reason) => {
+                log.debug(`Disposing pg pool [${key}] (${reason})`);
+                this.notifyCleanup(key);
+                this.disposePool(managedPool);
+            }
+        });
+    }
     // Register a cleanup callback to be called when pools are disposed
     registerCleanupCallback(callback) {
         this.cleanupCallbacks.add(callback);

package/esm/pg.js

@@ -4,6 +4,28 @@ import { Logger } from '@pgpmjs/logger';
 import { pgCache } from './lru';
 const log = new Logger('pg-cache');
 export const buildConnectionString = (user, password, host, port, database) => `postgres://${user}:${password}@${host}:${port}/${database}`;
+const parseEnvInt = (val, fallback) => {
+    if (!val)
+        return fallback;
+    const n = parseInt(val, 10);
+    return isNaN(n) ? fallback : n;
+};
+/**
+ * Read per-pool configuration from environment variables.
+ *
+ * Supports:
+ * - PG_POOL_MAX: Maximum clients per pool (default: 5)
+ * - PG_POOL_IDLE_TIMEOUT_MS: Close idle clients after ms (default: 30000)
+ * - PG_POOL_CONNECTION_TIMEOUT_MS: Fail connect() after ms (default: 5000)
+ */
+export function getPgPoolConfig(overrides) {
+    return {
+        max: overrides?.max ?? parseEnvInt(process.env.PG_POOL_MAX, 5),
+        idleTimeoutMillis: overrides?.idleTimeoutMillis ?? parseEnvInt(process.env.PG_POOL_IDLE_TIMEOUT_MS, 30000),
+        connectionTimeoutMillis: overrides?.connectionTimeoutMillis ?? parseEnvInt(process.env.PG_POOL_CONNECTION_TIMEOUT_MS, 5000),
+        ...(overrides?.allowExitOnIdle !== undefined && { allowExitOnIdle: overrides.allowExitOnIdle }),
+    };
+}
 export const getPgPool = (pgConfig) => {
     const config = getPgEnvOptions(pgConfig);
     const { user, password, host, port, database, } = config;
@@ -13,7 +35,8 @@ export const getPgPool = (pgConfig) => {
             return cached;
     }
     const connectionString = buildConnectionString(user, password, host, port, database);
-    const pgPool = new pg.Pool({ connectionString });
+    const poolConfig = getPgPoolConfig(pgConfig.pool);
+    const pgPool = new pg.Pool({ connectionString, ...poolConfig });
     /**
      * IMPORTANT: Pool-level error handler for idle connection errors.
      *

package/index.d.ts

@@ -1,3 +1,3 @@
-export { close, pgCache, PgPoolCacheManager, teardownPgPools } from './lru';
-export { buildConnectionString, getPgPool } from './pg';
-export type { PoolCleanupCallback } from './lru';
+export { close, getPgCacheConfig, pgCache, PgPoolCacheManager, teardownPgPools } from './lru';
+export { buildConnectionString, getPgPool, getPgPoolConfig } from './pg';
+export type { PgCacheConfig, PoolCleanupCallback } from './lru';

package/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPgPool = exports.buildConnectionString = exports.teardownPgPools = exports.PgPoolCacheManager = exports.pgCache = void 0;
+exports.getPgPoolConfig = exports.getPgPool = exports.buildConnectionString = exports.teardownPgPools = exports.PgPoolCacheManager = exports.pgCache = exports.getPgCacheConfig = void 0;
 // Main exports from pg-cache package
 var lru_1 = require("./lru");
 Object.defineProperty(exports, "close", { enumerable: true, get: function () { return lru_1.close; } });
+Object.defineProperty(exports, "getPgCacheConfig", { enumerable: true, get: function () { return lru_1.getPgCacheConfig; } });
 Object.defineProperty(exports, "pgCache", { enumerable: true, get: function () { return lru_1.pgCache; } });
 Object.defineProperty(exports, "PgPoolCacheManager", { enumerable: true, get: function () { return lru_1.PgPoolCacheManager; } });
 Object.defineProperty(exports, "teardownPgPools", { enumerable: true, get: function () { return lru_1.teardownPgPools; } });
 var pg_1 = require("./pg");
 Object.defineProperty(exports, "buildConnectionString", { enumerable: true, get: function () { return pg_1.buildConnectionString; } });
 Object.defineProperty(exports, "getPgPool", { enumerable: true, get: function () { return pg_1.getPgPool; } });
+Object.defineProperty(exports, "getPgPoolConfig", { enumerable: true, get: function () { return pg_1.getPgPoolConfig; } });

package/lru.d.ts

@@ -1,11 +1,27 @@
 import pg from 'pg';
 type PgPoolKey = string;
 export type PoolCleanupCallback = (pgPoolKey: string) => void;
+export interface PgCacheConfig {
+    /** Maximum number of pools in the LRU cache (env: PG_CACHE_MAX, default: 50) */
+    max: number;
+    /** TTL for cached pools in ms (default: ONE_YEAR) */
+    ttl: number;
+}
+/**
+ * Read cache configuration from environment variables.
+ *
+ * Supports:
+ * - PG_CACHE_MAX: Maximum number of pools (default: 50)
+ * - PG_CACHE_TTL_MS: TTL in milliseconds (default: ONE_YEAR)
+ */
+export declare function getPgCacheConfig(): PgCacheConfig;
 export declare class PgPoolCacheManager {
     private cleanupTasks;
     private closed;
     private cleanupCallbacks;
+    readonly config: PgCacheConfig;
     private readonly pgCache;
+    constructor(config?: Partial<PgCacheConfig>);
     registerCleanupCallback(callback: PoolCleanupCallback): () => void;
     get(key: PgPoolKey): pg.Pool | undefined;
     has(key: PgPoolKey): boolean;

package/lru.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.teardownPgPools = exports.close = exports.pgCache = exports.PgPoolCacheManager = void 0;
+exports.getPgCacheConfig = getPgCacheConfig;
 const logger_1 = require("@pgpmjs/logger");
 const lru_cache_1 = require("lru-cache");
 const log = new logger_1.Logger('pg-cache');
@@ -9,6 +10,25 @@ const ONE_DAY = ONE_HOUR_IN_MS * 24;
 const ONE_YEAR = ONE_DAY * 366;
 // Kubernetes sends only SIGTERM on pod shutdown
 const SYS_EVENTS = ['SIGTERM'];
+const parseEnvInt = (val, fallback) => {
+    if (!val)
+        return fallback;
+    const n = parseInt(val, 10);
+    return isNaN(n) ? fallback : n;
+};
+/**
+ * Read cache configuration from environment variables.
+ *
+ * Supports:
+ * - PG_CACHE_MAX: Maximum number of pools (default: 50)
+ * - PG_CACHE_TTL_MS: TTL in milliseconds (default: ONE_YEAR)
+ */
+function getPgCacheConfig() {
+    return {
+        max: parseEnvInt(process.env.PG_CACHE_MAX, 50),
+        ttl: parseEnvInt(process.env.PG_CACHE_TTL_MS, ONE_YEAR),
+    };
+}
 class ManagedPgPool {
     pool;
     key;
@@ -44,16 +64,22 @@ class PgPoolCacheManager {
     cleanupTasks = [];
     closed = false;
     cleanupCallbacks = new Set();
-    pgCache = new lru_cache_1.LRUCache({
-        max: 10,
-        ttl: ONE_YEAR,
-        updateAgeOnGet: true,
-        dispose: (managedPool, key, reason) => {
-            log.debug(`Disposing pg pool [${key}] (${reason})`);
-            this.notifyCleanup(key);
-            this.disposePool(managedPool);
-        }
-    });
+    config;
+    pgCache;
+    constructor(config) {
+        const defaults = getPgCacheConfig();
+        this.config = { ...defaults, ...config };
+        this.pgCache = new lru_cache_1.LRUCache({
+            max: this.config.max,
+            ttl: this.config.ttl,
+            updateAgeOnGet: true,
+            dispose: (managedPool, key, reason) => {
+                log.debug(`Disposing pg pool [${key}] (${reason})`);
+                this.notifyCleanup(key);
+                this.disposePool(managedPool);
+            }
+        });
+    }
     // Register a cleanup callback to be called when pools are disposed
     registerCleanupCallback(callback) {
         this.cleanupCallbacks.add(callback);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-cache",
-  "version": "3.10.1",
+  "version": "3.11.1",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostgreSQL connection pool LRU cache manager",
   "main": "index.js",
@@ -29,11 +29,11 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@pgpmjs/logger": "^2.11.0",
-    "@pgpmjs/types": "^2.27.0",
+    "@pgpmjs/logger": "^2.11.1",
+    "@pgpmjs/types": "^2.28.1",
     "lru-cache": "^11.2.7",
     "pg": "^8.21.0",
-    "pg-env": "^1.14.0"
+    "pg-env": "^1.15.1"
   },
   "devDependencies": {
     "@types/pg": "^8.20.0",
@@ -48,5 +48,5 @@
     "connection",
     "constructive"
   ],
-  "gitHead": "030e1144acbd4e288ee74eff2ac0021ca0382ef7"
+  "gitHead": "423992019655cc1e780149ce3f7e6e8c9b1c6e80"
 }

package/pg.d.ts

@@ -1,4 +1,15 @@
 import pg from 'pg';
-import { PgConfig } from 'pg-env';
+import { PgConfig, PgPoolConfig } from 'pg-env';
 export declare const buildConnectionString: (user: string, password: string, host: string, port: string | number, database: string) => string;
-export declare const getPgPool: (pgConfig: Partial<PgConfig>) => pg.Pool;
+/**
+ * Read per-pool configuration from environment variables.
+ *
+ * Supports:
+ * - PG_POOL_MAX: Maximum clients per pool (default: 5)
+ * - PG_POOL_IDLE_TIMEOUT_MS: Close idle clients after ms (default: 30000)
+ * - PG_POOL_CONNECTION_TIMEOUT_MS: Fail connect() after ms (default: 5000)
+ */
+export declare function getPgPoolConfig(overrides?: PgPoolConfig): pg.PoolConfig;
+export declare const getPgPool: (pgConfig: Partial<PgConfig> & {
+    pool?: PgPoolConfig;
+}) => pg.Pool;

package/pg.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPgPool = exports.buildConnectionString = void 0;
+exports.getPgPoolConfig = getPgPoolConfig;
 const pg_1 = __importDefault(require("pg"));
 const pg_env_1 = require("pg-env");
 const logger_1 = require("@pgpmjs/logger");
@@ -11,6 +12,28 @@ const lru_1 = require("./lru");
 const log = new logger_1.Logger('pg-cache');
 const buildConnectionString = (user, password, host, port, database) => `postgres://${user}:${password}@${host}:${port}/${database}`;
 exports.buildConnectionString = buildConnectionString;
+const parseEnvInt = (val, fallback) => {
+    if (!val)
+        return fallback;
+    const n = parseInt(val, 10);
+    return isNaN(n) ? fallback : n;
+};
+/**
+ * Read per-pool configuration from environment variables.
+ *
+ * Supports:
+ * - PG_POOL_MAX: Maximum clients per pool (default: 5)
+ * - PG_POOL_IDLE_TIMEOUT_MS: Close idle clients after ms (default: 30000)
+ * - PG_POOL_CONNECTION_TIMEOUT_MS: Fail connect() after ms (default: 5000)
+ */
+function getPgPoolConfig(overrides) {
+    return {
+        max: overrides?.max ?? parseEnvInt(process.env.PG_POOL_MAX, 5),
+        idleTimeoutMillis: overrides?.idleTimeoutMillis ?? parseEnvInt(process.env.PG_POOL_IDLE_TIMEOUT_MS, 30000),
+        connectionTimeoutMillis: overrides?.connectionTimeoutMillis ?? parseEnvInt(process.env.PG_POOL_CONNECTION_TIMEOUT_MS, 5000),
+        ...(overrides?.allowExitOnIdle !== undefined && { allowExitOnIdle: overrides.allowExitOnIdle }),
+    };
+}
 const getPgPool = (pgConfig) => {
     const config = (0, pg_env_1.getPgEnvOptions)(pgConfig);
     const { user, password, host, port, database, } = config;
@@ -20,7 +43,8 @@ const getPgPool = (pgConfig) => {
             return cached;
     }
     const connectionString = (0, exports.buildConnectionString)(user, password, host, port, database);
-    const pgPool = new pg_1.default.Pool({ connectionString });
+    const poolConfig = getPgPoolConfig(pgConfig.pool);
+    const pgPool = new pg_1.default.Pool({ connectionString, ...poolConfig });
     /**
      * IMPORTANT: Pool-level error handler for idle connection errors.
      *