@shivaedev/platform 0.6.0 → 0.7.0

package/src/server/appHostHttp.ts

@@ -0,0 +1,101 @@
+import { createServer } from "node:http";
+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 { 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, AppLocalHostOptions } from "./appHost.ts";
+import { boundedRpcRequest } from "./boundedRpcRequest.ts";
+import type { databaseLayer } from "./databaseLayer.ts";
+import type { HostOptions, HostPolicy } from "./hostOptions.ts";
+export function appHostHttp<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TSession extends SessionShape,
+>(
+	options: HostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> & HostPolicy<TSession>,
+) {
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const maxBodySize = options.config?.maxBodySize ?? (yield* Config.Int("MAX_BODY_SIZE").pipe(Config.withDefault(1024 * 1024)));
+			const bodySize = yield* Schema.decodeUnknownEffect(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))(maxBodySize).pipe(
+				Effect.mapError((cause) => new Config.ConfigError(cause)),
+			);
+			const trustedProxy =
+				options.policy === "loopback"
+					? undefined
+					: (options.config?.trustedProxy ?? Option.getOrUndefined(yield* Config.String("TRUSTED_PROXY").pipe(Config.option)));
+			if (trustedProxy !== undefined) {
+				yield* Schema.decodeUnknownEffect(TrustedProxy)(trustedProxy).pipe(Effect.mapError((cause) => new Config.ConfigError(cause)));
+			}
+			const middleware =
+				options.policy === "loopback"
+					? requestTracingLayer()
+					: Layer.mergeAll(authenticatedLayer(options.sessions), maybeAuthenticatedLayer(options.sessions), requestTracingLayer());
+			const routes = HttpRouter.use((router) =>
+				Effect.gen(function* () {
+					const wire = yield* RpcSerialization.RpcSerialization;
+					const handler = yield* RpcServer.toHttpEffect(options.group);
+					const guarded = localRpcGuard(handler, trustedProxy);
+					yield* router.add("POST", options.rpcPath ?? "/rpc", (request) =>
+						guarded.pipe(
+							Effect.provideService(HttpIncomingMessage.MaxBodySize, ByteSize.bytes(bodySize)),
+							Effect.provideService(HttpServerRequest.HttpServerRequest, boundedRpcRequest(request)),
+							Effect.provideService(RpcSerialization.RpcSerialization, wire),
+						),
+					);
+				}),
+			).pipe(Layer.provide(Layer.merge(options.handlers, middleware)), Layer.provide(RpcSerialization.layerNdjson));
+			const assets =
+				options.assets === undefined
+					? Layer.empty
+					: HttpStaticServer.layer(typeof options.assets === "string" ? { root: options.assets } : options.assets);
+			const application = options.services;
+			const server = Layer.unwrap(
+				Effect.gen(function* () {
+					const port = options.config?.port ?? (yield* Config.Int("PORT").pipe(Config.withDefault(3000)));
+					const host = options.config?.host ?? (yield* Config.String("HOST").pipe(Config.withDefault("127.0.0.1")));
+					return NodeHttpServer.layer(createServer, {
+						host,
+						port,
+						...(options.config?.disablePreemptiveShutdown === undefined
+							? {}
+							: { disablePreemptiveShutdown: options.config.disablePreemptiveShutdown }),
+					});
+				}),
+			);
+			return HttpRouter.serve(Layer.mergeAll(routes, assets, options.routes ?? Layer.empty), { disableLogger: true }).pipe(
+				Layer.provideMerge(application),
+				Layer.provideMerge(server),
+				Layer.provide(NodeServices.layer),
+			);
+		}),
+	);
+}
+
+export function migratedHost<
+	TRpcs extends Rpc.Any,
+	THandlers,
+	THandlerError,
+	THandlerRequirements,
+	TServices,
+	TServiceError,
+	TServiceRequirements,
+	TMigrations,
+	TSession extends SessionShape,
+>(
+	options:
+		| AppHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations, TSession>
+		| AppLocalHostOptions<TRpcs, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements, TMigrations>,
+	database: ReturnType<typeof databaseLayer<TMigrations>>,
+) {
+	return appHostHttp({ ...options, services: options.services.pipe(Layer.provideMerge(database)) });
+}

package/src/{better-auth → server/better-auth}/adapter.ts

@@ -4,38 +4,37 @@ import { Effect } from "effect";
 import type { AnyDatabase } from "@shivaedev/effect-prisma/databaseTypes.ts";
 import type { PlatformRuntime } from "#runtime/types.ts";
 import { type DynamicRelation, refineRelation } from "./relation.ts";
-import { makeRowAdapter, type RelationQuery } from "./row-adapter.ts";
-
+import { makeRowAdapter, type RelationQuery } from "./rowAdapter.ts";
 export interface EffectPrismaAdapterOptions {
 	readonly debugLogs?: boolean;
 	readonly modelName?: (model: string) => string;
 	readonly usePlural?: boolean;
 }
-
 interface DynamicDatabase {
 	readonly transaction: <A, E, R>(program: Effect.Effect<A, E, R>) => Effect.Effect<A, unknown, unknown>;
 }
-
-const isFunction = (value: unknown, key: string): boolean =>
-	((typeof value === "object" && value !== null) || typeof value === "function") && typeof Reflect.get(value, key) === "function";
-
-const isDynamicDatabase = (value: unknown): value is DynamicDatabase => isFunction(value, "transaction");
-
-const isDynamicRelation = (value: unknown): value is DynamicRelation<unknown> => isFunction(value, "where") && isFunction(value, "select");
-
-const modelRelation = (database: DynamicDatabase, model: string): DynamicRelation<unknown> => {
+function isFunction(value: unknown, key: string): boolean {
+	return ((typeof value === "object" && value !== null) || typeof value === "function") && typeof Reflect.get(value, key) === "function";
+}
+function isDynamicDatabase(value: unknown): value is DynamicDatabase {
+	return isFunction(value, "transaction");
+}
+function isDynamicRelation(value: unknown): value is DynamicRelation<unknown> {
+	return isFunction(value, "where") && isFunction(value, "select");
+}
+function modelRelation(database: DynamicDatabase, model: string): DynamicRelation<unknown> {
 	const relation: unknown = Reflect.get(database, model);
 	if (!isDynamicRelation(relation)) {
 		throw new TypeError(`Unknown database model: ${model}`);
 	}
 	return relation;
-};
-
-const defaultModelName = (model: string): string => (model.length === 0 ? model : `${model[0]?.toUpperCase()}${model.slice(1)}`);
-
-export function effectPrismaAdapter<Database extends AnyDatabase, Services, BuildError>(
-	databaseTag: Database,
-	runtime: PlatformRuntime<Services, BuildError>,
+}
+function defaultModelName(model: string): string {
+	return model.length === 0 ? model : `${model[0]?.toUpperCase()}${model.slice(1)}`;
+}
+export function effectPrismaAdapter<TDatabase extends AnyDatabase, TServices, TBuildError>(
+	databaseTag: TDatabase,
+	runtime: PlatformRuntime<TServices, TBuildError>,
 	adapterOptions?: EffectPrismaAdapterOptions,
 ): DBAdapterInstance;
 export function effectPrismaAdapter(
@@ -48,21 +47,19 @@ export function effectPrismaAdapter(
 		const databaseEffect = Effect.flatMap(databaseTag, (database) =>
 			isDynamicDatabase(database) ? Effect.succeed(database) : Effect.die(new TypeError("The database service has no transaction")),
 		);
-
-		const run = <Value>(operation: (database: DynamicDatabase) => Effect.Effect<Value, unknown, unknown>): Promise<Value> =>
-			runtime.runPromise(Effect.flatMap(databaseEffect, operation));
-
+		function run<TValue>(operation: (database: DynamicDatabase) => Effect.Effect<TValue, unknown, unknown>): Promise<TValue> {
+			return runtime.runPromise(Effect.flatMap(databaseEffect, operation));
+		}
 		const query: RelationQuery = (model, refinement, use) =>
 			run((database) => use(refineRelation(modelRelation(database, mapModelName(model)), refinement)));
-
-		const inTransaction = <Value>(callback: () => Promise<Value>): Effect.Effect<Value, unknown, unknown> =>
-			Effect.flatMap(Effect.context<unknown>(), (services) =>
+		function inTransaction<TValue>(callback: () => Promise<TValue>): Effect.Effect<TValue, unknown, unknown> {
+			return Effect.flatMap(Effect.context<unknown>(), (services) =>
 				Effect.tryPromise({
 					catch: (error) => error,
 					try: () => runtime.runWithServices(services, callback),
 				}),
 			);
-
+		}
 		let factory: ReturnType<typeof createAdapterFactory>;
 		factory = createAdapterFactory({
 			adapter: makeRowAdapter(query, adapterOptions.usePlural ?? false),
@@ -73,13 +70,12 @@ export function effectPrismaAdapter(
 				supportsArrays: true,
 				supportsBooleans: true,
 				supportsDates: true,
-				supportsJSON: true,
+				"supportsJSON": true,
 				supportsNumericIds: true,
-				supportsUUIDs: true,
+				"supportsUUIDs": true,
 				transaction: (callback) => run((database) => database.transaction(inTransaction(() => callback(factory(authOptions))))),
 			},
 		});
-
 		return factory(authOptions);
 	};
 }

package/src/{better-auth → server/better-auth}/relation.ts

@@ -1,24 +1,22 @@
 import { all } from "@prisma-next/sql-orm-client";
 import type { Effect, Option } from "effect";
 import { type CleanedWhere, type DynamicField, type Expression, whereExpression } from "./where.ts";
-
-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 interface DynamicRelation<TRequirements> extends Effect.Effect<readonly Record<string, unknown>[], unknown, TRequirements> {
+	count: () => Effect.Effect<number, unknown, TRequirements>;
+	create: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, unknown, TRequirements>;
+	delete: () => Effect.Effect<Record<string, unknown> | null, unknown, TRequirements>;
+	deleteAll: () => Effect.Effect<readonly Record<string, unknown>[], unknown, TRequirements>;
+	first: () => Effect.Effect<Option.Option<Record<string, unknown>>, unknown, TRequirements>;
+	orderBy: (ordering: (fields: Record<string, DynamicField>) => unknown) => DynamicRelation<TRequirements>;
+	select: (...fields: readonly string[]) => DynamicRelation<TRequirements>;
+	skip: (count: number) => DynamicRelation<TRequirements>;
+	take: (count: number) => DynamicRelation<TRequirements>;
+	update: (data: Record<string, unknown>) => Effect.Effect<Record<string, unknown> | null, unknown, TRequirements>;
+	updateAll: (data: Record<string, unknown>) => Effect.Effect<readonly Record<string, unknown>[], unknown, TRequirements>;
+	where: (predicate: (fields: Record<string, DynamicField>) => Expression) => DynamicRelation<TRequirements>;
 }
-
-export const refineRelation = <Requirements>(
-	relation: DynamicRelation<Requirements>,
+export function refineRelation<TRequirements>(
+	relation: DynamicRelation<TRequirements>,
 	options: {
 		readonly where?: readonly CleanedWhere[] | undefined;
 		readonly select?: readonly string[] | undefined;
@@ -31,7 +29,7 @@ export const refineRelation = <Requirements>(
 			  }
 			| undefined;
 	},
-): DynamicRelation<Requirements> => {
+): DynamicRelation<TRequirements> {
 	let refined = relation;
 	if (options.where !== undefined) {
 		refined = refined.where((fields) => {
@@ -58,4 +56,4 @@ export const refineRelation = <Requirements>(
 		refined = refined.select(...options.select);
 	}
 	return refined;
-};
+}

package/src/{better-auth/row-adapter.ts → server/better-auth/rowAdapter.ts}

@@ -9,43 +9,40 @@ type FindManyInput = Parameters<CustomAdapter["findMany"]>[0];
 type Row = Record<string, unknown>;
 type RowMethod = "create" | "findMany" | "findOne" | "update";
 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 update: (input: { readonly model: string; readonly update: Row; readonly where: CleanedWhere[] }) => Promise<Row | null>;
 }
-
-export type RelationQuery = <Value>(
+export type RelationQuery = <TValue>(
 	model: string,
 	refinement: Refinement,
-	use: (relation: DynamicRelation<unknown>) => Effect.Effect<Value, unknown, unknown>,
-) => Promise<Value>;
-
+	use: (relation: DynamicRelation<unknown>) => Effect.Effect<TValue, unknown, unknown>,
+) => Promise<TValue>;
 // Better Auth lets each call declare its row type; the rows are whatever its generated schema stored.
 function rowTyped(adapter: Omit<CustomAdapter, RowMethod> & RowMethods): CustomAdapter;
 function rowTyped(adapter: unknown): unknown {
 	return adapter;
 }
-
-const rejectJoin = (join: unknown): void => {
+function rejectJoin(join: unknown): void {
 	if (join !== undefined) {
 		throw new TypeError("The Effect Prisma Better Auth adapter does not support experimental native joins");
 	}
-};
-
-const namesId = (condition: CleanedWhere): boolean => condition.connector !== "OR" && condition.field === "id" && condition.operator === "eq";
-
-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);
-
+}
+function namesId(condition: CleanedWhere): boolean {
+	return condition.connector !== "OR" && condition.field === "id" && condition.operator === "eq";
+}
+export function makeRowAdapter(query: RelationQuery, usePlural: boolean): AdapterFactoryCustomizeAdapterCreator {
+	return ({ debugLog, getFieldAttributes }) => {
+		function isUnique(model: string, condition: CleanedWhere): boolean {
+			return (
+				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 }) => {
@@ -78,3 +75,4 @@ export const makeRowAdapter =
 			updateMany: ({ model, update, where }) => query(model, { where }, (relation) => Effect.map(relation.updateAll(update), (rows) => rows.length)),
 		});
 	};
+}

package/src/{better-auth → server/better-auth}/where.ts

@@ -1,9 +1,7 @@
 import { all, and, not, or } from "@prisma-next/sql-orm-client";
 import type { Where } from "better-auth";
-
 export type CleanedWhere = Required<Where>;
 export type Expression = Parameters<typeof and>[number];
-
 export interface DynamicField {
 	asc: () => unknown;
 	desc: () => unknown;
@@ -20,53 +18,49 @@ export interface DynamicField {
 	neq: (value: unknown) => Expression;
 	notIn: (value: readonly unknown[]) => Expression;
 }
-
-const escapeLike = (value: string): string => value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
-
-const nonNullValues = (value: unknown): readonly unknown[] => (Array.isArray(value) ? value : [value]).filter((item) => item !== null);
-
-const insensitiveStrings = (field: DynamicField, where: CleanedWhere, values: readonly unknown[]) => {
+function escapeLike(value: string): string {
+	return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+function nonNullValues(value: unknown): readonly unknown[] {
+	return (Array.isArray(value) ? value : [value]).filter((item) => item !== null);
+}
+function 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;
 	}
 	return values.map((item) => ilike(escapeLike(String(item))));
-};
-
-const membership = (field: DynamicField, where: CleanedWhere): Expression => {
+}
+function membership(field: DynamicField, where: CleanedWhere): Expression {
 	const values = nonNullValues(where.value);
 	if (values.length === 0) {
 		return and(field.isNull(), field.isNotNull());
 	}
 	const matches = insensitiveStrings(field, where, values);
 	return matches === undefined ? field.in(values) : or(...matches);
-};
-
-const exclusion = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+}
+function exclusion(field: DynamicField, where: CleanedWhere): Expression | undefined {
 	const values = nonNullValues(where.value);
 	if (values.length === 0) {
 		return undefined;
 	}
 	const matches = insensitiveStrings(field, where, values);
 	return matches === undefined ? field.notIn(values) : and(...matches.map((match) => not(match)));
-};
-
-const likePattern = (operator: CleanedWhere["operator"], escaped: string): string => {
+}
+function likePattern(operator: CleanedWhere["operator"], escaped: string): string {
 	if (operator === "contains") {
 		return `%${escaped}%`;
 	}
 	return operator === "starts_with" ? `${escaped}%` : `%${escaped}`;
-};
-
-const pattern = (field: DynamicField, where: CleanedWhere): Expression => {
+}
+function pattern(field: DynamicField, where: CleanedWhere): Expression {
 	if (typeof where.value !== "string") {
 		throw new TypeError(`${where.operator} requires a string value`);
 	}
 	const text = likePattern(where.operator, escapeLike(where.value));
 	return where.mode === "insensitive" && field.ilike !== undefined ? field.ilike(text) : field.like(text);
-};
-
-const insensitiveEquality = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+}
+function insensitiveEquality(field: DynamicField, where: CleanedWhere): Expression | undefined {
 	const value = where.value;
 	const operator = where.operator ?? "eq";
 	if (where.mode !== "insensitive" || typeof value !== "string" || field.ilike === undefined) {
@@ -79,9 +73,8 @@ const insensitiveEquality = (field: DynamicField, where: CleanedWhere): Expressi
 		return not(field.ilike(escapeLike(value)));
 	}
 	return undefined;
-};
-
-const comparison = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+}
+function comparison(field: DynamicField, where: CleanedWhere): Expression | undefined {
 	const value = where.value;
 	switch (where.operator ?? "eq") {
 		case "eq":
@@ -105,12 +98,10 @@ const comparison = (field: DynamicField, where: CleanedWhere): Expression | unde
 		case "ends_with":
 			return pattern(field, where);
 	}
-};
-
-export const whereExpression = (fields: Record<string, DynamicField>, where: readonly CleanedWhere[]): Expression | undefined => {
+}
+export function whereExpression(fields: Record<string, DynamicField>, where: readonly CleanedWhere[]): Expression | undefined {
 	const conjunctions: Expression[] = [];
 	const disjunctions: Expression[] = [];
-
 	for (const condition of where) {
 		const field = fields[condition.field];
 		if (field === undefined) {
@@ -122,7 +113,6 @@ export const whereExpression = (fields: Record<string, DynamicField>, where: rea
 		}
 		(condition.connector === "OR" ? disjunctions : conjunctions).push(expression);
 	}
-
 	if (disjunctions.length > 0) {
 		conjunctions.push(or(...disjunctions));
 	}
@@ -130,4 +120,4 @@ export const whereExpression = (fields: Record<string, DynamicField>, where: rea
 		return all();
 	}
 	return conjunctions.length === 1 ? conjunctions[0] : and(...conjunctions);
-};
+}

package/src/server/boundedRpcRequest.ts

@@ -0,0 +1,47 @@
+import { NodeHttpServerRequest, NodeStream } from "@effect/platform-node";
+import { Effect, Stream } from "effect";
+import { HttpIncomingMessage, HttpServerError, type HttpServerRequest } from "effect/http";
+
+export function boundedRpcRequest(request: HttpServerRequest.HttpServerRequest): HttpServerRequest.HttpServerRequest {
+	const incoming = NodeHttpServerRequest.toIncomingMessage(request);
+	function error(cause: unknown) {
+		return new HttpServerError.HttpServerError({ reason: new HttpServerError.RequestParseError({ cause, request }) });
+	}
+	const text = Effect.gen(function* () {
+		const limit = yield* HttpIncomingMessage.MaxBodySize;
+		const chunks: Uint8Array[] = [];
+		let size = 0n;
+		yield* NodeStream.fromReadable<Uint8Array, HttpServerError.HttpServerError>({
+			closeOnDone: false,
+			evaluate: () => incoming,
+			onError: error,
+		}).pipe(
+			Stream.runForEach((chunk) => {
+				size += BigInt(chunk.byteLength);
+				if (limit !== undefined && size > limit) {
+					return Effect.fail(error(new Error("RPC body exceeds MAX_BODY_SIZE")));
+				}
+				chunks.push(chunk);
+				return Effect.void;
+			}),
+		);
+		return Buffer.concat(chunks).toString("utf8");
+	}).pipe(
+		Effect.onError(() => Effect.sync(() => incoming.resume())),
+		Effect.cached,
+		Effect.runSync,
+	);
+	const arrayBuffer = Effect.map(text, (body) => new TextEncoder().encode(body).buffer);
+	// The native text reader destroys the HTTP socket on overflow, preventing a 4xx response.
+	return new Proxy(request, {
+		get: (target, key, receiver) => {
+			if (key === "text") {
+				return text;
+			}
+			if (key === "arrayBuffer") {
+				return arrayBuffer;
+			}
+			return Reflect.get(target, key, receiver);
+		},
+	});
+}

package/src/server/databaseLayer.ts

@@ -0,0 +1,36 @@
+import * as PgClient from "@effect/sql-pg/PgClient";
+import { Config, Effect, Layer } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { makeLiveServer } from "@shivaedev/effect-contract/makeLiveServer.ts";
+import { migratePostgres } from "@shivaedev/effect-sql/migrations.ts";
+import { postgresChanges } from "@shivaedev/effect-sql/postgresChanges.ts";
+import type { AppChanges, AppDatabaseOptions } from "./appHost.ts";
+
+export function databaseLayer<R>(options: AppDatabaseOptions<R>, changesService: typeof AppChanges) {
+	const pool = Layer.unwrap(
+		Effect.gen(function* () {
+			const url = options.config?.databaseUrl ?? (yield* Config.Redacted("DATABASE_URL"));
+			return PgClient.layer({
+				url,
+				...(options.config?.maxConnections === undefined ? {} : { maxConnections: options.config.maxConnections }),
+				...(options.config?.applicationName === undefined ? {} : { applicationName: options.config.applicationName }),
+			});
+		}),
+	);
+	const migrated = Layer.effectDiscard(migratePostgres({ ...options.migrations, lockTimeout: options.migrations.lockTimeout ?? "5 seconds" })).pipe(
+		Layer.provideMerge(pool),
+	);
+	const live = Layer.effect(changesService, makeLiveServer).pipe(Layer.provideMerge(Reactivity.layer));
+	const base = Layer.merge(migrated, live);
+	const changes = options.config?.changes;
+	if (changes === undefined) {
+		return base;
+	}
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const client = yield* PgClient.PgClient;
+			const hints = yield* changesService;
+			return postgresChanges({ ...changes, client, resync: hints.resync });
+		}),
+	).pipe(Layer.provideMerge(base));
+}

package/src/server/hostOptions.ts

@@ -0,0 +1,25 @@
+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 { AppDatabaseOptions } from "./appHost.ts";
+
+export interface HostOptions<TRpcs extends Rpc.Any, THandlers, THandlerError, THandlerRequirements, TServices, TServiceError, TServiceRequirements> {
+	readonly assets?: string | Parameters<typeof HttpStaticServer.layer>[0];
+	readonly config?: AppDatabaseOptions["config"] & {
+		readonly port?: number;
+		readonly host?: string;
+		readonly trustedProxy?: string;
+		readonly maxBodySize?: number;
+		readonly disablePreemptiveShutdown?: boolean;
+	};
+	readonly group: RpcGroup.RpcGroup<TRpcs>;
+	readonly handlers: Layer.Layer<THandlers, THandlerError, THandlerRequirements>;
+	readonly routes?: Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Error", unknown>>;
+	readonly rpcPath?: HttpRouter.PathInput;
+	readonly services: Layer.Layer<TServices, TServiceError, TServiceRequirements>;
+}
+
+export type HostPolicy<TSession extends SessionShape> =
+	| { readonly policy?: undefined; readonly sessions: SessionPolicy<TSession> }
+	| { readonly policy: "loopback"; readonly sessions?: never };

package/src/{node-http/subscription-signal.ts → server/node-http/subscriptionSignal.ts}

@@ -1,28 +1,25 @@
 import type { IncomingMessage } from "node:http";
-
 export interface NodeSubscriptionSignalOptions {
 	readonly nodeRequest?: IncomingMessage | undefined;
 	readonly request?: Request | undefined;
 	readonly signals?: Iterable<AbortSignal | undefined>;
 }
-
 export interface NodeSubscriptionSignal {
 	readonly dispose: () => void;
 	readonly signal: AbortSignal;
 }
-
-const property = (value: unknown, key: string): unknown => (typeof value === "object" && value !== null ? Reflect.get(value, key) : undefined);
-
-const isIncomingMessage = (value: unknown): value is IncomingMessage =>
-	typeof property(value, "socket") === "object" && typeof property(value, "once") === "function";
-
-const nodeRequestFrom = (request: Request | undefined): IncomingMessage | undefined => {
+function property(value: unknown, key: string): unknown {
+	return typeof value === "object" && value !== null ? Reflect.get(value, key) : undefined;
+}
+function isIncomingMessage(value: unknown): value is IncomingMessage {
+	return typeof property(value, "socket") === "object" && typeof property(value, "once") === "function";
+}
+function nodeRequestFrom(request: Request | undefined): IncomingMessage | undefined {
 	const req = property(property(property(request, "runtime"), "node"), "req");
 	return isIncomingMessage(req) ? req : undefined;
-};
-
+}
 // 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 => {
+export function nodeSubscriptionSignal(options: NodeSubscriptionSignalOptions): NodeSubscriptionSignal {
 	const controller = new AbortController();
 	const signals: AbortSignal[] = [controller.signal];
 	if (options.request !== undefined) {
@@ -33,25 +30,25 @@ export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions):
 			signals.push(signal);
 		}
 	}
-
 	const nodeRequest = options.nodeRequest ?? nodeRequestFrom(options.request);
 	if (nodeRequest === undefined) {
-		return { dispose: () => {}, signal: AbortSignal.any(signals) };
+		return { dispose: (): void => undefined, signal: AbortSignal.any(signals) };
 	}
-
-	const socket = nodeRequest.socket;
-	const onRequestClose = () => {
-		if (!nodeRequest.complete) {
+	const request = nodeRequest;
+	const socket = request.socket;
+	function onRequestClose() {
+		if (!request.complete) {
 			controller.abort();
 		}
-	};
-	const onSocketClose = () => controller.abort();
+	}
+	function onSocketClose() {
+		return controller.abort();
+	}
 	nodeRequest.once("close", onRequestClose);
 	socket.once("close", onSocketClose);
 	if (nodeRequest.destroyed || socket.destroyed) {
 		controller.abort();
 	}
-
 	let disposed = false;
 	return {
 		dispose: () => {
@@ -64,4 +61,4 @@ export const nodeSubscriptionSignal = (options: NodeSubscriptionSignalOptions):
 		},
 		signal: AbortSignal.any(signals),
 	};
-};
+}