@refpool/prisma 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,53 @@
+# @refpool/prisma
+
+Multi-tenant **`PrismaClient` pooling** built on [`@refpool/core`](../core)'s
+reference-counted, bounded LRU pool.
+
+A pool of `PrismaClient` instances keyed by tenant — useful for per-tenant
+database URLs — bounded at `max`, shared between concurrent requests for the same
+tenant, with idle clients `$disconnect`ed automatically.
+
+## Install
+
+```bash
+npm install @refpool/prisma @prisma/client
+```
+
+`@prisma/client` is an **optional** peer dependency (`>=5.0.0`). The adapter
+types against a minimal `{ $connect, $disconnect }` shape, so it works with any
+generated client without a hard build-time dependency.
+
+## Usage
+
+```ts
+import { createPrismaPool, withResource } from '@refpool/prisma';
+import { PrismaClient } from '@prisma/client';
+
+const pool = createPrismaPool({
+  max: 20,
+  idleTtlMs: 60_000,
+  client: (tenantId) =>
+    new PrismaClient({
+      datasources: { db: { url: `postgres://localhost:5432/tenant_${tenantId}` } },
+    }),
+});
+pool.start();
+
+const users = await withResource(pool, tenantId, (prisma) => prisma.user.findMany());
+
+await pool.stop(); // on shutdown: disconnects every live client
+```
+
+The factory calls your `client(key)` then `$connect`s it; `dispose` `$disconnect`s
+it on eviction/drain. All other [`PoolOptions`](../core#pooloptionst) pass through.
+
+## API
+
+- `createPrismaPool<TClient>(options)` → `RefCountedLruPool<TClient>` —
+  `options` is `PoolOptions` minus `factory`/`dispose`, plus
+  `client: (key) => TClient | Promise<TClient>` (a *not-yet-connected* client).
+- `withResource(pool, key, fn)` — acquire `key`, run `fn(client)`, release in `finally`.
+
+## License
+
+MIT © Atul Singh

package/dist/index.cjs

@@ -0,0 +1,61 @@
+"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, {
+  createPrismaPool: () => createPrismaPool,
+  withResource: () => withResource
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@refpool/core");
+function createPrismaPool(options) {
+  const { client, ...rest } = options;
+  return new import_core.RefCountedLruPool({
+    ...rest,
+    factory: async (key) => {
+      const instance = await client(key);
+      try {
+        await instance.$connect();
+      } catch (error) {
+        await instance.$disconnect().catch(() => {
+        });
+        throw error;
+      }
+      return instance;
+    },
+    dispose: async (instance) => {
+      await instance.$disconnect();
+    }
+  });
+}
+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 = {
+  createPrismaPool,
+  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';\n\n/**\n * Minimal structural shape of a `PrismaClient`. Adapting against this avoids a\n * hard dependency on a generated client at build time.\n */\nexport interface PrismaClientLike {\n  $connect(): Promise<void>;\n  $disconnect(): Promise<void>;\n}\n\n/** Options for a per-key `PrismaClient` pool. */\nexport type PrismaPoolOptions<TClient extends PrismaClientLike> = Omit<\n  PoolOptions<TClient>,\n  'factory' | 'dispose'\n> & {\n  /** Construct a (not-yet-connected) PrismaClient for a tenant key. */\n  client: (key: string) => TClient | Promise<TClient>;\n};\n\n/**\n * Create a reference-counted, bounded LRU pool of `PrismaClient` instances\n * keyed by tenant. The factory `$connect`s a client; dispose `$disconnect`s it\n * on eviction/drain.\n */\nexport function createPrismaPool<TClient extends PrismaClientLike>(\n  options: PrismaPoolOptions<TClient>,\n): RefCountedLruPool<TClient> {\n  const { client, ...rest } = options;\n  return new RefCountedLruPool<TClient>({\n    ...rest,\n    factory: async (key) => {\n      const instance = await client(key);\n      try {\n        await instance.$connect();\n      } catch (error) {\n        await instance.$disconnect().catch(() => {});\n        throw error;\n      }\n      return instance;\n    },\n    dispose: async (instance) => {\n      await instance.$disconnect();\n    },\n  });\n}\n\n/** Acquire `key`, run `fn`, and release the holder in `finally`. */\nexport async function withResource<TClient extends PrismaClientLike, R>(\n  pool: RefCountedLruPool<TClient>,\n  key: string,\n  fn: (client: TClient) => Promise<R> | R,\n): Promise<R> {\n  const handle: AcquireHandle<TClient> = 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;AA0B3B,SAAS,iBACd,SAC4B;AAC5B,QAAM,EAAE,QAAQ,GAAG,KAAK,IAAI;AAC5B,SAAO,IAAI,8BAA2B;AAAA,IACpC,GAAG;AAAA,IACH,SAAS,OAAO,QAAQ;AACtB,YAAM,WAAW,MAAM,OAAO,GAAG;AACjC,UAAI;AACF,cAAM,SAAS,SAAS;AAAA,MAC1B,SAAS,OAAO;AACd,cAAM,SAAS,YAAY,EAAE,MAAM,MAAM;AAAA,QAAC,CAAC;AAC3C,cAAM;AAAA,MACR;AACA,aAAO;AAAA,IACT;AAAA,IACA,SAAS,OAAO,aAAa;AAC3B,YAAM,SAAS,YAAY;AAAA,IAC7B;AAAA,EACF,CAAC;AACH;AAGA,eAAsB,aACpB,MACA,KACA,IACY;AACZ,QAAM,SAAiC,MAAM,KAAK,QAAQ,GAAG;AAC7D,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,25 @@
+import { PoolOptions, RefCountedLruPool } from '@refpool/core';
+
+/**
+ * Minimal structural shape of a `PrismaClient`. Adapting against this avoids a
+ * hard dependency on a generated client at build time.
+ */
+interface PrismaClientLike {
+    $connect(): Promise<void>;
+    $disconnect(): Promise<void>;
+}
+/** Options for a per-key `PrismaClient` pool. */
+type PrismaPoolOptions<TClient extends PrismaClientLike> = Omit<PoolOptions<TClient>, 'factory' | 'dispose'> & {
+    /** Construct a (not-yet-connected) PrismaClient for a tenant key. */
+    client: (key: string) => TClient | Promise<TClient>;
+};
+/**
+ * Create a reference-counted, bounded LRU pool of `PrismaClient` instances
+ * keyed by tenant. The factory `$connect`s a client; dispose `$disconnect`s it
+ * on eviction/drain.
+ */
+declare function createPrismaPool<TClient extends PrismaClientLike>(options: PrismaPoolOptions<TClient>): RefCountedLruPool<TClient>;
+/** Acquire `key`, run `fn`, and release the holder in `finally`. */
+declare function withResource<TClient extends PrismaClientLike, R>(pool: RefCountedLruPool<TClient>, key: string, fn: (client: TClient) => Promise<R> | R): Promise<R>;
+
+export { type PrismaClientLike, type PrismaPoolOptions, createPrismaPool, withResource };

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { PoolOptions, RefCountedLruPool } from '@refpool/core';
+
+/**
+ * Minimal structural shape of a `PrismaClient`. Adapting against this avoids a
+ * hard dependency on a generated client at build time.
+ */
+interface PrismaClientLike {
+    $connect(): Promise<void>;
+    $disconnect(): Promise<void>;
+}
+/** Options for a per-key `PrismaClient` pool. */
+type PrismaPoolOptions<TClient extends PrismaClientLike> = Omit<PoolOptions<TClient>, 'factory' | 'dispose'> & {
+    /** Construct a (not-yet-connected) PrismaClient for a tenant key. */
+    client: (key: string) => TClient | Promise<TClient>;
+};
+/**
+ * Create a reference-counted, bounded LRU pool of `PrismaClient` instances
+ * keyed by tenant. The factory `$connect`s a client; dispose `$disconnect`s it
+ * on eviction/drain.
+ */
+declare function createPrismaPool<TClient extends PrismaClientLike>(options: PrismaPoolOptions<TClient>): RefCountedLruPool<TClient>;
+/** Acquire `key`, run `fn`, and release the holder in `finally`. */
+declare function withResource<TClient extends PrismaClientLike, R>(pool: RefCountedLruPool<TClient>, key: string, fn: (client: TClient) => Promise<R> | R): Promise<R>;
+
+export { type PrismaClientLike, type PrismaPoolOptions, createPrismaPool, withResource };

package/dist/index.js

@@ -0,0 +1,35 @@
+// src/index.ts
+import { RefCountedLruPool } from "@refpool/core";
+function createPrismaPool(options) {
+  const { client, ...rest } = options;
+  return new RefCountedLruPool({
+    ...rest,
+    factory: async (key) => {
+      const instance = await client(key);
+      try {
+        await instance.$connect();
+      } catch (error) {
+        await instance.$disconnect().catch(() => {
+        });
+        throw error;
+      }
+      return instance;
+    },
+    dispose: async (instance) => {
+      await instance.$disconnect();
+    }
+  });
+}
+async function withResource(pool, key, fn) {
+  const handle = await pool.acquire(key);
+  try {
+    return await fn(handle.resource);
+  } finally {
+    handle.release();
+  }
+}
+export {
+  createPrismaPool,
+  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';\n\n/**\n * Minimal structural shape of a `PrismaClient`. Adapting against this avoids a\n * hard dependency on a generated client at build time.\n */\nexport interface PrismaClientLike {\n  $connect(): Promise<void>;\n  $disconnect(): Promise<void>;\n}\n\n/** Options for a per-key `PrismaClient` pool. */\nexport type PrismaPoolOptions<TClient extends PrismaClientLike> = Omit<\n  PoolOptions<TClient>,\n  'factory' | 'dispose'\n> & {\n  /** Construct a (not-yet-connected) PrismaClient for a tenant key. */\n  client: (key: string) => TClient | Promise<TClient>;\n};\n\n/**\n * Create a reference-counted, bounded LRU pool of `PrismaClient` instances\n * keyed by tenant. The factory `$connect`s a client; dispose `$disconnect`s it\n * on eviction/drain.\n */\nexport function createPrismaPool<TClient extends PrismaClientLike>(\n  options: PrismaPoolOptions<TClient>,\n): RefCountedLruPool<TClient> {\n  const { client, ...rest } = options;\n  return new RefCountedLruPool<TClient>({\n    ...rest,\n    factory: async (key) => {\n      const instance = await client(key);\n      try {\n        await instance.$connect();\n      } catch (error) {\n        await instance.$disconnect().catch(() => {});\n        throw error;\n      }\n      return instance;\n    },\n    dispose: async (instance) => {\n      await instance.$disconnect();\n    },\n  });\n}\n\n/** Acquire `key`, run `fn`, and release the holder in `finally`. */\nexport async function withResource<TClient extends PrismaClientLike, R>(\n  pool: RefCountedLruPool<TClient>,\n  key: string,\n  fn: (client: TClient) => Promise<R> | R,\n): Promise<R> {\n  const handle: AcquireHandle<TClient> = await pool.acquire(key);\n  try {\n    return await fn(handle.resource);\n  } finally {\n    handle.release();\n  }\n}\n"],"mappings":";AAAA,SAAS,yBAAyB;AA0B3B,SAAS,iBACd,SAC4B;AAC5B,QAAM,EAAE,QAAQ,GAAG,KAAK,IAAI;AAC5B,SAAO,IAAI,kBAA2B;AAAA,IACpC,GAAG;AAAA,IACH,SAAS,OAAO,QAAQ;AACtB,YAAM,WAAW,MAAM,OAAO,GAAG;AACjC,UAAI;AACF,cAAM,SAAS,SAAS;AAAA,MAC1B,SAAS,OAAO;AACd,cAAM,SAAS,YAAY,EAAE,MAAM,MAAM;AAAA,QAAC,CAAC;AAC3C,cAAM;AAAA,MACR;AACA,aAAO;AAAA,IACT;AAAA,IACA,SAAS,OAAO,aAAa;AAC3B,YAAM,SAAS,YAAY;AAAA,IAC7B;AAAA,EACF,CAAC;AACH;AAGA,eAAsB,aACpB,MACA,KACA,IACY;AACZ,QAAM,SAAiC,MAAM,KAAK,QAAQ,GAAG;AAC7D,MAAI;AACF,WAAO,MAAM,GAAG,OAAO,QAAQ;AAAA,EACjC,UAAE;AACA,WAAO,QAAQ;AAAA,EACjB;AACF;","names":[]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@refpool/prisma",
+  "version": "0.1.0",
+  "description": "Multi-tenant PrismaClient 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": [
+    "prisma",
+    "prisma-client",
+    "pool",
+    "multi-tenant",
+    "connection-pool",
+    "refpool"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/expedite-atul/refpool.git",
+    "directory": "packages/prisma"
+  },
+  "homepage": "https://github.com/expedite-atul/refpool/tree/main/packages/prisma#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": {
+    "@prisma/client": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/client": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}