@btravstack/prisma 0.42.0 → 0.44.0

package/README.md

@@ -9,10 +9,10 @@
 
 ```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
+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
 built from _your_ emitted contract, so there is none for this package to ship.
 Node `>=22.12`.
@@ -96,7 +96,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 SQL activity 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 +188,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 SQL activity 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,61 +4,33 @@ let _btravstack_core = require("@btravstack/core");
 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.
-*
-* **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.
-*/
+/** Observe both SQL lanes from encoding until their statement activity ends. */
 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 } }
-		}));
-		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 } }
-		});
-		return Promise.resolve();
-	};
+	const key = Symbol("btravstack-query-observer");
 	return {
 		name: "btravstack-observers",
 		familyId: "sql",
-		beforeQuery: start,
-		afterQuery: finish,
-		beforeExecute: start,
-		afterExecute: finish
+		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 } }
+			});
+			return Promise.resolve();
+		},
+		activityEnded: (_activity, result, ctx) => {
+			if (result.kind === "statement") {
+				const state = ctx.state(key);
+				const settle = state["settle"];
+				delete state["settle"];
+				settle?.({
+					outcome: result.outcome === "succeeded" ? "ok" : "error",
+					...result.source === void 0 ? {} : { attributes: { source: result.source } }
+				});
+			}
+			return Promise.resolve();
+		}
 	};
 };
 //#endregion

package/dist/index.d.cts

@@ -1,39 +1,28 @@
 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.
- *
- * 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.
- */
+/** Structural Prisma 8 SQL hooks; no target-package import reaches consumers. */
 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>;
+  readonly beforeEncode: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  readonly activityEnded: (activity: {
+    readonly kind: "statement" | "transaction";
+  }, 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";
+  readonly state: (key: string | symbol) => Record<string | symbol, unknown>;
 };
-/** What an `after` hook reports. There is no error here: Prisma's shape carries none. */
 type Settled = {
-  readonly completed: boolean;
+  readonly kind: "statement";
+  readonly outcome: "succeeded" | "failed" | "stopped";
   readonly source?: string;
+} | {
+  readonly kind: "transaction";
 };
 //#endregion
 //#region src/prisma.d.ts

package/dist/index.d.mts

@@ -1,39 +1,28 @@
 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.
- *
- * 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.
- */
+/** Structural Prisma 8 SQL hooks; no target-package import reaches consumers. */
 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>;
+  readonly beforeEncode: (plan: Plan, ctx: MiddlewareContext) => Promise<void>;
+  readonly activityEnded: (activity: {
+    readonly kind: "statement" | "transaction";
+  }, 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";
+  readonly state: (key: string | symbol) => Record<string | symbol, unknown>;
 };
-/** What an `after` hook reports. There is no error here: Prisma's shape carries none. */
 type Settled = {
-  readonly completed: boolean;
+  readonly kind: "statement";
+  readonly outcome: "succeeded" | "failed" | "stopped";
   readonly source?: string;
+} | {
+  readonly kind: "transaction";
 };
 //#endregion
 //#region src/prisma.d.ts

package/dist/index.mjs

@@ -3,61 +3,33 @@ import { HealthCheckFailed, HealthChecks, Observers, noObserverMember, observe }
 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.
-*
-* **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.
-*/
+/** Observe both SQL lanes from encoding until their statement activity ends. */
 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 } }
-		}));
-		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 } }
-		});
-		return Promise.resolve();
-	};
+	const key = Symbol("btravstack-query-observer");
 	return {
 		name: "btravstack-observers",
 		familyId: "sql",
-		beforeQuery: start,
-		afterQuery: finish,
-		beforeExecute: start,
-		afterExecute: finish
+		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 } }
+			});
+			return Promise.resolve();
+		},
+		activityEnded: (_activity, result, ctx) => {
+			if (result.kind === "statement") {
+				const state = ctx.state(key);
+				const settle = state["settle"];
+				delete state["settle"];
+				settle?.({
+					outcome: result.outcome === "succeeded" ? "ok" : "error",
+					...result.source === void 0 ? {} : { attributes: { source: result.source } }
+				});
+			}
+			return Promise.resolve();
+		}
 	};
 };
 //#endregion

package/package.json

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