arri 0.0.15 → 0.0.17

package/dist/shared/arri.38792eb4.cjs

@@ -0,0 +1,850 @@
+'use strict';
+
+const typebox = require('@sinclair/typebox');
+const h3 = require('h3');
+const errors = require('@sinclair/typebox/errors');
+const value = require('@sinclair/typebox/value');
+
+const ErrorResponse = typebox.Type.Object(
+  {
+    statusCode: typebox.Type.Integer(),
+    statusMessage: typebox.Type.String(),
+    stack: typebox.Type.Array(typebox.Type.Any()),
+    data: typebox.Type.Optional(typebox.Type.Object({}, { additionalProperties: true }))
+  },
+  { $id: "ErrorResponse" }
+);
+function defineError(statusCode, input = {}) {
+  const defaultVals = errorResponseDefaults[statusCode];
+  return h3.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"
+  }
+};
+
+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";
+};
+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.Value.Convert(schema, input) : input;
+    if (value.Value.Check(schema, finalInput)) {
+      return { success: true, value: finalInput };
+    }
+    const errs = [...value.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 (typebox.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) {
+  const httpMethod = procedure.method ?? "post";
+  const handler = h3.eventHandler(async (event) => {
+    const context = {
+      event
+    };
+    if (h3.isPreflightRequest(event)) {
+      return "ok";
+    }
+    if (middleware.length) {
+      await Promise.all(middleware.map((m) => m(context)));
+    }
+    if (procedure.params) {
+      switch (httpMethod) {
+        case "get":
+        case "head": {
+          const parsedParams = await h3.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 h3.readValidatedBody(
+            event,
+            typeboxSafeValidate(procedure.params)
+          );
+          if (!parsedParams.success) {
+            let isObjectError = false;
+            const errorParts = [];
+            for (const err of parsedParams.errors) {
+              if (err.type === errors.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;
+        }
+      }
+    }
+    const response = await procedure.handler(context);
+    if (typeof response === "object") {
+      h3.setResponseHeader(event, "Content-Type", "application/json");
+      await h3.send(event, JSON.stringify(response));
+    } else {
+      await h3.send(event, response);
+    }
+    if (procedure.postHandler) {
+      context.response = response;
+      await procedure.postHandler(context);
+    }
+    return null;
+  });
+  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) {
+  const handler = async (event) => {
+    const context = {
+      event
+    };
+    if (middleware.length) {
+      for (const m of middleware) {
+        await m(context);
+      }
+    }
+    if (route.query) {
+      const result = await h3.getValidatedQuery(
+        event,
+        typeboxSafeValidate(route.query)
+      );
+      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 h3.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);
+    if (typeof response === "object") {
+      h3.setResponseHeader(event, "Content-Type", "application/json");
+      await h3.send(event, JSON.stringify(response));
+    } else {
+      await h3.send(event, response);
+    }
+    if (route.postHandler) {
+      context.response = response;
+      await route.postHandler(context);
+    }
+    return null;
+  };
+  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", h3.createRouter());
+    __publicField(this, "rpcDefinitionPath");
+    __publicField(this, "rpcRoutePrefix");
+    __publicField(this, "appInfo");
+    __publicField(this, "procedures", {});
+    __publicField(this, "models", {});
+    __publicField(this, "middlewares", []);
+    this.appInfo = opts?.appInfo;
+    this.h3App = h3.createApp({
+      debug: opts?.debug,
+      onAfterResponse: opts?.onAfterResponse,
+      onBeforeResponse: opts?.onBeforeResponse,
+      onError: async (err, event) => {
+        if (opts?.onError) {
+          await opts.onError(err, event);
+        }
+        h3.sendError(event, err);
+      },
+      onRequest: async (event) => {
+        if (opts?.onRequest) {
+          await opts.onRequest(event);
+        }
+      }
+    });
+    this.rpcRoutePrefix = opts?.rpcRoutePrefix ?? "";
+    this.rpcDefinitionPath = opts?.rpcDefinitionPath ?? "__definition";
+    this.h3Router.get(
+      this.rpcRoutePrefix ? `/${this.rpcRoutePrefix}/${this.rpcDefinitionPath}`.split("//").join("/") : `/${this.rpcDefinitionPath}`,
+      h3.eventHandler((_) => this.getAppDefinition())
+    );
+    this.h3App.use(this.h3Router);
+    if (process.env.ARRI_DEV_MODE === "true") {
+      this.h3Router.get(
+        DEV_DEFINITION_ENDPOINT,
+        h3.eventHandler((_) => this.getAppDefinition())
+      );
+    }
+  }
+  registerMiddleware(middleware) {
+    this.middlewares.push(middleware);
+  }
+  registerRpc(name, procedure) {
+    const path = getRpcPath(name, this.rpcRoutePrefix);
+    this.procedures[name] = createRpcDefinition(name, path, procedure);
+    if (typebox.TypeGuard.TObject(procedure.params)) {
+      const paramName = getRpcParamName(name, procedure);
+      if (paramName) {
+        this.models[paramName] = procedure.params;
+      }
+    }
+    if (typebox.TypeGuard.TObject(procedure.response)) {
+      const responseName = getRpcResponseName(name, procedure);
+      if (responseName) {
+        this.models[responseName] = procedure.response;
+      }
+    }
+    registerRpc(this.h3Router, path, procedure, this.middlewares);
+  }
+  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);
+};
+
+exports.Arri = Arri;
+exports.DEV_DEFINITION_ENDPOINT = DEV_DEFINITION_ENDPOINT;
+exports.DEV_ENDPOINT_ROOT = DEV_ENDPOINT_ROOT;
+exports.ErrorResponse = ErrorResponse;
+exports.HttpMethodValues = HttpMethodValues;
+exports.JsonSchemaComplexTypeValues = JsonSchemaComplexTypeValues;
+exports.JsonSchemaNullTypeValues = JsonSchemaNullTypeValues;
+exports.JsonSchemaScalarTypeValues = JsonSchemaScalarTypeValues;
+exports.camelCase = camelCase;
+exports.createRpcDefinition = createRpcDefinition;
+exports.defineError = defineError;
+exports.defineMiddleware = defineMiddleware;
+exports.defineRoute = defineRoute;
+exports.defineRpc = defineRpc;
+exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
+exports.getRpcParamDefinition = getRpcParamDefinition;
+exports.getRpcParamName = getRpcParamName;
+exports.getRpcPath = getRpcPath;
+exports.getRpcResponseName = getRpcResponseName;
+exports.isApplicationDef = isApplicationDef;
+exports.isHttpMethod = isHttpMethod;
+exports.isJsonSchemaArray = isJsonSchemaArray;
+exports.isJsonSchemaEnum = isJsonSchemaEnum;
+exports.isJsonSchemaNullType = isJsonSchemaNullType;
+exports.isJsonSchemaObject = isJsonSchemaObject;
+exports.isJsonSchemaScalarType = isJsonSchemaScalarType;
+exports.isProcedureDef = isProcedureDef;
+exports.isRpc = isRpc;
+exports.isServiceDef = isServiceDef;
+exports.kebabCase = kebabCase;
+exports.normalizeWhitespace = normalizeWhitespace;
+exports.pascalCase = pascalCase;
+exports.registerRoute = registerRoute;
+exports.registerRpc = registerRpc;
+exports.removeDisallowedChars = removeDisallowedChars;
+exports.setNestedObjectProperty = setNestedObjectProperty;
+exports.unflattenObject = unflattenObject;
+exports.unflattenProcedures = unflattenProcedures;