@orpc/server 1.14.6 → 2.0.0-beta.1

package/dist/shared/server.BwHnWUuN.mjs

@@ -0,0 +1,222 @@
+import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.CrlKQucM.mjs';
+import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
+import { getOrBind, isTypescriptObject } from '@orpc/shared';
+
+const DEFAULT_SUCCESS_STATUS = 200;
+const DEFAULT_ERROR_STATUS = 500;
+
+function createGuardedProcedureLazy(lazy) {
+  const guarded = new Lazy({
+    ...lazy["~orpc"],
+    async loader() {
+      const { default: maybeProcedure } = await unlazy(lazy);
+      if (!(maybeProcedure instanceof Procedure)) {
+        throw new TypeError(`
+          Expected a lazy<procedure> but got lazy<unknown>.
+          This should be caught by TypeScript compilation.
+          Please report this issue if you think this is a bug.
+        `);
+      }
+      return { default: maybeProcedure };
+    }
+  });
+  return guarded;
+}
+function createContractProcedure(procedure, contract) {
+  return new Procedure({
+    ...procedure["~orpc"],
+    errorMap: contract["~orpc"].errorMap,
+    meta: contract["~orpc"].meta,
+    metaPlugins: contract["~orpc"].metaPlugins
+  });
+}
+function call(lazyableProcedure, ...[
+  input = void 0,
+  options = {}
+]) {
+  return createProcedureClient(lazyableProcedure, options)(input, options);
+}
+
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol.for("ORPC_HIDDEN_ROUTER_CONTRACT");
+function withHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
+    get(target, key) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+        return contract;
+      }
+      return getOrBind(target, key);
+    }
+  });
+}
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}
+
+function augmentRouter(router, options) {
+  if (router instanceof Lazy) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      options.meta,
+      options.metaPlugins,
+      router["~orpc"].metaPlugins
+    );
+    const enhanced2 = new Lazy({
+      meta,
+      metaPlugins,
+      async loader() {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = augmentRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      }
+    });
+    return enhanced2;
+  }
+  if (router instanceof Procedure) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      options.meta,
+      options.metaPlugins,
+      router["~orpc"].metaPlugins
+    );
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      meta,
+      metaPlugins,
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      orderedMiddlewares: [
+        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
+        ...router["~orpc"].orderedMiddlewares
+      ]
+    });
+    return enhanced2;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = augmentRouter(router[key], options);
+  }
+  return enhanced;
+}
+function augmentImplementedRouter(router, options) {
+  if (router instanceof Lazy) {
+    const enhanced2 = new Lazy({
+      ...router["~orpc"],
+      async loader() {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = augmentImplementedRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      }
+    });
+    return enhanced2;
+  }
+  if (router instanceof Procedure) {
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      orderedMiddlewares: [
+        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
+        ...router["~orpc"].orderedMiddlewares
+      ]
+    });
+    return enhanced2;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = augmentImplementedRouter(router[key], options);
+  }
+  return enhanced;
+}
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!isTypescriptObject(current)) {
+      return void 0;
+    }
+    if (current instanceof Procedure) {
+      return void 0;
+    }
+    if (!(current instanceof Lazy)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return new Lazy({
+      ...lazied["~orpc"],
+      async loader() {
+        const unwrapped = await unlazy(lazied);
+        const next = getRouter(unwrapped.default, rest);
+        return await unlazy(next);
+      }
+    });
+  }
+  if (!isTypescriptObject(current)) {
+    return void 0;
+  }
+  return current;
+}
+function walkProcedureContractsSync(router, callback, path = []) {
+  const hiddenContract = getHiddenRouterContract(router);
+  if (hiddenContract !== void 0) {
+    router = hiddenContract;
+  }
+  if (router instanceof ProcedureContract) {
+    callback(router, path);
+    return [];
+  }
+  if (!isTypescriptObject(router)) {
+    return [];
+  }
+  const lazyResults = [];
+  for (const key in router) {
+    const value = router[key];
+    if (value instanceof Lazy) {
+      lazyResults.push({ router: value, path: [...path, key] });
+    } else {
+      lazyResults.push(...walkProcedureContractsSync(value, callback, [...path, key]));
+    }
+  }
+  return lazyResults;
+}
+async function walkProcedureContractsAsync(router, callback, path = []) {
+  const hiddenContract = getHiddenRouterContract(router);
+  if (hiddenContract !== void 0) {
+    router = hiddenContract;
+  }
+  if (router instanceof ProcedureContract) {
+    await callback(router, path);
+    return;
+  }
+  if (!isTypescriptObject(router)) {
+    return;
+  }
+  for (const key in router) {
+    const value = router[key];
+    if (value instanceof Lazy) {
+      const { default: router2 } = await unlazy(value);
+      await walkProcedureContractsAsync(router2, callback, [...path, key]);
+    } else {
+      await walkProcedureContractsAsync(value, callback, [...path, key]);
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (router instanceof Procedure) {
+    return router;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+export { DEFAULT_SUCCESS_STATUS as D, DEFAULT_ERROR_STATUS as a, augmentRouter as b, createContractProcedure as c, augmentImplementedRouter as d, withHiddenRouterContract as e, createGuardedProcedureLazy as f, getRouter as g, call as h, getHiddenRouterContract as i, walkProcedureContractsAsync as j, unlazyRouter as u, walkProcedureContractsSync as w };

package/dist/shared/server.CX4vUnDk.mjs

@@ -0,0 +1,11 @@
+import { value } from '@orpc/shared';
+
+function createStandardPeerRequestHandler(handler, options) {
+  return async (request) => {
+    const context = await value(options.context ?? {}, request);
+    const { response } = await handler.handle(request, { ...options, context });
+    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
+  };
+}
+
+export { createStandardPeerRequestHandler as c };

package/dist/shared/server.CjOb6ItT.mjs

@@ -0,0 +1,41 @@
+import { resolveMetaPlugins, mergeErrorMap, getHiddenMetaPlugins } from '@orpc/contract';
+import { P as Procedure } from './server.CrlKQucM.mjs';
+
+class DecoratedProcedure extends Procedure {
+  meta(...plugins) {
+    const [meta, metaPlugins] = resolveMetaPlugins(this["~orpc"].meta, this["~orpc"].metaPlugins, plugins);
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      meta,
+      metaPlugins
+    });
+  }
+  errors(errors) {
+    let procedure = new DecoratedProcedure({
+      ...this["~orpc"],
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+    });
+    const plugins = getHiddenMetaPlugins(errors);
+    if (plugins) {
+      procedure = procedure.meta(...plugins);
+    }
+    return procedure;
+  }
+  use(middleware) {
+    let procedure = new DecoratedProcedure({
+      ...this["~orpc"],
+      errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap, this["~orpc"].errorMap),
+      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+        middleware,
+        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+      }]
+    });
+    if (middleware["~orpc"]?.metaPlugins) {
+      procedure = procedure.meta(...middleware["~orpc"]?.metaPlugins);
+    }
+    return procedure;
+  }
+}
+
+export { DecoratedProcedure as D };

package/dist/shared/server.CrlKQucM.mjs

@@ -0,0 +1,233 @@
+import { ORPCError, wrapEventIteratorPreservingMeta, cloneORPCError } from '@orpc/client';
+import { reconcileORPCError, ValidationError, ProcedureContract } from '@orpc/contract';
+import { getOrBind, resolveMaybeOptionalOptions, getConstructor, isTypescriptObject, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream } from '@orpc/shared';
+
+function createORPCErrorConstructorMap(errorMap) {
+  const proxy = new Proxy(errorMap, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return getOrBind(target, code);
+      }
+      const item = (...rest) => {
+        const options = resolveMaybeOptionalOptions(rest);
+        const config = errorMap[code];
+        const error = new ORPCError(code, {
+          message: options.message ?? config?.message,
+          data: options.data,
+          cause: options.cause
+        });
+        if (config) {
+          error.defined = true;
+          error.inferable = true;
+        }
+        return error;
+      };
+      return item;
+    }
+  });
+  return proxy;
+}
+
+class Lazy {
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  /**
+   * Checks if the given instance satisfies the {@see Lazy} class/interface.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (this !== Lazy) {
+      return Function.prototype[Symbol.hasInstance].call(this, instance);
+    }
+    const constructor = getConstructor(instance);
+    if (constructor === Lazy) {
+      return true;
+    }
+    return isTypescriptObject(instance) && isTypescriptObject(instance["~orpc"]) && isTypescriptObject(instance["~orpc"].meta) && (instance["~orpc"].metaPlugins === void 0 || Array.isArray(instance["~orpc"].metaPlugins)) && typeof instance["~orpc"].loader === "function";
+  }
+}
+function unlazy(maybeLazy) {
+  return maybeLazy instanceof Lazy ? maybeLazy["~orpc"].loader() : Promise.resolve({ default: maybeLazy });
+}
+
+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 reconcileError = async (e) => {
+      if (e instanceof ORPCError) {
+        return await reconcileORPCError(procedure["~orpc"].errorMap, e);
+      }
+      return e;
+    };
+    try {
+      const output = await runWithSpan("call_procedure", (span) => {
+        span?.setAttribute("procedure.path", path);
+        return intercept(
+          options.interceptors,
+          {
+            context,
+            // input can be optional if it is undefinable
+            input,
+            errors,
+            path,
+            procedure,
+            signal: callerOptions?.signal,
+            lastEventId: callerOptions?.lastEventId
+          },
+          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+        );
+      });
+      if (isAsyncIteratorObject(output)) {
+        return override(output, wrapEventIteratorPreservingMeta(
+          traceAsyncIterator("consume_event_iterator_output", output),
+          { mapError: reconcileError }
+        ));
+      }
+      if (output instanceof ReadableStream) {
+        return override(output, traceReadableStream("consume_octet_stream_output", output));
+      }
+      return output;
+    } catch (e) {
+      throw await reconcileError(e);
+    }
+  };
+}
+async function validateInput(i, schema, input) {
+  return runWithSpan(`validate_input.${i}`, async (span) => {
+    span?.setAttribute("input_schema.index", i);
+    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,
+          invalidData: input
+        })
+      });
+    }
+    return result.value;
+  });
+}
+async function validateOutput(i, schema, output) {
+  return runWithSpan(`validate_output.${i}`, async (span) => {
+    span?.setAttribute("output_schema.index", i);
+    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,
+          invalidData: output
+        })
+      });
+    }
+    return result.value;
+  });
+}
+const middlewareDone = (...rest) => {
+  const options = resolveMaybeOptionalOptions(rest);
+  return {
+    output: options.output,
+    // context can be undefined when all field is optional
+    context: options.context ?? {}
+  };
+};
+async function executeProcedureInternal(procedure, options) {
+  const inputSchemas = toArray(procedure["~orpc"].inputSchemas);
+  const outputSchemas = toArray(procedure["~orpc"].outputSchemas);
+  const orderedMiddlewares = procedure["~orpc"].orderedMiddlewares;
+  const next = async (midIndex, context, input) => {
+    let currentInput = input;
+    const startInputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].inputSchemasLengthAtUse ?? 0;
+    const endInputIndex = midIndex === orderedMiddlewares.length ? inputSchemas.length : orderedMiddlewares[midIndex].inputSchemasLengthAtUse ?? 0;
+    for (let i = startInputIndex; i < endInputIndex; i++) {
+      currentInput = await validateInput(i, inputSchemas[i], currentInput);
+    }
+    let currentOutput;
+    let currentContext = context;
+    if (midIndex < orderedMiddlewares.length) {
+      const { middleware } = orderedMiddlewares[midIndex];
+      const result = await runWithSpan(`middleware.${middleware.name}`, async (span) => {
+        span?.setAttribute("middleware.index", midIndex);
+        return await middleware(
+          {
+            ...options,
+            context,
+            next: (...rest) => {
+              const nextOptions = resolveMaybeOptionalOptions(rest);
+              const nextContext = nextOptions.context ?? {};
+              return next(
+                midIndex + 1,
+                { ...context, ...nextContext },
+                currentInput
+              );
+            },
+            lastEventId: options.lastEventId
+          },
+          currentInput,
+          middlewareDone
+        );
+      });
+      currentOutput = result.output;
+      currentContext = { ...context, ...result.context };
+    } else {
+      currentOutput = await runWithSpan(
+        "handler",
+        () => procedure["~orpc"].handler({ ...options, context, input: currentInput }, currentInput)
+      );
+      if (currentOutput instanceof ORPCError) {
+        if (procedure["~orpc"].opaqueReturnedErrors) {
+          throw currentOutput;
+        }
+        if (currentOutput.inferable && !currentOutput.defined) {
+          throw currentOutput;
+        }
+        const error = cloneORPCError(currentOutput);
+        error.defined = false;
+        error.inferable = true;
+        throw error;
+      }
+    }
+    const startOutputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].outputSchemasLengthAtUse ?? 0;
+    const endOutputIndex = midIndex === orderedMiddlewares.length ? outputSchemas.length : orderedMiddlewares[midIndex].outputSchemasLengthAtUse ?? 0;
+    for (let i = endOutputIndex - 1; i >= startOutputIndex; i--) {
+      currentOutput = await validateOutput(i, outputSchemas[i], currentOutput);
+    }
+    return { output: currentOutput, context: currentContext };
+  };
+  const { output } = await next(0, options.context, options.input);
+  return output;
+}
+
+class Procedure {
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  /**
+   * Checks if the given instance satisfies the {@see Procedure} class/interface.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (this !== Procedure) {
+      return Function.prototype[Symbol.hasInstance].call(this, instance);
+    }
+    const constructor = getConstructor(instance);
+    if (constructor === Procedure) {
+      return true;
+    }
+    return instance instanceof ProcedureContract && Array.isArray(instance["~orpc"].orderedMiddlewares) && typeof instance["~orpc"].handler === "function";
+  }
+}
+
+export { Lazy as L, Procedure as P, createORPCErrorConstructorMap as a, createProcedureClient as c, unlazy as u };

package/dist/shared/server.D_QauotT.mjs

@@ -0,0 +1,30 @@
+import { ORPCError } from '@orpc/client';
+import { toArray } from '@orpc/shared';
+import { flattenStandardHeader } from '@standardserver/core';
+
+class CSRFGuardHandlerPlugin {
+  name = "~csrf-guard";
+  init(options) {
+    const interceptor = async (interceptorOptions) => {
+      const mode = flattenStandardHeader(
+        interceptorOptions.request.headers["sec-fetch-mode"]
+      )?.toLowerCase();
+      if (mode === void 0) {
+        return interceptorOptions.next();
+      }
+      if (mode === "cors" || mode === "same-origin") {
+        return interceptorOptions.next();
+      }
+      throw new ORPCError("FORBIDDEN", {
+        message: "Request blocked by CSRF protection."
+      });
+    };
+    return {
+      ...options,
+      // appended last so user's interceptors can catch ORPCError
+      interceptors: [...toArray(options.interceptors), interceptor]
+    };
+  }
+}
+
+export { CSRFGuardHandlerPlugin as C };

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

@@ -0,0 +1,104 @@
+import { AnyORPCError } from '@orpc/client';
+import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BL22TloH.js';
+import { Schema, ErrorMap } from '@orpc/contract';
+
+interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
+    /**
+     * Initializes the plugin and returns new handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform handler options
+     * such as interceptors, or configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * init(options) {
+     *   return {
+     *     ...options,
+     *     interceptors: [...(options.interceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    init?(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    readonly name = "~composite";
+    protected readonly plugins: StandardHandlerPlugin<T>[];
+    constructor(plugins?: StandardHandlerPlugin<T>[]);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
+interface StandardHandlerHandleOptions<T extends Context> {
+    prefix?: `/${string}` | undefined;
+    context: T;
+}
+type StandardHandlerHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response?: undefined;
+};
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
+interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
+interface StandardHandlerOptions<TContext extends Context> {
+    /**
+     * Fired on every request before routing, useful when you want
+     * to intercept all requests regardless of whether they match a procedure or not.
+     *
+     * @examples
+     * - batch plugins - separate one request into multiple and call multiple next
+     * - openapi spec plugin - to intercept a request and early response
+     */
+    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[];
+    /**
+     * interceptor run after routing and before error handler,
+     * useful for error handling, logging, metrics, etc.
+     */
+    interceptors?: StandardHandlerInterceptor<TContext>[];
+    /**
+     *
+     * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
+     * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
+     */
+    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap, any>[];
+    plugins?: StandardHandlerPlugin<TContext>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly codec;
+    private readonly routingInterceptors;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
+    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+}
+declare class OtelHandlerPlugin implements StandardHandlerPlugin<any> {
+    name: string;
+    init(options: StandardHandlerOptions<any>): StandardHandlerOptions<any>;
+}
+
+interface StandardHandlerCodecResolvedProcedure {
+    path: string[];
+    procedure: AnyProcedure;
+    decodeInput: () => Promise<unknown>;
+}
+interface StandardHandlerCodec<T extends Context> {
+    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}
+
+export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
+export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerHandleResult as g, StandardHandlerInterceptor as h, StandardHandlerInterceptorOptions as i, StandardHandlerRoutingInterceptor as j };