@shivaedev/effect-changes-prisma 0.4.0 → 0.5.1

package/src/model.ts

@@ -4,22 +4,22 @@ export interface TransactionOptions {
 	readonly timeout?: number;
 }
 
-export interface Transactional<Tx> {
-	$transaction: <X>(run: (tx: Tx) => Promise<X>, options?: TransactionOptions) => PromiseLike<X>;
+export interface Transactional<TTx> {
+	$transaction: <TX>(run: (tx: TTx) => Promise<TX>, options?: TransactionOptions) => PromiseLike<TX>;
 }
 
-type PayloadOf<Delegate> = Delegate extends { readonly [key: symbol]: { readonly types: { readonly payload: infer Payload } } } ? Payload : never;
+type PayloadOf<TDelegate> = TDelegate extends { readonly [key: symbol]: { readonly types: { readonly payload: infer TPayload } } } ? TPayload : never;
 
-type Delegates<Client> = Exclude<keyof Client & string, `$${string}`>;
+type Delegates<TClient> = Exclude<keyof TClient & string, `$${string}`>;
 
-export type ModelName<Client> = {
-	[Key in Delegates<Client>]: PayloadOf<Client[Key]> extends { readonly name: infer Name extends string } ? Name : never;
-}[Delegates<Client>];
+export type ModelName<TClient> = {
+	[TKey in Delegates<TClient>]: PayloadOf<TClient[TKey]> extends { readonly name: infer TName extends string } ? TName : never;
+}[Delegates<TClient>];
 
-export type ModelRow<Client, Model extends string> = Extract<
+export type ModelRow<TClient, TModel extends string> = Extract<
 	{
-		[Key in Delegates<Client>]: PayloadOf<Client[Key]> extends { readonly name: Model; readonly scalars: infer Row } ? Row : never;
-	}[Delegates<Client>],
+		[TKey in Delegates<TClient>]: PayloadOf<TClient[TKey]> extends { readonly name: TModel; readonly scalars: infer TRow } ? TRow : never;
+	}[Delegates<TClient>],
 	object
 >;
 
@@ -27,10 +27,10 @@ export type RowOperation = "create" | "update" | "upsert" | "delete" | "createMa
 
 export type CountOperation = "createMany" | "updateMany" | "deleteMany";
 
-export type ModelChanges<Row, A> = (row: Row, operation: RowOperation) => Iterable<A>;
+export type ModelChanges<TRow, A> = (row: TRow, operation: RowOperation) => Iterable<A>;
 
-export type ChangeMap<Client, A> = {
-	readonly [Model in ModelName<Client>]: ModelChanges<ModelRow<Client, Model>, A> | null;
+export type ChangeMap<TClient, A> = {
+	readonly [TModel in ModelName<TClient>]: ModelChanges<ModelRow<TClient, TModel>, A> | null;
 };
 
 export const rowOperations: ReadonlySet<string> = new Set<RowOperation>([

package/src/recording.ts

@@ -10,10 +10,12 @@ export const delegatesOf = <A>(models: LooseMap<A>): ReadonlyMap<string, string>
 		),
 	);
 
-const bound = (value: unknown, target: object): unknown => (typeof value === "function" ? value.bind(target) : value);
+function bound(value: unknown, target: object): unknown {
+	return typeof value === "function" ? value.bind(target) : value;
+}
 
-const recordingDelegate = (delegate: object, model: string, collect: (write: Write) => void): object =>
-	new Proxy(delegate, {
+function recordingDelegate(delegate: object, model: string, collect: (write: Write) => void): object {
+	return new Proxy(delegate, {
 		get: (target, key) => {
 			const value: unknown = Reflect.get(target, key);
 			if (typeof key !== "string" || typeof value !== "function" || !isWriteOperation(key)) {
@@ -26,12 +28,13 @@ const recordingDelegate = (delegate: object, model: string, collect: (write: Wri
 				});
 		},
 	});
+}
 
-export const recordingClient = <Client extends object>(
-	client: Client,
+export const recordingClient = <TClient extends object>(
+	client: TClient,
 	delegates: ReadonlyMap<string, string>,
 	collect: (write: Write) => void,
-): Client =>
+): TClient =>
 	new Proxy(client, {
 		get: (target, key) => {
 			const value: unknown = Reflect.get(target, key);

package/src/transaction.ts

@@ -4,25 +4,25 @@ import { PrismaError, TransactionExpired } from "./error.ts";
 import { type Expire, expiring, isTransactionClosed } from "./expiry.ts";
 import type { Transactional, TransactionOptions } from "./model.ts";
 
-interface Settled<X, E> {
+interface Settled<TX, E> {
 	readonly closed?: TransactionExpired;
 	readonly committed: boolean;
-	readonly exit: Exit.Exit<X, E | TransactionExpired | PrismaError>;
+	readonly exit: Exit.Exit<TX, E | TransactionExpired | PrismaError>;
 }
 
 class BodyFailed {}
 
-const commit = <Tx extends Transactional<Tx>, X, E, R>(
-	client: Tx,
+function commit<TTx extends Transactional<TTx>, TX, E, R>(
+	client: TTx,
 	options: TransactionOptions | undefined,
 	savepoint: boolean,
-	body: (tx: Tx) => Effect.Effect<X, E, R>,
+	body: (tx: TTx) => Effect.Effect<TX, E, R>,
 	context: Context.Context<R>,
 	signal: AbortSignal,
-): Promise<Settled<X, E>> => {
+): Promise<Settled<TX, E>> {
 	let started = false;
-	let failed: Exit.Exit<X, E> | undefined;
-	const run = async (tx: Tx) => {
+	let failed: Exit.Exit<TX, E> | undefined;
+	async function run(tx: TTx) {
 		started = true;
 		const exit = await Effect.runPromiseExitWith(context)(body(tx), { signal });
 		if (Exit.isSuccess(exit)) {
@@ -30,8 +30,8 @@ const commit = <Tx extends Transactional<Tx>, X, E, R>(
 		}
 		failed = exit;
 		throw new BodyFailed();
-	};
-	const rejected = (cause: unknown): Settled<X, E> => {
+	}
+	function rejected(cause: unknown): Settled<TX, E> {
 		if (failed !== undefined) {
 			return { committed: false, exit: failed };
 		}
@@ -40,36 +40,39 @@ const commit = <Tx extends Transactional<Tx>, X, E, R>(
 		}
 		const closed = new TransactionExpired({ cause, message: "The transaction was closed before it could finish" });
 		return { closed, committed: false, exit: Exit.fail(closed) };
-	};
+	}
 	return Promise.resolve(client.$transaction(run, options)).then(
-		(value): Settled<X, E> => ({ committed: true, exit: Exit.succeed(value) }),
+		(value): Settled<TX, E> => ({ committed: true, exit: Exit.succeed(value) }),
 		rejected,
 	);
-};
+}
 
-export const runTransaction = <Tx extends Transactional<Tx>, X, E, R, RO>(options: {
-	readonly client: Tx;
-	readonly open: Effect.Effect<Frame, never, RO>;
-	readonly body: (tx: Tx) => Effect.Effect<X, E, R>;
+export const runTransaction = <TTx extends Transactional<TTx>, TX, E, R, TOpenRequirements>(options: {
+	readonly client: TTx;
+	readonly open: Effect.Effect<Frame, never, TOpenRequirements>;
+	readonly body: (tx: TTx) => Effect.Effect<TX, E, R>;
 	readonly transaction: TransactionOptions | undefined;
 	readonly savepoint: boolean;
 	readonly deadline: number | undefined;
 	readonly Expiry: Context.Reference<Expire>;
-}): Effect.Effect<X, E | TransactionExpired | PrismaError, R | RO> =>
+}): Effect.Effect<TX, E | TransactionExpired | PrismaError, R | TOpenRequirements> =>
 	Effect.uninterruptibleMask((restore) =>
 		Effect.gen(function* () {
 			const { client, savepoint, body, deadline, Expiry } = options;
 			const frame = yield* options.open;
 			const context = yield* Effect.context<R>();
 			const abort = new AbortController();
-			const guarded = (tx: Tx) => expiring(frame.provide(body(tx)), deadline, Expiry);
+			function guarded(tx: TTx) {
+				return expiring(frame.provide(body(tx)), deadline, Expiry);
+			}
 			const outcome = commit(client, options.transaction, savepoint, guarded, context, abort.signal);
 			const expire = yield* Expiry;
-			const settle = (settled: Settled<X, E | TransactionExpired>) =>
-				Effect.andThen(
+			function settle(settled: Settled<TX, E | TransactionExpired>) {
+				return Effect.andThen(
 					settled.closed === undefined ? Effect.void : expire(settled.closed.cause),
 					Effect.as(frame.settle(settled.committed ? "committed" : "rolledBack"), settled.exit),
 				);
+			}
 			const settled = yield* restore(Effect.promise(() => outcome)).pipe(
 				Effect.onInterrupt(() =>
 					Effect.andThen(

package/src/write.ts

@@ -28,8 +28,8 @@ class MissingField {
 	}
 }
 
-const guarded = (row: object): object =>
-	new Proxy(row, {
+function guarded(row: object): object {
+	return new Proxy(row, {
 		get: (target, key, receiver) => {
 			if (typeof key === "string" && !(key in target)) {
 				throw new MissingField(key);
@@ -37,11 +37,15 @@ const guarded = (row: object): object =>
 			return Reflect.get(target, key, receiver);
 		},
 	});
+}
 
-const isRowOperation = (operation: string): operation is RowOperation => rowOperations.has(operation);
+function isRowOperation(operation: string): operation is RowOperation {
+	return rowOperations.has(operation);
+}
 
-const rowsOf = (result: unknown): readonly object[] =>
-	(Array.isArray(result) ? result : [result]).filter((row): row is object => typeof row === "object" && row !== null);
+function rowsOf(result: unknown): readonly object[] {
+	return (Array.isArray(result) ? result : [result]).filter((row): row is object => typeof row === "object" && row !== null);
+}
 
 const nothing: Interpreted<never> = { changes: [], unnamed: undefined };