@shivaedev/effect-prisma 0.6.3 → 0.7.0

package/src/internal/recipe.ts

@@ -1,35 +1,30 @@
-import { getRelationPlan, type RelationPlan } from "./relation-plan.js";
+import { hasMethod, invokeMethod } from "./dynamic.ts";
+import { getRelationPlan, type RelationPlan } from "./relation-plan.ts";
 
 export interface RelationOperation {
+	readonly arguments: readonly unknown[];
 	readonly name: PropertyKey;
-	readonly arguments: ReadonlyArray<unknown>;
 }
 
 export interface RelationRecipe {
 	readonly model: string;
-	readonly parent?: RelationRecipe;
 	readonly operation?: RelationOperation;
+	readonly parent?: RelationRecipe;
 }
 
 export const rootRecipe = (model: string): RelationRecipe => ({ model });
 
-export const appendOperation = (
-	parent: RelationRecipe,
-	name: PropertyKey,
-	arguments_: ReadonlyArray<unknown>,
-): RelationRecipe => ({
+export const appendOperation = (parent: RelationRecipe, name: PropertyKey, arguments_: readonly unknown[]): RelationRecipe => ({
 	model: parent.model,
-	parent,
 	operation: {
-		name,
 		arguments: arguments_,
+		name,
 	},
+	parent,
 });
 
-const operations = (
-	recipe: RelationRecipe,
-): ReadonlyArray<RelationOperation> => {
-	const reversed: Array<RelationOperation> = [];
+const operations = (recipe: RelationRecipe): readonly RelationOperation[] => {
+	const reversed: RelationOperation[] = [];
 	let current: RelationRecipe | undefined = recipe;
 
 	while (current !== undefined) {
@@ -42,81 +37,43 @@ const operations = (
 	return reversed.reverse();
 };
 
-const applyMethod = (
-	current: unknown,
-	name: PropertyKey,
-	arguments_: ReadonlyArray<unknown>,
-	model: string,
-): unknown => {
-	if (
-		typeof current !== "object" ||
-		current === null ||
-		typeof Reflect.get(current, name) !== "function"
-	) {
+const applyMethod = (current: unknown, name: PropertyKey, arguments_: readonly unknown[], model: string): unknown => {
+	if (!hasMethod(current, name)) {
 		throw new TypeError(`Cannot call ${String(name)} while replaying ${model}`);
 	}
-
-	const method = Reflect.get(current, name) as (
-		...arguments_: ReadonlyArray<unknown>
-	) => unknown;
-	return Reflect.apply(method, current, arguments_);
+	return invokeMethod(current, name, arguments_);
 };
 
-const replayPlan = (
-	collection: unknown,
-	plan: RelationPlan,
-	owner: object,
-	transactionIdentity: object | undefined,
-): unknown => {
+const replayPlan = (collection: unknown, plan: RelationPlan, owner: object, transactionIdentity: object | undefined): unknown => {
 	if (!plan.liveness.open) {
 		throw new TypeError("Included Relation is closed");
 	}
 	if (plan.owner !== owner) {
 		throw new TypeError("Included Relations must use the same Database");
 	}
-	if (
-		plan.transactionIdentity !== undefined &&
-		plan.transactionIdentity !== transactionIdentity
-	) {
+	if (plan.transactionIdentity !== undefined && plan.transactionIdentity !== transactionIdentity) {
 		throw new TypeError("Included Relation belongs to another transaction");
 	}
-	const relatedModel =
-		typeof collection === "object" && collection !== null
-			? Reflect.get(collection, "modelName")
-			: undefined;
+	const relatedModel = typeof collection === "object" && collection !== null ? Reflect.get(collection, "modelName") : undefined;
 	if (typeof relatedModel === "string" && relatedModel !== plan.recipe.model) {
-		throw new TypeError(
-			`Included relation expects ${relatedModel}, received ${plan.recipe.model}`,
-		);
+		throw new TypeError(`Included relation expects ${relatedModel}, received ${plan.recipe.model}`);
 	}
 
-	const refined = replayRecipeFrom(
-		collection,
-		plan.recipe,
-		owner,
-		transactionIdentity,
-	);
+	const refined = replayRecipeFrom(collection, plan.recipe, owner, transactionIdentity);
 	if (plan.terminal !== "count") {
 		return refined;
 	}
 	return applyMethod(refined, "count", [], plan.recipe.model);
 };
 
-const includeRefinement = (
-	value: unknown,
-	owner: object,
-	transactionIdentity: object | undefined,
-): ((collection: unknown) => unknown) => {
+const includeRefinement = (value: unknown, owner: object, transactionIdentity: object | undefined): ((collection: unknown) => unknown) => {
 	const plan = getRelationPlan(value);
 	if (plan !== undefined) {
-		return (collection) =>
-			replayPlan(collection, plan, owner, transactionIdentity);
+		return (collection) => replayPlan(collection, plan, owner, transactionIdentity);
 	}
 
 	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		throw new TypeError(
-			"An included relation must be a Relation or query record",
-		);
+		throw new TypeError("An included relation must be a Relation or query record");
 	}
 
 	const entries = Object.entries(value);
@@ -137,46 +94,24 @@ const includeRefinement = (
 	}
 
 	return (collection) => {
-		const branches = Object.fromEntries(
-			plans.map(([name, queryPlan]) => [
-				name,
-				replayPlan(collection, queryPlan, owner, transactionIdentity),
-			]),
-		);
+		const branches = Object.fromEntries(plans.map(([name, queryPlan]) => [name, replayPlan(collection, queryPlan, owner, transactionIdentity)]));
 		return applyMethod(collection, "combine", [branches], model ?? "relation");
 	};
 };
 
-const replayRecipeFrom = (
-	root: unknown,
-	recipe: RelationRecipe,
-	owner: object,
-	transactionIdentity: object | undefined,
-): unknown => {
+const replayRecipeFrom = (root: unknown, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown => {
 	let current = root;
 	for (const operation of operations(recipe)) {
 		const arguments_ =
 			operation.name === "include" && operation.arguments.length === 2
-				? [
-						operation.arguments[0],
-						includeRefinement(
-							operation.arguments[1],
-							owner,
-							transactionIdentity,
-						),
-					]
+				? [operation.arguments[0], includeRefinement(operation.arguments[1], owner, transactionIdentity)]
 				: operation.arguments;
 		current = applyMethod(current, operation.name, arguments_, recipe.model);
 	}
 	return current;
 };
 
-export const replayRecipe = (
-	models: object,
-	recipe: RelationRecipe,
-	owner: object,
-	transactionIdentity: object | undefined,
-): unknown => {
+export const replayRecipe = (models: object, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown => {
 	const current: unknown = Reflect.get(models, recipe.model);
 
 	if (current === undefined) {

package/src/internal/relation-plan.ts

@@ -1,4 +1,4 @@
-import type { RelationRecipe } from "./recipe.js";
+import type { RelationRecipe } from "./recipe.ts";
 
 export interface RelationPlan {
 	readonly liveness: { readonly open: boolean };

package/src/internal/relation-result.ts

@@ -0,0 +1,27 @@
+import { Effect, Option } from "effect";
+import type { PrismaError } from "../error.ts";
+import { hasMethod, invokeMethod, isPromiseLike } from "./dynamic.ts";
+import { fromPrismaPromise } from "./promise.ts";
+
+const settle = (value: unknown, map: (result: unknown) => unknown): Effect.Effect<unknown, PrismaError> =>
+	isPromiseLike(value) ? fromPrismaPromise(() => value).pipe(Effect.map(map)) : Effect.succeed(map(value));
+
+const countOf = (result: unknown): unknown => (typeof result === "object" && result !== null ? Reflect.get(result, "count") : undefined);
+
+export const evaluateResult = (value: unknown, terminal: PropertyKey | undefined): Effect.Effect<unknown, PrismaError> => {
+	if (terminal === "count" && hasMethod(value, "aggregate")) {
+		return settle(invokeMethod(value, "aggregate", [(summary: { count: () => unknown }) => ({ count: summary.count() })]), countOf);
+	}
+
+	if (terminal === "exists" && hasMethod(value, "first")) {
+		return settle(invokeMethod(value, "first", []), (result) => result !== null);
+	}
+
+	const executable = hasMethod(value, "all") ? invokeMethod(value, "all", []) : value;
+
+	if (isPromiseLike(executable)) {
+		return settle(executable, (result) => (terminal === "first" ? Option.fromNullishOr(result) : result));
+	}
+
+	return Effect.succeed(executable);
+};

package/src/internal/relation-runtime.ts

@@ -1,167 +1,72 @@
-import { Effect, Effectable, Option, type Stream } from "effect";
-import type { PrismaError } from "../error.js";
-import type { Relation } from "../relation.js";
-import type { AnyPostgresContract, DatabaseExecutor } from "./executor.js";
-import { fromPrismaPromise } from "./promise.js";
-import { executeQuery } from "./query-execution.js";
-import {
-	appendOperation,
-	type RelationRecipe,
-	replayRecipe,
-	rootRecipe,
-} from "./recipe.js";
-import { setRelationPlan } from "./relation-plan.js";
-import { makeRelationStream } from "./relation-stream.js";
+import { Effect, Effectable, type Stream } from "effect";
+import type { PrismaError } from "../error.ts";
+import type { Relation } from "../relation.ts";
+import type { AnyPostgresContract, DatabaseExecutor } from "./executor.ts";
+import { executeQuery } from "./query-execution.ts";
+import { appendOperation, type RelationRecipe, replayRecipe, rootRecipe } from "./recipe.ts";
+import { setRelationPlan } from "./relation-plan.ts";
+import { evaluateResult } from "./relation-result.ts";
+import { makeRelationStream } from "./relation-stream.ts";
 
-type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
-
-interface RelationRuntime<
-	Models extends object,
-	Contract extends AnyPostgresContract,
-> {
+interface RelationRuntime<Models extends object, Contract extends AnyPostgresContract> {
 	readonly executor: DatabaseExecutor<Models, Contract>;
 	readonly recipe: RelationRecipe;
-	readonly resolveExecutor: Effect.Effect<
-		DatabaseExecutor<Models, Contract>,
-		PrismaError
-	>;
+	readonly resolveExecutor: Effect.Effect<DatabaseExecutor<Models, Contract>, PrismaError>;
 	readonly terminal?: PropertyKey;
 }
 
-const evaluateResult = (
-	value: unknown,
-	terminal: PropertyKey | undefined,
-): Effect.Effect<unknown, PrismaError> => {
-	if (
-		terminal === "count" &&
-		typeof value === "object" &&
-		value !== null &&
-		typeof Reflect.get(value, "aggregate") === "function"
-	) {
-		const aggregate = Reflect.apply(
-			Reflect.get(value, "aggregate") as AnyFunction,
-			value,
-			[(summary: { count(): unknown }) => ({ count: summary.count() })],
-		);
-		return fromPrismaPromise(
-			() => aggregate as PromiseLike<{ count: number }>,
-		).pipe(Effect.map((result) => result.count));
-	}
-
-	if (
-		terminal === "exists" &&
-		typeof value === "object" &&
-		value !== null &&
-		typeof Reflect.get(value, "first") === "function"
-	) {
-		const first = Reflect.apply(
-			Reflect.get(value, "first") as AnyFunction,
-			value,
-			[],
-		);
-		return fromPrismaPromise(() => first as PromiseLike<unknown>).pipe(
-			Effect.map((result) => result !== null),
-		);
-	}
-
-	const executable =
-		typeof value === "object" &&
-		value !== null &&
-		typeof Reflect.get(value, "all") === "function"
-			? Reflect.apply(Reflect.get(value, "all") as AnyFunction, value, [])
-			: value;
-
-	if (
-		typeof executable === "object" &&
-		executable !== null &&
-		"then" in executable
-	) {
-		return fromPrismaPromise(() => executable as PromiseLike<unknown>).pipe(
-			Effect.map((result) =>
-				terminal === "first" ? Option.fromNullishOr(result) : result,
-			),
-		);
-	}
-
-	return Effect.succeed(executable);
-};
-
 interface RelationValue extends Effect.Effect<unknown, PrismaError> {
 	readonly stream: Stream.Stream<unknown, PrismaError>;
 }
 
-const runtimes = new WeakMap<object, unknown>();
+type AnyRelationRuntime = RelationRuntime<object, AnyPostgresContract>;
+
+const runtimes = new WeakMap<object, AnyRelationRuntime>();
 
-const runtimeOf = <Models extends object, Contract extends AnyPostgresContract>(
-	self: object,
-): RelationRuntime<Models, Contract> => {
+const runtimeOf = (self: object): AnyRelationRuntime => {
 	const runtime = runtimes.get(self);
 	if (runtime === undefined) {
 		throw new TypeError("Relation runtime is unavailable");
 	}
-	return runtime as RelationRuntime<Models, Contract>;
+	return runtime;
 };
 
-const relationEffect = <
-	Models extends object,
-	Contract extends AnyPostgresContract,
->(
-	self: RelationValue,
-): Effect.Effect<unknown, PrismaError> => {
-	const runtime = runtimeOf<Models, Contract>(self);
+const relationEffect = (self: object): Effect.Effect<unknown, PrismaError> => {
+	const runtime = runtimeOf(self);
 	return Effect.flatMap(runtime.resolveExecutor, (executor) =>
 		executeQuery(
 			executor,
 			Effect.suspend(() =>
-				evaluateResult(
-					replayRecipe(
-						executor.models,
-						runtime.recipe,
-						executor.identity,
-						executor.transactionIdentity,
-					),
-					runtime.terminal,
-				),
+				evaluateResult(replayRecipe(executor.models, runtime.recipe, executor.identity, executor.transactionIdentity), runtime.terminal),
 			),
 		),
 	).pipe(
-		Effect.withSpan(
-			`prisma.${runtime.recipe.model}.${String(runtime.terminal ?? "all")}`,
-			{
-				kind: "client",
-				attributes: {
-					"db.system": "postgresql",
-					"db.model": runtime.recipe.model,
-					"db.operation": String(runtime.terminal ?? "all"),
-				},
+		Effect.withSpan(`prisma.${runtime.recipe.model}.${String(runtime.terminal ?? "all")}`, {
+			attributes: {
+				"db.model": runtime.recipe.model,
+				"db.operation": String(runtime.terminal ?? "all"),
+				"db.system": "postgresql",
 			},
-		),
+			kind: "client",
+		}),
 	);
 };
 
 const RelationPrototype = {
 	...Effectable.Prototype<RelationValue>({
-		label: "EffectPrismaRelation",
 		evaluate() {
 			return relationEffect(this);
 		},
+		label: "EffectPrismaRelation",
 	}),
 	get stream(): Stream.Stream<unknown, PrismaError> {
-		const relation = this as RelationValue;
-		const runtime = runtimeOf<Record<string, unknown>, AnyPostgresContract>(
-			relation,
-		);
+		const runtime = runtimeOf(this);
 		return makeRelationStream(runtime.resolveExecutor, runtime.recipe);
 	},
 };
 
-const makeRelationProxy = <
-	Models extends object,
-	Contract extends AnyPostgresContract,
->(
-	runtime: RelationRuntime<Models, Contract>,
-): unknown => {
-	const target = Object.create(RelationPrototype) as RelationValue;
+const makeRelationProxy = (runtime: AnyRelationRuntime): object => {
+	const target: object = Object.create(RelationPrototype);
 	const proxy = new Proxy(target, {
 		get(self, property, receiver) {
 			if (property === "then") {
@@ -184,7 +89,7 @@ const makeRelationProxy = <
 						terminal: "count",
 					});
 			}
-			return (...arguments_: ReadonlyArray<unknown>) =>
+			return (...arguments_: readonly unknown[]) =>
 				makeRelationProxy({
 					...runtime,
 					recipe: appendOperation(runtime.recipe, property, arguments_),
@@ -206,6 +111,12 @@ const makeRelationProxy = <
 	return proxy;
 };
 
+// The proxy replays every Relation call onto the Prisma collection for `model`, so it has that collection's Relation surface.
+function asRelation<Collection, Model extends string>(proxy: object): Relation<Collection, undefined, Model>;
+function asRelation(proxy: object): unknown {
+	return proxy;
+}
+
 export const makeModelRelation = <
 	Collection,
 	Models extends object,
@@ -214,13 +125,12 @@ export const makeModelRelation = <
 >(
 	executor: DatabaseExecutor<Models, ExecutorContract>,
 	model: Model,
-	resolveExecutor: Effect.Effect<
-		DatabaseExecutor<Models, ExecutorContract>,
-		PrismaError
-	> = Effect.succeed(executor),
+	resolveExecutor: Effect.Effect<DatabaseExecutor<Models, ExecutorContract>, PrismaError> = Effect.succeed(executor),
 ): Relation<Collection, undefined, Model> =>
-	makeRelationProxy({
-		executor,
-		recipe: rootRecipe(model),
-		resolveExecutor,
-	}) as Relation<Collection, undefined, Model>;
+	asRelation<Collection, Model>(
+		makeRelationProxy({
+			executor,
+			recipe: rootRecipe(model),
+			resolveExecutor,
+		}),
+	);

package/src/internal/relation-stream.ts

@@ -1,72 +1,45 @@
 import { Effect, Stream } from "effect";
-import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.js";
-import type { AnyPostgresContract, DatabaseExecutor } from "./executor.js";
-import { fromPrismaPromise } from "./promise.js";
-import { executeQuery } from "./query-execution.js";
-import { type RelationRecipe, replayRecipe } from "./recipe.js";
+import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.ts";
+import { hasMethod, invokeMethod, isAsyncIterable } from "./dynamic.ts";
+import type { AnyPostgresContract, DatabaseExecutor } from "./executor.ts";
+import { fromPrismaPromise } from "./promise.ts";
+import { executeQuery } from "./query-execution.ts";
+import { type RelationRecipe, replayRecipe } from "./recipe.ts";
 
-type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
+const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<unknown[], PrismaError> =>
+	fromPrismaPromise(async () => {
+		const rows: unknown[] = [];
+		for await (const row of iterable) {
+			rows.push(row);
+		}
+		return rows;
+	});
 
-export const makeRelationStream = <
-	Models extends object,
-	Contract extends AnyPostgresContract,
->(
-	resolveExecutor: Effect.Effect<
-		DatabaseExecutor<Models, Contract>,
-		PrismaError
-	>,
+export const makeRelationStream = <Models extends object, Contract extends AnyPostgresContract>(
+	resolveExecutor: Effect.Effect<DatabaseExecutor<Models, Contract>, PrismaError>,
 	recipe: RelationRecipe,
-): Stream.Stream<unknown, PrismaError> => {
-	return Stream.unwrap(
+): Stream.Stream<unknown, PrismaError> =>
+	Stream.unwrap(
 		Effect.flatMap(resolveExecutor, (executor) =>
 			executeQuery(
 				executor,
 				Effect.sync(() => {
-					const collection = replayRecipe(
-						executor.models,
-						recipe,
-						executor.identity,
-						executor.transactionIdentity,
-					);
-					if (
-						typeof collection !== "object" ||
-						collection === null ||
-						typeof Reflect.get(collection, "all") !== "function"
-					) {
+					const collection = replayRecipe(executor.models, recipe, executor.identity, executor.transactionIdentity);
+					const iterable = hasMethod(collection, "all") ? invokeMethod(collection, "all", []) : undefined;
+					if (!isAsyncIterable(iterable)) {
 						throw new TypeError("Only collection Relations can be streamed");
 					}
-					const iterable = Reflect.apply(
-						Reflect.get(collection, "all") as AnyFunction,
-						collection,
-						[],
-					) as AsyncIterable<unknown>;
 
 					if (executor.mode === "root") {
 						return Stream.fromAsyncIterable(iterable, (error) => error).pipe(
-							Stream.catch((error) =>
-								isPrismaFailure(error)
-									? Stream.fail(toPrismaError(error))
-									: Stream.die(error),
-							),
+							Stream.catch((error) => (isPrismaFailure(error) ? Stream.fail(toPrismaError(error)) : Stream.die(error))),
 						);
 					}
 
-					const buffered = executeQuery(
-						executor,
-						fromPrismaPromise(async () => {
-							const rows: Array<unknown> = [];
-							for await (const row of iterable) {
-								rows.push(row);
-							}
-							return rows;
-						}),
-					);
+					const buffered = executeQuery(executor, collectRows(iterable));
 
-					return Stream.unwrap(
-						Effect.map(buffered, (rows) => Stream.fromIterable(rows)),
-					);
+					return Stream.unwrap(Effect.map(buffered, (rows) => Stream.fromIterable(rows)));
 				}),
 			),
 		),
 	);
-};

package/src/internal/sqlite-datetime.ts

@@ -1,5 +1,5 @@
 import type { ExecutionContext } from "@prisma-next/sql-runtime";
-import type { AnySqlContract } from "./executor.js";
+import type { AnySqlContract } from "./executor.ts";
 
 type CodecRegistry = ExecutionContext<AnySqlContract>["contractCodecs"];
 type ContractCodec = ReturnType<CodecRegistry["forCodecRef"]>;
@@ -8,56 +8,24 @@ type CodecJson = Parameters<ContractCodec["decodeJson"]>[0];
 
 const sqliteDatetimeCodecId = "sqlite/datetime@1";
 
-const zonelessDatetime =
-	/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?)$/;
+const zonelessDatetime = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?)$/u;
 
-/**
- * Stamp `Z` onto a SQLite datetime string that carries no zone designator.
- *
- * SQLite stores `DateTime` as text and computes `datetime('now')` — the default
- * `prisma-next db init` generates — in UTC, but writes it as
- * `YYYY-MM-DD HH:MM:SS` with no zone. `new Date` reads that form as local time,
- * so decoding it unchanged shifts the instant by the process' UTC offset.
- * Values that already carry `Z` or a numeric offset, date-only values (which
- * `new Date` already reads as UTC), and anything that is not a datetime string
- * are returned unchanged.
- */
-export const normalizeSqliteDatetime = (value: string): string =>
-	value.replace(zonelessDatetime, "$1T$2Z");
+// SQLite computes `datetime('now')`, the default `prisma-next db init` generates, in UTC but writes it as `YYYY-MM-DD HH:MM:SS`
+// with no zone, and `new Date` reads that form as local time. Values with a zone and date-only values already read as UTC.
+export const normalizeSqliteDatetime = (value: string): string => value.replace(zonelessDatetime, "$1T$2Z");
 
 const decodeAsUtc = (codec: ContractCodec): ContractCodec => ({
-	id: sqliteDatetimeCodecId,
+	decode: (wire: CodecWire, context) => codec.decode(typeof wire === "string" ? normalizeSqliteDatetime(wire) : wire, context),
+	decodeJson: (json: CodecJson) => codec.decodeJson(typeof json === "string" ? normalizeSqliteDatetime(json) : json),
 	encode: (value, context) => codec.encode(value, context),
-	decode: (wire: CodecWire, context) =>
-		codec.decode(
-			typeof wire === "string" ? normalizeSqliteDatetime(wire) : wire,
-			context,
-		),
 	encodeJson: (value) => codec.encodeJson(value),
-	decodeJson: (json: CodecJson) =>
-		codec.decodeJson(
-			typeof json === "string" ? normalizeSqliteDatetime(json) : json,
-		),
+	id: sqliteDatetimeCodecId,
 });
 
-/**
- * Replace the client's codec registry with one that decodes zone-less
- * `sqlite/datetime@1` values as UTC.
- *
- * The registry is the single resolution point for both row decoding and the
- * JSON decoding of included relations, so wrapping it covers every read path
- * without touching encoding. Prisma Next rejects a second descriptor for an
- * already-registered codec id, so an extension pack cannot replace the codec
- * itself. Must run before the first query, because the runtime reads the
- * registry off the context when it is created.
- *
- * Codecs are identified by the resolved reference rather than by `codec.id`:
- * Prisma Next materializes a codec through an unbound descriptor factory, so
- * the instance's `id` accessor throws.
- */
-export const decodeSqliteDatetimesAsUtc = (
-	context: ExecutionContext<AnySqlContract>,
-): void => {
+// The registry resolves codecs for rows and included relations alike, and Prisma Next rejects a second descriptor for a registered
+// codec id, so wrapping the registry is the one way to cover every read. It must run before the first query, which reads the
+// registry off the context. Codecs are matched by reference because a materialized codec's `id` accessor throws.
+export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContract>): void => {
 	const registry = context.contractCodecs;
 	const descriptors = context.codecDescriptors;
 	const utcCodecs = new WeakMap<ContractCodec, ContractCodec>();
@@ -73,23 +41,21 @@ export const decodeSqliteDatetimesAsUtc = (
 	};
 
 	const utcRegistry: CodecRegistry = {
+		forCodecRef: (reference) => {
+			const codec = registry.forCodecRef(reference);
+			return reference.codecId === sqliteDatetimeCodecId ? wrap(codec) : codec;
+		},
 		forColumn: (namespaceId, table, column) => {
 			const codec = registry.forColumn(namespaceId, table, column);
 			if (codec === undefined) {
 				return undefined;
 			}
-			const reference = descriptors.codecRefForColumn(
-				namespaceId,
-				table,
-				column,
-			);
+			const reference = descriptors.codecRefForColumn(namespaceId, table, column);
 			return reference?.codecId === sqliteDatetimeCodecId ? wrap(codec) : codec;
 		},
-		forCodecRef: (reference) => {
-			const codec = registry.forCodecRef(reference);
-			return reference.codecId === sqliteDatetimeCodecId ? wrap(codec) : codec;
-		},
 	};
 
-	(context as { contractCodecs: CodecRegistry }).contractCodecs = utcRegistry;
+	if (!Reflect.set(context, "contractCodecs", utcRegistry)) {
+		throw new TypeError("The SQLite execution context does not accept a codec registry");
+	}
 };