@btravstack/prisma 0.15.0 → 0.16.0

package/dist/index.d.cts

@@ -1,61 +1,125 @@
 import { Env } from "@btravstack/config";
-import { HealthChecks, Instrumentations, Logger, Observers } from "@btravstack/core";
+import { HealthChecks, Observers } from "@btravstack/core";
 import { Module, PortClassOf } from "@btravstack/di";
-import { PrismaPg } from "@prisma/adapter-pg";
+//#region src/instrument.d.ts
+/**
+ * A Prisma 8 middleware, structurally — `name`, `familyId` and the four hooks
+ * this starter implements.
+ *
+ * Declared here rather than imported from `@prisma/orm-postgres/family-runtime`
+ * so the option's type does not drag the target package into a consumer that
+ * only reads this module's types. A real `SqlMiddleware` satisfies it.
+ */
+type SqlMiddlewareLike = {
+  readonly name: string;
+  readonly familyId: "sql";
+  readonly beforeQuery: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  readonly afterQuery: (plan: Plan, result: Settled, ctx: MiddlewareContext) => Promise<void>;
+  readonly beforeExecute: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  readonly afterExecute: (plan: Plan, result: Settled, ctx: MiddlewareContext) => Promise<void>;
+};
+/** The rendered statement, which both `before` hooks are handed. */
+type Plan = {
+  readonly sql?: string;
+};
+/**
+ * What every hook is handed. `planExecutionId` is the runtime's own correlation
+ * id — its TSDoc names tracing and timing as the reason it exists — and it is
+ * what pairs a `before` with its `after`.
+ */
+type MiddlewareContext = {
+  readonly planExecutionId: string;
+  readonly scope?: "runtime" | "connection" | "transaction";
+};
+/** What an `after` hook reports. There is no error here: Prisma's shape carries none. */
+type Settled = {
+  readonly completed: boolean;
+  readonly source?: string;
+};
+//#endregion
 //#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.
+ * All this starter needs of a client: a raw lane to probe with, and a runtime
+ * to run the probe on and to close.
+ *
+ * A Prisma 8 client satisfies it structurally. Both members are part of the
+ * contract rather than optional because every client has them, and a probe that
+ * has to feature-detect its own client cannot report the difference between
+ * "the database is down" and "this client cannot be asked".
  */
 type PrismaLike = {
-  readonly $disconnect: () => Promise<void>;
   /**
-   * What the health check asks. Part of the contract rather than optional
-   * because every generated Prisma client has it, and a probe that has to
-   * feature-detect its own client cannot report the difference between "the
-   * database is down" and "this client cannot be asked".
+   * The raw lane, required to EXIST and deliberately not described further.
+   *
+   * Spelling its signature out here would refuse every real client: a
+   * parameter is contravariant, and the genuine `raw.sql` takes the target's
+   * own interpolation union and its own row-spec type, both of which are
+   * narrower than anything this package — which cannot see a contract — could
+   * name. `unknown` on the property still requires it to be there, which is
+   * what makes a client with no raw lane a compile error.
+   */
+  readonly raw: {
+    readonly sql: unknown;
+  };
+  /**
+   * Required to exist, and read through the same cast for the same reason: the
+   * real `execute` takes the contract's own plan type.
+   */
+  readonly runtime: unknown;
+};
+/** What the starter hands {@link PrismaOptions.client}. */
+type PrismaBinding = {
+  /** `DATABASE_URL`, read through `Config` rather than by the application. */
+  readonly url: string;
+  /**
+   * The starter's own middleware — one `afterQuery` hook reporting every
+   * query to `Observers`. Spread it into the client's `middleware` array
+   * beside any of the application's own.
    */
-  readonly $queryRaw: (query: TemplateStringsArray, ...values: unknown[]) => Promise<unknown>;
+  readonly middleware: readonly SqlMiddlewareLike[];
 };
 /** What {@link prismaDatabase} is handed. */
 type PrismaOptions<C extends PrismaLike> = {
   /**
-   * Builds the client from the driver adapter, which is already constructed
-   * from the environment's URL.
+   * Builds the client from what the starter bound.
    *
-   * 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.
+   * This is the one thing the starter cannot own: a Prisma 8 client is typed by
+   * the application's own emitted `Contract` and constructed from its own
+   * `contract.json`, so there is no client type to ship. Building it here is
+   * what makes the returned type exactly the one the application will hold.
+   *
+   * @example
+   * ```ts
+   * prismaDatabase("OrderDatabase")({
+   *   client: ({ url, middleware }) =>
+   *     postgres<Contract>({ contractJson, url, middleware }),
+   * });
+   * ```
    */
-  readonly client: (adapter: PrismaPg) => C;
+  readonly client: (binding: PrismaBinding) => C;
 };
 /**
  * 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.
+ * Returns a module carrying 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.
  *
  * **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.
+ * value. `runtime().close()` ends the pool; 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`
+ * **Migrations are not run here.** A deployment runs `prisma db migrate`
  * against this same URL *before the process starts*; an application that
  * migrates itself at boot races every other replica.
  */
-export declare const prismaDatabase: <const N extends string>(name: N) => <C extends PrismaLike>({ client }: PrismaOptions<C>) => Module<HealthChecks | Instrumentations | (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, HealthChecks | Instrumentations | Observers | import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
-  readonly url: string;
-}>> | Exclude<Logger, HealthChecks | Instrumentations | Observers | import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+export declare const prismaDatabase: <const N extends string>(name: N) => <C extends PrismaLike>({ client }: PrismaOptions<C>) => Module<HealthChecks | (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, HealthChecks | Observers | import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
   readonly url: string;
 }>>> & {
   readonly port: PortClassOf<N, C>;
 };
 //#endregion
-export type { PrismaLike, PrismaOptions };
+export type { PrismaBinding, PrismaLike, PrismaOptions, SqlMiddlewareLike };

package/dist/index.d.mts

@@ -1,61 +1,125 @@
 import { Env } from "@btravstack/config";
-import { HealthChecks, Instrumentations, Logger, Observers } from "@btravstack/core";
+import { HealthChecks, Observers } from "@btravstack/core";
 import { Module, PortClassOf } from "@btravstack/di";
-import { PrismaPg } from "@prisma/adapter-pg";
+//#region src/instrument.d.ts
+/**
+ * A Prisma 8 middleware, structurally — `name`, `familyId` and the four hooks
+ * this starter implements.
+ *
+ * Declared here rather than imported from `@prisma/orm-postgres/family-runtime`
+ * so the option's type does not drag the target package into a consumer that
+ * only reads this module's types. A real `SqlMiddleware` satisfies it.
+ */
+type SqlMiddlewareLike = {
+  readonly name: string;
+  readonly familyId: "sql";
+  readonly beforeQuery: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  readonly afterQuery: (plan: Plan, result: Settled, ctx: MiddlewareContext) => Promise<void>;
+  readonly beforeExecute: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  readonly afterExecute: (plan: Plan, result: Settled, ctx: MiddlewareContext) => Promise<void>;
+};
+/** The rendered statement, which both `before` hooks are handed. */
+type Plan = {
+  readonly sql?: string;
+};
+/**
+ * What every hook is handed. `planExecutionId` is the runtime's own correlation
+ * id — its TSDoc names tracing and timing as the reason it exists — and it is
+ * what pairs a `before` with its `after`.
+ */
+type MiddlewareContext = {
+  readonly planExecutionId: string;
+  readonly scope?: "runtime" | "connection" | "transaction";
+};
+/** What an `after` hook reports. There is no error here: Prisma's shape carries none. */
+type Settled = {
+  readonly completed: boolean;
+  readonly source?: string;
+};
+//#endregion
 //#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.
+ * All this starter needs of a client: a raw lane to probe with, and a runtime
+ * to run the probe on and to close.
+ *
+ * A Prisma 8 client satisfies it structurally. Both members are part of the
+ * contract rather than optional because every client has them, and a probe that
+ * has to feature-detect its own client cannot report the difference between
+ * "the database is down" and "this client cannot be asked".
  */
 type PrismaLike = {
-  readonly $disconnect: () => Promise<void>;
   /**
-   * What the health check asks. Part of the contract rather than optional
-   * because every generated Prisma client has it, and a probe that has to
-   * feature-detect its own client cannot report the difference between "the
-   * database is down" and "this client cannot be asked".
+   * The raw lane, required to EXIST and deliberately not described further.
+   *
+   * Spelling its signature out here would refuse every real client: a
+   * parameter is contravariant, and the genuine `raw.sql` takes the target's
+   * own interpolation union and its own row-spec type, both of which are
+   * narrower than anything this package — which cannot see a contract — could
+   * name. `unknown` on the property still requires it to be there, which is
+   * what makes a client with no raw lane a compile error.
+   */
+  readonly raw: {
+    readonly sql: unknown;
+  };
+  /**
+   * Required to exist, and read through the same cast for the same reason: the
+   * real `execute` takes the contract's own plan type.
+   */
+  readonly runtime: unknown;
+};
+/** What the starter hands {@link PrismaOptions.client}. */
+type PrismaBinding = {
+  /** `DATABASE_URL`, read through `Config` rather than by the application. */
+  readonly url: string;
+  /**
+   * The starter's own middleware — one `afterQuery` hook reporting every
+   * query to `Observers`. Spread it into the client's `middleware` array
+   * beside any of the application's own.
    */
-  readonly $queryRaw: (query: TemplateStringsArray, ...values: unknown[]) => Promise<unknown>;
+  readonly middleware: readonly SqlMiddlewareLike[];
 };
 /** What {@link prismaDatabase} is handed. */
 type PrismaOptions<C extends PrismaLike> = {
   /**
-   * Builds the client from the driver adapter, which is already constructed
-   * from the environment's URL.
+   * Builds the client from what the starter bound.
    *
-   * 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.
+   * This is the one thing the starter cannot own: a Prisma 8 client is typed by
+   * the application's own emitted `Contract` and constructed from its own
+   * `contract.json`, so there is no client type to ship. Building it here is
+   * what makes the returned type exactly the one the application will hold.
+   *
+   * @example
+   * ```ts
+   * prismaDatabase("OrderDatabase")({
+   *   client: ({ url, middleware }) =>
+   *     postgres<Contract>({ contractJson, url, middleware }),
+   * });
+   * ```
    */
-  readonly client: (adapter: PrismaPg) => C;
+  readonly client: (binding: PrismaBinding) => C;
 };
 /**
  * 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.
+ * Returns a module carrying 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.
  *
  * **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.
+ * value. `runtime().close()` ends the pool; 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`
+ * **Migrations are not run here.** A deployment runs `prisma db migrate`
  * against this same URL *before the process starts*; an application that
  * migrates itself at boot races every other replica.
  */
-export declare const prismaDatabase: <const N extends string>(name: N) => <C extends PrismaLike>({ client }: PrismaOptions<C>) => Module<HealthChecks | Instrumentations | (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, HealthChecks | Instrumentations | Observers | import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
-  readonly url: string;
-}>> | Exclude<Logger, HealthChecks | Instrumentations | Observers | import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
+export declare const prismaDatabase: <const N extends string>(name: N) => <C extends PrismaLike>({ client }: PrismaOptions<C>) => Module<HealthChecks | (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, HealthChecks | Observers | import("@btravstack/di").PortInstance<string, C> | import("@btravstack/di").PortInstance<`${N}Config`, {
   readonly url: string;
 }>>> & {
   readonly port: PortClassOf<N, C>;
 };
 //#endregion
-export type { PrismaLike, PrismaOptions };
+export type { PrismaBinding, PrismaLike, PrismaOptions, SqlMiddlewareLike };

package/dist/index.mjs

@@ -1,150 +1,111 @@
 import { Config, Env } from "@btravstack/config";
-import { HealthCheckFailed, HealthChecks, Instrumentations, Logger, Observers, noObserver, observe } from "@btravstack/core";
+import { HealthCheckFailed, HealthChecks, Observers, noObserver, observe } from "@btravstack/core";
 import { Module, Port, Provider } from "@btravstack/di";
-import { PrismaPg } from "@prisma/adapter-pg";
 import { fromPromise, fromSafePromise } from "unthrown";
 //#region src/instrument.ts
 /**
-* Every query, handed to the graph's observers: a count of how it came out, and
-* a log line if it failed.
+* Every query, handed to the graph's observers: a span that spans the query, 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.
+* **This is why a client the starter cannot name can be instrumented at all.**
+* `middleware` is a construction option rather than a wrapper, and a hook sees
+* every statement on every lane — the ORM's, the SQL builder's and the raw
+* one — so it never needs to know the contract, which is the thing this package
+* cannot see.
 *
-* **It deliberately opens no span.** Prisma's own `@prisma/instrumentation`,
-* which this package offers to `Instrumentations` and
-* `@btravstack/observability/otel` enables, 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.
+* **It starts the operation in `beforeQuery` and settles it in `afterQuery`**,
+* paired by `ctx.planExecutionId`, because that is what `Observers` is for: the
+* port is called at the START and answers a finisher, so an observer can open a
+* span the query runs *inside*. Settling a span reconstructed afterwards from a
+* duration would make it the parent of nothing. It is also why the runtime's
+* own `latencyMs` is not reported — the observer started the operation, so the
+* duration is its own measurement rather than something to pass along.
 *
-* 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.
+* **Both lanes, because there are two.** A read settles through
+* `afterQuery`; a write with no `RETURNING` — a SQL-builder `delete()` run
+* through `runtime().execute(plan)` — settles through `afterExecute` and would
+* otherwise go unobserved entirely.
+*
+* `completed` is what settles the outcome, and a failed statement does reach
+* the hook: measured against a real database, a duplicate insert arrives as
+* `afterQuery … completed=false` before the rejection surfaces. That is what
+* keeps the errors half of RED honest.
 */
-const instrument = (client, observers) => {
-	return client.$extends({ query: { $allModels: { $allOperations: ({ model, operation, args, query }) => {
-		const settle = observe(observers, {
+const queryObserver = (observers) => {
+	const open = /* @__PURE__ */ new Map();
+	const start = (plan, ctx) => {
+		open.set(ctx.planExecutionId, observe(observers, {
 			component: "database",
-			name: operation,
-			attributes: {
-				model: model ?? "raw",
-				operation
-			},
-			traced: false
-		});
-		return query(args).then((value) => {
-			settle({ outcome: "ok" });
-			return value;
-		}, (cause) => {
-			settle({
-				outcome: "error",
-				cause
-			});
-			return Promise.reject(cause);
+			name: "query",
+			attributes: { scope: ctx.scope ?? "runtime" },
+			...plan.sql === void 0 ? {} : { details: { sql: plan.sql } }
+		}));
+		return Promise.resolve();
+	};
+	const finish = (_plan, result, ctx) => {
+		const settle = open.get(ctx.planExecutionId);
+		open.delete(ctx.planExecutionId);
+		settle?.({
+			outcome: result.completed ? "ok" : "error",
+			...result.source === void 0 ? {} : { attributes: { source: result.source } }
 		});
-	} } } });
-};
-//#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, loaded if it is installed.
-*
-* Handed to `@btravstack/observability/otel` through the `Instrumentations`
-* set port rather than registered here: a graph with no SDK collects nothing
-* and this is never called, so engine tracing follows from composing `otel()`
-* instead of from importing this package.
-*
-* **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.
-*
-* This is the one place in this package that still holds a `Logger`, and it is
-* why the module needs one: it is a STARTUP fact rather than an operation, so
-* the `Observers` seam has nothing to settle. An observer writes lines about
-* operations that fail; a missing optional peer is neither.
-*/
-const loadPrismaInstrumentation = 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;
-	}
+		return Promise.resolve();
+	};
+	return {
+		name: "btravstack-observers",
+		familyId: "sql",
+		beforeQuery: start,
+		afterQuery: finish,
+		beforeExecute: start,
+		afterExecute: finish
+	};
 };
 //#endregion
 //#region src/prisma.ts
+/** The one place the cast above is spelled. */
+const probeable = (db) => db;
 /**
 * 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.
+* Returns a module carrying 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.
 *
 * **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.
+* value. `runtime().close()` ends the pool; 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`
+* **Migrations are not run here.** A deployment runs `prisma db migrate`
 * against this same URL *before the process starts*; an application that
 * migrates itself at boot races every other replica.
 */
 const prismaDatabase = (name) => ({ client }) => {
 	const config = Config.provider(`${name}Config`)(Config.object({ url: Config.string("DATABASE_URL") }));
 	const DatabasePort = Port(name);
-	const open = (url) => client(new PrismaPg({ connectionString: url }));
 	const port = DatabasePort;
 	const clientProvider = Provider(port)({
 		inject: {
 			settings: config.port,
 			observers: Observers
 		},
-		acquire: ({ settings, observers }) => {
-			return fromSafePromise(Promise.resolve(instrument(open(settings.url), observers)));
-		},
-		release: (db) => db.$disconnect()
+		acquire: ({ settings, observers }) => fromSafePromise(Promise.resolve().then(() => client({
+			url: settings.url,
+			middleware: [queryObserver(observers)]
+		}))),
+		release: (db) => probeable(db).runtime().close()
 	});
 	const healthCheck = Provider.member(HealthChecks)({
 		inject: { db: port },
 		sync: ({ db }) => ({
 			name,
-			check: () => fromPromise(db.$queryRaw`SELECT 1`, (cause) => new HealthCheckFailed({ reason: cause instanceof Error ? cause.message : "database unreachable" })).map(() => void 0)
+			check: () => fromPromise(probeable(db).runtime().query(probeable(db).raw.sql`SELECT 1`.affectedCount().build()), (cause) => new HealthCheckFailed({ reason: cause instanceof Error ? cause.message : "database unreachable" })).map(() => void 0)
 		})
 	});
-	const instrumentation = Provider.member(Instrumentations)({
-		inject: { logger: Logger },
-		sync: ({ logger }) => () => loadPrismaInstrumentation(logger)
-	});
 	const database = Module(name)({
-		needs: [Env, Logger],
+		needs: [Env],
 		provides: [
 			config,
 			Provider.member(Observers)({
@@ -152,14 +113,9 @@ const prismaDatabase = (name) => ({ client }) => {
 				value: noObserver
 			}),
 			clientProvider,
-			healthCheck,
-			instrumentation
+			healthCheck
 		],
-		exports: [
-			DatabasePort,
-			HealthChecks,
-			Instrumentations
-		]
+		exports: [DatabasePort, HealthChecks]
 	});
 	return Object.assign(database, { port: DatabasePort });
 };

package/dist/result.cjs

@@ -0,0 +1,78 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let unthrown = require("unthrown");
+//#region src/result.ts
+/**
+* A write refused by a unique index or constraint — SQLSTATE `23505`.
+*
+* `constraint` is the index the database named, which is what makes this
+* translatable: a table with two unique constraints produces one error type and
+* the caller still knows which one fired.
+*/
+var UniqueConstraintViolation = class extends (0, unthrown.TaggedError)("UniqueConstraintViolation") {};
+/** A write refused by a foreign key — SQLSTATE `23503`. */
+var ForeignKeyViolation = class extends (0, unthrown.TaggedError)("ForeignKeyViolation") {};
+/**
+* The database refused the statement outright — SQLSTATE `42501`.
+*
+* On a table with row-level security this is what a `WITH CHECK` violation
+* looks like — an `INSERT` or an `UPDATE` whose resulting row falls outside the
+* policy. It is **not** what every cross-tenant statement produces: `USING`
+* FILTERS, so a `SELECT`, `UPDATE` or `DELETE` that matches another tenant's
+* rows answers nothing at all rather than failing. Only a write that lands
+* outside the policy raises this.
+*
+* It is modeled rather than left as a defect because only the caller knows
+* whether reaching it is a bug (an adapter bound to one tenant) or a request
+* (a caller asking for something it may not have).
+*/
+var NotAuthorized = class extends (0, unthrown.TaggedError)("NotAuthorized") {};
+/**
+* SQLSTATE → a tagged error, or the caller's defect for anything unmodeled.
+*
+* The three arms are the ones an application triages. Everything else — a
+* syntax error, a dead connection, a deadlock — is infrastructure a caller
+* cannot act on differently, and belongs on the defect channel where an
+* unexpected failure already goes.
+*/
+const qualify = (cause, defect) => {
+	const error = cause;
+	switch (error?.sqlState) {
+		case "23505": return new UniqueConstraintViolation({
+			constraint: error.constraint,
+			table: error.table
+		});
+		case "23503": return new ForeignKeyViolation({
+			constraint: error.constraint,
+			table: error.table
+		});
+		case "42501": return new NotAuthorized({ table: error.table });
+		default: return defect(cause);
+	}
+};
+/**
+* Runs a query and answers a `Result` instead of rejecting.
+*
+* It takes a **thunk**, not a promise: an `AsyncResult` is eager, and a promise
+* built at the call site has already started before the Result exists. Passing
+* the work in unstarted is what keeps a sequence of these a sequence rather
+* than a race.
+*
+* @example
+* ```ts
+* const save = (order: Order) =>
+*   tryQuery(() => db.orm.orders.Order.create({ orderId: order.id })).mapErrCases(
+*     (matcher, defect) =>
+*       matcher
+*         .with(P.tag("UniqueConstraintViolation"), () => new DuplicateOrder({ id: order.id }))
+*         .with(P.tag("ForeignKeyViolation"), (violation) => defect(violation))
+*         .with(P.tag("NotAuthorized"), (refused) => defect(refused)),
+*   );
+* ```
+*/
+const tryQuery = (run) => (0, unthrown.fromPromise)(Promise.resolve().then(run), qualify);
+//#endregion
+exports.ForeignKeyViolation = ForeignKeyViolation;
+exports.NotAuthorized = NotAuthorized;
+exports.UniqueConstraintViolation = UniqueConstraintViolation;
+exports.qualify = qualify;
+exports.tryQuery = tryQuery;