arri 0.0.38 → 0.0.40

package/dist/index.mjs

@@ -1,8 +1,641 @@
-export { A as Arri, D as DEV_DEFINITION_ENDPOINT, q as DEV_ENDPOINT_ROOT, K as ErrorResponse, H as HttpMethodValues, x as createRpcDefinition, L as defineError, G as defineMiddleware, F as defineRoute, w as defineRpc, M as errorResponseFromValidationErrors, B as getRpcParamDefinition, z as getRpcParamName, y as getRpcPath, C as getRpcResponseName, N as handleH3Error, t as isHttpMethod, v as isRpc, I as registerRoute, E as registerRpc } from './shared/arri.f1c922a6.mjs';
-import '@sinclair/typebox';
-import 'h3';
-import '@sinclair/typebox/errors';
-import '@sinclair/typebox/value';
+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 { e as isHttpMethod, r as removeDisallowedChars, k as kebabCase, p as pascalCase } from './shared/arri.ebf86912.mjs';
+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);
+}
+
+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 defaultConfig = {
   port: 3e3,
@@ -29,4 +662,4 @@ function defineConfig(config) {
   };
 }
 
-export { defaultConfig, defineConfig };
+export { Arri, DEV_DEFINITION_ENDPOINT, DEV_ENDPOINT_ROOT, ErrorResponse, createRpcDefinition, defaultConfig, defineConfig, defineError, defineMiddleware, defineRoute, defineRpc, errorResponseFromValidationErrors, getRpcParamDefinition, getRpcParamName, getRpcPath, getRpcResponseName, handleH3Error, isRpc, registerRoute, registerRpc };