arri 0.0.44 → 0.1.0-beta.2

package/dist/shared/arri.406d936a.cjs

@@ -0,0 +1,697 @@
+'use strict';
+
+const arriValidate = require('arri-validate');
+const h3 = require('h3');
+const arriCodegenUtils = require('arri-codegen-utils');
+const scule = require('scule');
+
+const ErrorResponse = arriValidate.a.object({
+  statusCode: arriValidate.a.int8(),
+  statusMessage: arriValidate.a.string(),
+  stack: arriValidate.a.array(arriValidate.a.any()),
+  data: arriValidate.a.optional(arriValidate.a.any())
+});
+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.instancePath?.split("/") ?? [];
+    if (propName.length) {
+      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, event, onError) {
+  const error = h3.isError(err) ? err : defineError(500, { data: err, stack: `${err}` });
+  h3.setResponseStatus(event, error.statusCode);
+  if (onError) {
+    await onError(error, event);
+  }
+  if (event.handled) {
+    return;
+  }
+  await h3.send(
+    event,
+    JSON.stringify({
+      statusCode: error.statusCode,
+      statusMessage: error.statusMessage,
+      data: error.data,
+      stack: error.stack
+    })
+  );
+}
+
+function isRpc(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  const anyInput = input;
+  if (!arriCodegenUtils.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: getRpcParamName(rpcName, procedure),
+    response: getRpcResponseDefinition(rpcName, procedure)
+  };
+}
+function getRpcPath(rpcName, prefix = "") {
+  const path = rpcName.split(".").map(
+    (part) => arriCodegenUtils.removeDisallowedChars(
+      scule.kebabCase(part),
+      `!@#$%^&*()+=[]{}|\\;:'"<>,./?`
+    )
+  ).join("/");
+  const finalPath = prefix ? `/${prefix}/${path}` : `/${path}`;
+  return finalPath;
+}
+function getRpcParamName(rpcName, procedure) {
+  if (!arriValidate.isAObjectSchema(procedure.params)) {
+    return void 0;
+  }
+  const nameParts = rpcName.split(".").map(
+    (part) => arriCodegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
+  );
+  const paramName = procedure.params.metadata.id ?? scule.pascalCase(`${nameParts.join(`_`)}_params`);
+  return paramName;
+}
+function getRpcResponseName(rpcName, procedure) {
+  if (!arriValidate.isAObjectSchema(procedure.response)) {
+    return void 0;
+  }
+  const nameParts = rpcName.split(".").map(
+    (part) => arriCodegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
+  );
+  const responseName = procedure.response.metadata.id ?? scule.pascalCase(`${nameParts.join("_")}_response`);
+  return responseName;
+}
+function getRpcResponseDefinition(rpcName, procedure) {
+  if (!arriValidate.isAObjectSchema(procedure.response)) {
+    return void 0;
+  }
+  const name = getRpcResponseName(rpcName, procedure);
+  if (!name) {
+    return void 0;
+  }
+  return name;
+}
+function registerRpc(router, path, procedure, opts) {
+  const paramValidator = procedure.params ? arriValidate.a.compile(procedure.params) : void 0;
+  const responseValidator = procedure.response ? arriValidate.a.compile(procedure.response) : void 0;
+  const httpMethod = procedure.method ?? "post";
+  const handler = h3.eventHandler(async (event) => {
+    if (h3.isPreflightRequest(event)) {
+      return "ok";
+    }
+    try {
+      if (opts.onRequest) {
+        await opts.onRequest(event);
+      }
+      if (opts.middleware.length) {
+        for (const m of opts.middleware) {
+          await m(event);
+        }
+      }
+      if (arriValidate.isAObjectSchema(procedure.params) && paramValidator) {
+        switch (httpMethod) {
+          case "get":
+          case "head": {
+            const parsedParams = await h3.getValidatedQuery(
+              event,
+              (input) => arriValidate.a.safeCoerce(procedure.params, input)
+            );
+            if (parsedParams.success) {
+              event.context.params = parsedParams.value;
+            } else {
+              const errParts = [];
+              for (const err of parsedParams.error.errors) {
+                const errPath = err.instancePath.split("/");
+                errPath.shift();
+                const propName = errPath.join(".");
+                if (!errParts.includes(propName)) {
+                  errParts.push(propName);
+                }
+              }
+              const message = `Missing or invalid url query parameters: [${errParts.join(
+                ", "
+              )}]`;
+              throw defineError(400, {
+                statusMessage: message,
+                data: parsedParams.error
+              });
+            }
+            break;
+          }
+          case "delete":
+          case "patch":
+          case "post":
+          case "put": {
+            const body = await h3.readRawBody(event);
+            if (!body) {
+              throw defineError(400, {
+                statusMessage: `Invalid request body. Expected object. Got undefined.`
+              });
+            }
+            const parsedParams = paramValidator.safeParse(body);
+            if (!parsedParams.success) {
+              const errorParts = [];
+              for (const err of parsedParams.error.errors) {
+                const errPath = err.instancePath.split("/");
+                errPath.shift();
+                if (!errorParts.includes(errPath.join("."))) {
+                  errorParts.push(errPath.join("."));
+                }
+              }
+              throw defineError(400, {
+                statusMessage: `Invalid request body. Affected properties [${errorParts.join(
+                  ", "
+                )}]`,
+                data: parsedParams.error
+              });
+            }
+            event.context.params = parsedParams.value;
+            break;
+          }
+          default:
+            break;
+        }
+      }
+      const response = await procedure.handler(
+        event.context,
+        event
+      );
+      event.context.response = response;
+      if (opts.onBeforeResponse) {
+        await opts.onBeforeResponse(event);
+      }
+      if (typeof response === "object") {
+        h3.setResponseHeader(event, "Content-Type", "application/json");
+        await h3.send(
+          event,
+          responseValidator?.serialize(response) ?? JSON.stringify(response)
+        );
+      } else {
+        await h3.send(
+          event,
+          response ?? `<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Empty Response</title>
+    </head>
+    <body>
+        nothing to see here
+    </body>
+</html>
+`
+        );
+      }
+      if (opts.onAfterResponse) {
+        await opts.onAfterResponse(event);
+      }
+      if (procedure.postHandler) {
+        await procedure.postHandler(event.context, event);
+      }
+    } catch (err) {
+      await handleH3Error(err, 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;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ArriRouter {
+  constructor() {
+    __publicField$1(this, "procedures", []);
+    __publicField$1(this, "routes", []);
+  }
+  rpc(procedure) {
+    this.procedures.push(procedure);
+  }
+  route(route) {
+    this.routes.push(route);
+  }
+  getProcedures() {
+    return this.procedures;
+  }
+  getRoutes() {
+    return this.routes;
+  }
+}
+
+function registerRoute(router, route, opts) {
+  if (typeof route.method === "string") {
+    handleRoute(router, route.method, route, opts);
+    return;
+  }
+  for (const method of route.method) {
+    handleRoute(router, method, route, opts);
+  }
+}
+function handleRoute(router, method, route, opts) {
+  const handler = h3.defineEventHandler(async (event) => {
+    try {
+      if (opts.onRequest) {
+        await opts.onRequest(event);
+      }
+      if (opts.middleware.length) {
+        for (const m of opts.middleware) {
+          await m(event);
+        }
+      }
+      const response = await route.handler(event);
+      event.context.response = response;
+      if (!event.handled) {
+        if (opts.onBeforeResponse) {
+          await opts.onBeforeResponse(event);
+        }
+        if (typeof response === "object" && response) {
+          h3.setHeader(event, "Content-Type", "application/json");
+          await h3.send(event, JSON.stringify(response));
+        } else {
+          await h3.send(event, response);
+        }
+      }
+      if (opts.onAfterResponse) {
+        await opts.onAfterResponse(event);
+      }
+      if (route.postHandler) {
+        await route.postHandler(event);
+      }
+    } catch (err) {
+      await handleH3Error(err, event, opts.onError);
+    }
+  });
+  switch (method) {
+    case "get":
+      router.get(route.path, handler);
+      break;
+    case "delete":
+      router.delete(route.path, handler);
+      break;
+    case "head":
+      router.head(route.path, handler);
+      break;
+    case "patch":
+      router.patch(route.path, handler);
+      break;
+    case "post":
+      router.post(route.path, handler);
+      break;
+    case "put":
+      router.put(route.path, 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 ArriApp {
+  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", []);
+    __publicField(this, "onRequest");
+    __publicField(this, "onAfterResponse");
+    __publicField(this, "onBeforeResponse");
+    __publicField(this, "onError");
+    this.appInfo = opts?.appInfo;
+    this.h3App = h3.createApp({
+      debug: opts?.debug
+    });
+    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.h3Router.get(
+      this.rpcRoutePrefix ? `/${this.rpcRoutePrefix}/${this.rpcDefinitionPath}`.split("//").join("/") : `/${this.rpcDefinitionPath}`,
+      h3.eventHandler(() => this.getAppDefinition())
+    );
+    if (process.env.ARRI_DEV_MODE === "true") {
+      this.h3Router.get(
+        DEV_DEFINITION_ENDPOINT,
+        h3.eventHandler(() => this.getAppDefinition())
+      );
+    }
+    this.h3Router.use(
+      "/**",
+      h3.eventHandler(async (event) => {
+        h3.setResponseStatus(event, 404);
+        const error = defineError(404);
+        try {
+          if (this.middlewares.length) {
+            for (const m of this.middlewares) {
+              await m(event);
+            }
+          }
+        } catch (err) {
+          await handleH3Error(err, event, this.onError);
+        }
+        if (event.handled) {
+          return;
+        }
+        if (this.onError) {
+          await this.onError(error, event);
+        }
+        if (event.handled) {
+          return;
+        }
+        h3.sendError(event, error);
+      })
+    );
+  }
+  use(input) {
+    if (typeof input === "object" && input instanceof ArriRouter) {
+      for (const route of input.getRoutes()) {
+        this.route(route);
+      }
+      for (const rpc of input.getProcedures()) {
+        this.rpc(rpc);
+      }
+      return;
+    }
+    this.middlewares.push(input);
+  }
+  rpc(procedure) {
+    const path = getRpcPath(procedure.name, this.rpcRoutePrefix);
+    this.procedures[procedure.name] = createRpcDefinition(
+      procedure.name,
+      path,
+      procedure
+    );
+    if (arriValidate.isAObjectSchema(procedure.params)) {
+      const paramName = getRpcParamName(procedure.name, procedure);
+      if (paramName) {
+        this.models[paramName] = procedure.params;
+      }
+    }
+    if (arriValidate.isAObjectSchema(procedure.response)) {
+      const responseName = getRpcResponseName(procedure.name, procedure);
+      if (responseName) {
+        this.models[responseName] = procedure.response;
+      }
+    }
+    registerRpc(this.h3Router, path, procedure, {
+      middleware: this.middlewares,
+      onError: this.onError,
+      onAfterResponse: this.onAfterResponse,
+      onBeforeResponse: this.onBeforeResponse
+    });
+  }
+  route(route) {
+    registerRoute(this.h3Router, route, {
+      middleware: this.middlewares,
+      onError: this.onError,
+      onAfterResponse: this.onAfterResponse,
+      onBeforeResponse: this.onBeforeResponse
+    });
+  }
+  getAppDefinition() {
+    const appDef = {
+      arriSchemaVersion: "0.0.2",
+      info: this.appInfo,
+      procedures: {},
+      models: this.models,
+      errors: ErrorResponse
+    };
+    for (const key of Object.keys(this.procedures)) {
+      const rpc = this.procedures[key];
+      appDef.procedures[key] = rpc;
+    }
+    return appDef;
+  }
+}
+
+function isArriConfig(input) {
+  if (typeof input !== "object" || !input) {
+    return false;
+  }
+  return "port" in input && typeof input.port === "number" && !Number.isNaN(input.port) && "entry" in input && typeof input.entry === "string";
+}
+function isResolvedArriConfig(input) {
+  if (!isArriConfig(input)) {
+    return false;
+  }
+  return typeof input.rootDir === "string" && typeof input.srcDir === "string" && (typeof input.procedureDir === "string" || typeof input.procedureDir === "boolean") && Array.isArray(input.procedureGlobPatterns) && Array.isArray(input.clientGenerators) && typeof input.buildDir === "string" && typeof input.esbuild === "object" && input.esbuild && !Array.isArray(input.esbuild);
+}
+const defaultConfig = {
+  port: 3e3,
+  rootDir: ".",
+  srcDir: ".",
+  entry: "app.ts",
+  procedureDir: "procedures",
+  procedureGlobPatterns: ["**/*.rpc.ts"],
+  clientGenerators: [],
+  buildDir: ".arri",
+  esbuild: {}
+};
+function defineConfig(config) {
+  return {
+    port: config.port ?? defaultConfig.port,
+    rootDir: config.rootDir ?? defaultConfig.rootDir,
+    srcDir: config.srcDir ?? defaultConfig.srcDir,
+    entry: config.entry ?? defaultConfig.entry,
+    procedureDir: config.procedureDir ?? defaultConfig.procedureDir,
+    procedureGlobPatterns: config.procedureGlobPatterns ?? defaultConfig.procedureGlobPatterns,
+    clientGenerators: config.clientGenerators ?? defaultConfig.clientGenerators,
+    buildDir: config.buildDir ?? defaultConfig.buildDir,
+    esbuild: config.esbuild ?? defaultConfig.esbuild
+  };
+}
+
+exports.ArriApp = ArriApp;
+exports.ArriRouter = ArriRouter;
+exports.DEV_DEFINITION_ENDPOINT = DEV_DEFINITION_ENDPOINT;
+exports.DEV_ENDPOINT_ROOT = DEV_ENDPOINT_ROOT;
+exports.ErrorResponse = ErrorResponse;
+exports.createRpcDefinition = createRpcDefinition;
+exports.defaultConfig = defaultConfig;
+exports.defineConfig = defineConfig;
+exports.defineError = defineError;
+exports.defineRpc = defineRpc;
+exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
+exports.getRpcParamName = getRpcParamName;
+exports.getRpcPath = getRpcPath;
+exports.getRpcResponseName = getRpcResponseName;
+exports.handleH3Error = handleH3Error;
+exports.isArriConfig = isArriConfig;
+exports.isResolvedArriConfig = isResolvedArriConfig;
+exports.isRpc = isRpc;
+exports.registerRpc = registerRpc;