arri 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# server
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build server` to build the library.
+
+## Running unit tests
+
+Run `nx test server` to execute the unit tests via [Jest](https://jestjs.io).

package/dist/cli.cjs

@@ -0,0 +1,55 @@
+#!/user/bin/env node
+'use strict';
+
+const citty = require('citty');
+const consola = require('consola');
+
+const devLogger = consola.consola.create({});
+consola.consola.create({});
+
+const dev = citty.defineCommand({
+  meta: {
+    name: "dev"
+  },
+  args: {
+    config: {
+      type: "string",
+      description: "path to a config file",
+      default: "./arri.config.ts",
+      alias: "c",
+      valueHint: "./arri.config.ts"
+    }
+  },
+  run({ args }) {
+    devLogger.log(args.config);
+  }
+});
+
+const build = citty.defineCommand({
+  meta: {
+    name: "build"
+  },
+  args: {
+    config: {
+      type: "string",
+      alias: "c",
+      default: "./arri.config.ts",
+      valueHint: "./arri.config.ts"
+    }
+  },
+  run({ args }) {
+    devLogger.log("Running build");
+    devLogger.log(args.config);
+  }
+});
+
+const main = citty.defineCommand({
+  meta: {
+    name: "arri"
+  },
+  subCommands: {
+    dev,
+    build
+  }
+});
+citty.runMain(main);

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export { }

package/dist/cli.mjs

@@ -0,0 +1,53 @@
+#!/user/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { consola } from 'consola';
+
+const devLogger = consola.create({});
+consola.create({});
+
+const dev = defineCommand({
+  meta: {
+    name: "dev"
+  },
+  args: {
+    config: {
+      type: "string",
+      description: "path to a config file",
+      default: "./arri.config.ts",
+      alias: "c",
+      valueHint: "./arri.config.ts"
+    }
+  },
+  run({ args }) {
+    devLogger.log(args.config);
+  }
+});
+
+const build = defineCommand({
+  meta: {
+    name: "build"
+  },
+  args: {
+    config: {
+      type: "string",
+      alias: "c",
+      default: "./arri.config.ts",
+      valueHint: "./arri.config.ts"
+    }
+  },
+  run({ args }) {
+    devLogger.log("Running build");
+    devLogger.log(args.config);
+  }
+});
+
+const main = defineCommand({
+  meta: {
+    name: "arri"
+  },
+  subCommands: {
+    dev,
+    build
+  }
+});
+runMain(main);

package/dist/index.cjs

@@ -0,0 +1,149 @@
+'use strict';
+
+const h3 = require('h3');
+const h3Zod = require('h3-zod');
+
+function isH3Error(input) {
+  if (typeof input !== "object" || input == null) {
+    return false;
+  }
+  const keys = Object.keys(input);
+  if (keys.includes("statusCode") && typeof input["statusCode"] === "number") {
+    return true;
+  }
+  return false;
+}
+function defineError(statusCode, opts = {}) {
+  const statusMessage = opts.statusMessage ?? opts.message;
+  const message = opts.message ?? opts.statusMessage;
+  return h3.createError({
+    statusCode,
+    ...opts,
+    statusMessage,
+    message
+  });
+}
+
+const defineRoute = (route) => route;
+const defineMiddleware = (middleware) => middleware;
+async function handleRoute(event, route, middlewares) {
+  const processedEvent = event;
+  try {
+    if (route.schema?.body) {
+      const body = await h3Zod.zh.useValidatedBody(event, route.schema.body);
+      processedEvent.context.body = body;
+    }
+    if (route.schema?.query) {
+      const query = await h3Zod.zh.useValidatedQuery(event, route.schema.query);
+      processedEvent.context.query = query;
+    }
+    for (const item of middlewares) {
+      await item(processedEvent);
+    }
+    if (processedEvent._handled) {
+      return;
+    }
+    const result = await route.handler(processedEvent);
+    await h3.send(processedEvent, result);
+    if (route.postHandler) {
+      processedEvent.context.response = result;
+      await route.postHandler(processedEvent);
+    }
+  } catch (err) {
+    if (isH3Error(err)) {
+      h3.setResponseStatus(processedEvent, err.statusCode);
+      h3.sendError(processedEvent, err);
+    }
+    h3.setResponseStatus(processedEvent, 500);
+    h3.sendError(
+      processedEvent,
+      defineError(500, {
+        statusMessage: "an unknown error occurred",
+        message: "an unknown error occurred",
+        data: err
+      })
+    );
+  }
+}
+function registerArriRoutes(app, routeMap) {
+  const routes = [];
+  Object.keys(routeMap).forEach((key) => {
+    const routeGetMap = routeMap[key];
+    Object.keys(routeGetMap).forEach((path) => {
+      routes.push(routeGetMap[path]);
+    });
+  });
+  for (const route of routes) {
+    registerArriRoute(app, route);
+  }
+}
+function registerArriRoute(app, route) {
+  app.use(
+    route.path,
+    h3.defineEventHandler(async (event) => {
+      const parsedContext = event.context;
+      parsedContext.params = event.context.params ?? {};
+      if (route.schema?.body && methodAllowsBody(route.method)) {
+        const body = await h3Zod.zh.useSafeValidatedBody(
+          event,
+          route.schema.body
+        );
+        if (!body || !body.success) {
+          throw defineError(400, {
+            statusMessage: "Invalid request body",
+            data: body.error.errors
+          });
+        }
+        parsedContext.body = body.data;
+      }
+      if (route.schema?.query) {
+        const query = await h3Zod.zh.useSafeValidatedQuery(
+          event,
+          route.schema.query
+        );
+        if (!query || !query.success) {
+          const params = [];
+          for (const err of query.error.errors) {
+            if (err.path.length) {
+              params.push(err.path[0]);
+            }
+          }
+          throw defineError(400, {
+            statusMessage: `Missing/invalid required url query parameters: [${params.join(
+              ", "
+            )}]`,
+            data: query.error.errors
+          });
+        }
+        parsedContext.query = query.data;
+      }
+      event.context = parsedContext;
+      const response = await route.handler(event);
+      event.context.response = response;
+      if (route.postHandler) {
+        await route.postHandler(event);
+      }
+    }),
+    { lazy: true }
+  );
+}
+const methodAllowsBody = (method) => {
+  switch (method) {
+    case "patch":
+    case "post":
+    case "put":
+    case "delete":
+      return true;
+    default:
+      return false;
+  }
+};
+
+exports.defineError = defineError;
+exports.defineMiddleware = defineMiddleware;
+exports.defineRoute = defineRoute;
+exports.handleRoute = handleRoute;
+exports.isH3Error = isH3Error;
+exports.methodAllowsBody = methodAllowsBody;
+exports.registerArriRoute = registerArriRoute;
+exports.registerArriRoutes = registerArriRoutes;

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { H3Error, H3Event, RouterMethod, App } from 'h3';
+import { ZodTypeAny, AnyZodObject } from 'zod';
+
+declare function isH3Error(input: unknown): input is H3Error;
+declare function defineError(statusCode: number, opts?: Partial<Omit<H3Error, "statusCode">>): H3Error;
+
+type ExtractParam<Path, NextPart> = Path extends `:${infer Param}` ? Record<Param, string> & NextPart : NextPart;
+type ExtractParams<Path> = Path extends `${infer Segment}/${infer Rest}` ? ExtractParam<Segment, ExtractParams<Rest>> : ExtractParam<Path, {}>;
+
+interface RouteEventContext<Params extends Record<string, string> = any, Body = any, Query = any, Response = any> {
+    params?: Params;
+    body?: Body;
+    query?: Query;
+    response?: Response;
+}
+interface RouteEvent<Context extends RouteEventContext> extends H3Event {
+    context: Context;
+}
+type ArriRouteHandler<Params extends Record<string, string>, Body, Query, Response> = (event: RouteEvent<RouteEventContext<Params, Body, Query>>) => Response | Promise<Response>;
+interface ArriRoute<Path extends string = "", Method extends RouterMethod = "get", Body extends undefined | ZodTypeAny = undefined, Query extends undefined | AnyZodObject = undefined, Response = any> {
+    id?: string;
+    path: Path;
+    method: Method;
+    schema?: {
+        body?: Body;
+        query?: Query;
+    };
+    handler: ArriRouteHandler<ExtractParams<Path>, Body extends ZodTypeAny ? Body["_type"] : undefined, Query extends AnyZodObject ? Query["_type"] : undefined, Response>;
+    postHandler?: (event: RouteEvent<RouteEventContext<ExtractParams<Path>, Body extends ZodTypeAny ? Body["_type"] : undefined, Query extends AnyZodObject ? Query["_type"] : undefined, Response>>) => any;
+}
+declare const defineRoute: <Path extends string, Method extends "get" | "head" | "patch" | "post" | "put" | "delete" | "connect" | "options" | "trace", Body_1 extends ZodTypeAny | undefined, Query extends AnyZodObject | undefined, Response_1 = any>(route: ArriRoute<Path, Method, Body_1, Query, Response_1>) => ArriRoute<Path, Method, Body_1, Query, Response_1>;
+type ApiRouteMiddleware = (event: RouteEvent<RouteEventContext<Record<string, string>, any, any, undefined>>) => void | Promise<void>;
+declare const defineMiddleware: (middleware: ApiRouteMiddleware) => ApiRouteMiddleware;
+declare function handleRoute(event: H3Event, route: ArriRoute, middlewares: ApiRouteMiddleware[]): Promise<void>;
+declare function registerArriRoutes(app: App, routeMap: any): void;
+declare function registerArriRoute(app: App, route: ArriRoute): void;
+declare const methodAllowsBody: (method: RouterMethod) => boolean;
+
+export { ApiRouteMiddleware, ArriRoute, ArriRouteHandler, ExtractParam, ExtractParams, RouteEvent, RouteEventContext, defineError, defineMiddleware, defineRoute, handleRoute, isH3Error, methodAllowsBody, registerArriRoute, registerArriRoutes };

package/dist/index.mjs

@@ -0,0 +1,140 @@
+import { createError, send, setResponseStatus, sendError, defineEventHandler } from 'h3';
+import { zh } from 'h3-zod';
+
+function isH3Error(input) {
+  if (typeof input !== "object" || input == null) {
+    return false;
+  }
+  const keys = Object.keys(input);
+  if (keys.includes("statusCode") && typeof input["statusCode"] === "number") {
+    return true;
+  }
+  return false;
+}
+function defineError(statusCode, opts = {}) {
+  const statusMessage = opts.statusMessage ?? opts.message;
+  const message = opts.message ?? opts.statusMessage;
+  return createError({
+    statusCode,
+    ...opts,
+    statusMessage,
+    message
+  });
+}
+
+const defineRoute = (route) => route;
+const defineMiddleware = (middleware) => middleware;
+async function handleRoute(event, route, middlewares) {
+  const processedEvent = event;
+  try {
+    if (route.schema?.body) {
+      const body = await zh.useValidatedBody(event, route.schema.body);
+      processedEvent.context.body = body;
+    }
+    if (route.schema?.query) {
+      const query = await zh.useValidatedQuery(event, route.schema.query);
+      processedEvent.context.query = query;
+    }
+    for (const item of middlewares) {
+      await item(processedEvent);
+    }
+    if (processedEvent._handled) {
+      return;
+    }
+    const result = await route.handler(processedEvent);
+    await send(processedEvent, result);
+    if (route.postHandler) {
+      processedEvent.context.response = result;
+      await route.postHandler(processedEvent);
+    }
+  } catch (err) {
+    if (isH3Error(err)) {
+      setResponseStatus(processedEvent, err.statusCode);
+      sendError(processedEvent, err);
+    }
+    setResponseStatus(processedEvent, 500);
+    sendError(
+      processedEvent,
+      defineError(500, {
+        statusMessage: "an unknown error occurred",
+        message: "an unknown error occurred",
+        data: err
+      })
+    );
+  }
+}
+function registerArriRoutes(app, routeMap) {
+  const routes = [];
+  Object.keys(routeMap).forEach((key) => {
+    const routeGetMap = routeMap[key];
+    Object.keys(routeGetMap).forEach((path) => {
+      routes.push(routeGetMap[path]);
+    });
+  });
+  for (const route of routes) {
+    registerArriRoute(app, route);
+  }
+}
+function registerArriRoute(app, route) {
+  app.use(
+    route.path,
+    defineEventHandler(async (event) => {
+      const parsedContext = event.context;
+      parsedContext.params = event.context.params ?? {};
+      if (route.schema?.body && methodAllowsBody(route.method)) {
+        const body = await zh.useSafeValidatedBody(
+          event,
+          route.schema.body
+        );
+        if (!body || !body.success) {
+          throw defineError(400, {
+            statusMessage: "Invalid request body",
+            data: body.error.errors
+          });
+        }
+        parsedContext.body = body.data;
+      }
+      if (route.schema?.query) {
+        const query = await zh.useSafeValidatedQuery(
+          event,
+          route.schema.query
+        );
+        if (!query || !query.success) {
+          const params = [];
+          for (const err of query.error.errors) {
+            if (err.path.length) {
+              params.push(err.path[0]);
+            }
+          }
+          throw defineError(400, {
+            statusMessage: `Missing/invalid required url query parameters: [${params.join(
+              ", "
+            )}]`,
+            data: query.error.errors
+          });
+        }
+        parsedContext.query = query.data;
+      }
+      event.context = parsedContext;
+      const response = await route.handler(event);
+      event.context.response = response;
+      if (route.postHandler) {
+        await route.postHandler(event);
+      }
+    }),
+    { lazy: true }
+  );
+}
+const methodAllowsBody = (method) => {
+  switch (method) {
+    case "patch":
+    case "post":
+    case "put":
+    case "delete":
+      return true;
+    default:
+      return false;
+  }
+};
+
+export { defineError, defineMiddleware, defineRoute, handleRoute, isH3Error, methodAllowsBody, registerArriRoute, registerArriRoutes };

package/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "arri",
+    "version": "0.0.1",
+    "type": "module",
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "bin": {
+        "arri": "./dist/cli.cjs"
+    },
+    "dependencies": {
+        "citty": "^0.1.2",
+        "consola": "^3.2.3",
+        "h3": "^1.7.1",
+        "h3-zod": "^0.5.1",
+        "zod": "^3.21.4"
+    }
+}