@temporary-name/server 1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d → 1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e

package/dist/shared/{server.DcfsPloY.mjs → server.BdGbIyq8.mjs}

@@ -1,25 +1,46 @@
-import { validateORPCError, ValidationError } from '@temporary-name/contract';
+import { isContractProcedure, mergePrefix, mergeErrorMap, enhanceRoute, 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 { safeParseAsync } from '@temporary-name/zod';
 
-const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
-function lazy(loader, meta = {}) {
-  return {
-    [LAZY_SYMBOL]: {
-      loader,
-      meta
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
     }
-  };
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
 }
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
 }
-function getLazyMeta(lazied) {
-  return lazied[LAZY_SYMBOL].meta;
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
 }
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+
+class Procedure {
+  /**
+   * This property holds the defined options.
+   */
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+function isProcedure(item) {
+  if (item instanceof Procedure) {
+    return true;
+  }
+  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
 function mergeCurrentContext(context, other) {
@@ -49,6 +70,179 @@ function createORPCErrorConstructorMap(errors) {
   return proxy;
 }
 
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
+function setHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
+    get(target, key) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+        return contract;
+      }
+      return Reflect.get(target, key);
+    }
+  });
+}
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}
+
+function getRouter(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);
+    return lazyInternal(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
+}
+function createAccessibleLazyRouter(lazied) {
+  const recursive = new Proxy(lazied, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(lazied, [key]);
+      return createAccessibleLazyRouter(next);
+    }
+  });
+  return recursive;
+}
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazyInternal(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = enhanceRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
+      dedupeLeading: options.dedupeLeadingMiddlewares
+    });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  let currentRouter = options.router;
+  const hiddenContract = getHiddenRouterContract(options.router);
+  if (hiddenContract !== void 0) {
+    currentRouter = hiddenContract;
+  }
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
+      path: options.path
+    });
+  } else if (isContractProcedure(currentRouter)) {
+    callback({
+      contract: currentRouter,
+      path: options.path
+    });
+  } else {
+    for (const key in currentRouter) {
+      traverseContractProcedures(
+        {
+          router: currentRouter[key],
+          path: [...options.path, key]
+        },
+        callback,
+        lazyOptions
+      );
+    }
+  }
+  return lazyOptions;
+}
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (isProcedure(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;
+}
+
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazyInternal(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function lazy(prefix, loader) {
+  return enhanceRouter(lazyInternal(loader), {
+    middlewares: [],
+    errorMap: {},
+    dedupeLeadingMiddlewares: true,
+    prefix
+  });
+}
+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 middlewareOutputFn(output) {
   return { output, context: {} };
 }
@@ -110,7 +304,7 @@ function createProcedureClient(lazyableProcedure, ...rest) {
   };
 }
 async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].inputSchema;
+  const schema = procedure["~orpc"].schemas.inputSchema;
   if (!schema) {
     return input;
   }
@@ -133,7 +327,7 @@ async function validateInput(procedure, input) {
   });
 }
 async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].outputSchema;
+  const schema = procedure["~orpc"].schemas.outputSchema;
   if (!schema) {
     return output;
   }
@@ -199,4 +393,4 @@ async function executeProcedureInternal(procedure, options) {
   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 };
+export { LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, createORPCErrorConstructorMap as f, getLazyMeta as g, lazy as h, isProcedure as i, middlewareOutputFn as j, isStartWithMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, mergeMiddlewares as n, getHiddenRouterContract as o, createAccessibleLazyRouter as p, unlazyRouter as q, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };

package/dist/shared/{server.Cp__uvkw.d.mts → server.Bk8Hmx7Z.d.mts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.Bzrdopnd.mjs';
-import { c as StandardHandleOptions } from './server.C-j2WKJz.mjs';
+import { C as Context } from './server.B5czSQQh.mjs';
+import { c as StandardHandleOptions } from './server.TgmlNh8r.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.B9i6p26R.d.ts → server.C4l2ZA3m.d.ts}

@@ -1,7 +1,7 @@
 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';
+import { C as Context, R as Router, H as ProcedureClientInterceptorOptions } from './server.B5czSQQh.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
@@ -48,7 +48,6 @@ declare class StandardHandler<T extends Context> {
     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>;
 }

package/dist/shared/{server.CYRDznXq.d.ts → server.D7UjcuIv.d.ts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.Bzrdopnd.js';
-import { c as StandardHandleOptions } from './server.B9i6p26R.js';
+import { C as Context } from './server.B5czSQQh.js';
+import { c as StandardHandleOptions } from './server.C4l2ZA3m.js';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.BEHw7Eyx.mjs → server.Kxw442A9.mjs}

@@ -244,4 +244,4 @@ function getDynamicParams(path) {
   })) : void 0;
 }
 
-export { standardizeHTTPPath as a, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };
+export { standardizeHTTPPath as a, bracketNotationDeserialize as b, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };

package/dist/shared/{server.B9VxPdeK.mjs → server.SmOM3Fae.mjs}

@@ -1,67 +1,45 @@
-import { isObject, stringifyJSON, isORPCErrorStatus, tryDecodeURIComponent, value, toHttpPath, toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, ORPCError, toORPCError } from '@temporary-name/shared';
+import { isObject, stringifyJSON, 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.DcfsPloY.mjs';
+import { c as createProcedureClient } from './server.BdGbIyq8.mjs';
 import { fallbackContractConfig } from '@temporary-name/contract';
-import { d as deserialize, s as serialize, a as standardizeHTTPPath } from './server.BEHw7Eyx.mjs';
+import { d as deserialize, s as serialize, b as bracketNotationDeserialize, a as standardizeHTTPPath } from './server.Kxw442A9.mjs';
 import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@temporary-name/server';
 import { createRouter, addRoute, findRoute } from 'rou3';
 
-class StandardOpenAPICodec {
-  constructor() {
+async function decode(request, pathParams) {
+  const deserializeSearchParams = () => {
+    return bracketNotationDeserialize(Array.from(request.url.searchParams.entries()));
+  };
+  const data = request.method === "GET" ? deserializeSearchParams() : deserialize(await request.body());
+  if (data === void 0) {
+    return pathParams;
   }
-  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);
+  if (isObject(data)) {
+    return {
+      ...pathParams,
+      ...data
     };
+  }
+  return data;
+}
+function encode(output, procedure) {
+  const successStatus = fallbackContractConfig(
+    "defaultSuccessStatus",
+    procedure["~orpc"].route.successStatus
+  );
+  const outputStructure = fallbackContractConfig(
+    "defaultOutputStructure",
+    procedure["~orpc"].route.outputStructure
+  );
+  if (outputStructure === "compact") {
     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())
+      status: successStatus,
+      headers: {},
+      body: serialize(output)
     };
   }
-  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(`
+  if (!isDetailedOutput(output)) {
+    throw new Error(`
         Invalid "detailed" output structure:
         \u2022 Expected an object with optional properties:
           - status (number 200-399)
@@ -72,32 +50,31 @@ class StandardOpenAPICodec {
         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" })
-    };
+  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;
   }
-  #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;
+  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) {
@@ -121,9 +98,6 @@ class StandardOpenAPIMatcher {
   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));
@@ -204,10 +178,8 @@ class StandardHandler {
   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);
@@ -242,10 +214,7 @@ class StandardHandler {
               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)
-              );
+              let input = await runWithSpan({ name: "decode_input" }, () => decode(request2, match.params));
               step = void 0;
               if (isAsyncIteratorObject(input)) {
                 input = asyncIteratorWithSpan(
@@ -264,7 +233,7 @@ class StandardHandler {
                 lastEventId: flattenHeader(request2.headers["last-event-id"])
               });
               step = void 0;
-              const response = this.codec.encode(output, match.procedure);
+              const response = encode(output, match.procedure);
               return {
                 matched: true,
                 response
@@ -279,7 +248,7 @@ class StandardHandler {
             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);
+          const response = encodeError(error);
           return {
             matched: true,
             response
@@ -290,4 +259,4 @@ class StandardHandler {
   }
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S, StandardOpenAPICodec as a, StandardOpenAPIMatcher as b, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+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 };

package/dist/shared/{server.C-j2WKJz.d.mts → server.TgmlNh8r.d.mts}

@@ -1,7 +1,7 @@
 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.mjs';
+import { C as Context, R as Router, H as ProcedureClientInterceptorOptions } from './server.B5czSQQh.mjs';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
@@ -48,7 +48,6 @@ declare class StandardHandler<T extends Context> {
     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>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@temporary-name/server",
   "type": "module",
-  "version": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
+  "version": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
   "license": "MIT",
   "homepage": "https://www.stainless.com/",
   "repository": {
@@ -73,15 +73,15 @@
     "cookie": "^1.0.2",
     "rou3": "^0.7.7",
     "zod": "^4.1.12",
-    "@temporary-name/contract": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/interop": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/shared": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/standard-server": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/standard-server-fetch": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/standard-server-node": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/json-schema": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d",
-    "@temporary-name/zod": "1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d"
+    "@temporary-name/interop": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/json-schema": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/shared": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/standard-server": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/contract": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/standard-server-node": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+    "@temporary-name/zod": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e"
   },
   "devDependencies": {
     "@types/supertest": "^6.0.3",