@shivaedev/platform 0.14.4 → 0.16.0

package/src/server/appHost.ts

@@ -1,21 +1,16 @@
-import { Context, type Duration, type Effect } from "effect";
+import { Context, type Effect } from "effect";
 import type { Rpc } from "effect/rpc";
-import type { Migrator } from "effect/sql";
 import type { makeLiveServer } from "@shivaedev/effect-contract/makeLiveServer.ts";
-import type { SessionPolicy, SessionShape } from "#rpc-server/session.ts";
 import { appHostHttp, deferredHost, migratedHost } from "#server/appHostHttp.ts";
 import { type DatabaseConfig, databaseLayer } from "#server/databaseLayer.ts";
 import type { HostOptions, HostPolicy } from "#server/hostOptions.ts";
+import type { MigrationOptions } from "#server/MigrationOptions.ts";
+import type { SessionPolicy, SessionShape } from "#server/rpc-server/session.ts";
 
 export class AppChanges extends Context.Service<AppChanges, Effect.Success<typeof makeLiveServer>>()("@shivaedev/platform/AppChanges") {}
 export interface AppDatabaseOptions<R = never> {
 	readonly config?: DatabaseConfig;
-	readonly migrations: {
-		readonly loader: Migrator.Loader<R>;
-		readonly mode?: "migrate" | "check";
-		readonly table?: string;
-		readonly lockTimeout?: Duration.Input;
-	};
+	readonly migrations: MigrationOptions<R>;
 }
 
 export function appDatabase<R>(options: AppDatabaseOptions<R>) {

package/src/server/appHostHttp.ts

@@ -3,17 +3,18 @@ import { NodeHttpServer, NodeServices } from "@effect/platform-node";
 import { ByteSize, Config, Effect, Layer, Option, Schema } from "effect";
 import { HttpIncomingMessage, HttpRouter, HttpServerRequest, HttpStaticServer } from "effect/http";
 import { type Rpc, RpcSerialization, RpcServer } from "effect/rpc";
-import type { AppHostOptions, AppHttpHostOptions, AppLocalHostOptions } from "#appHost.ts";
-import { boundedRpcRequest } from "#boundedRpcRequest.ts";
-import type { databaseLayer } from "#databaseLayer.ts";
-import type { HostOptions, HostPolicy } from "#hostOptions.ts";
-import { otlpTracing } from "#otlpTracing.ts";
 import type { Authenticated, MaybeAuthenticated, RequestTracing } from "#rpc/middleware.ts";
-import { localRpcGuard } from "#rpc-server/local.ts";
-import { authenticatedLayer, maybeAuthenticatedLayer, type SessionShape } from "#rpc-server/session.ts";
-import { requestTracingLayer } from "#rpc-server/tracing.ts";
-import { TrustedProxy } from "#rpc-server/trustedProxy.ts";
+import type { AppHostOptions, AppHttpHostOptions, AppLocalHostOptions } from "#server/appHost.ts";
+import { boundedRpcRequest } from "#server/boundedRpcRequest.ts";
+import type { databaseLayer } from "#server/databaseLayer.ts";
 import { healthRoute } from "#server/healthRoute.ts";
+import type { HostOptions, HostPolicy } from "#server/hostOptions.ts";
+import { otlpTracing } from "#server/otlpTracing.ts";
+import { localRpcGuard } from "#server/rpc-server/local.ts";
+import { authenticatedLayer, maybeAuthenticatedLayer, type SessionShape } from "#server/rpc-server/session.ts";
+import { requestTracingLayer } from "#server/rpc-server/tracing.ts";
+import { TrustedProxy } from "#server/rpc-server/trustedProxy.ts";
+import { tracedGroup } from "#server/tracedGroup.ts";
 export function appHostHttp<
 	TRpcs extends Rpc.Any,
 	THandlers,
@@ -46,7 +47,7 @@ export function appHostHttp<
 			const routes = HttpRouter.use((router) =>
 				Effect.gen(function* () {
 					const wire = yield* RpcSerialization.RpcSerialization;
-					const handler = yield* RpcServer.toHttpEffect(options.group);
+					const handler = yield* RpcServer.toHttpEffect(tracedGroup(options.group));
 					const guarded = localRpcGuard(handler, trustedProxy);
 					yield* router.add("POST", options.rpcPath ?? "/rpc", (request) =>
 						guarded.pipe(

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

@@ -2,7 +2,7 @@ import type { BetterAuthOptions, DBAdapterInstance } from "better-auth";
 import { createAdapterFactory } from "better-auth/adapters";
 import { Effect } from "effect";
 import type { AnyDatabase } from "@shivaedev/effect-prisma/databaseTypes.ts";
-import type { PlatformRuntime } from "#runtime/types.ts";
+import type { PlatformRuntime } from "#server/runtime/types.ts";
 import { type DynamicRelation, refineRelation } from "./relation.ts";
 import { makeRowAdapter, type RelationQuery } from "./rowAdapter.ts";
 export interface EffectPrismaAdapterOptions {

package/src/server/databaseLayer.ts

@@ -1,5 +1,5 @@
 import * as PgClient from "@effect/sql-pg/PgClient";
-import { Config, Effect, Layer, type Redacted } from "effect";
+import { Config, Effect, Layer, type Redacted, Schedule } from "effect";
 import * as Reactivity from "effect/reactivity/Reactivity";
 import { makeLiveServer } from "@shivaedev/effect-contract/makeLiveServer.ts";
 import { assertPostgresMigrations } from "@shivaedev/effect-sql/assertPostgresMigrations.ts";
@@ -27,11 +27,7 @@ export function databaseLayer<R>(options: AppDatabaseOptions<R>, changesService:
 			});
 		}),
 	);
-	const prepared = Layer.effectDiscard(
-		options.migrations.mode === "check"
-			? assertPostgresMigrations(options.migrations)
-			: migratePostgres({ ...options.migrations, lockTimeout: options.migrations.lockTimeout ?? "5 seconds" }),
-	).pipe(Layer.provideMerge(pool));
+	const prepared = Layer.effectDiscard(prepareMigrations(options.migrations)).pipe(Layer.provideMerge(pool));
 	const live = Layer.effect(changesService, makeLiveServer).pipe(Layer.provideMerge(Reactivity.layer));
 	const base = Layer.merge(prepared, live);
 	const changes = options.config?.changes;
@@ -46,3 +42,23 @@ export function databaseLayer<R>(options: AppDatabaseOptions<R>, changesService:
 		}),
 	).pipe(Layer.provideMerge(base));
 }
+
+function prepareMigrations<R>(migrations: AppDatabaseOptions<R>["migrations"]) {
+	switch (migrations.mode) {
+		case "check":
+			return assertPostgresMigrations(migrations);
+		case "wait":
+			return waitForMigrations(migrations);
+		default:
+			return migratePostgres({ ...migrations, lockTimeout: migrations.lockTimeout ?? "5 seconds" });
+	}
+}
+
+function waitForMigrations<R>(migrations: AppDatabaseOptions<R>["migrations"]) {
+	return assertPostgresMigrations(migrations).pipe(
+		Effect.retry({
+			schedule: Schedule.max([Schedule.spaced(migrations.pollInterval ?? "1 second"), Schedule.during(migrations.waitTimeout ?? "5 minutes")]),
+			while: (error) => error._tag === "MigrationError" && error.kind === "BadState",
+		}),
+	);
+}

package/src/server/hostOptions.ts

@@ -1,7 +1,7 @@
 import type { Layer } from "effect";
 import type { HttpRouter, HttpStaticServer } from "effect/http";
 import type { Rpc, RpcGroup } from "effect/rpc";
-import type { SessionPolicy, SessionShape } from "#rpc-server/session.ts";
+import type { SessionPolicy, SessionShape } from "#server/rpc-server/session.ts";
 import type { AppDatabaseOptions } from "./appHost.ts";
 
 export type HostOptions<TRpcs extends Rpc.Any, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> = {

package/src/server/otlpHttpClient.ts

@@ -1,6 +1,6 @@
 import { Effect, Layer } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientError, type HttpClientRequest } from "effect/http";
-import { redactOtlpText } from "#safeOtlpSerialization.ts";
+import { redactOtlpText } from "#server/safeOtlpSerialization.ts";
 
 function timeoutError(request: HttpClientRequest.HttpClientRequest) {
 	return new HttpClientError.HttpClientError({

package/src/server/otlpTracing.ts

@@ -1,7 +1,7 @@
 import { Config, Effect, Layer, Schema } from "effect";
 import { OtlpSerialization, OtlpTracer } from "effect/observability";
-import { otlpHttpClient } from "#otlpHttpClient.ts";
-import { safeOtlpSerialization } from "#safeOtlpSerialization.ts";
+import { otlpHttpClient } from "#server/otlpHttpClient.ts";
+import { safeOtlpSerialization } from "#server/safeOtlpSerialization.ts";
 
 export const otlpTracing: Layer.Layer<never, Config.ConfigError> = Layer.unwrap(
 	Effect.gen(function* () {

package/src/server/redactOtlpUrl.ts

@@ -1,4 +1,4 @@
-import { REDACTED } from "#rpc-server/sensitive.ts";
+import { REDACTED } from "#server/rpc-server/sensitive.ts";
 
 function query(value: string): string {
 	return value

package/src/server/rpc-server/adapters/betterAuthSessions.ts

@@ -1,20 +1,39 @@
 import { Effect, Option } from "effect";
 import type { Headers } from "effect/http";
 import { AuthUnavailable } from "#errors/taxonomy.ts";
-import { redact } from "#rpc-server/redact.ts";
-import type { SessionProvider, SessionShape } from "#rpc-server/session.ts";
+import type { ProviderAccountValue } from "#rpc/identity.ts";
+import { redact } from "#server/rpc-server/redact.ts";
+import type { SessionProvider, SessionShape } from "#server/rpc-server/session.ts";
 export type GetSession<TSession extends SessionShape> = (headers: globalThis.Headers) => Promise<TSession | null>;
+export type GetProviderAccounts = (headers: globalThis.Headers) => Promise<readonly ProviderAccountValue[]>;
+export type SessionWithProviderAccounts<TSession extends SessionShape> = TSession & {
+	readonly user: TSession["user"] & { readonly providerAccounts: readonly ProviderAccountValue[] };
+};
 function unavailable(cause: unknown) {
 	return Effect.andThen(
 		Effect.logError("Authentication provider failed", redact(cause)),
 		Effect.fail(new AuthUnavailable({ message: "Authentication is temporarily unavailable" })),
 	);
 }
-export function betterAuthSessions<TSession extends SessionShape>(getSession: GetSession<TSession>): SessionProvider<TSession> {
+export function betterAuthSessions<TSession extends SessionShape>(getSession: GetSession<TSession>): SessionProvider<TSession>;
+export function betterAuthSessions<TSession extends SessionShape>(
+	getSession: GetSession<TSession>,
+	getProviderAccounts: GetProviderAccounts,
+): SessionProvider<SessionWithProviderAccounts<TSession>>;
+export function betterAuthSessions<TSession extends SessionShape>(getSession: GetSession<TSession>, getProviderAccounts?: GetProviderAccounts) {
 	const betterAuthSession = Effect.fn("PlatformRpc.betterAuthSession")(function* (headers: Headers.Headers) {
-		const session = yield* Effect.tryPromise(() => getSession(new globalThis.Headers(headers))).pipe(
-			Effect.catch((error) => unavailable(error.cause)),
-		);
+		const session = yield* Effect.tryPromise(async () => {
+			const transport = new globalThis.Headers(headers);
+			const resolved = await getSession(transport);
+			if (resolved === null || getProviderAccounts === undefined) {
+				return resolved;
+			}
+			const accounts = await getProviderAccounts(transport);
+			return {
+				...resolved,
+				user: { ...resolved.user, providerAccounts: accounts.map(({ accountId, providerId }) => ({ accountId, providerId })) },
+			};
+		}).pipe(Effect.catch((error) => unavailable(error.cause)));
 		return Option.fromNullishOr(session);
 	});
 	return { get: betterAuthSession };

package/src/server/rpc-server/session.ts

@@ -60,20 +60,30 @@ export function maybeAuthenticatedLayer<TSession extends SessionShape>(policy: S
 export interface UserSessionShape extends SessionShape {
 	readonly user: SessionUserValue;
 }
-export function authenticatedUserLayer<TSession extends UserSessionShape>(policy: SessionPolicy<TSession>): Layer.Layer<AuthenticatedUser> {
-	return Layer.succeed(AuthenticatedUser, (effect, { headers, rpc }) =>
+export function withSessionUser<TSession extends UserSessionShape>(policy: SessionPolicy<TSession>, headers: Headers.Headers, operation: string) {
+	return <A, E, R>(effect: Effect.Effect<A, E, R>) =>
 		Effect.gen(function* () {
-			const session = yield* resolveSession(policy, headers, rpc._tag);
+			const session = yield* resolveSession(policy, headers, operation);
 			if (Option.isNone(session)) {
 				return yield* new Unauthorized({ message: "Authentication required" });
 			}
-			const { name, email } = session.value.user;
+			const { name, email, role, providerAccounts } = session.value.user;
 			const id = yield* identified(session.value.user.id);
 			return yield* effect.pipe(
 				Effect.provideService(Identity, { id }),
-				Effect.provideService(SessionUser, { email, id, name }),
+				Effect.provideService(SessionUser, {
+					email,
+					id,
+					name,
+					...(role === undefined ? {} : { role }),
+					...(providerAccounts === undefined
+						? {}
+						: { providerAccounts: providerAccounts.map(({ accountId, providerId }) => ({ accountId, providerId })) }),
+				}),
 				Effect.annotateLogs({ userId: id }),
 			);
-		}),
-	);
+		});
+}
+export function authenticatedUserLayer<TSession extends UserSessionShape>(policy: SessionPolicy<TSession>): Layer.Layer<AuthenticatedUser> {
+	return Layer.succeed(AuthenticatedUser, (effect, { headers, rpc }) => effect.pipe(withSessionUser(policy, headers, rpc._tag)));
 }

package/src/server/safeOtlpSerialization.ts

@@ -1,8 +1,8 @@
 import { Effect, Layer } from "effect";
 import type { OtlpResource } from "effect/observability";
 import { OtlpSerialization } from "effect/observability";
-import { redactOtlpUrl } from "#redactOtlpUrl.ts";
-import { isSensitiveKey, REDACTED, redactText } from "#rpc-server/sensitive.ts";
+import { redactOtlpUrl } from "#server/redactOtlpUrl.ts";
+import { isSensitiveKey, REDACTED, redactText } from "#server/rpc-server/sensitive.ts";
 
 function sensitive(key: string) {
 	return isSensitiveKey(key) || ["db.user", "db.user.name", "db.connection_string"].includes(key.toLowerCase());

package/src/server/testing/makePlatformIt.ts

@@ -2,10 +2,10 @@ import type { TestContext } from "@effect/vitest";
 import { Effect, type Layer } from "effect";
 import type { AnyDatabase } from "@shivaedev/effect-prisma/databaseTypes.ts";
 import { withTestTransaction } from "@shivaedev/effect-prisma/testing/transaction.ts";
-import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc/adapter.ts";
-import type { EffectCallerFactory } from "@shivaedev/effect-trpc/testing/caller.ts";
-import type { CallerOptions, CallerResult } from "@shivaedev/effect-trpc/testing/types.ts";
-import { makeTrpcHarnessIt } from "@shivaedev/effect-trpc/testing/vitest.ts";
+import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc/server/adapter.ts";
+import type { EffectCallerFactory } from "@shivaedev/effect-trpc/server/testing/caller.ts";
+import type { CallerOptions, CallerResult } from "@shivaedev/effect-trpc/server/testing/types.ts";
+import { makeTrpcHarnessIt } from "@shivaedev/effect-trpc/server/testing/vitest.ts";
 import type { Bivariant } from "@shivaedev/types/bivariant.ts";
 import type { MakePlatformItOptions, PlatformHarness, PlatformIt } from "./types.ts";
 

package/src/server/testing/types.ts

@@ -2,9 +2,9 @@ import type { TestContext, Vitest } from "@effect/vitest";
 import type { Effect, Layer } from "effect";
 import type { AnyDatabase } from "@shivaedev/effect-prisma/databaseTypes.ts";
 import type { DatabaseService } from "@shivaedev/effect-prisma/testing/types.ts";
-import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc/adapter.ts";
-import type { EffectCallerFactory } from "@shivaedev/effect-trpc/testing/caller.ts";
-import type { CallerOptions, CallerResult, TrpcHarnessTest, TrpcHarnessTester } from "@shivaedev/effect-trpc/testing/types.ts";
+import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc/server/adapter.ts";
+import type { EffectCallerFactory } from "@shivaedev/effect-trpc/server/testing/caller.ts";
+import type { CallerOptions, CallerResult, TrpcHarnessTest, TrpcHarnessTester } from "@shivaedev/effect-trpc/server/testing/types.ts";
 export type PlatformHarness<TDatabase extends AnyDatabase, TOptions, TCaller, TExtension> = Readonly<{
 	db: DatabaseService<TDatabase>;
 	trpc: EffectCallerFactory<TOptions, TCaller>;

package/src/server/tracedGroup.ts

@@ -0,0 +1,14 @@
+import type { Rpc, RpcGroup } from "effect/rpc";
+import { RequestTracing } from "#rpc/middleware.ts";
+
+export function tracedGroup<R extends Rpc.Any>(group: RpcGroup.RpcGroup<R>) {
+	const traced = group.middleware(RequestTracing);
+	for (const rpc of traced.requests.values()) {
+		const middlewares = new Set(rpc.middlewares);
+		middlewares.delete(RequestTracing);
+		middlewares.add(RequestTracing);
+		// Native middleware() clones each RPC but cannot move an existing middleware to the outermost position.
+		Object.assign(rpc, { middlewares });
+	}
+	return traced;
+}