effect-orpc 1.0.0-effect-v4.2 → 1.0.0-effect-v4.4

package/src/effect-runtime.ts

@@ -0,0 +1,144 @@
+import { ORPCError } from "@orpc/contract";
+import type {
+  Context as ORPCContext,
+  ProcedureHandler,
+  ProcedureHandlerOptions,
+} from "@orpc/server";
+import type { ManagedRuntime } from "effect";
+import { Cause, Effect, Exit, Result, Context } from "effect";
+
+import { getCurrentServices } from "./service-context-bridge";
+import type { EffectErrorConstructorMap, EffectErrorMap } from "./tagged-error";
+import {
+  createEffectErrorConstructorMap,
+  isORPCTaggedError,
+} from "./tagged-error";
+import type { EffectProcedureHandler, EffectSpanConfig } from "./types";
+
+export function toORPCErrorFromCause(
+  cause: Cause.Cause<unknown>,
+): ORPCError<string, unknown> {
+  if (Cause.hasFails(cause)) {
+    const reason = Cause.findFail(cause);
+    if (Result.isFailure(reason)) {
+      return new ORPCError("INTERNAL_SERVER_ERROR");
+    }
+
+    const error = reason.success.error;
+    if (isORPCTaggedError(error)) {
+      return error.toORPCError();
+    }
+    if (error instanceof ORPCError) {
+      return error;
+    }
+
+    return new ORPCError("INTERNAL_SERVER_ERROR", {
+      cause: error,
+    });
+  }
+
+  if (Cause.hasDies(cause)) {
+    const reason = Cause.findDie(cause);
+    if (Result.isFailure(reason)) {
+      return new ORPCError("INTERNAL_SERVER_ERROR", {
+        cause: new Error(`Died by unknown reason`),
+      });
+    }
+    return new ORPCError("INTERNAL_SERVER_ERROR", {
+      cause: reason.success.defect,
+    });
+  }
+
+  if (Cause.hasInterrupts(cause)) {
+    const reason = Cause.findInterrupt(cause);
+    if (Result.isFailure(reason)) {
+      return new ORPCError("INTERNAL_SERVER_ERROR", {
+        cause: new Error(`Unknown fiber got interrupted`),
+      });
+    }
+    return new ORPCError("INTERNAL_SERVER_ERROR", {
+      cause: new Error(`${reason.success.fiberId} got interrupted`),
+    });
+  }
+
+  return new ORPCError("INTERNAL_SERVER_ERROR");
+}
+
+export function createEffectProcedureHandler<
+  TCurrentContext extends ORPCContext,
+  TInput,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TRuntimeError,
+  TMeta,
+>(options: {
+  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  effectErrorMap: TEffectErrorMap;
+  effectFn: EffectProcedureHandler<
+    TCurrentContext,
+    TInput,
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided,
+    any
+  >;
+  spanConfig?: EffectSpanConfig;
+  defaultCaptureStackTrace: () => string | undefined;
+}): ProcedureHandler<
+  TCurrentContext,
+  TInput,
+  TOutput,
+  any,
+  TMeta & Record<never, never>
+> {
+  const {
+    runtime,
+    effectErrorMap,
+    effectFn,
+    spanConfig,
+    defaultCaptureStackTrace,
+  } = options;
+
+  return async (opts) => {
+    const effectOpts: ProcedureHandlerOptions<
+      TCurrentContext,
+      TInput,
+      EffectErrorConstructorMap<TEffectErrorMap>,
+      TMeta & Record<never, never>
+    > = {
+      context: opts.context,
+      input: opts.input,
+      path: opts.path,
+      procedure: opts.procedure,
+      signal: opts.signal,
+      lastEventId: opts.lastEventId,
+      errors: createEffectErrorConstructorMap(effectErrorMap),
+    };
+
+    const spanName = spanConfig?.name ?? opts.path.join(".");
+    const captureStackTrace =
+      spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
+    const resolver = Effect.fnUntraced(effectFn as any);
+    const tracedEffect = Effect.withSpan(resolver(effectOpts), spanName, {
+      captureStackTrace,
+    });
+
+    const parentServices = getCurrentServices();
+    const exit = parentServices
+      ? await Effect.runPromiseExitWith(
+          Context.merge(await runtime.context(), parentServices),
+        )(tracedEffect, {
+          signal: opts.signal,
+        })
+      : await runtime.runPromiseExit(tracedEffect, {
+          signal: opts.signal,
+        });
+
+    if (Exit.isFailure(exit)) {
+      throw toORPCErrorFromCause(exit.cause);
+    }
+
+    return exit.value as TOutput;
+  };
+}

package/src/eoc.ts

@@ -0,0 +1,499 @@
+import type {
+  AnySchema,
+  ContractProcedure,
+  ContractRouter,
+  ErrorMap,
+  HTTPPath,
+  Meta,
+  Route,
+  Schema,
+} from "@orpc/contract";
+import { isContractProcedure, oc } from "@orpc/contract";
+
+import type { EffectErrorMap, MergedEffectErrorMap } from "./tagged-error";
+import { effectErrorMapToErrorMap } from "./tagged-error";
+import type { EffectErrorMapToErrorMap } from "./types";
+
+export const effectContractSymbol: unique symbol = Symbol.for(
+  "@orpc/effect/contract",
+);
+
+interface EffectContractMetadata<TEffectErrorMap extends EffectErrorMap> {
+  readonly [effectContractSymbol]: {
+    readonly errorMap: TEffectErrorMap;
+  };
+}
+
+type LocalEffectErrorMap<T> =
+  T extends EffectContractMetadata<infer TEffectErrorMap extends EffectErrorMap>
+    ? TEffectErrorMap
+    : Record<never, never>;
+
+type ContractWithEffectErrorMap<T, TEffectErrorMap extends EffectErrorMap> =
+  T extends ContractProcedure<
+    infer TInputSchema,
+    infer TOutputSchema,
+    infer TErrorMap extends ErrorMap,
+    infer TMeta extends Meta
+  >
+    ? ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> &
+        EffectContractMetadata<
+          MergedEffectErrorMap<TEffectErrorMap, LocalEffectErrorMap<T>>
+        >
+    : T extends ContractRouter<Meta>
+      ? {
+          [K in keyof T]: ContractWithEffectErrorMap<T[K], TEffectErrorMap>;
+        }
+      : never;
+
+export interface EffectContractProcedureBuilder<
+  TInputSchema extends AnySchema,
+  TOutputSchema extends AnySchema,
+  TEffectErrorMap extends EffectErrorMap,
+  TMeta extends Meta,
+>
+  extends
+    ContractProcedure<
+      TInputSchema,
+      TOutputSchema,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
+      TMeta
+    >,
+    EffectContractMetadata<TEffectErrorMap> {
+  errors<U extends EffectErrorMap>(
+    errors: U,
+  ): EffectContractProcedureBuilder<
+    TInputSchema,
+    TOutputSchema,
+    MergedEffectErrorMap<TEffectErrorMap, U>,
+    TMeta
+  >;
+  meta(
+    meta: TMeta,
+  ): EffectContractProcedureBuilder<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  route(
+    route: Route,
+  ): EffectContractProcedureBuilder<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  input<U extends AnySchema>(
+    schema: U,
+  ): EffectContractProcedureBuilderWithInput<
+    U,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  output<U extends AnySchema>(
+    schema: U,
+  ): EffectContractProcedureBuilderWithOutput<
+    TInputSchema,
+    U,
+    TEffectErrorMap,
+    TMeta
+  >;
+}
+
+export interface EffectContractProcedureBuilderWithInput<
+  TInputSchema extends AnySchema,
+  TOutputSchema extends AnySchema,
+  TEffectErrorMap extends EffectErrorMap,
+  TMeta extends Meta,
+>
+  extends
+    ContractProcedure<
+      TInputSchema,
+      TOutputSchema,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
+      TMeta
+    >,
+    EffectContractMetadata<TEffectErrorMap> {
+  errors<U extends EffectErrorMap>(
+    errors: U,
+  ): EffectContractProcedureBuilderWithInput<
+    TInputSchema,
+    TOutputSchema,
+    MergedEffectErrorMap<TEffectErrorMap, U>,
+    TMeta
+  >;
+  meta(
+    meta: TMeta,
+  ): EffectContractProcedureBuilderWithInput<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  route(
+    route: Route,
+  ): EffectContractProcedureBuilderWithInput<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  output<U extends AnySchema>(
+    schema: U,
+  ): EffectContractProcedureBuilderWithInputOutput<
+    TInputSchema,
+    U,
+    TEffectErrorMap,
+    TMeta
+  >;
+}
+
+export interface EffectContractProcedureBuilderWithOutput<
+  TInputSchema extends AnySchema,
+  TOutputSchema extends AnySchema,
+  TEffectErrorMap extends EffectErrorMap,
+  TMeta extends Meta,
+>
+  extends
+    ContractProcedure<
+      TInputSchema,
+      TOutputSchema,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
+      TMeta
+    >,
+    EffectContractMetadata<TEffectErrorMap> {
+  errors<U extends EffectErrorMap>(
+    errors: U,
+  ): EffectContractProcedureBuilderWithOutput<
+    TInputSchema,
+    TOutputSchema,
+    MergedEffectErrorMap<TEffectErrorMap, U>,
+    TMeta
+  >;
+  meta(
+    meta: TMeta,
+  ): EffectContractProcedureBuilderWithOutput<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  route(
+    route: Route,
+  ): EffectContractProcedureBuilderWithOutput<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  input<U extends AnySchema>(
+    schema: U,
+  ): EffectContractProcedureBuilderWithInputOutput<
+    U,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+}
+
+export interface EffectContractProcedureBuilderWithInputOutput<
+  TInputSchema extends AnySchema,
+  TOutputSchema extends AnySchema,
+  TEffectErrorMap extends EffectErrorMap,
+  TMeta extends Meta,
+>
+  extends
+    ContractProcedure<
+      TInputSchema,
+      TOutputSchema,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
+      TMeta
+    >,
+    EffectContractMetadata<TEffectErrorMap> {
+  errors<U extends EffectErrorMap>(
+    errors: U,
+  ): EffectContractProcedureBuilderWithInputOutput<
+    TInputSchema,
+    TOutputSchema,
+    MergedEffectErrorMap<TEffectErrorMap, U>,
+    TMeta
+  >;
+  meta(
+    meta: TMeta,
+  ): EffectContractProcedureBuilderWithInputOutput<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  route(
+    route: Route,
+  ): EffectContractProcedureBuilderWithInputOutput<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+}
+
+export interface EffectContractRouterBuilder<
+  TEffectErrorMap extends EffectErrorMap,
+  TMeta extends Meta,
+> extends EffectContractMetadata<TEffectErrorMap> {
+  errors<U extends EffectErrorMap>(
+    errors: U,
+  ): EffectContractRouterBuilder<
+    MergedEffectErrorMap<TEffectErrorMap, U>,
+    TMeta
+  >;
+  prefix(prefix: HTTPPath): EffectContractRouterBuilder<TEffectErrorMap, TMeta>;
+  tag(...tags: string[]): EffectContractRouterBuilder<TEffectErrorMap, TMeta>;
+  router<T extends ContractRouter<TMeta>>(
+    router: T,
+  ): ContractWithEffectErrorMap<T, TEffectErrorMap>;
+}
+
+export interface EffectContractBuilder<
+  TInputSchema extends AnySchema,
+  TOutputSchema extends AnySchema,
+  TEffectErrorMap extends EffectErrorMap,
+  TMeta extends Meta,
+>
+  extends
+    ContractProcedure<
+      TInputSchema,
+      TOutputSchema,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
+      TMeta
+    >,
+    EffectContractMetadata<TEffectErrorMap> {
+  $meta<U extends Meta>(
+    initialMeta: U,
+  ): EffectContractBuilder<TInputSchema, TOutputSchema, TEffectErrorMap, U>;
+  $route(
+    initialRoute: Route,
+  ): EffectContractBuilder<TInputSchema, TOutputSchema, TEffectErrorMap, TMeta>;
+  $input<U extends AnySchema>(
+    initialInputSchema?: U,
+  ): EffectContractBuilder<U, TOutputSchema, TEffectErrorMap, TMeta>;
+  errors<U extends EffectErrorMap>(
+    errors: U,
+  ): EffectContractBuilder<
+    TInputSchema,
+    TOutputSchema,
+    MergedEffectErrorMap<TEffectErrorMap, U>,
+    TMeta
+  >;
+  meta(
+    meta: TMeta,
+  ): EffectContractProcedureBuilder<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  route(
+    route: Route,
+  ): EffectContractProcedureBuilder<
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  input<U extends AnySchema>(
+    schema: U,
+  ): EffectContractProcedureBuilderWithInput<
+    U,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta
+  >;
+  output<U extends AnySchema>(
+    schema: U,
+  ): EffectContractProcedureBuilderWithOutput<
+    TInputSchema,
+    U,
+    TEffectErrorMap,
+    TMeta
+  >;
+  prefix(prefix: HTTPPath): EffectContractRouterBuilder<TEffectErrorMap, TMeta>;
+  tag(...tags: string[]): EffectContractRouterBuilder<TEffectErrorMap, TMeta>;
+  router<T extends ContractRouter<TMeta>>(
+    router: T,
+  ): ContractWithEffectErrorMap<T, TEffectErrorMap>;
+}
+
+function isWrappableContractBuilder(value: unknown): value is {
+  "~orpc": { errorMap: ErrorMap };
+} {
+  return typeof value === "object" && value !== null && "~orpc" in value;
+}
+
+function mergeEffectErrorMaps(
+  left: EffectErrorMap | undefined,
+  right: EffectErrorMap | undefined,
+): EffectErrorMap | undefined {
+  if (!left) {
+    return right;
+  }
+
+  if (!right) {
+    return left;
+  }
+
+  return {
+    ...left,
+    ...right,
+  };
+}
+
+function setEffectContractErrorMap(
+  value: object,
+  effectErrorMap: EffectErrorMap | undefined,
+): void {
+  if (!effectErrorMap) {
+    return;
+  }
+
+  Object.defineProperty(value, effectContractSymbol, {
+    value: { errorMap: effectErrorMap },
+    enumerable: false,
+    configurable: true,
+  });
+}
+
+export function getEffectContractErrorMap(
+  value: unknown,
+): EffectErrorMap | undefined {
+  if (typeof value !== "object" || value === null) {
+    return undefined;
+  }
+
+  return (value as Partial<EffectContractMetadata<EffectErrorMap>>)[
+    effectContractSymbol
+  ]?.errorMap;
+}
+
+function applyEffectContractErrorMapToRouter(
+  router: ContractRouter<Meta>,
+  source: ContractRouter<Meta> | undefined,
+  inheritedEffectErrorMap: EffectErrorMap | undefined,
+): void {
+  const routerRecord = router as Record<string, ContractRouter<Meta>>;
+  const sourceRecord = source as
+    | Record<string, ContractRouter<Meta>>
+    | undefined;
+
+  for (const key of Object.keys(routerRecord)) {
+    const routerValue = routerRecord[key];
+    const sourceValue =
+      sourceRecord && typeof sourceRecord === "object"
+        ? sourceRecord[key]
+        : undefined;
+
+    if (!routerValue) {
+      continue;
+    }
+
+    if (isContractProcedure(routerValue)) {
+      const sourceEffectErrorMap = getEffectContractErrorMap(sourceValue);
+      setEffectContractErrorMap(
+        routerValue,
+        mergeEffectErrorMaps(inheritedEffectErrorMap, sourceEffectErrorMap),
+      );
+      continue;
+    }
+
+    if (typeof routerValue === "object") {
+      applyEffectContractErrorMapToRouter(
+        routerValue,
+        sourceValue as ContractRouter<Meta> | undefined,
+        inheritedEffectErrorMap,
+      );
+    }
+  }
+}
+
+function wrapEffectContractBuilder<T>(
+  builder: T,
+  inheritedEffectErrorMap?: EffectErrorMap,
+): T {
+  const currentEffectErrorMap =
+    inheritedEffectErrorMap ?? getEffectContractErrorMap(builder);
+
+  if (typeof builder === "object" && builder !== null) {
+    setEffectContractErrorMap(builder as object, currentEffectErrorMap);
+  }
+
+  const proxy = new Proxy(builder as object, {
+    get(target, prop, receiver) {
+      if (prop === effectContractSymbol) {
+        return currentEffectErrorMap
+          ? { errorMap: currentEffectErrorMap }
+          : undefined;
+      }
+
+      if (prop === "errors") {
+        return (errors: EffectErrorMap) => {
+          const nextEffectErrorMap = mergeEffectErrorMaps(
+            currentEffectErrorMap,
+            errors,
+          );
+
+          return wrapEffectContractBuilder(
+            Reflect.apply(Reflect.get(target, prop, receiver), target, [
+              effectErrorMapToErrorMap(errors),
+            ]),
+            nextEffectErrorMap,
+          );
+        };
+      }
+
+      if (prop === "router") {
+        return (router: ContractRouter<Meta>) => {
+          const result = Reflect.apply(
+            Reflect.get(target, prop, receiver),
+            target,
+            [router],
+          ) as ContractRouter<Meta>;
+
+          applyEffectContractErrorMapToRouter(
+            result,
+            router,
+            currentEffectErrorMap,
+          );
+
+          return result;
+        };
+      }
+
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+
+      return (...args: unknown[]) => {
+        const result = Reflect.apply(value, target, args);
+        return isWrappableContractBuilder(result)
+          ? wrapEffectContractBuilder(result, currentEffectErrorMap)
+          : result;
+      };
+    },
+  }) as T;
+
+  setEffectContractErrorMap(proxy as object, currentEffectErrorMap);
+
+  return proxy;
+}
+
+export const eoc = wrapEffectContractBuilder(
+  oc,
+  {},
+) as unknown as EffectContractBuilder<
+  Schema<unknown, unknown>,
+  Schema<unknown, unknown>,
+  Record<never, never>,
+  Record<never, never>
+>;

package/src/index.ts

@@ -1,3 +1,18 @@
+export { implementEffect } from "./contract";
+export type {
+  EffectImplementer,
+  EffectImplementerInternal,
+  EffectProcedureImplementer,
+} from "./contract";
+export { eoc } from "./eoc";
+export type {
+  EffectContractBuilder,
+  EffectContractProcedureBuilder,
+  EffectContractProcedureBuilderWithInput,
+  EffectContractProcedureBuilderWithInputOutput,
+  EffectContractProcedureBuilderWithOutput,
+  EffectContractRouterBuilder,
+} from "./eoc";
 export {
   addSpanStackTrace,
   EffectBuilder,
@@ -40,10 +55,10 @@ export type {
   EffectProcedureHandler,
   EffectRouterBuilder,
   EffectSpanConfig,
-  InferBuilderInitialContext,
   InferBuilderCurrentContext,
-  InferBuilderInputSchema,
-  InferBuilderOutputSchema,
   InferBuilderErrorMap,
+  InferBuilderInitialContext,
+  InferBuilderInputSchema,
   InferBuilderMeta,
+  InferBuilderOutputSchema,
 } from "./types";

package/src/node.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
-import type { ServiceMap } from "effect";
+import type { Context } from "effect";
 import { Effect } from "effect";
 
 import {
@@ -8,7 +8,7 @@ import {
   type ServiceContextBridge,
 } from "./service-context-bridge";
 
-const servicesStorage = new AsyncLocalStorage<ServiceMap.ServiceMap<any>>();
+const servicesStorage = new AsyncLocalStorage<Context.Context<any>>();
 
 const bridge: ServiceContextBridge = {
   getCurrentServices: () => servicesStorage.getStore(),
@@ -19,7 +19,7 @@ installServiceContextBridge(bridge);
 export function withFiberContext<T, R = never>(
   fn: () => Promise<T>,
 ): Effect.Effect<T, never, R> {
-  return Effect.flatMap(Effect.services<R>(), (services) =>
+  return Effect.flatMap(Effect.context<R>(), (services) =>
     Effect.promise(() => servicesStorage.run(services, fn)),
   );
 }

package/src/service-context-bridge.ts

@@ -1,7 +1,7 @@
-import type { ServiceMap } from "effect";
+import type { Context } from "effect";
 
 export interface ServiceContextBridge {
-  readonly getCurrentServices: () => ServiceMap.ServiceMap<any> | undefined;
+  readonly getCurrentServices: () => Context.Context<any> | undefined;
 }
 
 let bridge: ServiceContextBridge | undefined;
@@ -12,6 +12,6 @@ export function installServiceContextBridge(
   bridge = nextBridge;
 }
 
-export function getCurrentServices(): ServiceMap.ServiceMap<any> | undefined {
+export function getCurrentServices(): Context.Context<any> | undefined {
   return bridge?.getCurrentServices();
 }