@btravstack/prisma 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benoit TRAVERS
+
+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,98 @@
+# @btravstack/prisma
+
+> The Prisma starter for [`@btravstack/core`](https://github.com/btravstack/btravstack):
+> `DATABASE_URL` bound through `Config`, the Postgres driver adapter, and a
+> client whose pool is the application scope's.
+
+📖 **[Documentation](https://btravstack.github.io/btravstack/reference/prisma)** ·
+[API Reference](https://btravstack.github.io/btravstack/api/prisma/)
+
+```sh
+pnpm add @btravstack/prisma @btravstack/core @btravstack/config @btravstack/di unthrown \
+  @prisma/adapter-pg
+```
+
+Five peer dependencies — install every one, so the application holds a single
+copy of each. Your own `@prisma/client`, `prisma` and (if you want the `try*`
+twins) `@unthrown/prisma` are yours, not this package's: the client is
+generated from your schema. Node `>=20`.
+
+## A worked example
+
+<!-- doctest: group=order-api -->
+<!-- doctest: prelude
+import { Env } from "@btravstack/config";
+import { Logger, Meter, Tracer } from "@btravstack/core";
+import { Module } from "@btravstack/di";
+import { PrismaPg } from "@prisma/adapter-pg";
+
+// The stand-in for the client YOUR schema generates, and the extension you
+// apply to it. Neither exists in this package — that is what the `client`
+// arrow is for.
+declare class PrismaClient {
+  constructor(options: { readonly adapter: PrismaPg });
+  $disconnect(): Promise<void>;
+  $extends(extension: unknown): this;
+}
+declare const unthrownPrisma: unknown;
+-->
+
+```ts
+import { prismaDatabase } from "@btravstack/prisma";
+
+const database = prismaDatabase("OrderDatabase")({
+  client: (adapter) => new PrismaClient({ adapter }).$extends(unthrownPrisma),
+});
+```
+
+That is the whole surface. `database` carries three pieces, and a composition
+root wants all three:
+
+```ts
+export const PersistenceModule = Module("Persistence")({
+  imports: [database],
+  exports: [database.port],
+  needs: [Env, Logger, Meter, Tracer],
+});
+```
+
+**The client type is yours, and that is deliberate.** A Prisma client is
+generated from _your_ schema, so there is none for this package to ship — the
+`client` arrow is where your generated class and your extensions meet, and the
+port is typed by exactly what it returns.
+
+## What it owns
+
+- **`DATABASE_URL` through `Config`.** A missing or blank value is a modeled
+  `ConfigInvalid` naming the variable, not a throw — so a misconfigured
+  deployment exits `78` with the reason on stderr instead of crashing on the
+  first query.
+- **The Postgres driver adapter**, constructed from that URL. Another driver is
+  reachable — build it in your own `client` arrow and ignore the one passed in.
+- **The pool's lifetime.** The provider is _resourceful_, so `release` closes it
+  on every exit path, including a boot that fails after it ran.
+
+## What it does not
+
+**Migrations.** A deployment runs `prisma migrate deploy` against this same URL
+_before the process starts_. An application that migrates itself at boot races
+every other replica.
+
+**Transactions.** Commit boundaries belong to the adapter, spelled at the call —
+`@unthrown/prisma`'s `$tryTransaction` is the primitive. There is no unit-scoped
+transaction and there will not be one; see
+[the kernel maps nothing](https://btravstack.github.io/btravstack/explanation/the-kernel-maps-nothing).
+
+**A repository base class.** Ports are your application's vocabulary, not this
+package's.
+
+## Options
+
+| Option   | Default          | What it does                                       |
+| -------- | ---------------- | -------------------------------------------------- |
+| `client` | —                | Builds the client from the driver adapter and URL. |
+| `urlVar` | `"DATABASE_URL"` | The variable the connection string is read from.   |
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,150 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _btravstack_config = require("@btravstack/config");
+let _btravstack_core = require("@btravstack/core");
+let _btravstack_di = require("@btravstack/di");
+let _prisma_adapter_pg = require("@prisma/adapter-pg");
+let unthrown = require("unthrown");
+//#region src/instrument.ts
+/**
+* Every query, wrapped: a span around it, a count of how it came out, and a log
+* line if it failed.
+*
+* **This is why a generated client can be instrumented at all.** Prisma's
+* `$extends` takes a `query` component, and `$allModels.$allOperations`
+* intercepts every operation on every model — so the wrapper never needs to
+* know the schema, which is the thing this package cannot see. An earlier
+* revision of this package claimed instrumentation was impossible for that
+* reason; it was wrong, and this is the mechanism it missed.
+*
+* **It deliberately opens no span.** `@btravstack/prisma/otel` enables Prisma's
+* own `@prisma/instrumentation`, which traces at the ENGINE level — the real
+* SQL, the connection acquisition, the serialisation — all of it below what a
+* client-level wrapper can see. Emitting a span here as well would put two
+* spans on every query for strictly less information. What this wrapper keeps
+* is the pair Prisma's instrumentation does not do at all: a metric, and an
+* error line correlated with the ambient unit.
+*
+* The wrapper is transparent to the answer: whatever the query resolves or
+* rejects with is what the caller receives, which is the kernel's own `RunUnit`
+* rule one layer down. `Promise.reject` re-raises rather than `throw`, so the
+* rejection propagates to `@unthrown/prisma`'s `try*` twin without this file
+* needing a `no-throw` exemption.
+*/
+const instrument = (client, logger, meter) => {
+	const operations = meter.createCounter("btravstack.database.operations", { description: "Database queries, by model, operation and outcome" });
+	return client.$extends({ query: { $allModels: { $allOperations: ({ model, operation, args, query }) => {
+		const label = model ?? "raw";
+		return query(args).then((value) => {
+			operations.add(1, {
+				model: label,
+				operation,
+				outcome: "ok"
+			});
+			return value;
+		}, (cause) => {
+			operations.add(1, {
+				model: label,
+				operation,
+				outcome: "error"
+			});
+			logger.error("a database query failed", {
+				model: label,
+				operation
+			}, cause);
+			return Promise.reject(cause);
+		});
+	} } } });
+};
+//#endregion
+//#region src/tracing.ts
+/** Injected so a spec can drive the arm where the optional peer is absent. */
+const defaultLoader = async () => (await import("@prisma/instrumentation")).PrismaInstrumentation;
+/**
+* Prisma's own OpenTelemetry instrumentation, turned on if it is installed.
+*
+* **A dynamic import, and it has to be**: `@prisma/instrumentation` is an
+* OPTIONAL peer, so a static import would make every consumer install it. The
+* import is attempted once, when the instrumented client is built, and a
+* failure to resolve is an ordinary answer rather than a fault — an application
+* that never wanted engine tracing simply does not have the package.
+*
+* **This can be a provider at all** because `@prisma/instrumentation` patches no
+* modules: `enable()` sets a helper on `globalThis` under a versioned key, and
+* a Prisma client reads it PER QUERY. Registration order is therefore free, and
+* this works after `@prisma/client` is imported and after clients are built.
+* The `--import` preload rule in `@btravstack/observability` governs
+* instrumentations that patch, and does not reach this one.
+*
+* **The skip is logged, not silent.** Telemetry you believe you have and do not
+* is worse than none, so the one path that quietly produces no spans says so at
+* `debug` — the level for something that is a choice rather than a fault.
+*/
+const enableTracing = async (logger, load = defaultLoader) => {
+	try {
+		const instrumentation = new (await (load()))();
+		instrumentation.enable();
+		return instrumentation;
+	} catch {
+		logger.debug("engine-level tracing is off: @prisma/instrumentation is not installed. Queries are still counted and failures still logged.");
+		return;
+	}
+};
+//#endregion
+//#region src/prisma.ts
+/**
+* A Prisma client whose pool is the application scope's.
+*
+* Returns the three pieces a composition root needs and nothing more: the
+* `config` provider binding the connection string, the `port` the client is
+* reached through, and the resourceful `provider` that opens it and closes it
+* again. Put both providers in a module's `provides` and export the port.
+*
+* **The pool closes on every exit path**, including a boot that fails after
+* this provider ran — that is what makes it resourceful rather than a plain
+* value. `$disconnect` ends the driver adapter's pool without killing the
+* client; Prisma dials again lazily on the next statement, which is why no
+* spec asserts that a released client refuses to query.
+*
+* **Migrations are not run here.** A deployment runs `prisma migrate deploy`
+* against this same URL *before the process starts*; an application that
+* migrates itself at boot races every other replica.
+*/
+const prismaDatabase = (name) => ({ client, urlVar = "DATABASE_URL", instrumented }) => {
+	const config = _btravstack_config.Config.provider(`${name}Config`)(_btravstack_config.Config.object({ url: _btravstack_config.Config.string(urlVar) }));
+	const DatabasePort = (0, _btravstack_di.Port)(name);
+	const open = (url) => client(new _prisma_adapter_pg.PrismaPg({ connectionString: url }), url);
+	const port = DatabasePort;
+	const instrumentedProvider = (0, _btravstack_di.Provider)(port)({
+		settings: config.port,
+		logger: _btravstack_core.Logger,
+		tracer: _btravstack_core.Tracer,
+		meter: _btravstack_core.Meter
+	}, {
+		acquire: ({ settings, logger, tracer, meter }) => {
+			return (0, unthrown.fromSafePromise)(enableTracing(logger).then(() => instrument(open(settings.url), logger, meter)));
+		},
+		release: (db) => db.$disconnect()
+	});
+	const plainProvider = (0, _btravstack_di.Provider)(port)({ settings: config.port }, {
+		acquire: ({ settings }) => (0, unthrown.OkAsync)(open(settings.url)),
+		release: (db) => db.$disconnect()
+	});
+	const instrumentedModule = (0, _btravstack_di.Module)(name)({
+		needs: [
+			_btravstack_config.Env,
+			_btravstack_core.Logger,
+			_btravstack_core.Meter,
+			_btravstack_core.Tracer
+		],
+		provides: [config, instrumentedProvider],
+		exports: [DatabasePort]
+	});
+	const plainModule = (0, _btravstack_di.Module)(name)({
+		needs: [_btravstack_config.Env],
+		provides: [config, plainProvider],
+		exports: [DatabasePort]
+	});
+	return Object.assign(instrumented !== false ? instrumentedModule : plainModule, { port: DatabasePort });
+};
+//#endregion
+exports.prismaDatabase = prismaDatabase;

package/dist/index.d.cts

@@ -0,0 +1,76 @@
+import { Env } from "@btravstack/config";
+import { Logger, Meter, Tracer } from "@btravstack/core";
+import { Module, PortClassOf } from "@btravstack/di";
+import { PrismaPg } from "@prisma/adapter-pg";
+//#region src/prisma.d.ts
+/**
+ * All this starter needs of a client: a pool it can close. A generated Prisma
+ * client satisfies it structurally, and so does an extended one — `$extends`
+ * preserves `$disconnect` — which is why the application's own client type
+ * flows through untouched.
+ */
+type PrismaLike = {
+  readonly $disconnect: () => Promise<void>;
+};
+/** What {@link prismaDatabase} is handed. */
+type PrismaOptions<C extends PrismaLike, Instrumented extends boolean> = {
+  /**
+   * Builds the client. The driver adapter is already constructed from the
+   * environment's URL; the second argument is that URL, for a client that wants
+   * it directly.
+   *
+   * This is the one thing the starter cannot own: a Prisma client is
+   * **generated per application** from its own schema, so there is no client
+   * type to ship. Applying `@unthrown/prisma`'s extension belongs here too, so
+   * the returned type is exactly the one the application will hold.
+   */
+  readonly client: (adapter: PrismaPg, url: string) => C;
+  /** The variable the connection string is read from. `DATABASE_URL` by 12-factor convention. */
+  readonly urlVar?: string;
+  /**
+   * Span, count and log every query. **Default `true`**, `false` opts out — the
+   * same shape as `cache`, `mailer` and `storage`, and as `StartOptions`'
+   * `signals` and `probes`.
+   *
+   * On by default because telemetry that is missing is discovered during an
+   * incident. The cost is stated rather than hidden: instrumenting puts
+   * `Logger`, `Meter` and `Tracer` in the provider's dependencies, so a root
+   * without `observability()` and `otel()` gets a compile error naming all
+   * three. It also turns on Prisma's own engine-level tracing when
+   * `@prisma/instrumentation` is installed — no wiring at the root.
+   */
+  readonly instrumented?: Instrumented;
+};
+/**
+ * A Prisma client whose pool is the application scope's.
+ *
+ * Returns the three pieces a composition root needs and nothing more: the
+ * `config` provider binding the connection string, the `port` the client is
+ * reached through, and the resourceful `provider` that opens it and closes it
+ * again. Put both providers in a module's `provides` and export the port.
+ *
+ * **The pool closes on every exit path**, including a boot that fails after
+ * this provider ran — that is what makes it resourceful rather than a plain
+ * value. `$disconnect` ends the driver adapter's pool without killing the
+ * client; Prisma dials again lazily on the next statement, which is why no
+ * spec asserts that a released client refuses to query.
+ *
+ * **Migrations are not run here.** A deployment runs `prisma migrate deploy`
+ * against this same URL *before the process starts*; an application that
+ * migrates itself at boot races every other replica.
+ */
+declare const prismaDatabase: <const N extends string>(name: N) => <C extends PrismaLike, Instrumented extends boolean = true>({ client, urlVar, instrumented }: PrismaOptions<C, Instrumented>) => (Instrumented extends true ? Module<PortClassOf<N, C> extends (infer T) ? T extends PortClassOf<N, C> ? T extends import("@btravstack/di").AnyPort ? InstanceType<T> : T extends import("@btravstack/di").AnyProvider ? InstanceType<T["port"]> : never : never : never, import("@btravstack/config").ConfigInvalid, Exclude<Env, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>> | Exclude<Logger, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>> | Exclude<Meter, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>> | Exclude<Tracer, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>>> : Module<PortClassOf<N, C> extends (infer T) ? T extends PortClassOf<N, C> ? T extends import("@btravstack/di").AnyPort ? InstanceType<T> : T extends import("@btravstack/di").AnyProvider ? InstanceType<T["port"]> : never : never : never, import("@btravstack/config").ConfigInvalid, Exclude<Env, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>>>) & {
+  readonly port: PortClassOf<N, C>;
+};
+//#endregion
+export { type PrismaLike, type PrismaOptions, prismaDatabase };

package/dist/index.d.mts

@@ -0,0 +1,76 @@
+import { Env } from "@btravstack/config";
+import { Logger, Meter, Tracer } from "@btravstack/core";
+import { Module, PortClassOf } from "@btravstack/di";
+import { PrismaPg } from "@prisma/adapter-pg";
+//#region src/prisma.d.ts
+/**
+ * All this starter needs of a client: a pool it can close. A generated Prisma
+ * client satisfies it structurally, and so does an extended one — `$extends`
+ * preserves `$disconnect` — which is why the application's own client type
+ * flows through untouched.
+ */
+type PrismaLike = {
+  readonly $disconnect: () => Promise<void>;
+};
+/** What {@link prismaDatabase} is handed. */
+type PrismaOptions<C extends PrismaLike, Instrumented extends boolean> = {
+  /**
+   * Builds the client. The driver adapter is already constructed from the
+   * environment's URL; the second argument is that URL, for a client that wants
+   * it directly.
+   *
+   * This is the one thing the starter cannot own: a Prisma client is
+   * **generated per application** from its own schema, so there is no client
+   * type to ship. Applying `@unthrown/prisma`'s extension belongs here too, so
+   * the returned type is exactly the one the application will hold.
+   */
+  readonly client: (adapter: PrismaPg, url: string) => C;
+  /** The variable the connection string is read from. `DATABASE_URL` by 12-factor convention. */
+  readonly urlVar?: string;
+  /**
+   * Span, count and log every query. **Default `true`**, `false` opts out — the
+   * same shape as `cache`, `mailer` and `storage`, and as `StartOptions`'
+   * `signals` and `probes`.
+   *
+   * On by default because telemetry that is missing is discovered during an
+   * incident. The cost is stated rather than hidden: instrumenting puts
+   * `Logger`, `Meter` and `Tracer` in the provider's dependencies, so a root
+   * without `observability()` and `otel()` gets a compile error naming all
+   * three. It also turns on Prisma's own engine-level tracing when
+   * `@prisma/instrumentation` is installed — no wiring at the root.
+   */
+  readonly instrumented?: Instrumented;
+};
+/**
+ * A Prisma client whose pool is the application scope's.
+ *
+ * Returns the three pieces a composition root needs and nothing more: the
+ * `config` provider binding the connection string, the `port` the client is
+ * reached through, and the resourceful `provider` that opens it and closes it
+ * again. Put both providers in a module's `provides` and export the port.
+ *
+ * **The pool closes on every exit path**, including a boot that fails after
+ * this provider ran — that is what makes it resourceful rather than a plain
+ * value. `$disconnect` ends the driver adapter's pool without killing the
+ * client; Prisma dials again lazily on the next statement, which is why no
+ * spec asserts that a released client refuses to query.
+ *
+ * **Migrations are not run here.** A deployment runs `prisma migrate deploy`
+ * against this same URL *before the process starts*; an application that
+ * migrates itself at boot races every other replica.
+ */
+declare const prismaDatabase: <const N extends string>(name: N) => <C extends PrismaLike, Instrumented extends boolean = true>({ client, urlVar, instrumented }: PrismaOptions<C, Instrumented>) => (Instrumented extends true ? Module<PortClassOf<N, C> extends (infer T) ? T extends PortClassOf<N, C> ? T extends import("@btravstack/di").AnyPort ? InstanceType<T> : T extends import("@btravstack/di").AnyProvider ? InstanceType<T["port"]> : never : never : never, import("@btravstack/config").ConfigInvalid, Exclude<Env, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>> | Exclude<Logger, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>> | Exclude<Meter, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>> | Exclude<Tracer, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>>> : Module<PortClassOf<N, C> extends (infer T) ? T extends PortClassOf<N, C> ? T extends import("@btravstack/di").AnyPort ? InstanceType<T> : T extends import("@btravstack/di").AnyProvider ? InstanceType<T["port"]> : never : never : never, import("@btravstack/config").ConfigInvalid, Exclude<Env, import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+  readonly url: string;
+}>>>) & {
+  readonly port: PortClassOf<N, C>;
+};
+//#endregion
+export { type PrismaLike, type PrismaOptions, prismaDatabase };

package/dist/index.mjs

@@ -0,0 +1,149 @@
+import { Config, Env } from "@btravstack/config";
+import { Logger, Meter, Tracer } from "@btravstack/core";
+import { Module, Port, Provider } from "@btravstack/di";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { OkAsync, fromSafePromise } from "unthrown";
+//#region src/instrument.ts
+/**
+* Every query, wrapped: a span around it, a count of how it came out, and a log
+* line if it failed.
+*
+* **This is why a generated client can be instrumented at all.** Prisma's
+* `$extends` takes a `query` component, and `$allModels.$allOperations`
+* intercepts every operation on every model — so the wrapper never needs to
+* know the schema, which is the thing this package cannot see. An earlier
+* revision of this package claimed instrumentation was impossible for that
+* reason; it was wrong, and this is the mechanism it missed.
+*
+* **It deliberately opens no span.** `@btravstack/prisma/otel` enables Prisma's
+* own `@prisma/instrumentation`, which traces at the ENGINE level — the real
+* SQL, the connection acquisition, the serialisation — all of it below what a
+* client-level wrapper can see. Emitting a span here as well would put two
+* spans on every query for strictly less information. What this wrapper keeps
+* is the pair Prisma's instrumentation does not do at all: a metric, and an
+* error line correlated with the ambient unit.
+*
+* The wrapper is transparent to the answer: whatever the query resolves or
+* rejects with is what the caller receives, which is the kernel's own `RunUnit`
+* rule one layer down. `Promise.reject` re-raises rather than `throw`, so the
+* rejection propagates to `@unthrown/prisma`'s `try*` twin without this file
+* needing a `no-throw` exemption.
+*/
+const instrument = (client, logger, meter) => {
+	const operations = meter.createCounter("btravstack.database.operations", { description: "Database queries, by model, operation and outcome" });
+	return client.$extends({ query: { $allModels: { $allOperations: ({ model, operation, args, query }) => {
+		const label = model ?? "raw";
+		return query(args).then((value) => {
+			operations.add(1, {
+				model: label,
+				operation,
+				outcome: "ok"
+			});
+			return value;
+		}, (cause) => {
+			operations.add(1, {
+				model: label,
+				operation,
+				outcome: "error"
+			});
+			logger.error("a database query failed", {
+				model: label,
+				operation
+			}, cause);
+			return Promise.reject(cause);
+		});
+	} } } });
+};
+//#endregion
+//#region src/tracing.ts
+/** Injected so a spec can drive the arm where the optional peer is absent. */
+const defaultLoader = async () => (await import("@prisma/instrumentation")).PrismaInstrumentation;
+/**
+* Prisma's own OpenTelemetry instrumentation, turned on if it is installed.
+*
+* **A dynamic import, and it has to be**: `@prisma/instrumentation` is an
+* OPTIONAL peer, so a static import would make every consumer install it. The
+* import is attempted once, when the instrumented client is built, and a
+* failure to resolve is an ordinary answer rather than a fault — an application
+* that never wanted engine tracing simply does not have the package.
+*
+* **This can be a provider at all** because `@prisma/instrumentation` patches no
+* modules: `enable()` sets a helper on `globalThis` under a versioned key, and
+* a Prisma client reads it PER QUERY. Registration order is therefore free, and
+* this works after `@prisma/client` is imported and after clients are built.
+* The `--import` preload rule in `@btravstack/observability` governs
+* instrumentations that patch, and does not reach this one.
+*
+* **The skip is logged, not silent.** Telemetry you believe you have and do not
+* is worse than none, so the one path that quietly produces no spans says so at
+* `debug` — the level for something that is a choice rather than a fault.
+*/
+const enableTracing = async (logger, load = defaultLoader) => {
+	try {
+		const instrumentation = new (await (load()))();
+		instrumentation.enable();
+		return instrumentation;
+	} catch {
+		logger.debug("engine-level tracing is off: @prisma/instrumentation is not installed. Queries are still counted and failures still logged.");
+		return;
+	}
+};
+//#endregion
+//#region src/prisma.ts
+/**
+* A Prisma client whose pool is the application scope's.
+*
+* Returns the three pieces a composition root needs and nothing more: the
+* `config` provider binding the connection string, the `port` the client is
+* reached through, and the resourceful `provider` that opens it and closes it
+* again. Put both providers in a module's `provides` and export the port.
+*
+* **The pool closes on every exit path**, including a boot that fails after
+* this provider ran — that is what makes it resourceful rather than a plain
+* value. `$disconnect` ends the driver adapter's pool without killing the
+* client; Prisma dials again lazily on the next statement, which is why no
+* spec asserts that a released client refuses to query.
+*
+* **Migrations are not run here.** A deployment runs `prisma migrate deploy`
+* against this same URL *before the process starts*; an application that
+* migrates itself at boot races every other replica.
+*/
+const prismaDatabase = (name) => ({ client, urlVar = "DATABASE_URL", instrumented }) => {
+	const config = Config.provider(`${name}Config`)(Config.object({ url: Config.string(urlVar) }));
+	const DatabasePort = Port(name);
+	const open = (url) => client(new PrismaPg({ connectionString: url }), url);
+	const port = DatabasePort;
+	const instrumentedProvider = Provider(port)({
+		settings: config.port,
+		logger: Logger,
+		tracer: Tracer,
+		meter: Meter
+	}, {
+		acquire: ({ settings, logger, tracer, meter }) => {
+			return fromSafePromise(enableTracing(logger).then(() => instrument(open(settings.url), logger, meter)));
+		},
+		release: (db) => db.$disconnect()
+	});
+	const plainProvider = Provider(port)({ settings: config.port }, {
+		acquire: ({ settings }) => OkAsync(open(settings.url)),
+		release: (db) => db.$disconnect()
+	});
+	const instrumentedModule = Module(name)({
+		needs: [
+			Env,
+			Logger,
+			Meter,
+			Tracer
+		],
+		provides: [config, instrumentedProvider],
+		exports: [DatabasePort]
+	});
+	const plainModule = Module(name)({
+		needs: [Env],
+		provides: [config, plainProvider],
+		exports: [DatabasePort]
+	});
+	return Object.assign(instrumented !== false ? instrumentedModule : plainModule, { port: DatabasePort });
+};
+//#endregion
+export { prismaDatabase };

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@btravstack/prisma",
+  "version": "0.3.0",
+  "description": "The Prisma starter for @btravstack/core: DATABASE_URL through Config, the Postgres driver adapter, and a client whose pool is the application scope's",
+  "keywords": [
+    "database",
+    "dependency-injection",
+    "postgres",
+    "prisma",
+    "typescript",
+    "unthrown"
+  ],
+  "homepage": "https://github.com/btravstack/btravstack#readme",
+  "bugs": {
+    "url": "https://github.com/btravstack/btravstack/issues"
+  },
+  "license": "MIT",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravstack/btravstack.git",
+    "directory": "packages/prisma"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@btravstack/tsconfig": "0.2.0",
+    "@prisma/adapter-pg": "7.9.1",
+    "@prisma/instrumentation": "7.10.0",
+    "@types/node": "26.2.0",
+    "@unthrown/vitest": "5.7.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2",
+    "unthrown": "5.7.0",
+    "vitest": "4.1.11",
+    "@btravstack/config": "0.3.0",
+    "@btravstack/di": "0.3.0",
+    "@btravstack/core": "0.3.0"
+  },
+  "peerDependencies": {
+    "@prisma/adapter-pg": "^7.0.0",
+    "@prisma/instrumentation": "^7.0.0",
+    "unthrown": "^5.0.0",
+    "@btravstack/config": "^0.3.0",
+    "@btravstack/core": "^0.3.0",
+    "@btravstack/di": "^0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/instrumentation": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run --coverage",
+    "test:types": "tsc -p tsconfig.test-d.json --noEmit",
+    "typecheck": "tsc --noEmit"
+  }
+}