@shivaedev/effect-prisma 0.6.4 → 0.7.0

package/package.json

@@ -1,31 +1,19 @@
 {
   "name": "@shivaedev/effect-prisma",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "description": "Effect-native PostgreSQL queries and transactions for Prisma Next",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ShivaeDev/platform.git",
-    "directory": "packages/effect-prisma"
-  },
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-prisma#readme",
   "bugs": {
     "url": "https://github.com/ShivaeDev/platform/issues"
   },
-  "engines": {
-    "node": ">=24"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/effect-prisma"
   },
+  "license": "MIT",
   "sideEffects": false,
-  "bin": {
-    "effect-prisma-normalize": "./dist/bin/normalize-contract.js"
-  },
-  "files": [
-    "dist",
-    "src",
-    "CHANGELOG.md",
-    "README.md"
-  ],
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -47,10 +35,15 @@
     },
     "./package.json": "./package.json"
   },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+  "bin": {
+    "effect-prisma-normalize": "./dist/bin/normalize-contract.js"
   },
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
+    "README.md"
+  ],
   "dependencies": {
     "@prisma-next/contract": "0.15.0",
     "@prisma-next/postgres": "0.15.0",
@@ -61,15 +54,6 @@
     "@prisma-next/sqlite": "0.15.0",
     "@shivaedev/effect-test": "0.1.2"
   },
-  "peerDependencies": {
-    "@effect/vitest": "4.0.0-rc.112",
-    "effect": "4.0.0-rc.112"
-  },
-  "peerDependenciesMeta": {
-    "@effect/vitest": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.112",
     "@prisma-next/adapter-postgres": "0.15.0",
@@ -77,6 +61,7 @@
     "@prisma-next/cli": "0.15.0",
     "@prisma-next/target-postgres": "0.15.0",
     "@prisma-next/target-sqlite": "0.15.0",
+    "@shivaedev/quality": "0.7.0",
     "@types/node": "24.10.1",
     "@types/pg": "8.20.0",
     "@typescript/native": "npm:typescript@7.0.2",
@@ -84,13 +69,26 @@
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "vitest": "4.1.9"
   },
+  "peerDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.112"
+  },
+  "peerDependenciesMeta": {
+    "@effect/vitest": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
     "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
-    "check": "biome check .",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
     "test": "vitest run",
-    "test:package": "node scripts/test-package.mjs",
-    "typecheck": "tsc --noEmit",
-    "typecheck:compat": "tsc6 --noEmit",
-    "ready": "pnpm check && pnpm typecheck && pnpm typecheck:compat && pnpm test && pnpm build && pnpm test:package"
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/bin/normalize-contract.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { readFile, writeFile } from "node:fs/promises";
+import process from "node:process";
 import { normalizePrismaNextContractTypes } from "../internal/contract-normalization.ts";
 
 const arguments_ = process.argv.slice(2);

package/src/error.ts

@@ -54,19 +54,19 @@ export const toPrismaError = (error: PrismaFailure): PrismaError => {
 	if ("kind" in error && error.kind === "sql_query") {
 		return new PrismaError({
 			reason: new PrismaQueryFailure({
-				sqlState: error.sqlState,
-				constraint: error.constraint,
-				table: error.table,
 				column: error.column,
+				constraint: error.constraint,
 				original,
+				sqlState: error.sqlState,
+				table: error.table,
 			}),
 		});
 	}
 	if ("kind" in error && error.kind === "sql_connection") {
 		return new PrismaError({
 			reason: new PrismaConnectionFailure({
-				transient: error.transient,
 				original,
+				transient: error.transient,
 			}),
 		});
 	}

package/src/internal/adapters/transaction-settlement.ts

@@ -13,8 +13,11 @@ const runtimeFailure = (code: string, cause: unknown, details?: Readonly<Record<
 
 class ConnectionDisposal {
 	disposed = false;
+	private readonly connection: SettledConnection;
 
-	constructor(private readonly connection: SettledConnection) {}
+	constructor(connection: SettledConnection) {
+		this.connection = connection;
+	}
 
 	async destroy(reason: unknown): Promise<void> {
 		if (this.disposed) {

package/src/internal/client-lifecycle.ts

@@ -1,6 +1,6 @@
 export interface ClientLifecycle {
-	readonly connect: () => PromiseLike<unknown>;
 	readonly close: () => PromiseLike<void>;
+	readonly connect: () => PromiseLike<unknown>;
 }
 
 export const acquireConnectedClient = async <A>(client: ClientLifecycle, initialize: () => A): Promise<A> => {
@@ -15,7 +15,7 @@ export const acquireConnectedClient = async <A>(client: ClientLifecycle, initial
 
 const reservedModelNames = new Set(["transaction"]);
 
-export const assertAvailableModelNames = (modelNames: ReadonlyArray<string>): void => {
+export const assertAvailableModelNames = (modelNames: readonly string[]): void => {
 	for (const modelName of modelNames) {
 		if (reservedModelNames.has(modelName)) {
 			throw new TypeError(`Prisma model name conflicts with the database facade: ${modelName}`);

package/src/internal/contract-normalization.ts

@@ -1,11 +1,8 @@
-const timestampReference = /\b(?:Timestamp|Timestamptz)<(?:\d+|undefined)>/g;
-const timestampCodecReference = /\bCodecTypes\['pg\/(?:timestamp|timestamptz)@1'\]\['(?:input|output)'\]/g;
-const unsupportedTimestampReference = /\b(?:Timestamp|Timestamptz)\s*</;
+const timestampReference = /\b(?:Timestamp|Timestamptz)<(?:\d+|undefined)>/gu;
+const timestampCodecReference = /\bCodecTypes\['pg\/(?:timestamp|timestamptz)@1'\]\['(?:input|output)'\]/gu;
+const unsupportedTimestampReference = /\b(?:Timestamp|Timestamptz)\s*</u;
 
-/**
- * Align Prisma Next's generated PostgreSQL timestamp declarations with the
- * JavaScript Dates accepted and returned by its runtime codecs.
- */
+// Prisma Next declares PostgreSQL timestamps with types other than the JavaScript Dates its runtime codecs accept and return.
 export const normalizePrismaNextContractTypes = (source: string): string => {
 	const normalized = source.replaceAll(timestampReference, "Date").replaceAll(timestampCodecReference, "Date");
 

package/src/internal/database-facade.ts

@@ -29,11 +29,6 @@ function databaseFacade(facade: object): unknown {
 	return facade;
 }
 
-/**
- * Resolve the models of the single domain namespace from a namespaced ORM
- * client. Prisma Next namespaces PostgreSQL models under their schema and
- * SQLite models under the unbound namespace.
- */
 export const namespaceModels = <Contract extends AnySqlContract, Models extends object>(
 	contract: Contract,
 	namespacedOrm: TransactionOrm<Contract>,
@@ -43,9 +38,9 @@ export const namespaceModels = <Contract extends AnySqlContract, Models extends
 	if (namespaces.length !== 1 || only === undefined) {
 		throw new TypeError("Effect Prisma currently requires exactly one domain namespace");
 	}
-	const [name, namespace] = only;
+	const [postgresSchemaOrSqliteUnbound, namespace] = only;
 	assertAvailableModelNames(Object.keys(namespace.models));
-	return contractModels<Models>(Reflect.get(namespacedOrm, name));
+	return contractModels<Models>(Reflect.get(namespacedOrm, postgresSchemaOrSqliteUnbound));
 };
 
 export const runTransaction = <Contract extends AnySqlContract, Identifier extends string, A, E, R>(

package/src/internal/database-factory.ts

@@ -15,10 +15,6 @@ import { releaseTestTransaction } from "./transaction.ts";
 
 let activeTransactionReferenceSequence = 0;
 
-/**
- * Assemble the database service and its Layer around a driver-specific
- * executor acquisition.
- */
 export const makeSqlDatabase = <const Contract extends AnySqlContract, const Identifier extends string, Options>(
 	identifier: DatabaseIdentifierLiteral<Identifier>,
 	acquireExecutor: (options: Options) => Effect.Effect<DatabaseExecutor<DefaultModels<Contract>, Contract>, PrismaError>,
@@ -48,11 +44,11 @@ export const makeSqlDatabase = <const Contract extends AnySqlContract, const Ide
 	const withTestTransaction = <A, E, R>(
 		program: Effect.Effect<A, E, R> & (DatabaseId extends R ? unknown : never),
 	): Effect.Effect<A, E | PrismaError, DatabaseId | Exclude<R, DatabaseId>> =>
-		Effect.flatMap(Service, (facade) => {
-			return Effect.flatMap(executorOf(facade), (current) =>
+		Effect.flatMap(Service, (facade) =>
+			Effect.flatMap(executorOf(facade), (current) =>
 				runTransaction(scope, current, facade, program, releaseTestTransaction, "test", "prisma.testTransaction"),
-			);
-		});
+			),
+		);
 
 	const layer = (layerOptions: Options): Layer.Layer<DatabaseId, PrismaError> => {
 		const acquire = Effect.acquireRelease(

package/src/internal/database-types.ts

@@ -45,20 +45,16 @@ type DatabaseModels<Contract extends AnySqlContract, Identifier extends string>
 };
 
 export type DatabaseService<Contract extends AnySqlContract, Identifier extends string> = DatabaseModels<Contract, Identifier> & {
-	transaction<A, E, R>(
+	transaction: <A, E, R>(
 		program: Effect.Effect<A, E, R> & (DatabaseIdentifier<Contract, Identifier> extends R ? unknown : never),
-	): Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<Contract, Identifier>>>;
+	) => Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<Contract, Identifier>>>;
 };
 
-/**
- * The driver-independent part of a database definition: the Context service
- * carrying the typed facade. Driver entrypoints add their own `layer` options.
- */
 export interface DatabaseServiceHolder<Contract extends AnySqlContract, Identifier extends string>
 	extends Context.Service<DatabaseIdentifier<Contract, Identifier>, DatabaseService<Contract, Identifier>> {}
 
 export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
-	readonly layer: (...arguments_: ReadonlyArray<never>) => Layer.Any;
+	readonly layer: (...arguments_: readonly never[]) => Layer.Any;
 };
 
 export type DatabaseServiceOf<Database extends AnyDatabase> = Effect.Success<Database>;

package/src/internal/dynamic.ts

@@ -3,7 +3,7 @@ const isObjectLike = (value: unknown): value is object => (typeof value === "obj
 export const hasMethod = (value: unknown, name: PropertyKey): value is object =>
 	isObjectLike(value) && typeof Reflect.get(value, name) === "function";
 
-export const invokeMethod = (target: object, name: PropertyKey, arguments_: ReadonlyArray<unknown>): unknown => {
+export const invokeMethod = (target: object, name: PropertyKey, arguments_: readonly unknown[]): unknown => {
 	const method: unknown = Reflect.get(target, name);
 	if (typeof method !== "function") {
 		throw new TypeError(`${String(name)} is not a method`);

package/src/internal/executor.ts

@@ -6,15 +6,11 @@ import type { Semaphore } from "effect";
 export type AnySqlContract = PrismaContract<SqlStorage>;
 export type AnyPostgresContract = AnySqlContract;
 
-/**
- * The subset of a Prisma Next client the package depends on. Both the
- * PostgreSQL and the SQLite client satisfy it.
- */
 export interface SqlDatabaseClient<Contract extends AnySqlContract> {
-	readonly contract: Contract;
+	close: () => Promise<void>;
 	readonly context: ExecutionContext<Contract>;
-	runtime(): Runtime;
-	close(): Promise<void>;
+	readonly contract: Contract;
+	runtime: () => Runtime;
 }
 
 export interface DatabaseExecutor<Models extends object, Contract extends AnySqlContract = AnySqlContract> {

package/src/internal/promise.ts

@@ -3,6 +3,6 @@ import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.ts";
 
 export const fromPrismaPromise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, PrismaError> =>
 	Effect.tryPromise({
-		try: (signal) => Promise.resolve(evaluate(signal)),
 		catch: (error) => error,
+		try: (signal) => Promise.resolve(evaluate(signal)),
 	}).pipe(Effect.catch((error) => (isPrismaFailure(error) ? Effect.fail(toPrismaError(error)) : Effect.die(error))));

package/src/internal/recipe.ts

@@ -2,29 +2,29 @@ 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) {
@@ -37,7 +37,7 @@ const operations = (recipe: RelationRecipe): ReadonlyArray<RelationOperation> =>
 	return reversed.reverse();
 };
 
-const applyMethod = (current: unknown, name: PropertyKey, arguments_: ReadonlyArray<unknown>, model: string): unknown => {
+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}`);
 	}

package/src/internal/relation-result.ts

@@ -10,7 +10,7 @@ const countOf = (result: unknown): unknown => (typeof result === "object" && res
 
 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);
+		return settle(invokeMethod(value, "aggregate", [(summary: { count: () => unknown }) => ({ count: summary.count() })]), countOf);
 	}
 
 	if (terminal === "exists" && hasMethod(value, "first")) {

package/src/internal/relation-runtime.ts

@@ -42,22 +42,22 @@ const relationEffect = (self: object): Effect.Effect<unknown, PrismaError> => {
 		),
 	).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"),
+				"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 runtime = runtimeOf(this);
@@ -89,7 +89,7 @@ const makeRelationProxy = (runtime: AnyRelationRuntime): object => {
 						terminal: "count",
 					});
 			}
-			return (...arguments_: ReadonlyArray<unknown>) =>
+			return (...arguments_: readonly unknown[]) =>
 				makeRelationProxy({
 					...runtime,
 					recipe: appendOperation(runtime.recipe, property, arguments_),

package/src/internal/relation-stream.ts

@@ -6,9 +6,9 @@ import { fromPrismaPromise } from "./promise.ts";
 import { executeQuery } from "./query-execution.ts";
 import { type RelationRecipe, replayRecipe } from "./recipe.ts";
 
-const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<Array<unknown>, PrismaError> =>
+const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<unknown[], PrismaError> =>
 	fromPrismaPromise(async () => {
-		const rows: Array<unknown> = [];
+		const rows: unknown[] = [];
 		for await (const row of iterable) {
 			rows.push(row);
 		}
@@ -18,8 +18,8 @@ const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<Array<unkn
 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,
@@ -43,4 +43,3 @@ export const makeRelationStream = <Models extends object, Contract extends AnyPo
 			),
 		),
 	);
-};

package/src/internal/sqlite-datetime.ts

@@ -8,44 +8,23 @@ 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.
- */
+// 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,
-	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),
+	encode: (value, context) => codec.encode(value, context),
+	encodeJson: (value) => codec.encodeJson(value),
+	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.
- */
+// 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;
@@ -62,6 +41,10 @@ export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContr
 	};
 
 	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) {
@@ -70,10 +53,6 @@ export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContr
 			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;
-		},
 	};
 
 	if (!Reflect.set(context, "contractCodecs", utcRegistry)) {

package/src/internal/sqlite-pragmas.ts

@@ -2,11 +2,7 @@ import { DatabaseSync } from "node:sqlite";
 
 export const MEMORY_PATH = ":memory:";
 
-/**
- * Prisma Next's SQLite driver opens a fresh `node:sqlite` connection for every
- * `RuntimeConnection`, so an in-memory database would give each transaction its
- * own empty database.
- */
+// Prisma Next's SQLite driver opens a fresh `node:sqlite` connection per `RuntimeConnection`, so each transaction would get its own empty in-memory database.
 export const assertFileBackedPath = (path: string): void => {
 	if (path === MEMORY_PATH || path.trim().length === 0) {
 		throw new TypeError(
@@ -15,14 +11,8 @@ export const assertFileBackedPath = (path: string): void => {
 	}
 };
 
-/**
- * Apply connect-time pragmas.
- *
- * The driver already sets `foreign_keys` and `busy_timeout` on every connection
- * it opens, but it has no hook for anything else, so durable pragmas such as
- * `journal_mode` are applied once against the database file itself.
- */
-export const applySqlitePragmas = (path: string, pragmas: ReadonlyArray<string>): void => {
+// The driver has no hook for pragmas beyond `foreign_keys` and `busy_timeout`, so durable ones such as `journal_mode` go to the file once.
+export const applySqlitePragmas = (path: string, pragmas: readonly string[]): void => {
 	if (pragmas.length === 0) {
 		return;
 	}

package/src/internal/transaction.ts

@@ -14,10 +14,10 @@ export const withTransactionSemaphore = <A, E, R>(
 
 export interface TransactionResource<Models extends object, Contract extends AnySqlContract> {
 	readonly connection: SettledConnection;
-	readonly transaction: SettledTransaction;
 	readonly executor: DatabaseExecutor<Models, Contract> & {
 		readonly querySemaphore: Semaphore.Semaphore;
 	};
+	readonly transaction: SettledTransaction;
 }
 
 export const acquireTransaction = <Models extends object, Contract extends AnySqlContract>(
@@ -31,13 +31,12 @@ export const acquireTransaction = <Models extends object, Contract extends AnySq
 		try {
 			const transaction = await connection.transaction();
 			const transactionOrm = orm({
-				runtime: transaction,
 				context: current.client.context,
+				runtime: transaction,
 			});
 
 			return {
 				connection,
-				transaction,
 				executor: {
 					client: current.client,
 					identity: current.identity,
@@ -51,6 +50,7 @@ export const acquireTransaction = <Models extends object, Contract extends AnySq
 					transactionIdentity: {},
 					transactionSemaphore: current.transactionSemaphore,
 				},
+				transaction,
 			};
 		} catch (error) {
 			await connection.destroy(error).catch(() => undefined);

package/src/relation/include-metadata.ts

@@ -62,7 +62,7 @@ type AnyNullableField<Fields, Names extends readonly string[]> = Names extends r
 
 export type IncludedRelationValue<Contract extends AnyPostgresContract, Model extends string, RelationName extends string, Value> =
 	RelationCardinalityOf<Contract, Model, RelationName> extends "1:N" | "N:M"
-		? Array<Value>
+		? Value[]
 		: RelationCardinalityOf<Contract, Model, RelationName> extends "N:1"
 			? AnyNullableField<ModelFields<Contract, Model>, RelationLocalFields<Contract, Model, RelationName>> extends true
 				? Value | null