@refpool/typeorm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atul Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# @refpool/typeorm
+
+Multi-tenant **TypeORM `DataSource` pooling** built on
+[`@refpool/core`](../core)'s reference-counted, bounded LRU pool.
+
+Instead of holding one initialized `DataSource` per tenant forever, you get a
+bounded pool: at most `max` live data sources, shared between concurrent requests
+for the same tenant, with the coldest idle ones reclaimed automatically.
+
+## Install
+
+```bash
+npm install @refpool/typeorm typeorm
+```
+
+`typeorm` (`^0.3.0`) is a **required** peer dependency — this package statically
+imports it, so you must install `typeorm` alongside `@refpool/typeorm`.
+
+## Usage
+
+```ts
+import { createTypeOrmPool, withResource } from '@refpool/typeorm';
+
+const pool = createTypeOrmPool({
+  max: 20,
+  idleTtlMs: 60_000,
+  config: (tenantId) => ({
+    type: 'postgres',
+    url: `postgres://localhost:5432/tenant_${tenantId}`,
+    entities: [/* ... */],
+  }),
+});
+pool.start();
+
+// Acquire, run, release — release is guaranteed even if `fn` throws.
+const users = await withResource(pool, tenantId, async (dataSource) => {
+  return dataSource.getRepository(User).find();
+});
+
+await pool.stop(); // on shutdown: destroys every live DataSource
+```
+
+The factory builds a `DataSource` from `config(key)` and calls `.initialize()`;
+`dispose` calls `.destroy()` on eviction/drain. All other
+[`PoolOptions`](../core#pooloptionst) (`max`, `idleTtlMs`, `breaker`, `prewarm`,
+`statsIntervalMs`, …) pass straight through.
+
+## API
+
+- `createTypeOrmPool(options)` → `RefCountedLruPool<DataSource>` —
+  `options` is `PoolOptions` minus `factory`/`dispose`, plus
+  `config: (key) => DataSourceOptions | Promise<DataSourceOptions>`.
+- `withResource(pool, key, fn)` — acquire `key`, run `fn(dataSource)`, release in `finally`.
+
+## License
+
+MIT © Atul Singh

package/dist/index.cjs

@@ -0,0 +1,62 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createTypeOrmPool: () => createTypeOrmPool,
+  withResource: () => withResource
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@refpool/core");
+var import_typeorm = require("typeorm");
+function createTypeOrmPool(options) {
+  const { config, ...rest } = options;
+  return new import_core.RefCountedLruPool({
+    ...rest,
+    factory: async (key) => {
+      const dataSource = new import_typeorm.DataSource(await config(key));
+      try {
+        await dataSource.initialize();
+      } catch (error) {
+        await dataSource.destroy().catch(() => {
+        });
+        throw error;
+      }
+      return dataSource;
+    },
+    dispose: async (dataSource) => {
+      await dataSource.destroy();
+    }
+  });
+}
+async function withResource(pool, key, fn) {
+  const handle = await pool.acquire(key);
+  try {
+    return await fn(handle.resource);
+  } finally {
+    handle.release();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTypeOrmPool,
+  withResource
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { RefCountedLruPool } from '@refpool/core';\nimport type { AcquireHandle, PoolOptions } from '@refpool/core';\nimport { DataSource } from 'typeorm';\nimport type { DataSourceOptions } from 'typeorm';\n\n/** Options for a per-key TypeORM `DataSource` pool. */\nexport type TypeOrmPoolOptions = Omit<PoolOptions<DataSource>, 'factory' | 'dispose'> & {\n  /** Build the `DataSource` options for a tenant key. */\n  config: (key: string) => DataSourceOptions | Promise<DataSourceOptions>;\n};\n\n/**\n * Create a reference-counted, bounded LRU pool of TypeORM `DataSource`\n * instances keyed by tenant. The factory builds and `.initialize()`s a\n * `DataSource`; dispose `.destroy()`s it on eviction/drain.\n */\nexport function createTypeOrmPool(options: TypeOrmPoolOptions): RefCountedLruPool<DataSource> {\n  const { config, ...rest } = options;\n  return new RefCountedLruPool<DataSource>({\n    ...rest,\n    factory: async (key) => {\n      const dataSource = new DataSource(await config(key));\n      try {\n        await dataSource.initialize();\n      } catch (error) {\n        await dataSource.destroy().catch(() => {});\n        throw error;\n      }\n      return dataSource;\n    },\n    dispose: async (dataSource) => {\n      await dataSource.destroy();\n    },\n  });\n}\n\n/** Acquire `key`, run `fn`, and release the holder in `finally`. */\nexport async function withResource<R>(\n  pool: RefCountedLruPool<DataSource>,\n  key: string,\n  fn: (dataSource: DataSource) => Promise<R> | R,\n): Promise<R> {\n  const handle: AcquireHandle<DataSource> = await pool.acquire(key);\n  try {\n    return await fn(handle.resource);\n  } finally {\n    handle.release();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAkC;AAElC,qBAA2B;AAcpB,SAAS,kBAAkB,SAA4D;AAC5F,QAAM,EAAE,QAAQ,GAAG,KAAK,IAAI;AAC5B,SAAO,IAAI,8BAA8B;AAAA,IACvC,GAAG;AAAA,IACH,SAAS,OAAO,QAAQ;AACtB,YAAM,aAAa,IAAI,0BAAW,MAAM,OAAO,GAAG,CAAC;AACnD,UAAI;AACF,cAAM,WAAW,WAAW;AAAA,MAC9B,SAAS,OAAO;AACd,cAAM,WAAW,QAAQ,EAAE,MAAM,MAAM;AAAA,QAAC,CAAC;AACzC,cAAM;AAAA,MACR;AACA,aAAO;AAAA,IACT;AAAA,IACA,SAAS,OAAO,eAAe;AAC7B,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAGA,eAAsB,aACpB,MACA,KACA,IACY;AACZ,QAAM,SAAoC,MAAM,KAAK,QAAQ,GAAG;AAChE,MAAI;AACF,WAAO,MAAM,GAAG,OAAO,QAAQ;AAAA,EACjC,UAAE;AACA,WAAO,QAAQ;AAAA,EACjB;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,18 @@
+import { PoolOptions, RefCountedLruPool } from '@refpool/core';
+import { DataSource, DataSourceOptions } from 'typeorm';
+
+/** Options for a per-key TypeORM `DataSource` pool. */
+type TypeOrmPoolOptions = Omit<PoolOptions<DataSource>, 'factory' | 'dispose'> & {
+    /** Build the `DataSource` options for a tenant key. */
+    config: (key: string) => DataSourceOptions | Promise<DataSourceOptions>;
+};
+/**
+ * Create a reference-counted, bounded LRU pool of TypeORM `DataSource`
+ * instances keyed by tenant. The factory builds and `.initialize()`s a
+ * `DataSource`; dispose `.destroy()`s it on eviction/drain.
+ */
+declare function createTypeOrmPool(options: TypeOrmPoolOptions): RefCountedLruPool<DataSource>;
+/** Acquire `key`, run `fn`, and release the holder in `finally`. */
+declare function withResource<R>(pool: RefCountedLruPool<DataSource>, key: string, fn: (dataSource: DataSource) => Promise<R> | R): Promise<R>;
+
+export { type TypeOrmPoolOptions, createTypeOrmPool, withResource };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { PoolOptions, RefCountedLruPool } from '@refpool/core';
+import { DataSource, DataSourceOptions } from 'typeorm';
+
+/** Options for a per-key TypeORM `DataSource` pool. */
+type TypeOrmPoolOptions = Omit<PoolOptions<DataSource>, 'factory' | 'dispose'> & {
+    /** Build the `DataSource` options for a tenant key. */
+    config: (key: string) => DataSourceOptions | Promise<DataSourceOptions>;
+};
+/**
+ * Create a reference-counted, bounded LRU pool of TypeORM `DataSource`
+ * instances keyed by tenant. The factory builds and `.initialize()`s a
+ * `DataSource`; dispose `.destroy()`s it on eviction/drain.
+ */
+declare function createTypeOrmPool(options: TypeOrmPoolOptions): RefCountedLruPool<DataSource>;
+/** Acquire `key`, run `fn`, and release the holder in `finally`. */
+declare function withResource<R>(pool: RefCountedLruPool<DataSource>, key: string, fn: (dataSource: DataSource) => Promise<R> | R): Promise<R>;
+
+export { type TypeOrmPoolOptions, createTypeOrmPool, withResource };

package/dist/index.js

@@ -0,0 +1,36 @@
+// src/index.ts
+import { RefCountedLruPool } from "@refpool/core";
+import { DataSource } from "typeorm";
+function createTypeOrmPool(options) {
+  const { config, ...rest } = options;
+  return new RefCountedLruPool({
+    ...rest,
+    factory: async (key) => {
+      const dataSource = new DataSource(await config(key));
+      try {
+        await dataSource.initialize();
+      } catch (error) {
+        await dataSource.destroy().catch(() => {
+        });
+        throw error;
+      }
+      return dataSource;
+    },
+    dispose: async (dataSource) => {
+      await dataSource.destroy();
+    }
+  });
+}
+async function withResource(pool, key, fn) {
+  const handle = await pool.acquire(key);
+  try {
+    return await fn(handle.resource);
+  } finally {
+    handle.release();
+  }
+}
+export {
+  createTypeOrmPool,
+  withResource
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { RefCountedLruPool } from '@refpool/core';\nimport type { AcquireHandle, PoolOptions } from '@refpool/core';\nimport { DataSource } from 'typeorm';\nimport type { DataSourceOptions } from 'typeorm';\n\n/** Options for a per-key TypeORM `DataSource` pool. */\nexport type TypeOrmPoolOptions = Omit<PoolOptions<DataSource>, 'factory' | 'dispose'> & {\n  /** Build the `DataSource` options for a tenant key. */\n  config: (key: string) => DataSourceOptions | Promise<DataSourceOptions>;\n};\n\n/**\n * Create a reference-counted, bounded LRU pool of TypeORM `DataSource`\n * instances keyed by tenant. The factory builds and `.initialize()`s a\n * `DataSource`; dispose `.destroy()`s it on eviction/drain.\n */\nexport function createTypeOrmPool(options: TypeOrmPoolOptions): RefCountedLruPool<DataSource> {\n  const { config, ...rest } = options;\n  return new RefCountedLruPool<DataSource>({\n    ...rest,\n    factory: async (key) => {\n      const dataSource = new DataSource(await config(key));\n      try {\n        await dataSource.initialize();\n      } catch (error) {\n        await dataSource.destroy().catch(() => {});\n        throw error;\n      }\n      return dataSource;\n    },\n    dispose: async (dataSource) => {\n      await dataSource.destroy();\n    },\n  });\n}\n\n/** Acquire `key`, run `fn`, and release the holder in `finally`. */\nexport async function withResource<R>(\n  pool: RefCountedLruPool<DataSource>,\n  key: string,\n  fn: (dataSource: DataSource) => Promise<R> | R,\n): Promise<R> {\n  const handle: AcquireHandle<DataSource> = await pool.acquire(key);\n  try {\n    return await fn(handle.resource);\n  } finally {\n    handle.release();\n  }\n}\n"],"mappings":";AAAA,SAAS,yBAAyB;AAElC,SAAS,kBAAkB;AAcpB,SAAS,kBAAkB,SAA4D;AAC5F,QAAM,EAAE,QAAQ,GAAG,KAAK,IAAI;AAC5B,SAAO,IAAI,kBAA8B;AAAA,IACvC,GAAG;AAAA,IACH,SAAS,OAAO,QAAQ;AACtB,YAAM,aAAa,IAAI,WAAW,MAAM,OAAO,GAAG,CAAC;AACnD,UAAI;AACF,cAAM,WAAW,WAAW;AAAA,MAC9B,SAAS,OAAO;AACd,cAAM,WAAW,QAAQ,EAAE,MAAM,MAAM;AAAA,QAAC,CAAC;AACzC,cAAM;AAAA,MACR;AACA,aAAO;AAAA,IACT;AAAA,IACA,SAAS,OAAO,eAAe;AAC7B,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAGA,eAAsB,aACpB,MACA,KACA,IACY;AACZ,QAAM,SAAoC,MAAM,KAAK,QAAQ,GAAG;AAChE,MAAI;AACF,WAAO,MAAM,GAAG,OAAO,QAAQ;AAAA,EACjC,UAAE;AACA,WAAO,QAAQ;AAAA,EACjB;AACF;","names":[]}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@refpool/typeorm",
+  "version": "0.1.0",
+  "description": "Multi-tenant TypeORM DataSource pooling built on @refpool/core's reference-counted, bounded LRU pool.",
+  "license": "MIT",
+  "author": "Atul Singh <atulsingh.harsh@gmail.com> (https://atulsingh.io)",
+  "type": "module",
+  "sideEffects": false,
+  "keywords": [
+    "typeorm",
+    "datasource",
+    "pool",
+    "multi-tenant",
+    "connection-pool",
+    "refpool"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/expedite-atul/refpool.git",
+    "directory": "packages/typeorm"
+  },
+  "homepage": "https://github.com/expedite-atul/refpool/tree/main/packages/typeorm#readme",
+  "bugs": {
+    "url": "https://github.com/expedite-atul/refpool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@refpool/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "typeorm": "^0.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typeorm": "^0.3.20",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}