@shivaedev/platform 0.4.2 → 0.5.0

package/src/better-auth/relation.ts

@@ -1,27 +1,27 @@
-import { all } from "@shivaedev/effect-prisma";
 import type { Effect, Option } from "effect";
+import { all } from "@shivaedev/effect-prisma";
 import { type CleanedWhere, type DynamicField, type Expression, whereExpression } from "./where.ts";
 
-export interface DynamicRelation<Requirements> extends Effect.Effect<ReadonlyArray<Record<string, unknown>>, unknown, Requirements> {
-	where(predicate: (fields: Record<string, DynamicField>) => Expression): DynamicRelation<Requirements>;
-	orderBy(ordering: (fields: Record<string, DynamicField>) => unknown): DynamicRelation<Requirements>;
-	take(count: number): DynamicRelation<Requirements>;
-	skip(count: number): DynamicRelation<Requirements>;
-	select(...fields: ReadonlyArray<string>): DynamicRelation<Requirements>;
-	first(): Effect.Effect<Option.Option<Record<string, unknown>>, unknown, Requirements>;
-	count(): Effect.Effect<number, unknown, Requirements>;
-	create(data: Record<string, unknown>): Effect.Effect<Record<string, unknown>, unknown, Requirements>;
-	update(data: Record<string, unknown>): Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
-	updateAll(data: Record<string, unknown>): Effect.Effect<ReadonlyArray<Record<string, unknown>>, unknown, Requirements>;
-	delete(): Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
-	deleteAll(): Effect.Effect<ReadonlyArray<Record<string, unknown>>, unknown, Requirements>;
+export interface DynamicRelation<Requirements> extends Effect.Effect<readonly Record<string, unknown>[], unknown, Requirements> {
+	count: () => Effect.Effect<number, unknown, Requirements>;
+	create: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, unknown, Requirements>;
+	delete: () => Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
+	deleteAll: () => Effect.Effect<readonly Record<string, unknown>[], unknown, Requirements>;
+	first: () => Effect.Effect<Option.Option<Record<string, unknown>>, unknown, Requirements>;
+	orderBy: (ordering: (fields: Record<string, DynamicField>) => unknown) => DynamicRelation<Requirements>;
+	select: (...fields: readonly string[]) => DynamicRelation<Requirements>;
+	skip: (count: number) => DynamicRelation<Requirements>;
+	take: (count: number) => DynamicRelation<Requirements>;
+	update: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
+	updateAll: (data: Record<string, unknown>) => Effect.Effect<readonly Record<string, unknown>[], unknown, Requirements>;
+	where: (predicate: (fields: Record<string, DynamicField>) => Expression) => DynamicRelation<Requirements>;
 }
 
 export const refineRelation = <Requirements>(
 	relation: DynamicRelation<Requirements>,
 	options: {
-		readonly where?: ReadonlyArray<CleanedWhere> | undefined;
-		readonly select?: ReadonlyArray<string> | undefined;
+		readonly where?: readonly CleanedWhere[] | undefined;
+		readonly select?: readonly string[] | undefined;
 		readonly limit?: number | undefined;
 		readonly offset?: number | undefined;
 		readonly sortBy?:
@@ -48,8 +48,12 @@ export const refineRelation = <Requirements>(
 			return options.sortBy?.direction === "desc" ? field.desc() : field.asc();
 		});
 	}
-	if (options.offset !== undefined) refined = refined.skip(options.offset);
-	if (options.limit !== undefined) refined = refined.take(options.limit);
+	if (options.offset !== undefined) {
+		refined = refined.skip(options.offset);
+	}
+	if (options.limit !== undefined) {
+		refined = refined.take(options.limit);
+	}
 	if (options.select !== undefined && options.select.length > 0) {
 		refined = refined.select(...options.select);
 	}

package/src/better-auth/row-adapter.ts

@@ -12,8 +12,8 @@ type Refinement = Parameters<typeof refineRelation>[1];
 
 interface RowMethods {
 	readonly create: (input: { readonly data: Row; readonly model: string; readonly select?: string[] | undefined }) => Promise<Row>;
+	readonly findMany: (input: FindManyInput) => Promise<readonly Row[]>;
 	readonly findOne: (input: FindOneInput) => Promise<Row | null>;
-	readonly findMany: (input: FindManyInput) => Promise<ReadonlyArray<Row>>;
 	readonly update: (input: { readonly model: string; readonly update: Row; readonly where: CleanedWhere[] }) => Promise<Row | null>;
 }
 
@@ -41,38 +41,40 @@ export const makeRowAdapter =
 	(query: RelationQuery, usePlural: boolean): AdapterFactoryCustomizeAdapterCreator =>
 	({ debugLog, getFieldAttributes }) => {
 		const isUnique = (model: string, condition: CleanedWhere): boolean =>
-			condition.connector !== "OR" &&
-			condition.operator === "eq" &&
-			condition.mode !== "insensitive" &&
-			(condition.field === "id" || getFieldAttributes({ field: condition.field, model }).unique === true);
+			condition.connector !== "OR"
+			&& condition.operator === "eq"
+			&& condition.mode !== "insensitive"
+			&& (condition.field === "id" || getFieldAttributes({ field: condition.field, model }).unique === true);
 
 		return rowTyped({
+			count: ({ model, where }) => query(model, { where }, (relation) => relation.count()),
 			create: ({ data, model, select }) => {
 				debugLog("create", { model });
 				return query(model, { select }, (relation) => relation.create(data));
 			},
-			findOne: ({ join, model, select, where }) => {
-				rejectJoin(join);
-				return query(model, { select, where }, (relation) => Effect.map(relation.first(), Option.getOrNull));
+			delete: ({ model, where }) => {
+				const byId = where.some(namesId);
+				return query(model, { where }, (relation) => (byId ? Effect.asVoid(relation.delete()) : Effect.asVoid(relation.deleteAll())));
 			},
+			deleteMany: ({ model, where }) => query(model, { where }, (relation) => Effect.map(relation.deleteAll(), (rows) => rows.length)),
 			findMany: ({ join, limit, model, offset, select, sortBy, where }) => {
 				rejectJoin(join);
 				return query(model, { limit, offset, select, sortBy, where }, (relation) => relation);
 			},
+			findOne: ({ join, model, select, where }) => {
+				rejectJoin(join);
+				return query(model, { select, where }, (relation) => Effect.map(relation.first(), Option.getOrNull));
+			},
+			options: { usePlural },
 			update: ({ model, update, where }) => {
-				if (where.length === 0) return Promise.resolve(null);
+				if (where.length === 0) {
+					return Promise.resolve(null);
+				}
 				const unique = where.some((condition) => isUnique(model, condition));
 				return query(model, { where }, (relation) =>
 					unique ? relation.update(update) : Effect.map(relation.updateAll(update), (rows) => rows[0] ?? null),
 				);
 			},
 			updateMany: ({ model, update, where }) => query(model, { where }, (relation) => Effect.map(relation.updateAll(update), (rows) => rows.length)),
-			delete: ({ model, where }) => {
-				const byId = where.some(namesId);
-				return query(model, { where }, (relation) => (byId ? Effect.asVoid(relation.delete()) : Effect.asVoid(relation.deleteAll())));
-			},
-			deleteMany: ({ model, where }) => query(model, { where }, (relation) => Effect.map(relation.deleteAll(), (rows) => rows.length)),
-			count: ({ model, where }) => query(model, { where }, (relation) => relation.count()),
-			options: { usePlural },
 		});
 	};

package/src/better-auth/where.ts

@@ -1,31 +1,31 @@
-import { all, and, not, or } from "@shivaedev/effect-prisma";
 import type { Where } from "better-auth";
+import { all, and, not, or } from "@shivaedev/effect-prisma";
 
 export type CleanedWhere = Required<Where>;
 export type Expression = Parameters<typeof and>[number];
 
 export interface DynamicField {
-	eq(value: unknown): Expression;
-	neq(value: unknown): Expression;
-	gt(value: unknown): Expression;
-	gte(value: unknown): Expression;
-	lt(value: unknown): Expression;
-	lte(value: unknown): Expression;
-	in(value: ReadonlyArray<unknown>): Expression;
-	notIn(value: ReadonlyArray<unknown>): Expression;
-	like(value: string): Expression;
-	ilike?(value: string): Expression;
-	isNull(): Expression;
-	isNotNull(): Expression;
-	asc(): unknown;
-	desc(): unknown;
+	asc: () => unknown;
+	desc: () => unknown;
+	eq: (value: unknown) => Expression;
+	gt: (value: unknown) => Expression;
+	gte: (value: unknown) => Expression;
+	ilike?: (value: string) => Expression;
+	in: (value: readonly unknown[]) => Expression;
+	isNotNull: () => Expression;
+	isNull: () => Expression;
+	like: (value: string) => Expression;
+	lt: (value: unknown) => Expression;
+	lte: (value: unknown) => Expression;
+	neq: (value: unknown) => Expression;
+	notIn: (value: readonly unknown[]) => Expression;
 }
 
 const escapeLike = (value: string): string => value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
 
-const nonNullValues = (value: unknown): ReadonlyArray<unknown> => (Array.isArray(value) ? value : [value]).filter((item) => item !== null);
+const nonNullValues = (value: unknown): readonly unknown[] => (Array.isArray(value) ? value : [value]).filter((item) => item !== null);
 
-const insensitiveStrings = (field: DynamicField, where: CleanedWhere, values: ReadonlyArray<unknown>) => {
+const insensitiveStrings = (field: DynamicField, where: CleanedWhere, values: readonly unknown[]) => {
 	const ilike = field.ilike;
 	if (where.mode !== "insensitive" || ilike === undefined || !values.every((item) => typeof item === "string")) {
 		return undefined;
@@ -52,7 +52,9 @@ const exclusion = (field: DynamicField, where: CleanedWhere): Expression | undef
 };
 
 const likePattern = (operator: CleanedWhere["operator"], escaped: string): string => {
-	if (operator === "contains") return `%${escaped}%`;
+	if (operator === "contains") {
+		return `%${escaped}%`;
+	}
 	return operator === "starts_with" ? `${escaped}%` : `%${escaped}`;
 };
 
@@ -66,15 +68,22 @@ const pattern = (field: DynamicField, where: CleanedWhere): Expression => {
 
 const insensitiveEquality = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
 	const value = where.value;
-	if (where.mode !== "insensitive" || typeof value !== "string" || field.ilike === undefined) return undefined;
-	if (where.operator === "eq") return field.ilike(escapeLike(value));
-	if (where.operator === "ne") return not(field.ilike(escapeLike(value)));
+	const operator = where.operator ?? "eq";
+	if (where.mode !== "insensitive" || typeof value !== "string" || field.ilike === undefined) {
+		return undefined;
+	}
+	if (operator === "eq") {
+		return field.ilike(escapeLike(value));
+	}
+	if (operator === "ne") {
+		return not(field.ilike(escapeLike(value)));
+	}
 	return undefined;
 };
 
 const comparison = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
 	const value = where.value;
-	switch (where.operator) {
+	switch (where.operator ?? "eq") {
 		case "eq":
 			return value === null ? field.isNull() : field.eq(value);
 		case "ne":
@@ -98,7 +107,7 @@ const comparison = (field: DynamicField, where: CleanedWhere): Expression | unde
 	}
 };
 
-export const whereExpression = (fields: Record<string, DynamicField>, where: ReadonlyArray<CleanedWhere>): Expression | undefined => {
+export const whereExpression = (fields: Record<string, DynamicField>, where: readonly CleanedWhere[]): Expression | undefined => {
 	const conjunctions: Expression[] = [];
 	const disjunctions: Expression[] = [];
 
@@ -108,11 +117,17 @@ export const whereExpression = (fields: Record<string, DynamicField>, where: Rea
 			throw new TypeError(`Unknown database field: ${condition.field}`);
 		}
 		const expression = insensitiveEquality(field, condition) ?? comparison(field, condition);
-		if (expression === undefined) continue;
+		if (expression === undefined) {
+			continue;
+		}
 		(condition.connector === "OR" ? disjunctions : conjunctions).push(expression);
 	}
 
-	if (disjunctions.length > 0) conjunctions.push(or(...disjunctions));
-	if (conjunctions.length === 0) return all();
+	if (disjunctions.length > 0) {
+		conjunctions.push(or(...disjunctions));
+	}
+	if (conjunctions.length === 0) {
+		return all();
+	}
 	return conjunctions.length === 1 ? conjunctions[0] : and(...conjunctions);
 };

package/src/errors/taxonomy.ts

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 
 const described = { message: Schema.String };
-const perField = { message: Schema.String, field: Schema.optionalKey(Schema.String) };
+const perField = { field: Schema.optionalKey(Schema.String), message: Schema.String };
 
 export class NotFound extends Schema.TaggedError<NotFound>()("NotFound", described) {}
 

package/src/node-http/subscription-signal.ts

@@ -1,18 +1,13 @@
 import type { IncomingMessage } from "node:http";
 
 export interface NodeSubscriptionSignalOptions {
-	/** A Web request, including its signal and an optional srvx node runtime. */
-	readonly request?: Request | undefined;
-	/** The node request when the transport exposes it directly. */
 	readonly nodeRequest?: IncomingMessage | undefined;
-	/** Additional transport or procedure signals to combine. */
+	readonly request?: Request | undefined;
 	readonly signals?: Iterable<AbortSignal | undefined>;
 }
 
 export interface NodeSubscriptionSignal {
-	/** Detach node listeners when the subscription ends. */
 	readonly dispose: () => void;
-	/** Aborts when any supplied signal or the underlying connection closes. */
 	readonly signal: AbortSignal;
 }
 
@@ -26,17 +21,17 @@ const nodeRequestFrom = (request: Request | undefined): IncomingMessage | undefi
 	return isIncomingMessage(req) ? req : undefined;
 };
 
-/**
- * Combine Web/procedure abort signals with node request and socket close events.
- * The node events cover long-lived responses under Bun's node:http compatibility
- * layer, where a Web request signal alone may not report an abandoned socket.
- */
+// Under Bun's node:http compatibility layer a Web request signal may miss an abandoned socket, so node close events cover long-lived responses.
 export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions): NodeSubscriptionSignal => {
 	const controller = new AbortController();
 	const signals: AbortSignal[] = [controller.signal];
-	if (options.request !== undefined) signals.push(options.request.signal);
+	if (options.request !== undefined) {
+		signals.push(options.request.signal);
+	}
 	for (const signal of options.signals ?? []) {
-		if (signal !== undefined) signals.push(signal);
+		if (signal !== undefined) {
+			signals.push(signal);
+		}
 	}
 
 	const nodeRequest = options.nodeRequest ?? nodeRequestFrom(options.request);
@@ -46,17 +41,23 @@ export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions):
 
 	const socket = nodeRequest.socket;
 	const onRequestClose = () => {
-		if (!nodeRequest.complete) controller.abort();
+		if (!nodeRequest.complete) {
+			controller.abort();
+		}
 	};
 	const onSocketClose = () => controller.abort();
 	nodeRequest.once("close", onRequestClose);
 	socket.once("close", onSocketClose);
-	if (nodeRequest.destroyed || socket.destroyed) controller.abort();
+	if (nodeRequest.destroyed || socket.destroyed) {
+		controller.abort();
+	}
 
 	let disposed = false;
 	return {
 		dispose: () => {
-			if (disposed) return;
+			if (disposed) {
+				return;
+			}
 			disposed = true;
 			nodeRequest.removeListener("close", onRequestClose);
 			socket.removeListener("close", onSocketClose);

package/src/rpc-server/origin.ts

@@ -2,15 +2,15 @@ import { Option } from "effect";
 import { Headers } from "effect/unstable/http";
 
 export interface OriginRequest {
+	readonly headers: Headers.Headers;
 	readonly origin: Option.Option<string>;
 	readonly rpc: string;
-	readonly headers: Headers.Headers;
 }
 
 export type OriginPolicy = (request: OriginRequest) => boolean;
 
 export interface TrustedOriginsOptions {
-	readonly allow: ReadonlyArray<string>;
+	readonly allow: readonly string[];
 	readonly missing: "allow" | "reject";
 }
 
@@ -23,7 +23,7 @@ export const trustedOrigins =
 		});
 
 export const originRequest = (headers: Headers.Headers, rpc: string): OriginRequest => ({
+	headers,
 	origin: Headers.get(headers, "origin"),
 	rpc,
-	headers,
 });

package/src/rpc-server/redact-cause.ts

@@ -11,11 +11,11 @@ const reporterHints = (error: Error, sensitive: SensitiveKey) => ({
 const redactError = (error: Error, sensitive: SensitiveKey): Error => {
 	const options = error.cause === undefined ? undefined : { cause: redact(error.cause, sensitive) };
 	const copy = new Error(redactText(error.message, sensitive), options);
-	Object.defineProperty(copy, "name", { value: error.name, writable: true, configurable: true });
+	Object.defineProperty(copy, "name", { configurable: true, value: error.name, writable: true });
 	Object.defineProperty(copy, "stack", {
+		configurable: true,
 		value: error.stack === undefined ? undefined : redactText(error.stack, sensitive),
 		writable: true,
-		configurable: true,
 	});
 	return Object.assign(copy, redact(Object.fromEntries(Object.entries(error)), sensitive), reporterHints(error, sensitive));
 };

package/src/rpc-server/redact.ts

@@ -5,15 +5,21 @@ const MAX_DEPTH = 8;
 const MAX_ENTRIES = 50;
 
 const binary = (value: object): string | undefined => {
-	if (ArrayBuffer.isView(value)) return `<${value.constructor.name} ${value.byteLength} bytes>`;
-	if (value instanceof ArrayBuffer) return `<ArrayBuffer ${value.byteLength} bytes>`;
+	if (ArrayBuffer.isView(value)) {
+		return `<${value.constructor.name} ${value.byteLength} bytes>`;
+	}
+	if (value instanceof ArrayBuffer) {
+		return `<ArrayBuffer ${value.byteLength} bytes>`;
+	}
 	return undefined;
 };
 
-const entriesOf = (value: object): Array<[string, unknown]> => {
+const entriesOf = (value: object): [string, unknown][] => {
 	const entries = Object.entries(value);
-	if (!Predicate.isError(value)) return entries;
-	const shape: Array<[string, unknown]> = [
+	if (!Predicate.isError(value)) {
+		return entries;
+	}
+	const shape: [string, unknown][] = [
 		["name", value.name],
 		["message", value.message],
 		["stack", value.stack],
@@ -22,12 +28,22 @@ const entriesOf = (value: object): Array<[string, unknown]> => {
 };
 
 const walk = (value: unknown, sensitive: SensitiveKey, depth: number): unknown => {
-	if (Redacted.isRedacted(value)) return REDACTED;
-	if (Predicate.isString(value)) return redactText(value, sensitive);
-	if (!Predicate.isObjectOrArray(value)) return value;
+	if (Redacted.isRedacted(value)) {
+		return REDACTED;
+	}
+	if (Predicate.isString(value)) {
+		return redactText(value, sensitive);
+	}
+	if (!Predicate.isObjectOrArray(value)) {
+		return value;
+	}
 	const summary = binary(value);
-	if (summary !== undefined) return summary;
-	if (depth >= MAX_DEPTH) return "<truncated>";
+	if (summary !== undefined) {
+		return summary;
+	}
+	if (depth >= MAX_DEPTH) {
+		return "<truncated>";
+	}
 	if (Array.isArray(value)) {
 		const items = value.slice(0, MAX_ENTRIES).map((item) => walk(item, sensitive, depth + 1));
 		return value.length > MAX_ENTRIES ? [...items, `<${value.length - MAX_ENTRIES} more items>`] : items;

package/src/rpc-server/sensitive.ts

@@ -26,26 +26,26 @@ const SENSITIVE_NAMES = ["session", "pan"];
 
 export type SensitiveKey = (key: string) => boolean;
 
-const wordsOf = (key: string): Array<string> =>
+const wordsOf = (key: string): string[] =>
 	key
-		.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2")
-		.replaceAll(/([A-Z])([A-Z][a-z])/g, "$1 $2")
+		.replaceAll(/([a-z0-9])([A-Z])/gu, "$1 $2")
+		.replaceAll(/([A-Z])([A-Z][a-z])/gu, "$1 $2")
 		.toLowerCase()
-		.split(/[\s_-]+/);
+		.split(/[\s_-]+/u);
 
 export const isSensitiveKey: SensitiveKey = (key) => {
-	const normalized = key.toLowerCase().replaceAll(/[-_]/g, "");
+	const normalized = key.toLowerCase().replaceAll(/[-_]/gu, "");
 	return (
-		SENSITIVE_NAMES.includes(normalized) ||
-		SENSITIVE_PARTS.some((part) => normalized.includes(part)) ||
-		wordsOf(key).some((word) => SENSITIVE_WORDS.includes(word))
+		SENSITIVE_NAMES.includes(normalized)
+		|| SENSITIVE_PARTS.some((part) => normalized.includes(part))
+		|| wordsOf(key).some((word) => SENSITIVE_WORDS.includes(word))
 	);
 };
 
-const AUTH_SCHEME = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/-]+=*/gi;
-const JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g;
-const URL_PASSWORD = /(\/\/[^:/\s@]+:)[^@/\s]+@/g;
-const ASSIGNMENT = /([A-Za-z][\w.-]*)(["']?\s*[=:]\s*["']?)([^\s"'&,;]+)/g;
+const AUTH_SCHEME = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/-]+=*/giu;
+const JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/gu;
+const URL_PASSWORD = /(\/\/[^:/\s@]+:)[^@/\s]+@/gu;
+const ASSIGNMENT = /([A-Za-z][\w.-]*)(["']?\s*[=:]\s*["']?)([^\s"'&,;]+)/gu;
 
 const scrub = (text: string, sensitive: SensitiveKey): string =>
 	text

package/src/rpc-server/session.ts

@@ -15,8 +15,8 @@ export interface SessionProvider<Session extends SessionShape> {
 }
 
 export interface SessionPolicy<Session extends SessionShape> {
-	readonly provider: SessionProvider<Session>;
 	readonly origin: OriginPolicy;
+	readonly provider: SessionProvider<Session>;
 }
 
 export const resolveSession: <Session extends SessionShape>(
@@ -27,7 +27,9 @@ export const resolveSession: <Session extends SessionShape>(
 	Session extends SessionShape,
 >(policy: SessionPolicy<Session>, headers: Headers.Headers, rpc: string) {
 	const transport = yield* transportHeaders(headers);
-	if (!policy.origin(originRequest(transport, rpc))) return yield* new Forbidden({ message: "Origin not allowed" });
+	if (!policy.origin(originRequest(transport, rpc))) {
+		return yield* new Forbidden({ message: "Origin not allowed" });
+	}
 	return yield* policy.provider.get(transport);
 });
 
@@ -37,7 +39,9 @@ export const authenticatedLayer = <Session extends SessionShape>(policy: Session
 	Layer.succeed(Authenticated, (effect, { headers, rpc }) =>
 		Effect.gen(function* () {
 			const session = yield* resolveSession(policy, headers, rpc._tag);
-			if (Option.isNone(session)) return yield* new Unauthorized({ message: "Authentication required" });
+			if (Option.isNone(session)) {
+				return yield* new Unauthorized({ message: "Authentication required" });
+			}
 			const id = yield* identified(session.value.user.id);
 			return yield* effect.pipe(Effect.provideService(Identity, { id }), Effect.annotateLogs({ userId: id }));
 		}),
@@ -47,7 +51,9 @@ export const maybeAuthenticatedLayer = <Session extends SessionShape>(policy: Se
 	Layer.succeed(MaybeAuthenticated, (effect, { headers, rpc }) =>
 		Effect.gen(function* () {
 			const session = yield* resolveSession(policy, headers, rpc._tag);
-			if (Option.isNone(session)) return yield* Effect.provideService(effect, OptionalIdentity, Option.none());
+			if (Option.isNone(session)) {
+				return yield* Effect.provideService(effect, OptionalIdentity, Option.none());
+			}
 			const id = yield* identified(session.value.user.id);
 			return yield* effect.pipe(Effect.provideService(OptionalIdentity, Option.some({ id })), Effect.annotateLogs({ userId: id }));
 		}),

package/src/rpc-server/tracing.ts

@@ -11,7 +11,7 @@ export interface RequestTracingOptions {
 	readonly sensitive?: SensitiveKey;
 }
 
-const ACCEPTED_REQUEST_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+const ACCEPTED_REQUEST_ID = /^[A-Za-z0-9._:-]{1,128}$/u;
 
 const hex = (byte: number): string => byte.toString(16).padStart(2, "0");
 
@@ -33,9 +33,13 @@ const failureTag = (cause: Cause.Cause<unknown>): string =>
 	});
 
 const logFailure = (cause: Cause.Cause<unknown>, payload: unknown, sensitive: SensitiveKey | undefined): Effect.Effect<void> => {
-	if (Cause.hasInterruptsOnly(cause)) return Effect.void;
+	if (Cause.hasInterruptsOnly(cause)) {
+		return Effect.void;
+	}
 	const annotations = { "rpc.payload": redact(payload, sensitive) };
-	if (!Cause.hasDies(cause)) return Effect.annotateLogs(Effect.logInfo("RPC failure"), { ...annotations, "rpc.failure": failureTag(cause) });
+	if (!Cause.hasDies(cause)) {
+		return Effect.annotateLogs(Effect.logInfo("RPC failure"), { ...annotations, "rpc.failure": failureTag(cause) });
+	}
 	const defects = cause.reasons.filter(Cause.isDieReason).map((reason) => redact(reason.defect, sensitive));
 	return Effect.annotateLogs(Effect.logError("RPC defect"), { ...annotations, "rpc.defect": defects });
 };

package/src/runtime/make.ts

@@ -40,7 +40,9 @@ const make = <Services, BuildError>(layer: Layer.Layer<Services, BuildError>): P
 		dispose: () => managed.dispose(),
 		runPromise: async (effect, options) => {
 			const exit = await runPromiseExit(effect, options);
-			if (Exit.isSuccess(exit)) return exit.value;
+			if (Exit.isSuccess(exit)) {
+				return exit.value;
+			}
 			throw Cause.squash(exit.cause);
 		},
 		runPromiseExit,
@@ -57,7 +59,9 @@ export const makePlatformRuntime = <Services, BuildError>(
 	options: PlatformRuntimeOptions = {},
 ): PlatformRuntime<Services, BuildError> => {
 	const key = Effect.runSync(production) ? undefined : options.developmentCacheKey;
-	if (key === undefined) return make(layer);
+	if (key === undefined) {
+		return make(layer);
+	}
 
 	const cached = runtimeCache.get(key);
 	if (cached !== undefined) {
@@ -68,7 +72,9 @@ export const makePlatformRuntime = <Services, BuildError>(
 	const cachedRuntime: PlatformRuntime<Services, BuildError> = {
 		...runtime,
 		dispose: async () => {
-			if (runtimeCache.get(key) === cachedRuntime) runtimeCache.delete(key);
+			if (runtimeCache.get(key) === cachedRuntime) {
+				runtimeCache.delete(key);
+			}
 			await runtime.dispose();
 		},
 	};

package/src/runtime/types.ts

@@ -1,7 +1,6 @@
 import type { Context, Effect, Exit } from "effect";
 
 export interface PlatformRuntimeOptions {
-	/** Reuse one runtime across development module reloads. */
 	readonly developmentCacheKey?: string | symbol;
 }
 

package/src/testing/types.ts

@@ -1,8 +1,8 @@
 import type { TestContext, Vitest } from "@effect/vitest";
+import type { Effect, Layer } from "effect";
 import type { AnyDatabase, DatabaseService } from "@shivaedev/effect-prisma/testing";
 import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc";
 import type { CallerOptions, CallerResult, EffectCallerFactory, TrpcHarnessTest, TrpcHarnessTester } from "@shivaedev/effect-trpc/testing";
-import type { Effect, Layer } from "effect";
 
 export type PlatformHarness<Database extends AnyDatabase, Options, Caller, Extension> = Readonly<{
 	db: DatabaseService<Database>;

package/src/testing/vitest.ts

@@ -1,17 +1,20 @@
 import type { TestContext } from "@effect/vitest";
+import { Effect, type Layer } from "effect";
 import { type AnyDatabase, withTestTransaction } from "@shivaedev/effect-prisma/testing";
 import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc";
 import { type CallerOptions, type CallerResult, type EffectCallerFactory, makeTrpcHarnessIt } from "@shivaedev/effect-trpc/testing";
-import { Effect, type Layer } from "effect";
+import type { Bivariant } from "@shivaedev/types";
 import type { MakePlatformItOptions, PlatformHarness, PlatformIt } from "./types.ts";
 
 interface LooseOptions {
 	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
 	readonly createCaller: (options?: unknown) => object;
-	extend?(
-		base: { readonly db: unknown; readonly trpc: EffectCallerFactory<unknown, object> },
-		context: TestContext,
-	): Effect.Effect<object, unknown, unknown>;
+	extend?: Bivariant<
+		(
+			base: { readonly db: unknown; readonly trpc: EffectCallerFactory<unknown, object> },
+			context: TestContext,
+		) => Effect.Effect<object, unknown, unknown>
+	>;
 	readonly layer: Layer.Layer<unknown, unknown>;
 }
 
@@ -30,9 +33,9 @@ function platformIt<
 function platformIt(database: AnyDatabase, options: LooseOptions): unknown {
 	const trpcIt = makeTrpcHarnessIt({
 		adapter: options.adapter,
+		around: (effect) => withTestTransaction(database, effect),
 		createCaller: options.createCaller,
 		layer: options.layer,
-		around: (effect) => withTestTransaction(database, effect),
 		makeHarness: (trpc, context) =>
 			Effect.gen(function* () {
 				const services = yield* Effect.context<unknown>();