@temporary-name/server 1.9.3-alpha.32780b2c7ad58cf8dcbc93a40f13494185223e6e → 1.9.3-alpha.3bfad2d4c9c25a8fb0e01d57b30d58f74bc8f953

package/dist/shared/server.u-02Z0mj.mjs

@@ -1,254 +0,0 @@
-import { stringifyJSON, isObject, isORPCErrorStatus, tryDecodeURIComponent, toHttpPath, toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, ORPCError, toORPCError } from '@temporary-name/shared';
-import { flattenHeader } from '@temporary-name/standard-server';
-import { c as createProcedureClient } from './server.DlRH_uit.mjs';
-import { fallbackContractConfig } from '@temporary-name/contract';
-import { d as deserialize, b as bracketNotationDeserialize, s as serialize, a as standardizeHTTPPath } from './server.Kxw442A9.mjs';
-import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@temporary-name/server';
-import { createRouter, addRoute, findRoute } from 'rou3';
-
-async function decode(request, pathParams) {
-  return {
-    path: pathParams ?? {},
-    query: bracketNotationDeserialize(Array.from(request.url.searchParams.entries())),
-    headers: request.headers,
-    body: deserialize(await request.body()) ?? {}
-  };
-}
-function encode(output, procedure) {
-  const successStatus = fallbackContractConfig(
-    "defaultSuccessStatus",
-    procedure["~orpc"].route.successStatus
-  );
-  const outputStructure = fallbackContractConfig(
-    "defaultOutputStructure",
-    procedure["~orpc"].route.outputStructure
-  );
-  if (outputStructure === "compact") {
-    return {
-      status: successStatus,
-      headers: {},
-      body: serialize(output)
-    };
-  }
-  if (!isDetailedOutput(output)) {
-    throw new Error(`
-        Invalid "detailed" output structure:
-        \u2022 Expected an object with optional properties:
-          - status (number 200-399)
-          - headers (Record<string, string | string[]>)
-          - body (any)
-        \u2022 No extra keys allowed.
-
-        Actual value:
-          ${stringifyJSON(output)}
-      `);
-  }
-  return {
-    status: output.status ?? successStatus,
-    headers: output.headers ?? {},
-    body: serialize(output.body)
-  };
-}
-function encodeError(error) {
-  return {
-    status: error.status,
-    headers: {},
-    body: serialize(error.toJSON(), { outputFormat: "plain" })
-  };
-}
-function isDetailedOutput(output) {
-  if (!isObject(output)) {
-    return false;
-  }
-  if (output.headers && !isObject(output.headers)) {
-    return false;
-  }
-  if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) {
-    return false;
-  }
-  return true;
-}
-
-function resolveFriendlyStandardHandleOptions(options) {
-  return {
-    ...options,
-    context: options.context ?? {}
-    // Context only optional if all fields are optional
-  };
-}
-function toRou3Pattern(path) {
-  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
-}
-function decodeParams(params) {
-  return Object.fromEntries(
-    Object.entries(params).map(([key, value]) => [key, tryDecodeURIComponent(value)])
-  );
-}
-
-class StandardOpenAPIMatcher {
-  tree = createRouter();
-  pendingRouters = [];
-  init(router, path = []) {
-    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
-      const { path: path2, contract } = traverseOptions;
-      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
-      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
-      if (isProcedure(contract)) {
-        addRoute(this.tree, method, httpPath, {
-          path: path2,
-          contract,
-          procedure: contract,
-          // this mean dev not used contract-first so we can used contract as procedure directly
-          router
-        });
-      } else {
-        addRoute(this.tree, method, httpPath, {
-          path: path2,
-          contract,
-          procedure: void 0,
-          router
-        });
-      }
-    });
-    this.pendingRouters.push(
-      ...laziedOptions.map((option) => ({
-        ...option,
-        httpPathPrefix: toHttpPath(option.path),
-        laziedPrefix: getLazyMeta(option.router).prefix
-      }))
-    );
-  }
-  async match(method, pathname) {
-    if (this.pendingRouters.length) {
-      const newPendingRouters = [];
-      for (const pendingRouter of this.pendingRouters) {
-        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || 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 = findRoute(this.tree, method, pathname);
-    if (!match) {
-      return void 0;
-    }
-    if (!match.data.procedure) {
-      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
-      if (!isProcedure(maybeProcedure)) {
-        throw new Error(`
-          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
-          Ensure that the procedure is correctly defined and matches the expected contract.
-        `);
-      }
-      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
-    }
-    return {
-      path: match.data.path,
-      procedure: match.data.procedure,
-      params: match.params ? decodeParams(match.params) : void 0
-    };
-  }
-}
-
-class CompositeStandardHandlerPlugin {
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-  }
-  init(options, router) {
-    for (const plugin of this.plugins) {
-      plugin.init?.(options, router);
-    }
-  }
-}
-
-class StandardHandler {
-  interceptors;
-  clientInterceptors;
-  rootInterceptors;
-  matcher;
-  constructor(router, options) {
-    this.matcher = new StandardOpenAPIMatcher();
-    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
-    plugins.init(options, router);
-    this.interceptors = toArray(options.interceptors);
-    this.clientInterceptors = toArray(options.clientInterceptors);
-    this.rootInterceptors = toArray(options.rootInterceptors);
-    this.matcher.init(router);
-  }
-  async handle(request, options) {
-    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
-    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
-      return { matched: false, response: void 0 };
-    }
-    return intercept(this.rootInterceptors, { ...options, request, prefix }, async (interceptorOptions) => {
-      return runWithSpan({ name: `${request.method} ${request.url.pathname}` }, async (span) => {
-        let step;
-        try {
-          return await intercept(
-            this.interceptors,
-            interceptorOptions,
-            async ({ request: request2, context, prefix: prefix2 }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
-              const match = await runWithSpan(
-                { name: "find_procedure" },
-                () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
-              );
-              if (!match) {
-                return { matched: false, response: void 0 };
-              }
-              span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
-              span?.setAttribute("rpc.system", ORPC_NAME);
-              span?.setAttribute("rpc.method", match.path.join("."));
-              step = "decode_input";
-              const input = await runWithSpan({ name: "decode_input" }, () => decode(request2, match.params));
-              step = void 0;
-              if (isAsyncIteratorObject(input.body)) {
-                input.body = asyncIteratorWithSpan(
-                  { name: "consume_event_iterator_input", signal: request2.signal },
-                  input.body
-                );
-              }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path,
-                interceptors: this.clientInterceptors
-              });
-              step = "call_procedure";
-              const output = await client(input, {
-                signal: request2.signal,
-                lastEventId: flattenHeader(request2.headers["last-event-id"])
-              });
-              step = void 0;
-              const response = encode(output, match.procedure);
-              return {
-                matched: true,
-                response
-              };
-            }
-          );
-        } catch (e) {
-          if (step !== "call_procedure") {
-            setSpanError(span, e);
-          }
-          const error = step === "decode_input" && !(e instanceof ORPCError) ? 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 = encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
-      });
-    });
-  }
-}
-
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S, encodeError as a, StandardOpenAPIMatcher as b, decodeParams as c, decode as d, encode as e, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };