@shivaedev/effect-prisma 0.4.3 → 0.5.0

package/src/internal/executor.ts

@@ -1,15 +1,27 @@
 import type { Contract as PrismaContract } from "@prisma-next/contract/types";
-import type { PostgresClient } from "@prisma-next/postgres/runtime";
 import type { SqlStorage } from "@prisma-next/sql-contract/types";
+import type { ExecutionContext, Runtime } from "@prisma-next/sql-runtime";
 import type { Context, Semaphore } from "effect";
 
-export type AnyPostgresContract = PrismaContract<SqlStorage>;
+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;
+	readonly context: ExecutionContext<Contract>;
+	runtime(): Runtime;
+	close(): Promise<void>;
+}
 
 export interface DatabaseExecutor<
 	Models extends object,
-	Contract extends AnyPostgresContract = AnyPostgresContract,
+	Contract extends AnySqlContract = AnySqlContract,
 > {
-	readonly client: PostgresClient<Contract>;
+	readonly client: SqlDatabaseClient<Contract>;
 	readonly models: Models;
 	readonly querySemaphore: Semaphore.Semaphore | undefined;
 	readonly transactional: boolean;
@@ -17,7 +29,7 @@ export interface DatabaseExecutor<
 
 export type ExecutorService<
 	Models extends object,
-	Contract extends AnyPostgresContract = AnyPostgresContract,
+	Contract extends AnySqlContract = AnySqlContract,
 > = Context.Service<
 	ExecutorIdentifier<Models>,
 	DatabaseExecutor<Models, Contract>

package/src/internal/sqlite-datetime.ts

@@ -0,0 +1,95 @@
+import type { ExecutionContext } from "@prisma-next/sql-runtime";
+import type { AnySqlContract } from "./executor.js";
+
+type CodecRegistry = ExecutionContext<AnySqlContract>["contractCodecs"];
+type ContractCodec = ReturnType<CodecRegistry["forCodecRef"]>;
+type CodecWire = Parameters<ContractCodec["decode"]>[0];
+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+)?)$/;
+
+/**
+ * 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");
+
+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,
+		),
+});
+
+/**
+ * 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 => {
+	const registry = context.contractCodecs;
+	const descriptors = context.codecDescriptors;
+	const utcCodecs = new WeakMap<ContractCodec, ContractCodec>();
+
+	const wrap = (codec: ContractCodec): ContractCodec => {
+		const existing = utcCodecs.get(codec);
+		if (existing !== undefined) {
+			return existing;
+		}
+		const utc = decodeAsUtc(codec);
+		utcCodecs.set(codec, utc);
+		return utc;
+	};
+
+	const utcRegistry: CodecRegistry = {
+		forColumn: (namespaceId, table, column) => {
+			const codec = registry.forColumn(namespaceId, table, column);
+			if (codec === undefined) {
+				return undefined;
+			}
+			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;
+};

package/src/internal/sqlite-pragmas.ts

@@ -0,0 +1,41 @@
+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.
+ */
+export const assertFileBackedPath = (path: string): void => {
+	if (path === MEMORY_PATH || path.trim().length === 0) {
+		throw new TypeError(
+			"Effect Prisma requires a file-backed SQLite database; transactions run on their own connection and cannot see an in-memory database",
+		);
+	}
+};
+
+/**
+ * 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 => {
+	if (pragmas.length === 0) {
+		return;
+	}
+
+	const database = new DatabaseSync(path);
+	try {
+		for (const pragma of pragmas) {
+			database.exec(`PRAGMA ${pragma}`);
+		}
+	} finally {
+		database.close();
+	}
+};

package/src/internal/transaction.ts

@@ -1,4 +1,3 @@
-import type { PostgresClient } from "@prisma-next/postgres/runtime";
 import { orm } from "@prisma-next/sql-orm-client";
 import type {
 	RuntimeConnection,
@@ -6,12 +5,16 @@ import type {
 } from "@prisma-next/sql-runtime";
 import { Effect, Exit, Semaphore } from "effect";
 import type { PrismaError } from "../error.js";
-import type { AnyPostgresContract, DatabaseExecutor } from "./executor.js";
+import type { AnySqlContract, DatabaseExecutor } from "./executor.js";
 import { fromPrismaPromise } from "./promise.js";
 
+export type TransactionOrm<Contract extends AnySqlContract> = ReturnType<
+	typeof orm<Contract>
+>;
+
 export interface TransactionResource<
 	Models extends object,
-	Contract extends AnyPostgresContract,
+	Contract extends AnySqlContract,
 > {
 	readonly connection: RuntimeConnection;
 	readonly transaction: RuntimeTransaction;
@@ -27,10 +30,10 @@ const runtimeFailure = (
 
 export const acquireTransaction = <
 	Models extends object,
-	Contract extends AnyPostgresContract,
+	Contract extends AnySqlContract,
 >(
 	current: DatabaseExecutor<Models, Contract>,
-	models: (orm: PostgresClient<Contract>["orm"]) => Models,
+	models: (orm: TransactionOrm<Contract>) => Models,
 ): Effect.Effect<TransactionResource<Models, Contract>, PrismaError> =>
 	fromPrismaPromise(async () => {
 		const connection = await current.client.runtime().connection();
@@ -60,7 +63,7 @@ export const acquireTransaction = <
 
 export const releaseTransaction = <
 	Models extends object,
-	Contract extends AnyPostgresContract,
+	Contract extends AnySqlContract,
 	A,
 	E,
 >(
@@ -70,7 +73,7 @@ export const releaseTransaction = <
 
 export const releaseTestTransaction = <
 	Models extends object,
-	Contract extends AnyPostgresContract,
+	Contract extends AnySqlContract,
 	A,
 	E,
 >(
@@ -80,7 +83,7 @@ export const releaseTestTransaction = <
 
 const settleTransaction = <
 	Models extends object,
-	Contract extends AnyPostgresContract,
+	Contract extends AnySqlContract,
 	A,
 	E,
 >(

package/src/sqlite.ts

@@ -0,0 +1,108 @@
+import sqlite, {
+	type SqliteClient,
+	type SqliteOptionsBase,
+} from "@prisma-next/sqlite/runtime";
+import type { Layer } from "effect";
+import type { PrismaError } from "./error.js";
+import {
+	acquireConnectedClient,
+	assertAvailableModelNames,
+} from "./internal/client-lifecycle.js";
+import {
+	type DatabaseIdentifier,
+	type DatabaseServiceHolder,
+	type DefaultModels,
+	makeSqlDatabase,
+} from "./internal/database-factory.js";
+import type {
+	AnySqlContract,
+	ExecutorIdentifier,
+} from "./internal/executor.js";
+import { fromPrismaPromise } from "./internal/promise.js";
+import { decodeSqliteDatetimesAsUtc } from "./internal/sqlite-datetime.js";
+import {
+	applySqlitePragmas,
+	assertFileBackedPath,
+} from "./internal/sqlite-pragmas.js";
+
+export const defaultSqlitePragmas: ReadonlyArray<string> = ["journal_mode=WAL"];
+
+export interface SqliteDatabaseLayerOptions extends SqliteOptionsBase {
+	/** Path to the database file. In-memory databases are not supported. */
+	readonly path: string;
+	/**
+	 * Pragmas applied once when the Layer connects. Defaults to
+	 * {@link defaultSqlitePragmas}; pass `[]` to skip them.
+	 */
+	readonly pragmas?: ReadonlyArray<string>;
+}
+
+type SqliteFactoryOptions<Contract extends AnySqlContract> =
+	| {
+			readonly contract: Contract;
+			readonly contractJson?: never;
+	  }
+	| {
+			readonly contractJson: unknown;
+			readonly contract?: never;
+	  };
+
+export interface SqliteDatabaseDefinition<
+	Contract extends AnySqlContract,
+	Requirement = ExecutorIdentifier<DefaultModels<Contract>>,
+> extends DatabaseServiceHolder<Contract, Requirement> {
+	readonly layer: (
+		options: SqliteDatabaseLayerOptions,
+	) => Layer.Layer<DatabaseIdentifier<Contract> | Requirement, PrismaError>;
+}
+
+export const makeSqliteDatabase = <const Contract extends AnySqlContract>(
+	identifier: string,
+	options: SqliteFactoryOptions<Contract>,
+): SqliteDatabaseDefinition<Contract> => {
+	type Models = DefaultModels<Contract>;
+
+	return makeSqlDatabase<Contract, SqliteDatabaseLayerOptions>(
+		identifier,
+		(layerOptions) => {
+			assertFileBackedPath(layerOptions.path);
+			applySqlitePragmas(
+				layerOptions.path,
+				layerOptions.pragmas ?? defaultSqlitePragmas,
+			);
+
+			const clientOptions = {
+				path: layerOptions.path,
+				extensions: layerOptions.extensions,
+				middleware: layerOptions.middleware,
+				verifyMarker: layerOptions.verifyMarker,
+			};
+			const client: SqliteClient<Contract> =
+				options.contract === undefined
+					? sqlite<Contract>({
+							...clientOptions,
+							contractJson: options.contractJson,
+						})
+					: sqlite<Contract>({
+							...clientOptions,
+							contract: options.contract,
+						});
+
+			decodeSqliteDatetimesAsUtc(client.context);
+
+			return fromPrismaPromise(() =>
+				acquireConnectedClient(client, () => {
+					// The SQLite client already exposes the unbound namespace.
+					const models = client.orm as Models;
+					assertAvailableModelNames(Object.keys(models));
+					return {
+						client,
+						models,
+						querySemaphore: undefined,
+						transactional: false,
+					};
+				}),
+			);
+		},
+	) as SqliteDatabaseDefinition<Contract>;
+};