@temporary-name/server 1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d → 1.9.3-alpha.59a0ffc2afa5d7ac78321380832e510591ebe734

package/dist/shared/server.B9VxPdeK.mjs

@@ -1,293 +0,0 @@
-import { isObject, stringifyJSON, isORPCErrorStatus, tryDecodeURIComponent, value, 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.DcfsPloY.mjs';
-import { fallbackContractConfig } from '@temporary-name/contract';
-import { d as deserialize, s as serialize, a as standardizeHTTPPath } from './server.BEHw7Eyx.mjs';
-import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@temporary-name/server';
-import { createRouter, addRoute, findRoute } from 'rou3';
-
-class StandardOpenAPICodec {
-  constructor() {
-  }
-  async decode(request, params, procedure) {
-    const inputStructure = fallbackContractConfig(
-      "defaultInputStructure",
-      procedure["~orpc"].route.inputStructure
-    );
-    if (inputStructure === "compact") {
-      const data = request.method === "GET" ? deserialize(request.url.searchParams) : deserialize(await request.body());
-      if (data === void 0) {
-        return params;
-      }
-      if (isObject(data)) {
-        return {
-          ...params,
-          ...data
-        };
-      }
-      return data;
-    }
-    const deserializeSearchParams = () => {
-      return deserialize(request.url.searchParams);
-    };
-    return {
-      params,
-      get query() {
-        const value = deserializeSearchParams();
-        Object.defineProperty(this, "query", { value, writable: true });
-        return value;
-      },
-      set query(value) {
-        Object.defineProperty(this, "query", { value, writable: true });
-      },
-      headers: request.headers,
-      body: deserialize(await request.body())
-    };
-  }
-  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 (!this.#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)
-    };
-  }
-  encodeError(error) {
-    return {
-      status: error.status,
-      headers: {},
-      body: serialize(error.toJSON(), { outputFormat: "plain" })
-    };
-  }
-  #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) => {
-      if (!value(true, traverseOptions)) {
-        return;
-      }
-      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;
-  codec;
-  constructor(router, options) {
-    this.matcher = new StandardOpenAPIMatcher();
-    this.codec = new StandardOpenAPICodec();
-    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";
-              let input = await runWithSpan(
-                { name: "decode_input" },
-                () => this.codec.decode(request2, match.params, match.procedure)
-              );
-              step = void 0;
-              if (isAsyncIteratorObject(input)) {
-                input = asyncIteratorWithSpan(
-                  { name: "consume_event_iterator_input", signal: request2.signal },
-                  input
-                );
-              }
-              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 = this.codec.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 = this.codec.encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
-      });
-    });
-  }
-}
-
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S, StandardOpenAPICodec as a, StandardOpenAPIMatcher as b, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };

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

@@ -1,57 +0,0 @@
-import { Meta } from '@temporary-name/contract';
-import { HTTPPath, Interceptor } from '@temporary-name/shared';
-import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
-import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.Bzrdopnd.js';
-
-interface StandardHandlerPlugin<T extends Context> {
-    order?: number;
-    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
-}
-declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
-    protected readonly plugins: TPlugin[];
-    constructor(plugins?: readonly TPlugin[]);
-    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
-}
-
-interface StandardHandleOptions<T extends Context> {
-    prefix?: HTTPPath;
-    context: T;
-}
-type StandardHandleResult = {
-    matched: true;
-    response: StandardResponse;
-} | {
-    matched: false;
-    response: undefined;
-};
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
-    request: StandardLazyRequest;
-}
-interface StandardHandlerOptions<TContext extends Context> {
-    plugins?: StandardHandlerPlugin<TContext>[];
-    /**
-     * Interceptors at the request level, helpful when you want catch errors
-     */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
-    /**
-     * Interceptors at the root level, helpful when you want override the request/response
-     */
-    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
-    /**
-     *
-     * Interceptors for procedure client.
-     */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
-}
-declare class StandardHandler<T extends Context> {
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    private readonly rootInterceptors;
-    private readonly matcher;
-    private readonly codec;
-    constructor(router: Router<any, T>, options: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
-}
-
-export { CompositeStandardHandlerPlugin as C, StandardHandler as e };
-export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };

package/dist/shared/server.BEHw7Eyx.mjs

@@ -1,247 +0,0 @@
-import { isObject, NullProtoObj, isAsyncIteratorObject, isORPCErrorJson, createORPCErrorFromJson, toORPCError } from '@temporary-name/shared';
-import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
-
-function bracketNotationSerialize(data, segments = [], result = []) {
-  if (Array.isArray(data)) {
-    data.forEach((item, i) => {
-      bracketNotationSerialize(item, [...segments, i], result);
-    });
-  } else if (isObject(data)) {
-    for (const key in data) {
-      bracketNotationSerialize(data[key], [...segments, key], result);
-    }
-  } else {
-    result.push([stringifyPath(segments), data]);
-  }
-  return result;
-}
-function bracketNotationDeserialize(serialized, { maxArrayIndex = 9999 } = {}) {
-  if (serialized.length === 0) {
-    return {};
-  }
-  const arrayPushStyles = /* @__PURE__ */ new WeakSet();
-  const ref = { value: [] };
-  for (const [path, value] of serialized) {
-    const segments = parsePath(path);
-    let currentRef = ref;
-    let nextSegment = "value";
-    segments.forEach((segment, i) => {
-      if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
-        currentRef[nextSegment] = [];
-      }
-      if (i !== segments.length - 1) {
-        if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, maxArrayIndex)) {
-          if (arrayPushStyles.has(currentRef[nextSegment])) {
-            arrayPushStyles.delete(currentRef[nextSegment]);
-            currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
-          } else {
-            currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
-          }
-        }
-      } else {
-        if (Array.isArray(currentRef[nextSegment])) {
-          if (segment === "") {
-            if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
-              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
-            }
-          } else {
-            if (arrayPushStyles.has(currentRef[nextSegment])) {
-              arrayPushStyles.delete(currentRef[nextSegment]);
-              currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
-            } else if (!isValidArrayIndex(segment, maxArrayIndex)) {
-              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
-            }
-          }
-        }
-      }
-      currentRef = currentRef[nextSegment];
-      nextSegment = segment;
-    });
-    if (Array.isArray(currentRef) && nextSegment === "") {
-      arrayPushStyles.add(currentRef);
-      currentRef.push(value);
-    } else if (nextSegment in currentRef) {
-      if (Array.isArray(currentRef[nextSegment])) {
-        currentRef[nextSegment].push(value);
-      } else {
-        currentRef[nextSegment] = [currentRef[nextSegment], value];
-      }
-    } else {
-      currentRef[nextSegment] = value;
-    }
-  }
-  return ref.value;
-}
-function stringifyPath(segments) {
-  return segments.map((segment) => {
-    return segment.toString().replace(/[\\[\]]/g, (match) => {
-      switch (match) {
-        case "\\":
-          return "\\\\";
-        case "[":
-          return "\\[";
-        case "]":
-          return "\\]";
-        /* v8 ignore next 2 */
-        default:
-          return match;
-      }
-    });
-  }).reduce((result, segment, i) => {
-    if (i === 0) {
-      return segment;
-    }
-    return `${result}[${segment}]`;
-  }, "");
-}
-function parsePath(path) {
-  const segments = [];
-  let inBrackets = false;
-  let currentSegment = "";
-  let backslashCount = 0;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    const nextChar = path[i + 1];
-    if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
-      if (nextChar === void 0) {
-        inBrackets = false;
-      }
-      segments.push(currentSegment);
-      currentSegment = "";
-      i++;
-    } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
-      inBrackets = true;
-      segments.push(currentSegment);
-      currentSegment = "";
-    } else if (char === "\\") {
-      backslashCount++;
-    } else {
-      currentSegment += "\\".repeat(backslashCount / 2) + char;
-      backslashCount = 0;
-    }
-  }
-  return inBrackets || segments.length === 0 ? [path] : segments;
-}
-function isValidArrayIndex(value, maxIndex) {
-  return /^0$|^[1-9]\d*$/.test(value) && Number(value) <= maxIndex;
-}
-function arrayToObject(array) {
-  const obj = new NullProtoObj();
-  array.forEach((item, i) => {
-    obj[i] = item;
-  });
-  return obj;
-}
-function pushStyleArrayToObject(array) {
-  const obj = new NullProtoObj();
-  obj[""] = array.length === 1 ? array[0] : array;
-  return obj;
-}
-
-function jsonSerialize(data, hasBlobRef = { value: false }) {
-  if (data instanceof Blob) {
-    hasBlobRef.value = true;
-    return [data, hasBlobRef.value];
-  }
-  if (data instanceof Set) {
-    return jsonSerialize(Array.from(data), hasBlobRef);
-  }
-  if (data instanceof Map) {
-    return jsonSerialize(Array.from(data.entries()), hasBlobRef);
-  }
-  if (Array.isArray(data)) {
-    const json = data.map((v) => v === void 0 ? null : jsonSerialize(v, hasBlobRef)[0]);
-    return [json, hasBlobRef.value];
-  }
-  if (isObject(data)) {
-    const json = {};
-    for (const k in data) {
-      if (k === "toJSON" && typeof data[k] === "function") {
-        continue;
-      }
-      json[k] = jsonSerialize(data[k], hasBlobRef)[0];
-    }
-    return [json, hasBlobRef.value];
-  }
-  if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
-    return [data.toString(), hasBlobRef.value];
-  }
-  if (data instanceof Date) {
-    return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
-  }
-  if (Number.isNaN(data)) {
-    return [null, hasBlobRef.value];
-  }
-  return [data, hasBlobRef.value];
-}
-
-function serialize(data, options = {}) {
-  if (isAsyncIteratorObject(data) && !options.outputFormat) {
-    return mapEventIterator(data, {
-      value: async (value) => _serialize(value, { outputFormat: "plain" }),
-      error: async (e) => {
-        return new ErrorEvent({
-          data: _serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
-          cause: e
-        });
-      }
-    });
-  }
-  return _serialize(data, options);
-}
-function _serialize(data, options) {
-  const [json, hasBlob] = jsonSerialize(data);
-  if (options.outputFormat === "plain") {
-    return json;
-  }
-  if (options.outputFormat === "URLSearchParams") {
-    const params = new URLSearchParams();
-    for (const [path, value] of bracketNotationSerialize(json)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        params.append(path, value.toString());
-      }
-    }
-    return params;
-  }
-  if (json instanceof Blob || json === void 0 || !hasBlob) {
-    return json;
-  }
-  const form = new FormData();
-  for (const [path, value] of bracketNotationSerialize(json)) {
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      form.append(path, value.toString());
-    } else if (value instanceof Blob) {
-      form.append(path, value);
-    }
-  }
-  return form;
-}
-function deserialize(data) {
-  if (data instanceof URLSearchParams || data instanceof FormData) {
-    return bracketNotationDeserialize(Array.from(data.entries()));
-  }
-  if (isAsyncIteratorObject(data)) {
-    return mapEventIterator(data, {
-      value: async (value) => value,
-      error: async (e) => {
-        if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
-          return createORPCErrorFromJson(e.data, { cause: e });
-        }
-        return e;
-      }
-    });
-  }
-  return data;
-}
-
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function getDynamicParams(path) {
-  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
-    raw: v,
-    name: v.match(/\{\+?([^}]+)\}/)[1]
-  })) : void 0;
-}
-
-export { standardizeHTTPPath as a, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };