effect-orpc 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,18 +1,35 @@
 // src/effect-builder.ts
 import {
-  mergeErrorMap,
   mergeMeta as mergeMeta2,
+  mergePrefix as mergePrefix2,
   mergeRoute as mergeRoute2,
+  mergeTags,
   ORPCError as ORPCError2
 } from "@orpc/contract";
 import {
   addMiddleware as addMiddleware2,
   Builder,
   decorateMiddleware as decorateMiddleware2,
-  fallbackConfig
+  fallbackConfig,
+  lazy as lazy2
 } from "@orpc/server";
 import { Cause, Effect, Exit } from "effect";
 
+// src/effect-enhance-router.ts
+import {
+  enhanceRoute,
+  mergePrefix
+} from "@orpc/contract";
+import {
+  createAccessibleLazyRouter,
+  getLazyMeta,
+  isLazy,
+  isProcedure,
+  lazy,
+  mergeMiddlewares,
+  unlazy
+} from "@orpc/server";
+
 // src/effect-procedure.ts
 import { mergeMeta, mergeRoute } from "@orpc/contract";
 import {
@@ -44,7 +61,7 @@ function isORPCTaggedError(value) {
 function toConstantCase(str) {
   return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase();
 }
-function ORPCTaggedError() {
+function ORPCTaggedError(schema) {
   const factory = (tag, codeOrOptions, defaultOptions) => {
     const isCodeProvided = typeof codeOrOptions === "string";
     const code = isCodeProvided ? codeOrOptions : toConstantCase(tag);
@@ -53,6 +70,7 @@ function ORPCTaggedError() {
     const defaultMessage = options?.message;
     const BaseTaggedError = Data.TaggedError(tag);
     class ORPCTaggedErrorBase extends BaseTaggedError {
+      static schema = schema;
       static _tag = tag;
       static code = code;
       [ORPCErrorSymbol];
@@ -67,18 +85,19 @@ function ORPCTaggedError() {
         }
         const finalStatus = fallbackORPCErrorStatus(code, status);
         const finalMessage = fallbackORPCErrorMessage(code, inputMessage);
+        const data = opts.data;
         super({
           message: finalMessage,
           cause: opts.cause,
           code,
           status: finalStatus,
-          data: opts.data,
+          data,
           defined: opts.defined ?? true
         });
         this[ORPCErrorSymbol] = new ORPCError(code, {
           status: finalStatus,
           message: finalMessage,
-          data: opts.data,
+          data,
           defined: this.defined,
           cause: opts.cause
         });
@@ -117,7 +136,7 @@ function createEffectErrorConstructorMap(errors) {
       }
       const config = target[code];
       if (isORPCTaggedErrorClass(config)) {
-        return config;
+        return (...opts) => new config(...opts);
       }
       return (...rest) => {
         const options = resolveMaybeOptionalOptions(rest);
@@ -143,11 +162,11 @@ function effectErrorMapToErrorMap(errorMap) {
       continue;
     }
     if (isORPCTaggedErrorClass(ClassOrErrorItem)) {
-      const error = new ClassOrErrorItem().toORPCError();
-      result[code] = {
-        status: error.status,
-        message: error.message,
-        data: error.data
+      const classInstance = new ClassOrErrorItem();
+      result[classInstance.code] = {
+        status: classInstance.status,
+        message: classInstance.message,
+        data: classInstance.schema
       };
     } else {
       result[code] = ClassOrErrorItem;
@@ -157,9 +176,16 @@ function effectErrorMapToErrorMap(errorMap) {
 }
 
 // src/effect-procedure.ts
-var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends Procedure {
+var EffectProcedure = class extends Procedure {
+  constructor(def) {
+    super(def);
+    this["~effect"] = def;
+  }
+};
+var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends EffectProcedure {
   constructor(def) {
     super(def);
+    this["~effect"] = def;
   }
   /**
    * Adds type-safe custom errors.
@@ -168,9 +194,12 @@ var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends Procedure
    * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
    */
   errors(errors) {
-    const newEffectErrorMap = { ...this["~orpc"].effectErrorMap, ...errors };
+    const newEffectErrorMap = {
+      ...this["~effect"].effectErrorMap,
+      ...errors
+    };
     return new _EffectDecoratedProcedure({
-      ...this["~orpc"],
+      ...this["~effect"],
       effectErrorMap: newEffectErrorMap,
       errorMap: effectErrorMapToErrorMap(newEffectErrorMap)
     });
@@ -183,8 +212,8 @@ var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends Procedure
    */
   meta(meta) {
     return new _EffectDecoratedProcedure({
-      ...this["~orpc"],
-      meta: mergeMeta(this["~orpc"].meta, meta)
+      ...this["~effect"],
+      meta: mergeMeta(this["~effect"].meta, meta)
     });
   }
   /**
@@ -197,15 +226,15 @@ var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends Procedure
    */
   route(route) {
     return new _EffectDecoratedProcedure({
-      ...this["~orpc"],
-      route: mergeRoute(this["~orpc"].route, route)
+      ...this["~effect"],
+      route: mergeRoute(this["~effect"].route, route)
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _EffectDecoratedProcedure({
-      ...this["~orpc"],
-      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
+      ...this["~effect"],
+      middlewares: addMiddleware(this["~effect"].middlewares, mapped)
     });
   }
   /**
@@ -242,6 +271,56 @@ var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends Procedure
   }
 };
 
+// src/effect-enhance-router.ts
+function enhanceEffectRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazy(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = enhanceEffectRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(
+      options.middlewares,
+      router["~orpc"].middlewares,
+      { dedupeLeading: options.dedupeLeadingMiddlewares }
+    );
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const effectErrorMap = {
+      ...options.errorMap,
+      ...router["~orpc"].errorMap
+    };
+    const errorMap = effectErrorMapToErrorMap(effectErrorMap);
+    const enhanced2 = new EffectProcedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      effectErrorMap,
+      errorMap,
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded,
+      runtime: options.runtime
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceEffectRouter(router[key], options);
+  }
+  return enhanced;
+}
+
 // src/effect-builder.ts
 function addSpanStackTrace() {
   const ErrorConstructor = Error;
@@ -264,9 +343,96 @@ function addSpanStackTrace() {
   };
 }
 var EffectBuilder = class _EffectBuilder {
-  "~orpc";
   constructor(def) {
-    this["~orpc"] = def;
+    const { runtime, spanConfig, effectErrorMap, ...orpcDef } = def;
+    this["~orpc"] = orpcDef;
+    this["~effect"] = { runtime, spanConfig, effectErrorMap, ...orpcDef };
+  }
+  /**
+   * Sets or overrides the config.
+   *
+   * @see {@link https://orpc.dev/docs/client/server-side#middlewares-order Middlewares Order Docs}
+   * @see {@link https://orpc.dev/docs/best-practices/dedupe-middleware#configuration Dedupe Middleware Docs}
+   */
+  $config(config) {
+    const inputValidationCount = this["~effect"].inputValidationIndex - fallbackConfig(
+      "initialInputValidationIndex",
+      this["~effect"].config.initialInputValidationIndex
+    );
+    const outputValidationCount = this["~effect"].outputValidationIndex - fallbackConfig(
+      "initialOutputValidationIndex",
+      this["~effect"].config.initialOutputValidationIndex
+    );
+    return new _EffectBuilder({
+      ...this["~effect"],
+      config,
+      dedupeLeadingMiddlewares: fallbackConfig(
+        "dedupeLeadingMiddlewares",
+        config.dedupeLeadingMiddlewares
+      ),
+      inputValidationIndex: fallbackConfig(
+        "initialInputValidationIndex",
+        config.initialInputValidationIndex
+      ) + inputValidationCount,
+      outputValidationIndex: fallbackConfig(
+        "initialOutputValidationIndex",
+        config.initialOutputValidationIndex
+      ) + outputValidationCount
+    });
+  }
+  /**
+   * Set or override the initial context.
+   *
+   * @see {@link https://orpc.dev/docs/context Context Docs}
+   */
+  $context() {
+    return new _EffectBuilder({
+      ...this["~effect"],
+      middlewares: [],
+      inputValidationIndex: fallbackConfig(
+        "initialInputValidationIndex",
+        this["~effect"].config.initialInputValidationIndex
+      ),
+      outputValidationIndex: fallbackConfig(
+        "initialOutputValidationIndex",
+        this["~effect"].config.initialOutputValidationIndex
+      )
+    });
+  }
+  /**
+   * Sets or overrides the initial meta.
+   *
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+   */
+  $meta(initialMeta) {
+    return new _EffectBuilder({
+      ...this["~effect"],
+      meta: initialMeta
+    });
+  }
+  /**
+   * Sets or overrides the initial route.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+   */
+  $route(initialRoute) {
+    return new _EffectBuilder({
+      ...this["~effect"],
+      route: initialRoute
+    });
+  }
+  /**
+   * Sets or overrides the initial input schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#initial-configuration Initial Procedure Configuration Docs}
+   */
+  $input(initialInputSchema) {
+    return new _EffectBuilder({
+      ...this["~effect"],
+      inputSchema: initialInputSchema
+    });
   }
   /**
    * Adds type-safe custom errors.
@@ -290,23 +456,21 @@ var EffectBuilder = class _EffectBuilder {
    * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
    */
   errors(errors) {
+    const newEffectErrorMap = {
+      ...this["~effect"].effectErrorMap,
+      ...errors
+    };
     return new _EffectBuilder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(
-        this["~orpc"].errorMap,
-        effectErrorMapToErrorMap(errors)
-      ),
-      effectErrorMap: {
-        ...this["~orpc"].effectErrorMap,
-        ...errors
-      }
+      ...this["~effect"],
+      errorMap: effectErrorMapToErrorMap(newEffectErrorMap),
+      effectErrorMap: newEffectErrorMap
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware2(middleware).mapInput(mapInput) : middleware;
     return new _EffectBuilder({
-      ...this["~orpc"],
-      middlewares: addMiddleware2(this["~orpc"].middlewares, mapped)
+      ...this["~effect"],
+      middlewares: addMiddleware2(this["~effect"].middlewares, mapped)
     });
   }
   /**
@@ -317,8 +481,8 @@ var EffectBuilder = class _EffectBuilder {
    */
   meta(meta) {
     return new _EffectBuilder({
-      ...this["~orpc"],
-      meta: mergeMeta2(this["~orpc"].meta, meta)
+      ...this["~effect"],
+      meta: mergeMeta2(this["~effect"].meta, meta)
     });
   }
   /**
@@ -331,8 +495,8 @@ var EffectBuilder = class _EffectBuilder {
    */
   route(route) {
     return new _EffectBuilder({
-      ...this["~orpc"],
-      route: mergeRoute2(this["~orpc"].route, route)
+      ...this["~effect"],
+      route: mergeRoute2(this["~effect"].route, route)
     });
   }
   /**
@@ -342,12 +506,17 @@ var EffectBuilder = class _EffectBuilder {
    */
   input(schema) {
     return new _EffectBuilder({
-      ...this["~orpc"],
+      ...this["~effect"],
       inputSchema: schema,
       inputValidationIndex: fallbackConfig(
         "initialInputValidationIndex",
-        this["~orpc"].config.initialInputValidationIndex
-      ) + this["~orpc"].middlewares.length
+        this["~effect"].config.initialInputValidationIndex
+      ) + this["~effect"].middlewares.length
+      // we cast to any because EffectProcedureBuilderWithInput is expecting
+      // use() input type to be defined, and EffectBuilder types its use() input
+      // to unknown to allow any middleware to be passed
+      // ---
+      // note: the original implentation of the builder also uses any for the same reason
     });
   }
   /**
@@ -357,12 +526,12 @@ var EffectBuilder = class _EffectBuilder {
    */
   output(schema) {
     return new _EffectBuilder({
-      ...this["~orpc"],
+      ...this["~effect"],
       outputSchema: schema,
       outputValidationIndex: fallbackConfig(
         "initialOutputValidationIndex",
-        this["~orpc"].config.initialOutputValidationIndex
-      ) + this["~orpc"].middlewares.length
+        this["~effect"].config.initialOutputValidationIndex
+      ) + this["~effect"].middlewares.length
     });
   }
   /**
@@ -386,13 +555,19 @@ var EffectBuilder = class _EffectBuilder {
    */
   traced(spanName) {
     return new _EffectBuilder({
-      ...this["~orpc"],
+      ...this["~effect"],
       spanConfig: {
         name: spanName,
         captureStackTrace: addSpanStackTrace()
       }
     });
   }
+  handler(handler) {
+    return new EffectDecoratedProcedure({
+      ...this["~effect"],
+      handler
+    });
+  }
   /**
    * Defines the handler of the procedure using an Effect.
    * The Effect is executed using the ManagedRuntime provided during builder creation.
@@ -401,10 +576,10 @@ var EffectBuilder = class _EffectBuilder {
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
    */
   effect(effectFn) {
-    const { runtime, spanConfig } = this["~orpc"];
+    const { runtime, spanConfig } = this["~effect"];
     const defaultCaptureStackTrace = addSpanStackTrace();
     return new EffectDecoratedProcedure({
-      ...this["~orpc"],
+      ...this["~effect"],
       handler: async (opts) => {
         const effectOpts = {
           context: opts.context,
@@ -413,12 +588,14 @@ var EffectBuilder = class _EffectBuilder {
           procedure: opts.procedure,
           signal: opts.signal,
           lastEventId: opts.lastEventId,
-          errors: createEffectErrorConstructorMap(this["~orpc"].effectErrorMap)
+          errors: createEffectErrorConstructorMap(
+            this["~effect"].effectErrorMap
+          )
         };
-        const baseEffect = effectFn(effectOpts);
         const spanName = spanConfig?.name ?? opts.path.join(".");
         const captureStackTrace = spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
-        const tracedEffect = Effect.withSpan(baseEffect, spanName, {
+        const resolver = Effect.fnUntraced(effectFn);
+        const tracedEffect = Effect.withSpan(resolver(effectOpts), spanName, {
           captureStackTrace
         });
         const exit = await runtime.runPromiseExit(tracedEffect, {
@@ -462,11 +639,59 @@ var EffectBuilder = class _EffectBuilder {
       }
     });
   }
+  /**
+   * Prefixes all procedures in the router.
+   * The provided prefix is post-appended to any existing router prefix.
+   *
+   * @note This option does not affect procedures that do not define a path in their route definition.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
+   */
+  prefix(prefix) {
+    return new _EffectBuilder({
+      ...this["~effect"],
+      prefix: mergePrefix2(this["~effect"].prefix, prefix)
+    });
+  }
+  /**
+   * Adds tags to all procedures in the router.
+   * This helpful when you want to group procedures together in the OpenAPI specification.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+   */
+  tag(...tags) {
+    return new _EffectBuilder({
+      ...this["~effect"],
+      tags: mergeTags(this["~effect"].tags, tags)
+    });
+  }
+  /**
+   * Applies all of the previously defined options to the specified router.
+   *
+   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+   */
+  router(router) {
+    return enhanceEffectRouter(router, {
+      ...this["~effect"]
+    });
+  }
+  /**
+   * Create a lazy router
+   * And applies all of the previously defined options to the specified router.
+   *
+   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+   */
+  lazy(loader) {
+    return enhanceEffectRouter(lazy2(loader), {
+      ...this["~effect"]
+    });
+  }
 };
 function makeEffectORPC(runtime, builder) {
   const resolvedBuilder = builder ?? emptyBuilder();
   return new EffectBuilder({
     ...resolvedBuilder["~orpc"],
+    errorMap: effectErrorMapToErrorMap(resolvedBuilder["~orpc"].errorMap),
     effectErrorMap: resolvedBuilder["~orpc"].errorMap,
     runtime
   });