@btravstack/prisma 0.44.0 → 0.44.1

package/README.md

@@ -12,8 +12,17 @@ pnpm add @btravstack/prisma @btravstack/core @btravstack/config @btravstack/di u
   @prisma/orm-postgres@8.0.0-rc.18 temporal-polyfill@1.0.4
 ```
 
-Install the required peers and Postgres polyfill, so the application holds a single
-copy of each. The `prisma` CLI is yours, as a dev dependency: the client is
+Install the required peers, so the application holds a single copy of each;
+`temporal-polyfill` is the Postgres package's own peer from rc.14. The
+`@prisma/orm-postgres` peer is `^8.0.0-rc.11`, and both ends are tested: an
+application already on rc.11 keeps it.
+
+**Upgrading with released migrations:** upgrade `@btravstack/prisma` and its
+`@btravstack/*` peers, and leave Prisma where it is. No contract, migration or
+database marker changes. Upgrading Prisma itself from rc.11 rewrites every
+released migration and re-signs every database, which is Prisma's path rather
+than this package's; see
+[Supported Prisma trains](https://btravstack.github.io/btravstack/reference/prisma#supported-prisma-trains). The `prisma` CLI is yours, as a dev dependency: the client is
 built from _your_ emitted contract, so there is none for this package to ship.
 Node `>=22.12`.
 
@@ -96,7 +105,7 @@ the per-query observation below comes from.
   lane, folded into the kernel's `GET /healthz` with nothing wired. `/readyz`
   does not read it: failing readiness on a dependency every replica shares
   removes them all at once.
-- **Every query handed to `Observers`**, as one SQL activity middleware, so
+- **Every query handed to `Observers`**, as one statement middleware, so
   composing `observability()` writes the failures as lines and `otel()` opens
   the spans and mints the instruments — with no flag here and no port list to
   satisfy when you compose neither. A middleware sees the ORM lane, the SQL
@@ -188,7 +197,7 @@ rather than the role `DATABASE_URL` carries. An application that migrates itself
 at boot races every other replica.
 
 **Engine-level tracing.** There is no engine: Prisma 8 is a TypeScript runtime
-and ships no instrumentation package, so the SQL activity middleware is the
+and ships no instrumentation package, so the statement middleware is the
 whole seam and it already carries the runtime's own latency.
 
 **Transactions.** Commit boundaries belong to the adapter, spelled at the call —

package/dist/index.cjs

@@ -4,33 +4,63 @@ let _btravstack_core = require("@btravstack/core");
 let _btravstack_di = require("@btravstack/di");
 let unthrown = require("unthrown");
 //#region src/instrument.ts
-/** Observe both SQL lanes from encoding until their statement activity ends. */
+/**
+* Every statement, handed to the graph's observers: a span around it, a count
+* of how it came out, and a log line if it failed.
+*
+* The operation STARTS before the driver runs and settles after it, because
+* `Observers` answers a finisher precisely so a span can be opened around the
+* work. On rc.18 the finisher rides the activity's own `ctx.state`. On rc.11 it
+* is keyed WEAKLY by the operation's context, the one object every hook of a
+* statement is handed: a statement refused after `beforeQuery` (a later
+* middleware, a codec, an abort) never reaches `afterQuery`, and a map keyed by
+* `planExecutionId` would keep its finisher for the client's lifetime.
+*/
 const queryObserver = (observers) => {
 	const key = Symbol("btravstack-query-observer");
+	const inFlight = /* @__PURE__ */ new WeakMap();
+	const start = (plan, scope) => (0, _btravstack_core.observe)(observers, {
+		component: "database",
+		name: "query",
+		attributes: { scope: scope ?? "runtime" },
+		...plan.sql === void 0 ? {} : { details: { sql: plan.sql } }
+	});
+	const settle = (finish, ok, source) => {
+		finish?.({
+			outcome: ok ? "ok" : "error",
+			...source === void 0 ? {} : { attributes: { source } }
+		});
+	};
+	const beforePlan = (plan, ctx) => {
+		inFlight.set(ctx, start(plan, ctx.scope));
+		return Promise.resolve();
+	};
+	const afterPlan = (_plan, result, ctx) => {
+		const finish = inFlight.get(ctx);
+		inFlight.delete(ctx);
+		settle(finish, result.completed, result.source);
+		return Promise.resolve();
+	};
 	return {
 		name: "btravstack-observers",
 		familyId: "sql",
 		beforeEncode: (plan, ctx) => {
-			ctx.state(key)["settle"] = (0, _btravstack_core.observe)(observers, {
-				component: "database",
-				name: "query",
-				attributes: { scope: ctx.scope ?? "runtime" },
-				...plan.sql === void 0 ? {} : { details: { sql: plan.sql } }
-			});
+			ctx.state(key)["settle"] = start(plan, ctx.scope);
 			return Promise.resolve();
 		},
 		activityEnded: (_activity, result, ctx) => {
 			if (result.kind === "statement") {
 				const state = ctx.state(key);
-				const settle = state["settle"];
+				const finish = state["settle"];
 				delete state["settle"];
-				settle?.({
-					outcome: result.outcome === "succeeded" ? "ok" : "error",
-					...result.source === void 0 ? {} : { attributes: { source: result.source } }
-				});
+				settle(finish, result.outcome === "succeeded", result.source);
 			}
 			return Promise.resolve();
-		}
+		},
+		beforeQuery: beforePlan,
+		afterQuery: afterPlan,
+		beforeExecute: beforePlan,
+		afterExecute: afterPlan
 	};
 };
 //#endregion

package/dist/index.d.cts

@@ -1,29 +1,55 @@
 import { HealthChecks, Observers } from "@btravstack/core";
 import { Module, PortClassOf } from "@btravstack/di";
 //#region src/instrument.d.ts
-/** Structural Prisma 8 SQL hooks; no target-package import reaches consumers. */
+/**
+ * A Prisma 8 SQL middleware, structurally, with the hooks of BOTH release
+ * trains the peer range admits.
+ *
+ * Prisma 8.0.0-rc.18 replaced the per-statement hooks: `beforeQuery` and
+ * `beforeExecute` became `beforeEncode`, `afterQuery` and `afterExecute`
+ * became `activityEnded`. The two sets are disjoint and neither runtime refuses
+ * a hook it does not know, so one object serves both: each runtime calls its
+ * own pair and never the other's. Declared here rather than imported so the
+ * option's type drags no target package into a consumer.
+ */
 type SqlMiddlewareLike = {
   readonly name: string;
   readonly familyId: "sql";
-  readonly beforeEncode: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  /** rc.18 and later: before the statement's parameters are encoded, on both lanes. */
+  readonly beforeEncode: (plan: Plan, ctx: ActivityContext) => Promise<void>;
+  /** rc.18 and later: a statement or a transaction ended. */
   readonly activityEnded: (activity: {
     readonly kind: "statement" | "transaction";
-  }, result: Settled, ctx: MiddlewareContext) => Promise<void>;
+  }, result: ActivityEnded, ctx: ActivityContext) => Promise<void>;
+  /** rc.11 to rc.17: a statement read for its rows. */
+  readonly beforeQuery: (plan: Plan, ctx: PlanContext) => Promise<void>;
+  readonly afterQuery: (plan: Plan, result: Completed, ctx: PlanContext) => Promise<void>;
+  /** rc.11 to rc.17: a statement run for its statistics, such as a write with no `RETURNING`. */
+  readonly beforeExecute: (plan: Plan, ctx: PlanContext) => Promise<void>;
+  readonly afterExecute: (plan: Plan, result: Completed, ctx: PlanContext) => Promise<void>;
 };
 type Plan = {
   readonly sql?: string;
 };
-type MiddlewareContext = {
-  readonly scope?: "runtime" | "connection" | "transaction";
+type Scope = "runtime" | "connection" | "transaction";
+type ActivityContext = {
+  readonly scope?: Scope;
   readonly state: (key: string | symbol) => Record<string | symbol, unknown>;
 };
-type Settled = {
+type ActivityEnded = {
   readonly kind: "statement";
   readonly outcome: "succeeded" | "failed" | "stopped";
   readonly source?: string;
 } | {
   readonly kind: "transaction";
 };
+type PlanContext = {
+  readonly scope?: Scope;
+};
+type Completed = {
+  readonly completed: boolean;
+  readonly source?: string;
+};
 //#endregion
 //#region src/prisma.d.ts
 /**
@@ -87,9 +113,9 @@ 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.
+   * The starter's own middleware — the statement hooks of every supported
+   * Prisma train, reporting every query to `Observers`. Spread it into the
+   * client's `middleware` array beside any of the application's own.
    */
   readonly middleware: readonly SqlMiddlewareLike[];
 };

package/dist/index.d.mts

@@ -1,29 +1,55 @@
 import { HealthChecks, Observers } from "@btravstack/core";
 import { Module, PortClassOf } from "@btravstack/di";
 //#region src/instrument.d.ts
-/** Structural Prisma 8 SQL hooks; no target-package import reaches consumers. */
+/**
+ * A Prisma 8 SQL middleware, structurally, with the hooks of BOTH release
+ * trains the peer range admits.
+ *
+ * Prisma 8.0.0-rc.18 replaced the per-statement hooks: `beforeQuery` and
+ * `beforeExecute` became `beforeEncode`, `afterQuery` and `afterExecute`
+ * became `activityEnded`. The two sets are disjoint and neither runtime refuses
+ * a hook it does not know, so one object serves both: each runtime calls its
+ * own pair and never the other's. Declared here rather than imported so the
+ * option's type drags no target package into a consumer.
+ */
 type SqlMiddlewareLike = {
   readonly name: string;
   readonly familyId: "sql";
-  readonly beforeEncode: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  /** rc.18 and later: before the statement's parameters are encoded, on both lanes. */
+  readonly beforeEncode: (plan: Plan, ctx: ActivityContext) => Promise<void>;
+  /** rc.18 and later: a statement or a transaction ended. */
   readonly activityEnded: (activity: {
     readonly kind: "statement" | "transaction";
-  }, result: Settled, ctx: MiddlewareContext) => Promise<void>;
+  }, result: ActivityEnded, ctx: ActivityContext) => Promise<void>;
+  /** rc.11 to rc.17: a statement read for its rows. */
+  readonly beforeQuery: (plan: Plan, ctx: PlanContext) => Promise<void>;
+  readonly afterQuery: (plan: Plan, result: Completed, ctx: PlanContext) => Promise<void>;
+  /** rc.11 to rc.17: a statement run for its statistics, such as a write with no `RETURNING`. */
+  readonly beforeExecute: (plan: Plan, ctx: PlanContext) => Promise<void>;
+  readonly afterExecute: (plan: Plan, result: Completed, ctx: PlanContext) => Promise<void>;
 };
 type Plan = {
   readonly sql?: string;
 };
-type MiddlewareContext = {
-  readonly scope?: "runtime" | "connection" | "transaction";
+type Scope = "runtime" | "connection" | "transaction";
+type ActivityContext = {
+  readonly scope?: Scope;
   readonly state: (key: string | symbol) => Record<string | symbol, unknown>;
 };
-type Settled = {
+type ActivityEnded = {
   readonly kind: "statement";
   readonly outcome: "succeeded" | "failed" | "stopped";
   readonly source?: string;
 } | {
   readonly kind: "transaction";
 };
+type PlanContext = {
+  readonly scope?: Scope;
+};
+type Completed = {
+  readonly completed: boolean;
+  readonly source?: string;
+};
 //#endregion
 //#region src/prisma.d.ts
 /**
@@ -87,9 +113,9 @@ 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.
+   * The starter's own middleware — the statement hooks of every supported
+   * Prisma train, reporting every query to `Observers`. Spread it into the
+   * client's `middleware` array beside any of the application's own.
    */
   readonly middleware: readonly SqlMiddlewareLike[];
 };

package/dist/index.mjs

@@ -3,33 +3,63 @@ import { HealthCheckFailed, HealthChecks, Observers, noObserverMember, observe }
 import { Module, Port, Provider } from "@btravstack/di";
 import { TaggedError, fromPromise, fromSafePromise } from "unthrown";
 //#region src/instrument.ts
-/** Observe both SQL lanes from encoding until their statement activity ends. */
+/**
+* Every statement, handed to the graph's observers: a span around it, a count
+* of how it came out, and a log line if it failed.
+*
+* The operation STARTS before the driver runs and settles after it, because
+* `Observers` answers a finisher precisely so a span can be opened around the
+* work. On rc.18 the finisher rides the activity's own `ctx.state`. On rc.11 it
+* is keyed WEAKLY by the operation's context, the one object every hook of a
+* statement is handed: a statement refused after `beforeQuery` (a later
+* middleware, a codec, an abort) never reaches `afterQuery`, and a map keyed by
+* `planExecutionId` would keep its finisher for the client's lifetime.
+*/
 const queryObserver = (observers) => {
 	const key = Symbol("btravstack-query-observer");
+	const inFlight = /* @__PURE__ */ new WeakMap();
+	const start = (plan, scope) => observe(observers, {
+		component: "database",
+		name: "query",
+		attributes: { scope: scope ?? "runtime" },
+		...plan.sql === void 0 ? {} : { details: { sql: plan.sql } }
+	});
+	const settle = (finish, ok, source) => {
+		finish?.({
+			outcome: ok ? "ok" : "error",
+			...source === void 0 ? {} : { attributes: { source } }
+		});
+	};
+	const beforePlan = (plan, ctx) => {
+		inFlight.set(ctx, start(plan, ctx.scope));
+		return Promise.resolve();
+	};
+	const afterPlan = (_plan, result, ctx) => {
+		const finish = inFlight.get(ctx);
+		inFlight.delete(ctx);
+		settle(finish, result.completed, result.source);
+		return Promise.resolve();
+	};
 	return {
 		name: "btravstack-observers",
 		familyId: "sql",
 		beforeEncode: (plan, ctx) => {
-			ctx.state(key)["settle"] = observe(observers, {
-				component: "database",
-				name: "query",
-				attributes: { scope: ctx.scope ?? "runtime" },
-				...plan.sql === void 0 ? {} : { details: { sql: plan.sql } }
-			});
+			ctx.state(key)["settle"] = start(plan, ctx.scope);
 			return Promise.resolve();
 		},
 		activityEnded: (_activity, result, ctx) => {
 			if (result.kind === "statement") {
 				const state = ctx.state(key);
-				const settle = state["settle"];
+				const finish = state["settle"];
 				delete state["settle"];
-				settle?.({
-					outcome: result.outcome === "succeeded" ? "ok" : "error",
-					...result.source === void 0 ? {} : { attributes: { source: result.source } }
-				});
+				settle(finish, result.outcome === "succeeded", result.source);
 			}
 			return Promise.resolve();
-		}
+		},
+		beforeQuery: beforePlan,
+		afterQuery: afterPlan,
+		beforeExecute: beforePlan,
+		afterExecute: afterPlan
 	};
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btravstack/prisma",
-  "version": "0.44.0",
+  "version": "0.44.1",
   "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",
@@ -63,9 +63,9 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@btravstack/config": "0.44.0",
-    "@btravstack/core": "0.44.0",
-    "@btravstack/di": "0.44.0",
+    "@btravstack/config": "0.44.1",
+    "@btravstack/core": "0.44.1",
+    "@btravstack/di": "0.44.1",
     "@btravstack/tsconfig": "0.4.0",
     "@prisma/orm-postgres": "8.0.0-rc.18",
     "@types/node": "26.6.5",
@@ -79,10 +79,10 @@
     "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@btravstack/config": "^0.44.0",
-    "@btravstack/core": "^0.44.0",
-    "@btravstack/di": "^0.44.0",
-    "@prisma/orm-postgres": "^8.0.0-rc.18",
+    "@btravstack/config": "^0.44.1",
+    "@btravstack/core": "^0.44.1",
+    "@btravstack/di": "^0.44.1",
+    "@prisma/orm-postgres": "^8.0.0-rc.11",
     "unthrown": "^5.0.0"
   },
   "engines": {