arri 0.0.37 → 0.0.40

package/dist/shared/arri.f1c922a6.mjs

@@ -1,893 +0,0 @@
-import { Type, TypeGuard } from '@sinclair/typebox';
-import { createError, isError, setResponseStatus, sendError, eventHandler, isPreflightRequest, readValidatedBody, getValidatedQuery, setResponseHeader, send, createRouter, createApp, getQuery, readBody } from 'h3';
-import { ValueErrorType } from '@sinclair/typebox/errors';
-import { Value } from '@sinclair/typebox/value';
-
-const ErrorResponse = Type.Object(
-  {
-    statusCode: Type.Integer(),
-    statusMessage: Type.String(),
-    stack: Type.Array(Type.Any()),
-    data: Type.Optional(Type.Object({}, { additionalProperties: true }))
-  },
-  { $id: "ErrorResponse" }
-);
-function defineError(statusCode, input = {}) {
-  const defaultVals = errorResponseDefaults[statusCode];
-  return createError({
-    statusCode,
-    statusMessage: input.statusMessage ?? defaultVals.message ?? "An unknown error occurred",
-    stack: input.stack ?? "",
-    data: input.data
-  });
-}
-function errorResponseFromValidationErrors(errors, prefixText = `Missing or invalid parameters`) {
-  const errorParts = [];
-  for (const err of errors) {
-    const propName = err.path.split("/");
-    propName.shift();
-    if (!errorParts.includes(propName.join("."))) {
-      errorParts.push(propName.join("."));
-    }
-  }
-  throw defineError(400, {
-    statusMessage: `${prefixText}: [${errorParts.join(",")}]`,
-    data: errors
-  });
-}
-const errorResponseDefaults = {
-  400: {
-    name: "BAD_REQUEST",
-    message: "Bad Request"
-  },
-  401: {
-    name: "UNAUTHORIZED",
-    message: "Unauthorized"
-  },
-  402: {
-    name: "PAYMENT_REQUIRED",
-    message: "Payment Required"
-  },
-  403: {
-    name: "FORBIDDEN",
-    message: "Forbidden"
-  },
-  404: {
-    name: "NOT_FOUND",
-    message: "Not Found"
-  },
-  405: {
-    name: "METHOD_NOT_ALLOWED",
-    message: "Method Not Allowed"
-  },
-  406: {
-    name: "NOT_ACCEPTABLE",
-    message: "Not Acceptable"
-  },
-  407: {
-    name: "PROXY_AUTHENTICATION_REQUIRED",
-    message: "Proxy Authentication Required"
-  },
-  408: {
-    name: "REQUEST_TIMEOUT",
-    message: "Request Timeout"
-  },
-  409: {
-    name: "CONFLICT",
-    message: "Conflict"
-  },
-  410: {
-    name: "GONE",
-    message: "Gone"
-  },
-  411: {
-    name: "LENGTH_REQUIRED",
-    message: "Length Required"
-  },
-  412: {
-    name: "PRECONDITION_FAILED",
-    message: "Precondition Failed"
-  },
-  413: {
-    name: "REQUEST_TOO_LONG",
-    message: "Request Entity Too Large"
-  },
-  414: {
-    name: "REQUEST_URI_TOO_LONG",
-    message: "Request-URI Too Long"
-  },
-  415: {
-    name: "UNSUPPORTED_MEDIA_TYPE",
-    message: "Unsupported Media Type"
-  },
-  416: {
-    name: "REQUESTED_RANGE_NOT_SATISFIABLE",
-    message: "Requested Range Not Satisfiable"
-  },
-  417: {
-    name: "EXPECTATION_FAILED",
-    message: "Expectation Failed"
-  },
-  418: {
-    name: "IM_A_TEAPOT",
-    message: "I'm a teapot"
-  },
-  419: {
-    name: "INSUFFICIENT_SPACE_ON_RESOURCE",
-    message: "Insufficient Space on Resource"
-  },
-  420: {
-    name: "METHOD_FAILURE",
-    message: "Method Failure"
-  },
-  421: {
-    name: "MISDIRECTED_REQUEST",
-    message: "Misdirected Request"
-  },
-  422: {
-    name: "UNPROCESSABLE_ENTITY",
-    message: "Unprocessable Entity"
-  },
-  423: {
-    name: "LOCKED",
-    message: "Locked"
-  },
-  424: {
-    name: "FAILED_DEPENDENCY",
-    message: "Failed Dependency"
-  },
-  428: {
-    name: "PRECONDITION_REQUIRED",
-    message: "Precondition Required"
-  },
-  429: {
-    name: "TOO_MANY_REQUESTS",
-    message: "Too Many Requests"
-  },
-  431: {
-    name: "REQUEST_HEADER_FIELDS_TOO_LARGE",
-    message: "Request Header Fields Too Large"
-  },
-  451: {
-    name: "UNAVAILABLE_FOR_LEGAL_REASONS",
-    message: "Unavailable For Legal Reasons"
-  },
-  500: {
-    name: "INTERNAL_SERVER_ERROR",
-    message: "Internal Server Error"
-  },
-  501: {
-    name: "NOT_IMPLEMENTED",
-    message: "Not Implemented"
-  },
-  502: {
-    name: "BAD_GATEWAY",
-    message: "Bad Gateway"
-  },
-  503: {
-    name: "SERVICE_UNAVAILABLE",
-    message: "Service Unavailable"
-  },
-  504: {
-    name: "GATEWAY_TIMEOUT",
-    message: "Gateway Timeout"
-  },
-  505: {
-    name: "HTTP_VERSION_NOT_SUPPORTED",
-    message: "HTTP Version Not Supported"
-  },
-  507: {
-    name: "INSUFFICIENT_STORAGE",
-    message: "Insufficient Storage"
-  },
-  511: {
-    name: "NETWORK_AUTHENTICATION_REQUIRED",
-    message: "Network Authentication Required"
-  }
-};
-async function handleH3Error(err, context, event, onError) {
-  const error = isError(err) ? err : defineError(500, { data: err, stack: `${err}` });
-  setResponseStatus(event, error.statusCode);
-  if (onError) {
-    await onError(error, context, event);
-  }
-  if (event.handled) {
-    return;
-  }
-  sendError(event, error);
-}
-
-const NUMBER_CHAR_RE = /\d/;
-const STR_SPLITTERS = ["-", "_", "/", "."];
-function isUppercase(char = "") {
-  if (NUMBER_CHAR_RE.test(char)) {
-    return void 0;
-  }
-  return char.toUpperCase() === char;
-}
-function splitByCase(string_, separators) {
-  const splitters = separators ?? STR_SPLITTERS;
-  const parts = [];
-  if (!string_ || typeof string_ !== "string") {
-    return parts;
-  }
-  let buff = "";
-  let previousUpper;
-  let previousSplitter;
-  for (const char of string_) {
-    const isSplitter = splitters.includes(char);
-    if (isSplitter === true) {
-      parts.push(buff);
-      buff = "";
-      previousUpper = void 0;
-      continue;
-    }
-    const isUpper = isUppercase(char);
-    if (previousSplitter === false) {
-      if (previousUpper === false && isUpper === true) {
-        parts.push(buff);
-        buff = char;
-        previousUpper = isUpper;
-        continue;
-      }
-      if (previousUpper === true && isUpper === false && buff.length > 1) {
-        const lastChar = buff[buff.length - 1];
-        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
-        buff = lastChar + char;
-        previousUpper = isUpper;
-        continue;
-      }
-    }
-    buff += char;
-    previousUpper = isUpper;
-    previousSplitter = isSplitter;
-  }
-  parts.push(buff);
-  return parts;
-}
-function upperFirst(string_) {
-  return !string_ ? "" : string_[0].toUpperCase() + string_.slice(1);
-}
-function lowerFirst(string_) {
-  return !string_ ? "" : string_[0].toLowerCase() + string_.slice(1);
-}
-function pascalCase(string_) {
-  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => upperFirst(p)).join("");
-}
-function camelCase(string_) {
-  return lowerFirst(pascalCase(string_));
-}
-function kebabCase(string_, joiner) {
-  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => p.toLowerCase()).join(joiner ?? "-");
-}
-
-function normalizeWhitespace(input) {
-  if (input.includes("\n\n")) {
-    return normalizeWhitespace(input.split("\n\n").join("\n"));
-  }
-  const lines = [];
-  for (const line of input.split("\n")) {
-    lines.push(line.trim());
-  }
-  const result = lines.join("\n").trim();
-  if (result.includes("\n\n")) {
-    return normalizeWhitespace(result.split("\n\n").join("\n"));
-  }
-  return result;
-}
-function isProcedureDef(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  const expectedKeys = ["path", "method"];
-  const existingKeys = Object.keys(input);
-  for (const key of expectedKeys) {
-    if (!existingKeys.includes(key)) {
-      return false;
-    }
-  }
-  return isHttpMethod(input.method) && typeof input.path === "string" && (typeof input.params === "string" || typeof input.params === "undefined") && (typeof input.response === "string" || typeof input.response === "undefined");
-}
-function isServiceDef(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  for (const key of Object.keys(input)) {
-    if (typeof input[key] !== "object") {
-      return false;
-    }
-  }
-  return true;
-}
-function isApplicationDef(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  if (!("procedures" in input) || typeof input.procedures !== "object") {
-    return false;
-  }
-  if (!("models" in input) || typeof input.models !== "object") {
-    return false;
-  }
-  if (!("errors" in input) || typeof input.errors !== "object") {
-    return false;
-  }
-  return true;
-}
-function unflattenObject(data) {
-  if (Object(data) !== data || Array.isArray(data))
-    return data;
-  const regex = /\.?([^.[\]]+)|\[(\d+)\]/g;
-  const result = {};
-  for (const p in data) {
-    let cur = result;
-    let prop = "";
-    let m;
-    while (m = regex.exec(p)) {
-      cur = cur[prop] || (cur[prop] = m[2] ? [] : {});
-      prop = m[2] || m[1];
-    }
-    cur[prop] = data[p];
-  }
-  return result[""] || result;
-}
-function unflattenProcedures(procedures) {
-  return unflattenObject(procedures);
-}
-function setNestedObjectProperty(targetProp, value, object) {
-  const parts = targetProp.split(".");
-  let current = object;
-  for (let i = 0; i < parts.length; i++) {
-    const key = parts[i];
-    if (i === parts.length - 1) {
-      current[key] = value;
-    } else {
-      if (!current[key]) {
-        current[key] = {};
-      }
-      current = current[key];
-    }
-  }
-  return object;
-}
-const removeDisallowedChars = (input, disallowedChars) => {
-  let result = input;
-  for (const char of disallowedChars) {
-    if (result.includes(char)) {
-      result = result.split(char).join("");
-    }
-  }
-  return result;
-};
-const JsonSchemaScalarTypeValues = [
-  "integer",
-  "number",
-  "bigint",
-  "string",
-  "boolean",
-  "Date"
-];
-const JsonSchemaNullTypeValues = ["null", "undefined"];
-const JsonSchemaComplexTypeValues = [
-  "object",
-  "list",
-  "array",
-  "Uint8Array"
-];
-function isJsonSchemaScalarType(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  if (!("type" in input)) {
-    return false;
-  }
-  return JsonSchemaScalarTypeValues.includes(input.type);
-}
-function isJsonSchemaNullType(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  if (!("type" in input)) {
-    return false;
-  }
-  return JsonSchemaNullTypeValues.includes(input.type);
-}
-const isJsonSchemaObject = (input) => {
-  if (typeof input !== "object") {
-    return false;
-  }
-  return "type" in input && input.type === "object" && "properties" in input && typeof input.properties === "object";
-};
-const isJsonSchemaRecord = (input) => {
-  if (typeof input !== "object") {
-    return false;
-  }
-  return "type" in input && input.type === "object" && "patternProperties" in input && typeof input.patternProperties === "object";
-};
-function isJsonSchemaArray(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  if ("type" in input && input.type === "array") {
-    return true;
-  }
-  return false;
-}
-function isJsonSchemaEnum(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  if (!("anyOf" in input) || !Array.isArray(input.anyOf)) {
-    return false;
-  }
-  let prevType;
-  for (const item of input.anyOf) {
-    if (!isJsonSchemaScalarType(item)) {
-      return false;
-    }
-    if (item.type !== "string" && item.type !== "integer" && item.type !== "number") {
-      return false;
-    }
-    if (!prevType) {
-      prevType = item.type;
-    } else if (prevType !== item.type) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function typeboxSafeValidate(schema, coerce = false) {
-  const fn = (input) => {
-    const finalInput = coerce ? Value.Convert(schema, input) : input;
-    if (Value.Check(schema, finalInput)) {
-      return { success: true, value: finalInput };
-    }
-    const errs = [...Value.Errors(schema, finalInput)];
-    return {
-      success: false,
-      errors: errs
-    };
-  };
-  return fn;
-}
-
-function isRpc(input) {
-  if (typeof input !== "object") {
-    return false;
-  }
-  const anyInput = input;
-  if (!isHttpMethod(anyInput.method)) {
-    return false;
-  }
-  if (typeof anyInput.handler !== "function") {
-    return false;
-  }
-  return true;
-}
-function defineRpc(config) {
-  return config;
-}
-function createRpcDefinition(rpcName, httpPath, procedure) {
-  return {
-    description: procedure.description,
-    path: httpPath,
-    method: procedure.method ?? "post",
-    params: getRpcParamDefinition(rpcName, procedure),
-    response: getRpcResponseDefinition(rpcName, procedure)
-  };
-}
-function getRpcPath(rpcName, prefix = "") {
-  const path = rpcName.split(".").map(
-    (part) => removeDisallowedChars(
-      kebabCase(part),
-      `!@#$%^&*()+=[]{}|\\;:'"<>,./?`
-    )
-  ).join("/");
-  const finalPath = prefix ? `/${prefix}/${path}` : `/${path}`;
-  return finalPath;
-}
-function getRpcParamName(rpcName, procedure) {
-  if (!procedure.params) {
-    return null;
-  }
-  const nameParts = rpcName.split(".").map(
-    (part) => removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
-  );
-  const paramName = procedure.params.$id ?? pascalCase(`${nameParts.join(`_`)}_params`);
-  return paramName;
-}
-function getRpcParamDefinition(rpcName, procedure) {
-  if (!procedure.params) {
-    return void 0;
-  }
-  const name = getRpcParamName(rpcName, procedure);
-  if (!name) {
-    return void 0;
-  }
-  return name;
-}
-function getRpcResponseName(rpcName, procedure) {
-  if (!procedure.response) {
-    return null;
-  }
-  if (TypeGuard.TObject(procedure.response)) {
-    const nameParts = rpcName.split(".").map(
-      (part) => removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
-    );
-    const responseName = procedure.response.$id ?? pascalCase(`${nameParts.join("_")}_response`);
-    return responseName;
-  }
-  return null;
-}
-function getRpcResponseDefinition(rpcName, procedure) {
-  if (!procedure.response) {
-    return void 0;
-  }
-  const name = getRpcResponseName(rpcName, procedure);
-  if (!name) {
-    return void 0;
-  }
-  return name;
-}
-function registerRpc(router, path, procedure, middleware, opts) {
-  const httpMethod = procedure.method ?? "post";
-  const handler = eventHandler(async (event) => {
-    const context = {
-      type: "procedure",
-      params: void 0
-    };
-    if (isPreflightRequest(event)) {
-      return "ok";
-    }
-    try {
-      if (middleware.length) {
-        await Promise.all(middleware.map((m) => m(context, event)));
-      }
-      if (procedure.params) {
-        switch (httpMethod) {
-          case "get":
-          case "head": {
-            const parsedParams = await getValidatedQuery(
-              event,
-              typeboxSafeValidate(procedure.params, true)
-            );
-            if (!parsedParams.success) {
-              const errorParts = [];
-              for (const err of parsedParams.errors) {
-                const propName = err.path.split("/");
-                propName.shift();
-                if (!errorParts.includes(propName.join("."))) {
-                  errorParts.push(propName.join("."));
-                }
-              }
-              throw defineError(400, {
-                statusMessage: `Missing or invalid url query parameters: [${errorParts.join(
-                  ","
-                )}]`,
-                data: parsedParams.errors
-              });
-            }
-            context.params = parsedParams.value;
-            break;
-          }
-          case "delete":
-          case "patch":
-          case "post":
-          case "put": {
-            const parsedParams = await readValidatedBody(
-              event,
-              typeboxSafeValidate(procedure.params)
-            );
-            if (!parsedParams.success) {
-              let isObjectError = false;
-              const errorParts = [];
-              for (const err of parsedParams.errors) {
-                if (err.type === ValueErrorType.Object) {
-                  isObjectError = true;
-                }
-                const propName = err.path.split("/");
-                propName.shift();
-                if (!errorParts.includes(propName.join("."))) {
-                  errorParts.push(propName.join("."));
-                }
-              }
-              if (isObjectError) {
-                throw defineError(400, {
-                  statusMessage: `Invalid request body. Expected object.`
-                });
-              }
-              throw defineError(400, {
-                statusMessage: `Invalid request body. Affected properties [${errorParts.join(
-                  ", "
-                )}]`,
-                data: parsedParams.errors
-              });
-            }
-            context.params = parsedParams.value;
-            break;
-          }
-          default:
-            break;
-        }
-      }
-      const response = await procedure.handler(context, event);
-      context.response = response;
-      if (opts.onBeforeResponse) {
-        await opts.onBeforeResponse(context, event);
-      }
-      if (typeof response === "object") {
-        setResponseHeader(event, "Content-Type", "application/json");
-        await send(event, JSON.stringify(response));
-      } else {
-        await send(event, response ?? "");
-      }
-      if (opts.onAfterResponse) {
-        await opts.onAfterResponse(context, event);
-      }
-      if (procedure.postHandler) {
-        await procedure.postHandler(context, event);
-      }
-    } catch (err) {
-      await handleH3Error(err, context, event, opts.onError);
-    }
-    return "";
-  });
-  switch (httpMethod) {
-    case "get":
-      router.get(path, handler);
-      break;
-    case "head":
-      router.head(path, handler);
-      break;
-    case "delete":
-      router.delete(path, handler);
-      break;
-    case "patch":
-      router.patch(path, handler);
-      break;
-    case "put":
-      router.put(path, handler);
-      break;
-    case "post":
-    default:
-      router.post(path, handler);
-      break;
-  }
-}
-
-function defineRoute(config) {
-  return config;
-}
-const defineMiddleware = (middleware) => middleware;
-function registerRoute(router, route, middleware, prefix, opts) {
-  const handler = eventHandler(async (event) => {
-    const context = {
-      type: "route",
-      params: event.context.params,
-      query: void 0,
-      body: void 0
-    };
-    try {
-      if (middleware.length) {
-        for (const m of middleware) {
-          await m(context, event);
-        }
-      }
-      if (route.query) {
-        const result = await getValidatedQuery(
-          event,
-          typeboxSafeValidate(route.query, true)
-        );
-        if (!result.success) {
-          throw errorResponseFromValidationErrors(
-            result.errors,
-            "Missing or invalid query parameters"
-          );
-        }
-        context.query = result.value;
-      }
-      if (route.body && route.method !== "get" && route.method !== "head") {
-        const result = await readValidatedBody(
-          event,
-          typeboxSafeValidate(route.body)
-        );
-        if (!result.success) {
-          throw errorResponseFromValidationErrors(
-            result.errors,
-            "Missing or invalid body parameters"
-          );
-        }
-        context.body = result.value;
-      }
-      const response = await route.handler(context, event);
-      context.response = response;
-      if (opts?.onBeforeResponse) {
-        await opts.onBeforeResponse(context, event);
-      }
-      if (typeof response === "object") {
-        setResponseHeader(event, "Content-Type", "application/json");
-        await send(event, JSON.stringify(response));
-      } else {
-        await send(event, response ?? "");
-      }
-      if (opts?.onAfterResponse) {
-        await opts.onAfterResponse(context, event);
-      }
-      if (route.postHandler) {
-        await route.postHandler(context, event);
-      }
-    } catch (err) {
-      await handleH3Error(err, context, event, opts?.onError);
-    }
-    if (!event.handled) {
-      await send(event, "");
-    }
-    return "";
-  });
-  const finalPath = (prefix ? `/${prefix}${route.path}` : route.path).split("//").join("/");
-  switch (route.method) {
-    case "get":
-      router.get(finalPath, handler);
-      break;
-    case "head":
-      router.head(finalPath, handler);
-      break;
-    case "delete":
-      router.delete(finalPath, handler);
-      break;
-    case "patch":
-      router.patch(finalPath, handler);
-      break;
-    case "post":
-      router.post(finalPath, handler);
-      break;
-    case "put":
-      router.put(finalPath, handler);
-      break;
-  }
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const DEV_ENDPOINT_ROOT = `/__arri_dev__`;
-const DEV_DEFINITION_ENDPOINT = `${DEV_ENDPOINT_ROOT}/definition`;
-class Arri {
-  constructor(opts = {}) {
-    __publicField(this, "__isArri__", true);
-    __publicField(this, "h3App");
-    __publicField(this, "h3Router", createRouter());
-    __publicField(this, "rpcDefinitionPath");
-    __publicField(this, "rpcRoutePrefix");
-    __publicField(this, "appInfo");
-    __publicField(this, "procedures", {});
-    __publicField(this, "models", {});
-    __publicField(this, "middlewares", []);
-    __publicField(this, "onAfterResponse");
-    __publicField(this, "onBeforeResponse");
-    __publicField(this, "onError");
-    this.appInfo = opts?.appInfo;
-    this.h3App = createApp({
-      debug: opts?.debug,
-      onRequest: opts?.onRequest
-    });
-    this.onError = opts.onError;
-    this.onAfterResponse = opts.onAfterResponse;
-    this.onBeforeResponse = opts.onBeforeResponse;
-    this.rpcRoutePrefix = opts?.rpcRoutePrefix ?? "";
-    this.rpcDefinitionPath = opts?.rpcDefinitionPath ?? "__definition";
-    this.h3App.use(this.h3Router);
-    this.registerRoute({
-      path: this.rpcRoutePrefix ? `/${this.rpcRoutePrefix}/${this.rpcDefinitionPath}`.split("//").join("/") : `/${this.rpcDefinitionPath}`,
-      method: "get",
-      handler: () => this.getAppDefinition()
-    });
-    if (process.env.ARRI_DEV_MODE === "true") {
-      this.registerRoute({
-        path: DEV_DEFINITION_ENDPOINT,
-        method: "get",
-        handler: () => this.getAppDefinition()
-      });
-    }
-    this.h3Router.use(
-      "/**",
-      eventHandler(async (event) => {
-        setResponseStatus(event, 404);
-        const error = defineError(404);
-        const query = getQuery(event);
-        const disallowedBodyMethods = ["GET", "HEAD", "OPTION"];
-        const canBody = !disallowedBodyMethods.includes(event.method);
-        const context = {
-          type: "route",
-          params: event.context.params,
-          query,
-          // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-          body: canBody ? await readBody(event).catch((_) => void 0) : void 0
-        };
-        try {
-          if (this.middlewares.length) {
-            for (const m of this.middlewares) {
-              await m(context, event);
-            }
-          }
-        } catch (err) {
-          await handleH3Error(err, context, event, this.onError);
-        }
-        if (event.handled) {
-          return;
-        }
-        if (this.onError) {
-          await this.onError(error, context, event);
-        }
-        if (event.handled) {
-          return;
-        }
-        sendError(event, error);
-      })
-    );
-  }
-  registerMiddleware(middleware) {
-    this.middlewares.push(middleware);
-  }
-  registerRpc(name, procedure) {
-    const path = getRpcPath(name, this.rpcRoutePrefix);
-    this.procedures[name] = createRpcDefinition(name, path, procedure);
-    if (TypeGuard.TObject(procedure.params)) {
-      const paramName = getRpcParamName(name, procedure);
-      if (paramName) {
-        this.models[paramName] = procedure.params;
-      }
-    }
-    if (TypeGuard.TObject(procedure.response)) {
-      const responseName = getRpcResponseName(name, procedure);
-      if (responseName) {
-        this.models[responseName] = procedure.response;
-      }
-    }
-    registerRpc(this.h3Router, path, procedure, this.middlewares, {
-      onError: this.onError,
-      onAfterResponse: this.onAfterResponse,
-      onBeforeResponse: this.onBeforeResponse
-    });
-  }
-  registerRoute(route) {
-    registerRoute(this.h3Router, route, this.middlewares);
-  }
-  getAppDefinition() {
-    const appDef = {
-      arriSchemaVersion: "0.0.1",
-      info: this.appInfo,
-      procedures: {},
-      models: this.models,
-      errors: ErrorResponse
-    };
-    Object.keys(this.procedures).forEach((key) => {
-      const rpc = this.procedures[key];
-      appDef.procedures[key] = rpc;
-    });
-    return appDef;
-  }
-  getH3Instance() {
-    return this.h3App;
-  }
-}
-const HttpMethodValues = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "head"
-];
-const isHttpMethod = (input) => {
-  if (typeof input !== "string") {
-    return false;
-  }
-  return HttpMethodValues.includes(input);
-};
-
-export { Arri as A, getRpcParamDefinition as B, getRpcResponseName as C, DEV_DEFINITION_ENDPOINT as D, registerRpc as E, defineRoute as F, defineMiddleware as G, HttpMethodValues as H, registerRoute as I, JsonSchemaScalarTypeValues as J, ErrorResponse as K, defineError as L, errorResponseFromValidationErrors as M, handleH3Error as N, isProcedureDef as a, isJsonSchemaScalarType as b, isJsonSchemaNullType as c, isJsonSchemaObject as d, isJsonSchemaRecord as e, isJsonSchemaEnum as f, isJsonSchemaArray as g, unflattenProcedures as h, isServiceDef as i, camelCase as j, isApplicationDef as k, JsonSchemaNullTypeValues as l, JsonSchemaComplexTypeValues as m, normalizeWhitespace as n, kebabCase as o, pascalCase as p, DEV_ENDPOINT_ROOT as q, removeDisallowedChars as r, setNestedObjectProperty as s, isHttpMethod as t, unflattenObject as u, isRpc as v, defineRpc as w, createRpcDefinition as x, getRpcPath as y, getRpcParamName as z };