@temporary-name/server 1.9.3-alpha.6ef4729e23affbe6454d37025d1dfc4d998b0649 → 1.9.3-alpha.72daecd600ae901064d3c4f8ab780582c1335ffe

package/dist/plugins/index.mjs

@@ -1,288 +0,0 @@
-import { runWithSpan, value, setSpanError, isAsyncIteratorObject, AsyncIteratorClass, clone, ORPCError } from '@temporary-name/shared';
-import { flattenHeader } from '@temporary-name/standard-server';
-import { parseBatchRequest, toBatchResponse } from '@temporary-name/standard-server/batch';
-import { toFetchHeaders } from '@temporary-name/standard-server-fetch';
-
-class BatchHandlerPlugin {
-  maxSize;
-  mapRequestItem;
-  successStatus;
-  headers;
-  order = 5e6;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 10;
-    this.mapRequestItem = options.mapRequestItem ?? ((request, { request: batchRequest }) => ({
-      ...request,
-      headers: {
-        ...batchRequest.headers,
-        ...request.headers
-      }
-    }));
-    this.successStatus = options.successStatus ?? 207;
-    this.headers = options.headers ?? {};
-  }
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.unshift(async (options2) => {
-      const xHeader = flattenHeader(options2.request.headers["x-orpc-batch"]);
-      if (xHeader === void 0) {
-        return options2.next();
-      }
-      let isParsing = false;
-      try {
-        return await runWithSpan({ name: "handle_batch_request" }, async (span) => {
-          const mode = xHeader === "buffered" ? "buffered" : "streaming";
-          isParsing = true;
-          const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
-          isParsing = false;
-          span?.setAttribute("batch.mode", mode);
-          span?.setAttribute("batch.size", parsed.length);
-          const maxSize = await value(this.maxSize, options2);
-          if (parsed.length > maxSize) {
-            const message = "Batch request size exceeds the maximum allowed size";
-            setSpanError(span, message);
-            return {
-              matched: true,
-              response: {
-                status: 413,
-                headers: {},
-                body: message
-              }
-            };
-          }
-          const responses = parsed.map((request, index) => {
-            const mapped = this.mapRequestItem(request, options2);
-            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
-              span?.addEvent(`response.${index}.${matched ? "success" : "not_matched"}`);
-              if (matched) {
-                if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
-                  return {
-                    index,
-                    status: 500,
-                    headers: {},
-                    body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
-                  };
-                }
-                return { ...response2, index };
-              }
-              return { index, status: 404, headers: {}, body: "No procedure matched" };
-            }).catch((err) => {
-              Promise.reject(err);
-              return { index, status: 500, headers: {}, body: "Internal server error" };
-            });
-          });
-          await Promise.race(responses);
-          const status = await value(this.successStatus, responses, options2);
-          const headers = await value(this.headers, responses, options2);
-          const promises = [...responses];
-          const response = await toBatchResponse({
-            status,
-            headers,
-            mode,
-            body: new AsyncIteratorClass(
-              async () => {
-                const handling = promises.filter((p) => p !== void 0);
-                if (handling.length <= 0) {
-                  return { done: true, value: void 0 };
-                }
-                const value2 = await Promise.race(handling);
-                promises[value2.index] = void 0;
-                return { done: false, value: value2 };
-              },
-              async () => {
-              }
-            )
-          });
-          return {
-            matched: true,
-            response
-          };
-        });
-      } catch (cause) {
-        if (isParsing) {
-          return {
-            matched: true,
-            response: {
-              status: 400,
-              headers: {},
-              body: "Invalid batch request, this could be caused by a malformed request body or a missing header"
-            }
-          };
-        }
-        throw cause;
-      }
-    });
-  }
-}
-
-class CORSPlugin {
-  options;
-  order = 9e6;
-  constructor(options = {}) {
-    const defaults = {
-      origin: (origin) => origin,
-      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
-    };
-    this.options = {
-      ...defaults,
-      ...options
-    };
-  }
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.unshift(async (interceptorOptions) => {
-      if (interceptorOptions.request.method === "OPTIONS") {
-        const resHeaders = {};
-        if (this.options.maxAge !== void 0) {
-          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
-        }
-        if (this.options.allowMethods?.length) {
-          resHeaders["access-control-allow-methods"] = flattenHeader(this.options.allowMethods);
-        }
-        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
-        if (typeof allowHeaders === "string" || allowHeaders?.length) {
-          resHeaders["access-control-allow-headers"] = flattenHeader(allowHeaders);
-        }
-        return {
-          matched: true,
-          response: {
-            status: 204,
-            headers: resHeaders,
-            body: void 0
-          }
-        };
-      }
-      return interceptorOptions.next();
-    });
-    options.rootInterceptors.unshift(async (interceptorOptions) => {
-      const result = await interceptorOptions.next();
-      if (!result.matched) {
-        return result;
-      }
-      const origin = flattenHeader(interceptorOptions.request.headers.origin) ?? "";
-      const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
-      const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
-      if (allowedOriginArr.includes("*")) {
-        result.response.headers["access-control-allow-origin"] = "*";
-      } else {
-        if (allowedOriginArr.includes(origin)) {
-          result.response.headers["access-control-allow-origin"] = origin;
-        }
-        result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
-      }
-      const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
-      const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
-      if (allowedTimingOriginArr.includes("*")) {
-        result.response.headers["timing-allow-origin"] = "*";
-      } else if (allowedTimingOriginArr.includes(origin)) {
-        result.response.headers["timing-allow-origin"] = origin;
-      }
-      if (this.options.credentials) {
-        result.response.headers["access-control-allow-credentials"] = "true";
-      }
-      if (this.options.exposeHeaders?.length) {
-        result.response.headers["access-control-expose-headers"] = flattenHeader(this.options.exposeHeaders);
-      }
-      return result;
-    });
-  }
-}
-
-class RequestHeadersPlugin {
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.push((interceptorOptions) => {
-      const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
-      return interceptorOptions.next({
-        ...interceptorOptions,
-        context: {
-          ...interceptorOptions.context,
-          reqHeaders
-        }
-      });
-    });
-  }
-}
-
-class ResponseHeadersPlugin {
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.push(async (interceptorOptions) => {
-      const resHeaders = interceptorOptions.context.resHeaders ?? new Headers();
-      const result = await interceptorOptions.next({
-        ...interceptorOptions,
-        context: {
-          ...interceptorOptions.context,
-          resHeaders
-        }
-      });
-      if (!result.matched) {
-        return result;
-      }
-      const responseHeaders = clone(result.response.headers);
-      for (const [key, value] of resHeaders) {
-        if (Array.isArray(responseHeaders[key])) {
-          responseHeaders[key].push(value);
-        } else if (responseHeaders[key] !== void 0) {
-          responseHeaders[key] = [responseHeaders[key], value];
-        } else {
-          responseHeaders[key] = value;
-        }
-      }
-      return {
-        ...result,
-        response: {
-          ...result.response,
-          headers: responseHeaders
-        }
-      };
-    });
-  }
-}
-
-const SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL = Symbol("SIMPLE_CSRF_PROTECTION_CONTEXT");
-class SimpleCsrfProtectionHandlerPlugin {
-  headerName;
-  headerValue;
-  exclude;
-  error;
-  constructor(options = {}) {
-    this.headerName = options.headerName ?? "x-csrf-token";
-    this.headerValue = options.headerValue ?? "orpc";
-    this.exclude = options.exclude ?? false;
-    this.error = options.error ?? new ORPCError("CSRF_TOKEN_MISMATCH", {
-      status: 403,
-      message: "Invalid CSRF token"
-    });
-  }
-  order = 8e6;
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.clientInterceptors ??= [];
-    options.rootInterceptors.unshift(async (options2) => {
-      const headerName = await value(this.headerName, options2);
-      const headerValue = await value(this.headerValue, options2);
-      return options2.next({
-        ...options2,
-        context: {
-          ...options2.context,
-          [SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL]: options2.request.headers[headerName] === headerValue
-        }
-      });
-    });
-    options.clientInterceptors.unshift(async (options2) => {
-      if (typeof options2.context[SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL] !== "boolean") {
-        throw new TypeError(
-          "[SimpleCsrfProtectionHandlerPlugin] CSRF protection context has been corrupted or modified by another plugin or interceptor"
-        );
-      }
-      const excluded = await value(this.exclude, options2);
-      if (!excluded && !options2.context[SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL]) {
-        throw this.error;
-      }
-      return options2.next();
-    });
-  }
-}
-
-export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };

package/dist/shared/server.BEQrAa3A.mjs

@@ -1,207 +0,0 @@
-import { validateORPCError, ValidationError } from '@temporary-name/contract';
-import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
-import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { g as gatingContext, w as withoutGatedFields } from './server.D6K9uoPI.mjs';
-
-const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
-function lazy(loader, meta = {}) {
-  return {
-    [LAZY_SYMBOL]: {
-      loader,
-      meta
-    }
-  };
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
-}
-function getLazyMeta(lazied) {
-  return lazied[LAZY_SYMBOL].meta;
-}
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
-}
-
-function mergeCurrentContext(context, other) {
-  return { ...context, ...other };
-}
-
-function createORPCErrorConstructorMap(errors) {
-  const proxy = new Proxy(errors, {
-    get(target, code) {
-      if (typeof code !== "string") {
-        return Reflect.get(target, code);
-      }
-      const item = (...rest) => {
-        const options = resolveMaybeOptionalOptions(rest);
-        const config = errors[code];
-        return new ORPCError(code, {
-          defined: Boolean(config),
-          status: config?.status,
-          message: options.message ?? config?.message,
-          data: options.data,
-          cause: options.cause
-        });
-      };
-      return item;
-    }
-  });
-  return proxy;
-}
-
-function middlewareOutputFn(output) {
-  return { output, context: {} };
-}
-
-function createProcedureClient(lazyableProcedure, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  return async (...[input, callerOptions]) => {
-    const path = toArray(options.path);
-    const { default: procedure } = await unlazy(lazyableProcedure);
-    const clientContext = callerOptions?.context ?? {};
-    const context = await value(options.context ?? {}, clientContext);
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const validateError = async (e) => {
-      if (e instanceof ORPCError) {
-        return await validateORPCError(procedure["~orpc"].errorMap, e);
-      }
-      return e;
-    };
-    try {
-      const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
-        span?.setAttribute("procedure.path", [...path]);
-        return intercept(
-          toArray(options.interceptors),
-          {
-            context,
-            input,
-            // input only optional when it undefinable so we can safely cast it
-            errors,
-            path,
-            procedure,
-            signal: callerOptions?.signal,
-            lastEventId: callerOptions?.lastEventId
-          },
-          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
-        );
-      });
-      if (isAsyncIteratorObject(output)) {
-        if (output instanceof HibernationEventIterator) {
-          return output;
-        }
-        return overlayProxy(
-          output,
-          mapEventIterator(
-            asyncIteratorWithSpan(
-              { name: "consume_event_iterator_output", signal: callerOptions?.signal },
-              output
-            ),
-            {
-              value: (v) => v,
-              error: (e) => validateError(e)
-            }
-          )
-        );
-      }
-      return output;
-    } catch (e) {
-      throw await validateError(e);
-    }
-  };
-}
-async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].inputSchema;
-  if (!schema) {
-    return input;
-  }
-  return runWithSpan({ name: "validate_input" }, async () => {
-    const result = await schema["~standard"].validate(input);
-    if (result.issues) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Input validation failed",
-        data: {
-          issues: result.issues
-        },
-        cause: new ValidationError({
-          message: "Input validation failed",
-          issues: result.issues,
-          data: input
-        })
-      });
-    }
-    return result.value;
-  });
-}
-async function validateOutput(schema, output) {
-  return runWithSpan({ name: "validate_output" }, async () => {
-    const result = await schema["~standard"].validate(output);
-    if (result.issues) {
-      throw new ORPCError("INTERNAL_SERVER_ERROR", {
-        message: "Output validation failed",
-        cause: new ValidationError({
-          message: "Output validation failed",
-          issues: result.issues,
-          data: output
-        })
-      });
-    }
-    return result.value;
-  });
-}
-async function executeProcedureInternal(procedure, options) {
-  const middlewares = procedure["~orpc"].middlewares;
-  const inputValidationIndex = Math.min(
-    Math.max(0, procedure["~orpc"].inputValidationIndex),
-    middlewares.length
-  );
-  const outputValidationIndex = Math.min(
-    Math.max(0, procedure["~orpc"].outputValidationIndex),
-    middlewares.length
-  );
-  const next = async (index, context, input) => {
-    let currentInput = input;
-    if (index === inputValidationIndex) {
-      currentInput = await validateInput(procedure, currentInput);
-    }
-    const mid = middlewares[index];
-    const output = mid ? await runWithSpan({ name: `middleware.${mid.name}`, signal: options.signal }, async (span) => {
-      span?.setAttribute("middleware.index", index);
-      span?.setAttribute("middleware.name", mid.name);
-      const result = await mid(
-        {
-          ...options,
-          context,
-          next: async (...[nextOptions]) => {
-            const nextContext = nextOptions?.context ?? {};
-            return {
-              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
-              context: nextContext
-            };
-          }
-        },
-        currentInput,
-        middlewareOutputFn
-      );
-      return result.output;
-    }) : await runWithSpan(
-      { name: "handler", signal: options.signal },
-      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
-    );
-    if (index === outputValidationIndex) {
-      const schema = procedure["~orpc"].outputSchema;
-      if (!schema) {
-        return output;
-      }
-      const validated = await validateOutput(schema, output);
-      const isGateEnabled = gatingContext.getStore();
-      if (!validated || !isGateEnabled) {
-        return validated;
-      }
-      return withoutGatedFields(validated, schema, isGateEnabled);
-    }
-    return output;
-  };
-  return next(0, options.context, options.input);
-}
-
-export { LAZY_SYMBOL as L, createORPCErrorConstructorMap as a, middlewareOutputFn as b, createProcedureClient as c, getLazyMeta as g, isLazy as i, lazy as l, mergeCurrentContext as m, unlazy as u };

package/dist/shared/server.Bo94xDTv.d.mts

@@ -1,73 +0,0 @@
-import { Meta } from '@temporary-name/contract';
-import { HTTPPath, ORPCError, Interceptor } from '@temporary-name/shared';
-import { StandardResponse, StandardLazyRequest } from '@temporary-name/standard-server';
-import { C as Context, R as Router, A as AnyRouter, a as AnyProcedure, P as ProcedureClientInterceptorOptions } from './server.C1YnHvvf.mjs';
-
-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;
-}
-
-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>;
-}
-
-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 matcher;
-    private readonly codec;
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    private readonly rootInterceptors;
-    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
-}
-
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S };
-export type { StandardHandlerPlugin as a, StandardHandleOptions as b, StandardHandlerInterceptorOptions as c, StandardHandlerOptions as d, StandardHandleResult as e, StandardParams as f, StandardMatchResult as g, StandardMatcher as h, StandardCodec as i };

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

@@ -1,73 +0,0 @@
-import { Meta } from '@temporary-name/contract';
-import { HTTPPath, ORPCError, Interceptor } from '@temporary-name/shared';
-import { StandardResponse, StandardLazyRequest } from '@temporary-name/standard-server';
-import { C as Context, R as Router, A as AnyRouter, a as AnyProcedure, P as ProcedureClientInterceptorOptions } from './server.C1YnHvvf.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;
-}
-
-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>;
-}
-
-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 matcher;
-    private readonly codec;
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    private readonly rootInterceptors;
-    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
-}
-
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S };
-export type { StandardHandlerPlugin as a, StandardHandleOptions as b, StandardHandlerInterceptorOptions as c, StandardHandlerOptions as d, StandardHandleResult as e, StandardParams as f, StandardMatchResult as g, StandardMatcher as h, StandardCodec as i };