@btravstack/prisma 0.43.0 → 0.44.1

package/README.md

@@ -9,11 +9,20 @@
 
 ```sh
 pnpm add @btravstack/prisma @btravstack/core @btravstack/config @btravstack/di unthrown \
-  @prisma/orm-postgres@8.0.0-rc.11
+  @prisma/orm-postgres@8.0.0-rc.18 temporal-polyfill@1.0.4
 ```
 
-Five peer dependencies — install every one, 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 `afterQuery` 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 `afterQuery` 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

@@ -5,60 +5,62 @@ let _btravstack_di = require("@btravstack/di");
 let unthrown = require("unthrown");
 //#region src/instrument.ts
 /**
-* 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.
+* 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.
 *
-* **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 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.
-*
-* **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.
+* 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 open = /* @__PURE__ */ new Map();
-	const start = (plan, ctx) => {
-		open.set(ctx.planExecutionId, (0, _btravstack_core.observe)(observers, {
-			component: "database",
-			name: "query",
-			attributes: { scope: ctx.scope ?? "runtime" },
-			...plan.sql === void 0 ? {} : { details: { sql: plan.sql } }
-		}));
+	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 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 } }
-		});
+	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",
-		beforeQuery: start,
-		afterQuery: finish,
-		beforeExecute: start,
-		afterExecute: finish
+		beforeEncode: (plan, ctx) => {
+			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 finish = state["settle"];
+				delete state["settle"];
+				settle(finish, result.outcome === "succeeded", result.source);
+			}
+			return Promise.resolve();
+		},
+		beforeQuery: beforePlan,
+		afterQuery: afterPlan,
+		beforeExecute: beforePlan,
+		afterExecute: afterPlan
 	};
 };
 //#endregion

package/dist/index.d.cts

@@ -2,36 +2,51 @@ import { HealthChecks, Observers } from "@btravstack/core";
 import { Module, PortClassOf } from "@btravstack/di";
 //#region src/instrument.d.ts
 /**
- * A Prisma 8 middleware, structurally — `name`, `familyId` and the four hooks
- * this starter implements.
+ * A Prisma 8 SQL middleware, structurally, with the hooks of BOTH release
+ * trains the peer range admits.
  *
- * 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.
+ * 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 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>;
+  /** 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: 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>;
 };
-/** 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";
+type Scope = "runtime" | "connection" | "transaction";
+type ActivityContext = {
+  readonly scope?: Scope;
+  readonly state: (key: string | symbol) => Record<string | symbol, unknown>;
+};
+type ActivityEnded = {
+  readonly kind: "statement";
+  readonly outcome: "succeeded" | "failed" | "stopped";
+  readonly source?: string;
+} | {
+  readonly kind: "transaction";
+};
+type PlanContext = {
+  readonly scope?: Scope;
 };
-/** What an `after` hook reports. There is no error here: Prisma's shape carries none. */
-type Settled = {
+type Completed = {
   readonly completed: boolean;
   readonly source?: string;
 };
@@ -98,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

@@ -2,36 +2,51 @@ import { HealthChecks, Observers } from "@btravstack/core";
 import { Module, PortClassOf } from "@btravstack/di";
 //#region src/instrument.d.ts
 /**
- * A Prisma 8 middleware, structurally — `name`, `familyId` and the four hooks
- * this starter implements.
+ * A Prisma 8 SQL middleware, structurally, with the hooks of BOTH release
+ * trains the peer range admits.
  *
- * 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.
+ * 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 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>;
+  /** 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: 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>;
 };
-/** 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";
+type Scope = "runtime" | "connection" | "transaction";
+type ActivityContext = {
+  readonly scope?: Scope;
+  readonly state: (key: string | symbol) => Record<string | symbol, unknown>;
+};
+type ActivityEnded = {
+  readonly kind: "statement";
+  readonly outcome: "succeeded" | "failed" | "stopped";
+  readonly source?: string;
+} | {
+  readonly kind: "transaction";
+};
+type PlanContext = {
+  readonly scope?: Scope;
 };
-/** What an `after` hook reports. There is no error here: Prisma's shape carries none. */
-type Settled = {
+type Completed = {
   readonly completed: boolean;
   readonly source?: string;
 };
@@ -98,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

@@ -4,60 +4,62 @@ import { Module, Port, Provider } from "@btravstack/di";
 import { TaggedError, fromPromise, fromSafePromise } from "unthrown";
 //#region src/instrument.ts
 /**
-* 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.
+* 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.
 *
-* **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 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.
-*
-* **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.
+* 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 open = /* @__PURE__ */ new Map();
-	const start = (plan, ctx) => {
-		open.set(ctx.planExecutionId, observe(observers, {
-			component: "database",
-			name: "query",
-			attributes: { scope: ctx.scope ?? "runtime" },
-			...plan.sql === void 0 ? {} : { details: { sql: plan.sql } }
-		}));
+	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 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 } }
-		});
+	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",
-		beforeQuery: start,
-		afterQuery: finish,
-		beforeExecute: start,
-		afterExecute: finish
+		beforeEncode: (plan, ctx) => {
+			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 finish = state["settle"];
+				delete state["settle"];
+				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.43.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,14 +63,15 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@btravstack/config": "0.43.0",
-    "@btravstack/core": "0.43.0",
-    "@btravstack/di": "0.43.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.11",
+    "@prisma/orm-postgres": "8.0.0-rc.18",
     "@types/node": "26.6.5",
     "@unthrown/vitest": "5.12.1",
     "@vitest/coverage-v8": "5.0.3",
+    "temporal-polyfill": "1.0.4",
     "tsdown": "0.23.1",
     "typescript": "7.0.2",
     "typescript-consumer": "npm:typescript@5.9.3",
@@ -78,9 +79,9 @@
     "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@btravstack/config": "^0.43.0",
-    "@btravstack/core": "^0.43.0",
-    "@btravstack/di": "^0.43.0",
+    "@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"
   },