@shivaedev/platform 0.5.2 → 0.6.1

package/src/rpc-server.ts

@@ -1,15 +0,0 @@
-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,
-	resolveSession,
-	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";

package/src/rpc.ts

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

package/src/runtime/types.ts

@@ -1,24 +0,0 @@
-import type { Context, Effect, Exit } from "effect";
-
-export interface PlatformRuntimeOptions {
-	readonly developmentCacheKey?: string | symbol;
-}
-
-export interface PlatformRuntime<Services, BuildError> {
-	readonly contextEffect: Effect.Effect<Context.Context<Services>, BuildError>;
-	readonly currentServices: () => Context.Context<never> | undefined;
-	readonly dispose: () => Promise<void>;
-	readonly runPromise: <A, E, Requirements extends Services>(
-		effect: Effect.Effect<A, E, Requirements>,
-		options?: { readonly signal?: AbortSignal },
-	) => Promise<A>;
-	readonly runPromiseExit: <A, E, Requirements extends Services>(
-		effect: Effect.Effect<A, E, Requirements>,
-		options?: { readonly signal?: AbortSignal },
-	) => Promise<Exit.Exit<A, E | BuildError>>;
-	readonly runWithServices: <Provided, Value>(services: Context.Context<Provided>, evaluate: () => Value) => Value;
-}
-
-export type PlatformRuntimeServices<Runtime> = Runtime extends PlatformRuntime<infer Services, infer _BuildError> ? Services : never;
-
-export type PlatformRuntimeBuildError<Runtime> = Runtime extends PlatformRuntime<infer _Services, infer BuildError> ? BuildError : never;

package/src/runtime.ts

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

package/src/testing/types.ts

@@ -1,41 +0,0 @@
-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";
-
-export type PlatformHarness<Database extends AnyDatabase, Options, Caller, Extension> = Readonly<{
-	db: DatabaseService<Database>;
-	trpc: EffectCallerFactory<Options, Caller>;
-}> &
-	Readonly<{
-		promise: <Value>(evaluate: () => Promise<Value>) => Effect.Effect<Value, unknown>;
-	}> &
-	Omit<Extension, "db" | "promise" | "trpc">;
-
-export type PlatformTest<Harness, Provided> = TrpcHarnessTest<Harness, Provided>;
-
-export type PlatformTester<Harness, Provided> = TrpcHarnessTester<Harness, Provided>;
-
-export type PlatformIt<Harness, Provided> = Vitest.Methods & {
-	readonly effectApp: PlatformTester<Harness, Provided>;
-};
-
-export interface MakePlatformItOptions<
-	Database extends AnyDatabase,
-	CreateCaller extends (...arguments_: never[]) => object,
-	Provided,
-	LayerError,
-	Extension,
-> {
-	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
-	readonly createCaller: CreateCaller;
-	readonly extend?: (
-		base: Readonly<{
-			db: DatabaseService<Database>;
-			trpc: EffectCallerFactory<CallerOptions<NoInfer<CreateCaller>>, CallerResult<NoInfer<CreateCaller>>>;
-		}>,
-		context: TestContext,
-	) => Effect.Effect<Extension, unknown, Provided | Effect.Services<Database>>;
-	readonly layer: Layer.Layer<Provided, LayerError>;
-}

package/src/testing/vitest.ts

@@ -1,69 +0,0 @@
-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 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?: Bivariant<
-		(
-			base: { readonly db: unknown; readonly trpc: EffectCallerFactory<unknown, object> },
-			context: TestContext,
-		) => Effect.Effect<object, unknown, unknown>
-	>;
-	readonly layer: Layer.Layer<unknown, unknown>;
-}
-
-function platformIt<
-	Database extends AnyDatabase,
-	CreateCaller extends (...arguments_: never[]) => object,
-	Provided,
-	LayerError,
-	Extension extends object,
->(
-	database: Database,
-	options: MakePlatformItOptions<Database, CreateCaller, Provided, LayerError, Extension> & {
-		readonly layer: Layer.Layer<Provided | Effect.Services<Database>, LayerError>;
-	},
-): PlatformIt<PlatformHarness<Database, CallerOptions<CreateCaller>, CallerResult<CreateCaller>, Extension>, Provided | Effect.Services<Database>>;
-function platformIt(database: AnyDatabase, options: LooseOptions): unknown {
-	const trpcIt = makeTrpcHarnessIt({
-		adapter: options.adapter,
-		around: (effect) => withTestTransaction(database, effect),
-		createCaller: options.createCaller,
-		layer: options.layer,
-		makeHarness: (trpc, context) =>
-			Effect.gen(function* () {
-				const services = yield* Effect.context<unknown>();
-				const db = yield* database;
-				const extension = options.extend ? yield* options.extend({ db, trpc }, context) : {};
-				const promise = <Value>(evaluate: () => Promise<Value>) => Effect.tryPromise(() => options.adapter.runWithServices(services, evaluate));
-				return { ...extension, db, promise, trpc };
-			}),
-	});
-
-	return new Proxy(trpcIt, {
-		get(target, property, receiver) {
-			if (property === "effectApp") {
-				return trpcIt.effectTRPC;
-			}
-			return Reflect.get(target, property, receiver);
-		},
-	});
-}
-
-export const makePlatformIt =
-	<const Database extends AnyDatabase>(database: Database) =>
-	<CreateCaller extends (...arguments_: never[]) => object, Provided, LayerError, Extension extends object = Record<never, never>>(
-		options: MakePlatformItOptions<Database, CreateCaller, Provided, LayerError, Extension> & {
-			readonly layer: Layer.Layer<Provided | Effect.Services<Database>, LayerError>;
-		},
-	): PlatformIt<
-		PlatformHarness<Database, CallerOptions<CreateCaller>, CallerResult<CreateCaller>, Extension>,
-		Provided | Effect.Services<Database>
-	> =>
-		platformIt(database, options);

package/src/testing.ts

@@ -1,8 +0,0 @@
-export type {
-	MakePlatformItOptions,
-	PlatformHarness,
-	PlatformIt,
-	PlatformTest,
-	PlatformTester,
-} from "#testing/types.ts";
-export { makePlatformIt } from "#testing/vitest.ts";