@shivaedev/platform 0.4.3 → 0.5.1

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

@@ -1,8 +1,8 @@
 import { Effect, Layer, Option } from "effect";
 import type { Headers } from "effect/unstable/http";
-import { type AuthUnavailable, Forbidden, Unauthorized } from "../errors/taxonomy.ts";
-import { Identity, OptionalIdentity } from "../rpc/identity.ts";
-import { Authenticated, MaybeAuthenticated } from "../rpc/middleware.ts";
+import { type AuthUnavailable, Forbidden, Unauthorized } from "#errors/taxonomy.ts";
+import { Identity, OptionalIdentity } from "#rpc/identity.ts";
+import { Authenticated, MaybeAuthenticated } from "#rpc/middleware.ts";
 import { type OriginPolicy, originRequest } from "./origin.ts";
 import { transportHeaders } from "./transport.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

@@ -1,7 +1,7 @@
 import { Cause, Effect, Layer, Option, Predicate, Random } from "effect";
 import { Headers } from "effect/unstable/http";
-import { RequestId } from "../rpc/identity.ts";
-import { RequestTracing } from "../rpc/middleware.ts";
+import { RequestId } from "#rpc/identity.ts";
+import { RequestTracing } from "#rpc/middleware.ts";
 import { redact } from "./redact.ts";
 import { redactCause } from "./redact-cause.ts";
 import type { SensitiveKey } from "./sensitive.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/rpc-server.ts

@@ -1,8 +1,8 @@
-export { betterAuthSessions, type GetSession } from "./rpc-server/adapters/better-auth-sessions.ts";
-export { type OriginPolicy, type OriginRequest, type TrustedOriginsOptions, trustedOrigins } from "./rpc-server/origin.ts";
-export { redact } from "./rpc-server/redact.ts";
-export { redactCause, redactDefect, redactingErrorReporter } from "./rpc-server/redact-cause.ts";
-export { isSensitiveKey, type SensitiveKey } from "./rpc-server/sensitive.ts";
+export { betterAuthSessions, type GetSession } from "#rpc-server/adapters/better-auth-sessions.ts";
+export { type OriginPolicy, type OriginRequest, type TrustedOriginsOptions, trustedOrigins } from "#rpc-server/origin.ts";
+export { redact } from "#rpc-server/redact.ts";
+export { redactCause, redactDefect, redactingErrorReporter } from "#rpc-server/redact-cause.ts";
+export { isSensitiveKey, type SensitiveKey } from "#rpc-server/sensitive.ts";
 export {
 	authenticatedLayer,
 	maybeAuthenticatedLayer,
@@ -10,6 +10,6 @@ export {
 	type SessionPolicy,
 	type SessionProvider,
 	type SessionShape,
-} from "./rpc-server/session.ts";
-export { type RequestTracingOptions, requestTracingLayer } from "./rpc-server/tracing.ts";
-export { transportHeaders } from "./rpc-server/transport.ts";
+} from "#rpc-server/session.ts";
+export { type RequestTracingOptions, requestTracingLayer } from "#rpc-server/tracing.ts";
+export { transportHeaders } from "#rpc-server/transport.ts";

package/src/rpc.ts

@@ -1,2 +1,2 @@
-export { Identity, type IdentityValue, OptionalIdentity, RequestId } from "./rpc/identity.ts";
-export { Authenticated, MaybeAuthenticated, RequestTracing } from "./rpc/middleware.ts";
+export { Identity, type IdentityValue, OptionalIdentity, RequestId } from "#rpc/identity.ts";
+export { Authenticated, MaybeAuthenticated, RequestTracing } from "#rpc/middleware.ts";

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/runtime.ts

@@ -1,7 +1,7 @@
-export { makePlatformRuntime } from "./runtime/make.ts";
+export { makePlatformRuntime } from "#runtime/make.ts";
 export type {
 	PlatformRuntime,
 	PlatformRuntimeBuildError,
 	PlatformRuntimeOptions,
 	PlatformRuntimeServices,
-} from "./runtime/types.ts";
+} from "#runtime/types.ts";

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>();

package/src/testing.ts

@@ -4,5 +4,5 @@ export type {
 	PlatformIt,
 	PlatformTest,
 	PlatformTester,
-} from "./testing/types.ts";
-export { makePlatformIt } from "./testing/vitest.ts";
+} from "#testing/types.ts";
+export { makePlatformIt } from "#testing/vitest.ts";