@orpc/server 0.0.0-next.9b3a030 → 0.0.0-next.9b9ade5

package/dist/shared/server.CSZRzcSW.mjs

@@ -0,0 +1,158 @@
+import { ORPCError, toORPCError } from '@orpc/client';
+import { intercept, trim, parseEmptyableJSON } from '@orpc/shared';
+import { C as CompositePlugin } from './server.Q6ZmnTgO.mjs';
+import { c as createProcedureClient, t as traverseContractProcedures, a as toHttpPath, i as isProcedure, u as unlazy, g as getRouter, b as createContractedProcedure } from './server.CMrS28Go.mjs';
+
+class StandardHandler {
+  constructor(router, matcher, codec, options) {
+    this.matcher = matcher;
+    this.codec = codec;
+    this.options = options;
+    this.plugin = new CompositePlugin(options.plugins);
+    this.plugin.init(this.options);
+    this.matcher.init(router);
+  }
+  plugin;
+  handle(request, ...[options]) {
+    return intercept(
+      this.options.rootInterceptors ?? [],
+      {
+        request,
+        ...options,
+        context: options?.context ?? {}
+        // context is optional only when all fields are optional so we can safely force it to have a context
+      },
+      async (interceptorOptions) => {
+        let isDecoding = false;
+        try {
+          return await intercept(
+            this.options.interceptors ?? [],
+            interceptorOptions,
+            async (interceptorOptions2) => {
+              const method = interceptorOptions2.request.method;
+              const url = interceptorOptions2.request.url;
+              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
+              const match = await this.matcher.match(method, pathname);
+              if (!match) {
+                return { matched: false, response: void 0 };
+              }
+              const client = createProcedureClient(match.procedure, {
+                context: interceptorOptions2.context,
+                path: match.path,
+                interceptors: this.options.clientInterceptors
+              });
+              isDecoding = true;
+              const input = await this.codec.decode(request, match.params, match.procedure);
+              isDecoding = false;
+              const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
+              const output = await client(input, { signal: request.signal, lastEventId });
+              const response = this.codec.encode(output, match.procedure);
+              return {
+                matched: true,
+                response
+              };
+            }
+          );
+        } catch (e) {
+          const error = isDecoding ? new ORPCError("BAD_REQUEST", {
+            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+            cause: e
+          }) : toORPCError(e);
+          const response = this.codec.encodeError(error);
+          return {
+            matched: true,
+            response
+          };
+        }
+      }
+    );
+  }
+}
+
+class RPCCodec {
+  constructor(serializer) {
+    this.serializer = serializer;
+  }
+  async decode(request, _params, _procedure) {
+    const serialized = request.method === "GET" ? parseEmptyableJSON(request.url.searchParams.getAll("data").at(-1)) : await request.body();
+    return this.serializer.deserialize(serialized);
+  }
+  encode(output, _procedure) {
+    return {
+      status: 200,
+      headers: {},
+      body: this.serializer.serialize(output)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+}
+
+class RPCMatcher {
+  tree = {};
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+      const httpPath = toHttpPath(path2);
+      if (isProcedure(contract)) {
+        this.tree[httpPath] = {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        };
+      } else {
+        this.tree[httpPath] = {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        };
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: toHttpPath(option.path)
+    })));
+  }
+  async match(_method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.router);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = this.tree[pathname];
+    if (!match) {
+      return void 0;
+    }
+    if (!match.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouter(match.router, match.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.procedure = createContractedProcedure(maybeProcedure, match.contract);
+    }
+    return {
+      path: match.path,
+      procedure: match.procedure
+    };
+  }
+}
+
+export { RPCCodec as R, StandardHandler as S, RPCMatcher as a };

package/dist/shared/server.Cq3B6PoL.mjs

@@ -0,0 +1,28 @@
+import { RPCSerializer } from '@orpc/client/standard';
+import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { S as StandardHandler, a as RPCMatcher, R as RPCCodec } from './server.CSZRzcSW.mjs';
+
+class RPCHandler {
+  standardHandler;
+  constructor(router, options = {}) {
+    const serializer = new RPCSerializer();
+    const matcher = new RPCMatcher();
+    const codec = new RPCCodec(serializer);
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...[
+    options = {}
+  ]) {
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, options)
+    };
+  }
+}
+
+export { RPCHandler as R };

package/dist/shared/server.DmW25ynm.d.ts

@@ -0,0 +1,75 @@
+import { HTTPPath, AnySchema, Meta, InferSchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.CPteJIPP.js';
+import { ORPCError } from '@orpc/client';
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+type StandardHandlerInterceptorOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+    request: StandardLazyRequest;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: HandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, AnySchema, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
+}
+
+interface HandlerPlugin<TContext extends Context> {
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositePlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly plugins;
+    constructor(plugins?: HandlerPlugin<TContext>[]);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { CompositePlugin as C, type HandlerPlugin as H, type StandardHandleOptions as S, type StandardHandlerInterceptorOptions as a, type StandardHandlerOptions as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };

package/dist/shared/server.Q6ZmnTgO.mjs

@@ -0,0 +1,12 @@
+class CompositePlugin {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
+
+export { CompositePlugin as C };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.9b3a030",
+  "version": "0.0.0-next.9b9ade5",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,37 +15,42 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     },
     "./hono": {
-      "types": "./dist/src/adapters/hono/index.d.ts",
-      "import": "./dist/hono.js",
-      "default": "./dist/hono.js"
+      "types": "./dist/adapters/hono/index.d.mts",
+      "import": "./dist/adapters/hono/index.mjs",
+      "default": "./dist/adapters/hono/index.mjs"
     },
     "./next": {
-      "types": "./dist/src/adapters/next/index.d.ts",
-      "import": "./dist/next.js",
-      "default": "./dist/next.js"
+      "types": "./dist/adapters/next/index.d.mts",
+      "import": "./dist/adapters/next/index.mjs",
+      "default": "./dist/adapters/next/index.mjs"
     },
     "./node": {
-      "types": "./dist/src/adapters/node/index.d.ts",
-      "import": "./dist/node.js",
-      "default": "./dist/node.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/adapters/node/index.d.mts",
+      "import": "./dist/adapters/node/index.mjs",
+      "default": "./dist/adapters/node/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
@@ -53,11 +58,18 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.9b3a030",
-    "@orpc/shared": "0.0.0-next.9b3a030"
+    "@orpc/contract": "0.0.0-next.9b9ade5",
+    "@orpc/client": "0.0.0-next.9b9ade5",
+    "@orpc/shared": "0.0.0-next.9b9ade5",
+    "@orpc/standard-server": "0.0.0-next.9b9ade5",
+    "@orpc/standard-server-fetch": "0.0.0-next.9b9ade5",
+    "@orpc/standard-server-node": "0.0.0-next.9b9ade5"
+  },
+  "devDependencies": {
+    "light-my-request": "^6.5.1"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-DNG2IB3R.js

@@ -1,227 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
-// src/procedure.ts
-import { isContractProcedure } from "@orpc/contract";
-var Procedure = class {
-  "~type" = "Procedure";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-};
-function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "Procedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "contract" in item["~orpc"] && isContractProcedure(item["~orpc"].contract) && "handler" in item["~orpc"] && typeof item["~orpc"].handler === "function";
-}
-
-// src/error.ts
-import { ORPCError } from "@orpc/contract";
-function createORPCErrorConstructorMap(errors) {
-  const constructors = {};
-  if (!errors) {
-    return constructors;
-  }
-  for (const code in errors) {
-    const config = errors[code];
-    if (!config) {
-      continue;
-    }
-    const constructor = (...[options]) => {
-      return new ORPCError({
-        code,
-        defined: true,
-        status: config.status,
-        message: options?.message ?? config.message,
-        data: options?.data,
-        cause: options?.cause
-      });
-    };
-    constructors[code] = constructor;
-  }
-  return constructors;
-}
-
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function lazy(loader) {
-  return {
-    [LAZY_LOADER_SYMBOL]: loader
-  };
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
-}
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_LOADER_SYMBOL]() : Promise.resolve({ default: lazied });
-}
-function flatLazy(lazied) {
-  const flattenLoader = async () => {
-    let current = await unlazy(lazied);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await unlazy(current.default);
-    }
-    return current;
-  };
-  return lazy(flattenLoader);
-}
-
-// src/procedure-client.ts
-import { ORPCError as ORPCError2, validateORPCError, ValidationError } from "@orpc/contract";
-import { executeWithHooks, toError, value } from "@orpc/shared";
-function createProcedureClient(options) {
-  return async (...[input, callerOptions]) => {
-    const path = options.path ?? [];
-    const { default: procedure } = await unlazy(options.procedure);
-    const context = await value(options.context);
-    const meta = {
-      path,
-      procedure,
-      signal: callerOptions?.signal
-    };
-    const executeWithValidation = async () => {
-      const validInput = await validateInput(procedure, input);
-      const output = await executeMiddlewareChain({
-        context,
-        input: validInput,
-        path,
-        procedure,
-        signal: callerOptions?.signal,
-        errors: createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap)
-      });
-      return validateOutput(procedure, output);
-    };
-    try {
-      const output = await executeWithHooks({
-        hooks: options,
-        input,
-        context,
-        meta,
-        execute: executeWithValidation
-      });
-      return output;
-    } catch (e) {
-      if (!(e instanceof ORPCError2)) {
-        throw toError(e);
-      }
-      const validated = await validateORPCError(procedure["~orpc"].contract["~orpc"].errorMap, e);
-      throw validated;
-    }
-  };
-}
-async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].contract["~orpc"].InputSchema;
-  if (!schema)
-    return input;
-  const result = await schema["~standard"].validate(input);
-  if (result.issues) {
-    throw new ORPCError2({
-      message: "Input validation failed",
-      code: "BAD_REQUEST",
-      data: {
-        issues: result.issues
-      },
-      cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
-}
-async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].contract["~orpc"].OutputSchema;
-  if (!schema)
-    return output;
-  const result = await schema["~standard"].validate(output);
-  if (result.issues) {
-    throw new ORPCError2({
-      message: "Output validation failed",
-      code: "INTERNAL_SERVER_ERROR",
-      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
-}
-async function executeMiddlewareChain(opt) {
-  const middlewares = opt.procedure["~orpc"].middlewares ?? [];
-  let currentMidIndex = 0;
-  let currentContext = opt.context;
-  const next = async (nextOptions) => {
-    const mid = middlewares[currentMidIndex];
-    currentMidIndex += 1;
-    currentContext = mergeContext(currentContext, nextOptions.context);
-    if (mid) {
-      return await mid({ ...opt, context: currentContext, next }, opt.input, (output) => ({ output, context: void 0 }));
-    }
-    const result = {
-      output: await opt.procedure["~orpc"].handler({ ...opt, context: currentContext }),
-      context: currentContext
-    };
-    return result;
-  };
-  return (await next({})).output;
-}
-
-// src/router.ts
-function getRouterChild(router, ...path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!current) {
-      return void 0;
-    }
-    if (isProcedure(current)) {
-      return void 0;
-    }
-    if (!isLazy(current)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    const newLazy = lazy(async () => {
-      const unwrapped = await unlazy(lazied);
-      if (!unwrapped.default) {
-        return unwrapped;
-      }
-      const next = getRouterChild(unwrapped.default, ...rest);
-      return { default: next };
-    });
-    return flatLazy(newLazy);
-  }
-  return current;
-}
-
-export {
-  __export,
-  mergeContext,
-  Procedure,
-  isProcedure,
-  createORPCErrorConstructorMap,
-  LAZY_LOADER_SYMBOL,
-  lazy,
-  isLazy,
-  unlazy,
-  flatLazy,
-  createProcedureClient,
-  getRouterChild
-};
-//# sourceMappingURL=chunk-DNG2IB3R.js.map