@shivaedev/effect-prisma 0.6.2 → 0.6.4

package/src/sqlite.ts

@@ -1,27 +1,14 @@
-import sqlite, {
-	type SqliteClient,
-	type SqliteOptionsBase,
-} from "@prisma-next/sqlite/runtime";
+import sqlite, { type SqliteClient, type SqliteOptionsBase } from "@prisma-next/sqlite/runtime";
 import { type Layer, Semaphore } from "effect";
-import type { PrismaError } from "./error.js";
-import {
-	acquireConnectedClient,
-	assertAvailableModelNames,
-} from "./internal/client-lifecycle.js";
-import {
-	type DatabaseIdentifier,
-	type DatabaseIdentifierLiteral,
-	type DatabaseServiceHolder,
-	type DefaultModels,
-	makeSqlDatabase,
-} from "./internal/database-factory.js";
-import type { AnySqlContract } 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";
+import type { PrismaError } from "./error.ts";
+import { acquireConnectedClient, assertAvailableModelNames } from "./internal/client-lifecycle.ts";
+import { contractModels } from "./internal/database-facade.ts";
+import { makeSqlDatabase } from "./internal/database-factory.ts";
+import type { DatabaseIdentifier, DatabaseIdentifierLiteral, DatabaseServiceHolder, DefaultModels } from "./internal/database-types.ts";
+import type { AnySqlContract } from "./internal/executor.ts";
+import { fromPrismaPromise } from "./internal/promise.ts";
+import { decodeSqliteDatetimesAsUtc } from "./internal/sqlite-datetime.ts";
+import { applySqlitePragmas, assertFileBackedPath } from "./internal/sqlite-pragmas.ts";
 
 export const defaultSqlitePragmas: ReadonlyArray<string> = ["journal_mode=WAL"];
 
@@ -45,15 +32,18 @@ type SqliteFactoryOptions<Contract extends AnySqlContract> =
 			readonly contract?: never;
 	  };
 
-export interface SqliteDatabaseDefinition<
-	Contract extends AnySqlContract,
-	Identifier extends string,
-> extends DatabaseServiceHolder<Contract, Identifier> {
-	readonly layer: (
-		options: SqliteDatabaseLayerOptions,
-	) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
+export interface SqliteDatabaseDefinition<Contract extends AnySqlContract, Identifier extends string>
+	extends DatabaseServiceHolder<Contract, Identifier> {
+	readonly layer: (options: SqliteDatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
 }
 
+const clientOptions = ({ path, extensions, middleware, verifyMarker }: SqliteDatabaseLayerOptions) => ({
+	path,
+	...(extensions === undefined ? {} : { extensions }),
+	...(middleware === undefined ? {} : { middleware }),
+	...(verifyMarker === undefined ? {} : { verifyMarker }),
+});
+
 export const makeSqliteDatabase =
 	<const Contract extends AnySqlContract>() =>
 	<const Identifier extends string>(
@@ -62,55 +52,44 @@ export const makeSqliteDatabase =
 	): SqliteDatabaseDefinition<Contract, Identifier> => {
 		type Models = DefaultModels<Contract>;
 
-		return makeSqlDatabase<Contract, Identifier, SqliteDatabaseLayerOptions>(
-			identifier,
-			(layerOptions) => {
-				assertFileBackedPath(layerOptions.path);
-				applySqlitePragmas(
-					layerOptions.path,
-					layerOptions.pragmas ?? defaultSqlitePragmas,
-				);
+		return makeSqlDatabase<Contract, Identifier, 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,
-							});
+			const forwarded = clientOptions(layerOptions);
+			const client: SqliteClient<Contract> =
+				options.contract === undefined
+					? sqlite<Contract>({
+							...forwarded,
+							contractJson: options.contractJson,
+						})
+					: sqlite<Contract>({
+							...forwarded,
+							contract: options.contract,
+						});
 
-				decodeSqliteDatetimesAsUtc(client.context);
+			decodeSqliteDatetimesAsUtc(client.context);
 
-				return fromPrismaPromise(() =>
-					acquireConnectedClient(client, () => {
-						// The SQLite client already exposes the unbound namespace.
-						const models = client.orm as Models;
-						const accessSemaphore = Semaphore.makeUnsafe(1);
-						assertAvailableModelNames(Object.keys(models));
-						return {
-							client,
-							identity: {},
-							liveness: {
-								closedCode: "RUNTIME.DATABASE_CLOSED",
-								open: true,
-							},
-							mode: "root",
-							models,
-							querySemaphore: accessSemaphore,
-							transactionIdentity: undefined,
-							transactionSemaphore: accessSemaphore,
-						};
-					}),
-				);
-			},
-		) as SqliteDatabaseDefinition<Contract, Identifier>;
+			return fromPrismaPromise(() =>
+				acquireConnectedClient(client, () => {
+					// The SQLite client already exposes the unbound namespace.
+					const models = contractModels<Models>(client.orm);
+					const accessSemaphore = Semaphore.makeUnsafe(1);
+					assertAvailableModelNames(Object.keys(models));
+					return {
+						client,
+						identity: {},
+						liveness: {
+							closedCode: "RUNTIME.DATABASE_CLOSED",
+							open: true,
+						},
+						mode: "root",
+						models,
+						querySemaphore: accessSemaphore,
+						transactionIdentity: undefined,
+						transactionSemaphore: accessSemaphore,
+					};
+				}),
+			);
+		});
 	};

package/src/testing/transaction.ts

@@ -1,38 +1,25 @@
 import type { Effect } from "effect";
-import type { PrismaError } from "../error.js";
-import { getDatabaseTesting } from "../internal/testing.js";
-import type { AnyDatabase } from "./types.js";
+import type { PrismaError } from "../error.ts";
+import { getDatabaseTesting } from "../internal/testing.ts";
+import type { AnyDatabase } from "./types.ts";
 
-type WithTestTransaction = {
-	<Database extends AnyDatabase>(
-		database: Database,
-	): <A, E, R>(
-		program: Effect.Effect<A, E, R> &
-			(Effect.Services<Database> extends R ? unknown : never),
-	) => Effect.Effect<
-		A,
-		E | PrismaError,
-		Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
-	>;
-	<Database extends AnyDatabase, A, E, R>(
-		database: Database,
-		program: Effect.Effect<A, E, R> &
-			(Effect.Services<Database> extends R ? unknown : never),
-	): Effect.Effect<
-		A,
-		E | PrismaError,
-		Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
-	>;
-};
+type TestProgram<Database extends AnyDatabase, A, E, R> = Effect.Effect<A, E, R> & (Effect.Services<Database> extends R ? unknown : never);
 
-export const withTestTransaction: WithTestTransaction = ((
-	database: AnyDatabase,
-	program?: Effect.Effect<unknown, unknown, unknown>,
-) => {
-	const run = (effect: Effect.Effect<unknown, unknown, unknown>) =>
-		getDatabaseTesting<Effect.Services<typeof database>>(
-			database,
-		).withTestTransaction(effect);
+type TestTransaction<Database extends AnyDatabase, A, E, R> = Effect.Effect<
+	A,
+	E | PrismaError,
+	Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
+>;
+
+export function withTestTransaction<Database extends AnyDatabase>(
+	database: Database,
+): <A, E, R>(program: TestProgram<Database, A, E, R>) => TestTransaction<Database, A, E, R>;
+export function withTestTransaction<Database extends AnyDatabase, A, E, R>(
+	database: Database,
+	program: TestProgram<Database, A, E, R>,
+): TestTransaction<Database, A, E, R>;
+export function withTestTransaction(database: AnyDatabase, program?: Effect.Effect<unknown, unknown, unknown>): unknown {
+	const run = (effect: Effect.Effect<unknown, unknown, unknown>) => getDatabaseTesting<unknown>(database).withTestTransaction(effect);
 
 	return program === undefined ? run : run(program);
-}) as WithTestTransaction;
+}

package/src/testing/types.ts

@@ -1,26 +1,18 @@
 import type { TestContext, Vitest } from "@effect/vitest";
 import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test";
 import type { Effect, Layer } from "effect";
-import type { AnyDatabase, DatabaseServiceOf } from "../database.js";
+import type { AnyDatabase, DatabaseServiceOf } from "../database.ts";
 
-export type { AnyDatabase } from "../database.js";
-export type DatabaseService<Database extends AnyDatabase> =
-	DatabaseServiceOf<Database>;
+export type { AnyDatabase } from "../database.ts";
+export type DatabaseService<Database extends AnyDatabase> = DatabaseServiceOf<Database>;
 
-export type DatabaseTest<Database extends AnyDatabase, Provided> = <
-	A,
-	Eff extends Effect.Effect<unknown, unknown, Provided>,
->(
+export type DatabaseTest<Database extends AnyDatabase, Provided> = <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 	name: string,
-	body: (
-		database: DatabaseService<Database>,
-		context: TestContext,
-	) => Generator<Eff, A, never>,
+	body: (database: DatabaseService<Database>, context: TestContext) => Generator<Eff, A, never>,
 	options?: number | EffectTestOptions,
 ) => void;
 
-export interface DatabaseTester<Database extends AnyDatabase, Provided>
-	extends DatabaseTest<Database, Provided> {
+export interface DatabaseTester<Database extends AnyDatabase, Provided> extends DatabaseTest<Database, Provided> {
 	readonly skip: DatabaseTest<Database, Provided>;
 	readonly skipIf: (condition: unknown) => DatabaseTest<Database, Provided>;
 	readonly runIf: (condition: unknown) => DatabaseTest<Database, Provided>;
@@ -29,28 +21,17 @@ export interface DatabaseTester<Database extends AnyDatabase, Provided>
 		cases: ReadonlyArray<Item>,
 	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 		name: string,
-		body: (
-			item: Item,
-			database: DatabaseService<Database>,
-			context: TestContext,
-		) => Generator<Eff, A, never>,
+		body: (item: Item, database: DatabaseService<Database>, context: TestContext) => Generator<Eff, A, never>,
 		options?: number | EffectTestOptions,
 	) => void;
 	readonly fails: DatabaseTest<Database, Provided>;
 }
 
-export type DatabaseIt<
-	Database extends AnyDatabase,
-	Provided,
-> = Vitest.Methods & {
+export type DatabaseIt<Database extends AnyDatabase, Provided> = Vitest.Methods & {
 	readonly effectDB: DatabaseTester<Database, Provided>;
 };
 
-export interface MakeDatabaseItOptions<
-	Database extends AnyDatabase,
-	Provided,
-	LayerError,
-> {
+export interface MakeDatabaseItOptions<Database extends AnyDatabase, Provided, LayerError> {
 	readonly clock?: EffectClock;
 	readonly database: Database;
 	readonly layer: Layer.Layer<Provided, LayerError>;

package/src/testing/vitest.ts

@@ -1,38 +1,24 @@
 import { it as effectIt } from "@effect/vitest";
-import { makeEffectIt } from "@shivaedev/effect-test";
+import { type EffectClock, makeEffectIt } from "@shivaedev/effect-test";
 import type { Effect, Layer } from "effect";
-import { withTestTransaction } from "./transaction.js";
-import type {
-	AnyDatabase,
-	DatabaseIt,
-	DatabaseService,
-	MakeDatabaseItOptions,
-} from "./types.js";
+import { withTestTransaction } from "./transaction.ts";
+import type { AnyDatabase, DatabaseIt, MakeDatabaseItOptions } from "./types.ts";
 
-export const makeDatabaseIt = <
-	Database extends AnyDatabase,
-	Provided,
-	LayerError,
->(
+export function makeDatabaseIt<Database extends AnyDatabase, Provided, LayerError>(
 	options: MakeDatabaseItOptions<Database, Provided, LayerError> & {
-		readonly layer: Layer.Layer<
-			Provided | Effect.Services<Database>,
-			LayerError
-		>;
+		readonly layer: Layer.Layer<Provided | Effect.Services<Database>, LayerError>;
 	},
-): DatabaseIt<Database, Provided | Effect.Services<Database>> => {
-	type Services = Provided | Effect.Services<Database>;
-
+): DatabaseIt<Database, Provided | Effect.Services<Database>>;
+export function makeDatabaseIt(options: {
+	readonly clock?: EffectClock | undefined;
+	readonly database: AnyDatabase;
+	readonly layer: Layer.Layer<unknown, unknown>;
+}): unknown {
 	const { effectApp } = makeEffectIt({
 		around: (effect) => withTestTransaction(options.database, effect),
 		clock: options.clock,
 		layer: options.layer,
-		makeHarness: () =>
-			options.database as unknown as Effect.Effect<
-				DatabaseService<Database>,
-				never,
-				Effect.Services<Database>
-			>,
+		makeHarness: () => options.database,
 	});
 
 	return new Proxy(effectIt, {
@@ -42,5 +28,5 @@ export const makeDatabaseIt = <
 			}
 			return Reflect.get(target, property, receiver);
 		},
-	}) as unknown as DatabaseIt<Database, Services>;
-};
+	});
+}

package/src/testing.ts

@@ -1,4 +1,4 @@
-export { withTestTransaction } from "./testing/transaction.js";
+export { withTestTransaction } from "./testing/transaction.ts";
 export type {
 	AnyDatabase,
 	DatabaseIt,
@@ -6,5 +6,5 @@ export type {
 	DatabaseTest,
 	DatabaseTester,
 	MakeDatabaseItOptions,
-} from "./testing/types.js";
-export { makeDatabaseIt } from "./testing/vitest.js";
+} from "./testing/types.ts";
+export { makeDatabaseIt } from "./testing/vitest.ts";