@shivaedev/effect-changes-prisma 0.3.3 → 0.5.0

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

@@ -1,28 +1,28 @@
 import { type Context, Effect, Exit } from "effect";
-import type { Frame } from "@shivaedev/effect-changes";
+import type { Frame } from "@shivaedev/effect-changes/frame.ts";
 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

@@ -1,4 +1,4 @@
-import type { Bivariant } from "@shivaedev/types";
+import type { Bivariant } from "@shivaedev/types/bivariant.ts";
 import { countOperations, type RowOperation, rowOperations } from "./model.ts";
 
 export interface Write {
@@ -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 };
 

package/dist/index.d.ts

@@ -1,7 +0,0 @@
-export { makePrismaChanges, type PrismaChanges, type PrismaChangesOptions, type UnnamedObserver } from "./changes.ts";
-export { type Coverage, type CoverageViolation, checkCoverage } from "./coverage.ts";
-export { PrismaError, TransactionExpired } from "./error.ts";
-export type { ChangeMap, CountOperation, ModelChanges, ModelName, ModelRow, RowOperation, Transactional, TransactionOptions, } from "./model.ts";
-export { type RawQueryClient, type TableWrites, tablesOf, tableWrites, writtenTables } from "./tables.ts";
-export type { UnnamedWrite, Write } from "./write.ts";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,KAAK,oBAAoB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACtH,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,iBAAiB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC7D,YAAY,EACX,SAAS,EACT,cAAc,EACd,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,kBAAkB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC1G,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,5 +0,0 @@
-export { makePrismaChanges } from "./changes.js";
-export { checkCoverage } from "./coverage.js";
-export { PrismaError, TransactionExpired } from "./error.js";
-export { tablesOf, tableWrites, writtenTables } from "./tables.js";
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAuE,MAAM,cAAc,CAAC;AACtH,OAAO,EAAyC,aAAa,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAW7D,OAAO,EAAyC,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/src/index.ts

@@ -1,15 +0,0 @@
-export { makePrismaChanges, type PrismaChanges, type PrismaChangesOptions, type UnnamedObserver } from "./changes.ts";
-export { type Coverage, type CoverageViolation, checkCoverage } from "./coverage.ts";
-export { PrismaError, TransactionExpired } from "./error.ts";
-export type {
-	ChangeMap,
-	CountOperation,
-	ModelChanges,
-	ModelName,
-	ModelRow,
-	RowOperation,
-	Transactional,
-	TransactionOptions,
-} from "./model.ts";
-export { type RawQueryClient, type TableWrites, tablesOf, tableWrites, writtenTables } from "./tables.ts";
-export type { UnnamedWrite, Write } from "./write.ts";