feat: initial boilerplate

api/libraries/server/api.ts

@@ -0,0 +1,415 @@
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalServerError,
+  NotFoundError,
+  NotImplementedError,
+  Route,
+  RouteMethod,
+  ServerError,
+  type ServerErrorResponse,
+  UnauthorizedError,
+  ZodValidationError,
+} from "@spec/relay";
+import { treeifyError } from "zod";
+
+import { logger } from "~libraries/logger/mod.ts";
+
+import { getRequestContext } from "./context.ts";
+import { req } from "./request.ts";
+
+const SUPPORTED_MEHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+
+export class Api {
+  readonly #index = new Map<string, Route>();
+
+  /**
+   * Route maps funneling registered routes to the specific methods supported by
+   * the relay instance.
+   */
+  readonly routes: Routes = {
+    POST: [],
+    GET: [],
+    PUT: [],
+    PATCH: [],
+    DELETE: [],
+  };
+
+  /**
+   * List of paths in the '${method} ${path}' format allowing us to quickly throw
+   * errors if a duplicate route path is being added.
+   */
+  readonly #paths = new Set<string>();
+
+  /**
+   * Instantiate a new Api instance.
+   *
+   * @param routes - Initial list of routes to register with the api.
+   */
+  constructor(routes: Route[] = []) {
+    this.register(routes);
+  }
+
+  /**
+   * Register relays with the API instance allowing for decoupled registration
+   * of server side handling of relay contracts.
+   *
+   * @param routes - Relays to register with the instance.
+   */
+  register(routes: Route[]): this {
+    const methods: (keyof typeof this.routes)[] = [];
+    for (const route of routes) {
+      const path = `${route.method} ${route.path}`;
+      if (this.#paths.has(path)) {
+        throw new Error(`Router > Path ${path} already exists`);
+      }
+      this.#paths.add(path);
+      this.routes[route.method].push(route);
+      methods.push(route.method);
+      this.#index.set(`${route.method} ${route.path}`, route);
+    }
+    for (const method of methods) {
+      this.routes[method].sort(byStaticPriority);
+    }
+    return this;
+  }
+
+  /**
+   * Executes request and returns a `Response` instance.
+   *
+   * @param request - REST request to pass to a route handler.
+   */
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+
+    // ### Route
+    // Locate a route matching the incoming request method and path.
+
+    const resolved = this.#getResolvedRoute(request.method, url.pathname);
+    if (resolved === undefined) {
+      return toResponse(
+        new NotFoundError(`Invalid routing path provided for ${request.url}`, {
+          method: request.method,
+          url: request.url,
+        }),
+        request,
+      );
+    }
+
+    // ### Handle
+    // Execute request and return a response.
+
+    const response = await this.#getRouteResponse(resolved, request).catch((error) =>
+      this.#getErrorResponse(error, resolved.route, request),
+    );
+
+    return response;
+  }
+
+  /**
+   * Attempt to resolve a route based on the given method and pathname.
+   *
+   * @param method - HTTP method.
+   * @param url    - HTTP request url.
+   */
+  #getResolvedRoute(method: string, url: string): ResolvedRoute | undefined {
+    assertMethod(method);
+    for (const route of this.routes[method]) {
+      if (route.match(url) === true) {
+        return { route, params: route.getParsedParams(url) };
+      }
+    }
+  }
+
+  /**
+   * Resolve the request on the given route and return a `Response` instance.
+   *
+   * @param resolved - Route and paramter details resolved for the request.
+   * @param request  - Request instance to resolve.
+   */
+  async #getRouteResponse({ route, params }: ResolvedRoute, request: Request): Promise<Response> {
+    const url = new URL(request.url);
+
+    // ### Args
+    // Arguments is passed to every route handler and provides a suite of functionality
+    // and request data.
+
+    const args: any[] = [];
+
+    // ### Input
+    // Generate route input which contains a map fo params, query, and/or body. If
+    // none of these are present then the input is not added to the final argument
+    // context of the handler.
+
+    const input: {
+      params?: object;
+      query?: object;
+      body?: unknown;
+    } = {
+      params: undefined,
+      query: undefined,
+      body: undefined,
+    };
+
+    // ### Access
+    // Check the access requirements of the route and run any additional checks
+    // if nessesary before proceeding with further request handling.
+    //   1. All routes needs access assignment, else we consider it an internal error.
+    //   2. If access requires a session we throw Unauthorized if the request is not authenticated.
+    //   3. If access is an array of access resources, we check that each resources can be
+    //      accessed by the request.
+
+    if (route.state.access === undefined) {
+      return toResponse(
+        new InternalServerError(`Route '${route.method} ${route.path}' is missing access assignment.`),
+        request,
+      );
+    }
+
+    if (route.state.access === "session" && req.isAuthenticated === false) {
+      return toResponse(new UnauthorizedError(), request);
+    }
+
+    if (Array.isArray(route.state.access)) {
+      for (const hasAccess of route.state.access) {
+        if (hasAccess() === false) {
+          return toResponse(new ForbiddenError(), request);
+        }
+      }
+    }
+
+    // ### Params
+    // If the route has params we want to coerce the values to the expected types.
+
+    if (route.state.params !== undefined) {
+      const result = await route.state.params.safeParseAsync(params);
+      if (result.success === false) {
+        return toResponse(new ZodValidationError("Invalid request params", treeifyError(result.error)), request);
+      }
+      input.params = result.data;
+    }
+
+    // ### Query
+    // If the route has a query schema we need to validate and parse the query.
+
+    if (route.state.query !== undefined) {
+      const result = await route.state.query.safeParseAsync(toQuery(url.searchParams) ?? {});
+      if (result.success === false) {
+        return toResponse(new ZodValidationError("Invalid request query", treeifyError(result.error)), request);
+      }
+      input.query = result.data;
+    }
+
+    // ### Body
+    // If the route has a body schema we need to validate and parse the body.
+
+    if (route.state.body !== undefined) {
+      const body = await this.#getRequestBody(request);
+      const result = await route.state.body.safeParseAsync(body);
+      if (result.success === false) {
+        return toResponse(new ZodValidationError("Invalid request body", treeifyError(result.error)), request);
+      }
+      input.body = result.data;
+    }
+
+    if (input.params !== undefined || input.query !== undefined || input.body !== undefined) {
+      args.push(input);
+    }
+
+    // ### Context
+    // Request context pass to every route as the last argument.
+
+    args.push(getRequestContext(request));
+
+    // ### Handler
+    // Execute the route handler and apply the result.
+
+    if (route.state.handle === undefined) {
+      return toResponse(new NotImplementedError(`Path '${route.method} ${route.path}' is not implemented.`), request);
+    }
+
+    return toResponse(await route.state.handle(...args), request);
+  }
+
+  #getErrorResponse(error: unknown, route: Route, request: Request): Response {
+    if (route?.state.hooks?.onError !== undefined) {
+      return route.state.hooks.onError(error);
+    }
+    if (error instanceof ServerError) {
+      return toResponse(error, request);
+    }
+    logger.error(error);
+    if (error instanceof Error) {
+      return toResponse(new InternalServerError(error.message), request);
+    }
+    return toResponse(new InternalServerError(), request);
+  }
+
+  /**
+   * Resolves request body and returns it.
+   *
+   * @param request - Request to resolve body from.
+   * @param files   - Files to populate if present.
+   */
+  async #getRequestBody(request: Request): Promise<Record<string, unknown>> {
+    let body: Record<string, unknown> = {};
+
+    const type = request.headers.get("content-type");
+    if (!type || request.method === "GET") {
+      return body;
+    }
+
+    if (type.includes("json")) {
+      body = await request.json();
+    }
+
+    if (type.includes("application/x-www-form-urlencoded") || type.includes("multipart/form-data")) {
+      try {
+        const formData = await request.formData();
+        for (const [name, value] of Array.from(formData.entries())) {
+          body[name] = value;
+        }
+      } catch (error) {
+        logger.error(error);
+        throw new BadRequestError(`Malformed FormData`, { error });
+      }
+    }
+
+    return body;
+  }
+}
+
+/*
+ |--------------------------------------------------------------------------------
+ | Helpers
+ |--------------------------------------------------------------------------------
+ */
+
+/**
+ * Assert that the given method string is a valid routing method.
+ *
+ * @param candidate - Method candidate.
+ */
+function assertMethod(candidate: string): asserts candidate is RouteMethod {
+  if (!SUPPORTED_MEHODS.includes(candidate)) {
+    throw new Error(`Router > Unsupported method '${candidate}'`);
+  }
+}
+
+/**
+ * Sorting method for routes to ensure that static properties takes precedence
+ * for when a route is matched against incoming requests.
+ *
+ * @param a - Route A
+ * @param b - Route B
+ */
+function byStaticPriority(a: Route, b: Route) {
+  const aSegments = a.path.split("/");
+  const bSegments = b.path.split("/");
+
+  const maxLength = Math.max(aSegments.length, bSegments.length);
+
+  for (let i = 0; i < maxLength; i++) {
+    const aSegment = aSegments[i] || "";
+    const bSegment = bSegments[i] || "";
+
+    const isADynamic = aSegment.startsWith(":");
+    const isBDynamic = bSegment.startsWith(":");
+
+    if (isADynamic !== isBDynamic) {
+      return isADynamic ? 1 : -1;
+    }
+
+    if (isADynamic === false && aSegment !== bSegment) {
+      return aSegment.localeCompare(bSegment);
+    }
+  }
+
+  return a.path.localeCompare(b.path);
+}
+
+/**
+ * Resolve and return query object from the provided search parameters, or undefined
+ * if the search parameters does not have any entries.
+ *
+ * @param searchParams - Search params to create a query object from.
+ */
+function toQuery(searchParams: URLSearchParams): object | undefined {
+  if (searchParams.size === 0) {
+    return undefined;
+  }
+  const result: Record<string, string> = {};
+  for (const [key, value] of searchParams.entries()) {
+    result[key] = value;
+  }
+  return result;
+}
+
+/**
+ * Takes a server side request result and returns a fetch Response.
+ *
+ * @param result  - Result to send back as a Response.
+ * @param request - Request instance.
+ */
+export function toResponse(result: unknown, request: Request): Response {
+  const method = request.method;
+
+  if (result instanceof Response) {
+    if (method === "HEAD") {
+      return new Response(null, {
+        status: result.status,
+        statusText: result.statusText,
+        headers: new Headers(result.headers),
+      });
+    }
+    return result;
+  }
+
+  if (result instanceof ServerError) {
+    const body = JSON.stringify({
+      error: {
+        status: result.status,
+        message: result.message,
+        data: result.data,
+      },
+    } satisfies ServerErrorResponse);
+
+    return new Response(method === "HEAD" ? null : body, {
+      statusText: result.message || "Internal Server Error",
+      status: result.status || 500,
+      headers: {
+        "content-type": "application/json",
+      },
+    });
+  }
+
+  const body = JSON.stringify({
+    data: result ?? null,
+  });
+
+  return new Response(method === "HEAD" ? null : body, {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+  });
+}
+
+/*
+ |--------------------------------------------------------------------------------
+ | Types
+ |--------------------------------------------------------------------------------
+ */
+
+type Routes = {
+  POST: Route[];
+  GET: Route[];
+  PUT: Route[];
+  PATCH: Route[];
+  DELETE: Route[];
+};
+
+type ResolvedRoute = {
+  route: Route;
+  params: any;
+};

api/libraries/server/context.ts

@@ -0,0 +1,16 @@
+import { RouteContext } from "@spec/relay";
+
+export function getRequestContext(request: Request): RouteContext {
+  return {
+    request,
+  };
+}
+
+declare module "@spec/relay" {
+  interface RouteContext {
+    /**
+     * Current request instance being  handled.
+     */
+    request: Request;
+  }
+}

api/libraries/server/mod.ts

@@ -0,0 +1,5 @@
+export * from "./api.ts";
+export * from "./context.ts";
+export * from "./modules.ts";
+export * from "./request.ts";
+export * from "./storage.ts";

api/libraries/server/modules.ts

@@ -0,0 +1,40 @@
+import { Route } from "@spec/relay";
+
+/**
+ * Resolve and return all routes that has been created under any 'routes'
+ * folders that can be found under the given path.
+ *
+ * If the filter is empty, all paths are resolved, otherwise only paths
+ * declared in the array is resolved.
+ *
+ * @param path   - Path to resolve routes from.
+ * @param filter - List of modules to include.
+ * @param routes - List of routes that has been resolved.
+ */
+export async function resolveRoutes(path: string, routes: Route[] = []): Promise<Route[]> {
+  for await (const entry of Deno.readDir(path)) {
+    if (entry.isDirectory === true) {
+      await loadRoutes(`${path}/${entry.name}/routes`, routes, [name]);
+    }
+  }
+  return routes;
+}
+
+async function loadRoutes(path: string, routes: Route[], modules: string[]): Promise<void> {
+  for await (const entry of Deno.readDir(path)) {
+    if (entry.isDirectory === true) {
+      await loadRoutes(`${path}/${entry.name}`, routes, [...modules, entry.name]);
+    } else {
+      if (!entry.name.endsWith(".ts") || entry.name.endsWith("i9n.ts")) {
+        continue;
+      }
+      const { default: route } = (await import(`${path}/${entry.name}`)) as { default: Route };
+      if (route instanceof Route === false) {
+        throw new Error(
+          `Router Violation: Could not load '${path}/${entry.name}' as it does not export a default Route instance.`,
+        );
+      }
+      routes.push(route);
+    }
+  }
+}

api/libraries/server/request.ts

@@ -0,0 +1,57 @@
+import { asyncLocalStorage } from "./storage.ts";
+
+export const req = {
+  get store() {
+    const store = asyncLocalStorage.getStore();
+    if (store === undefined) {
+      throw new Error("Request > AsyncLocalStorage not defined.");
+    }
+    return store;
+  },
+
+  get socket() {
+    return this.store.socket;
+  },
+
+  /**
+   * Get store that is potentially undefined.
+   * Typically used when utility functions might run in and out of request scope.
+   */
+  get unsafeStore() {
+    return asyncLocalStorage.getStore();
+  },
+
+  /**
+   * Check if the request is authenticated.
+   */
+  get isAuthenticated() {
+    return this.session !== undefined;
+  },
+
+  /**
+   * Get current session.
+   */
+  get session() {
+    return this.store.session;
+  },
+
+  /**
+   * Gets the meta information stored in the request.
+   */
+  get info() {
+    return this.store.info;
+  },
+
+  /**
+   * Sends a JSON-RPC 2.0 notification to the request if sent through a
+   * WebSocket connection.
+   *
+   * @param method - Method to send notification to.
+   * @param params - Params to pass to the method.
+   */
+  notify(method: string, params: any): void {
+    this.socket?.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
+  },
+} as const;
+
+export type ReqContext = typeof req;

api/libraries/server/storage.ts

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+import type { Session } from "~libraries/auth/mod.ts";
+
+export const asyncLocalStorage = new AsyncLocalStorage<{
+  session?: Session;
+  info: {
+    method: string;
+    start: number;
+    end?: number;
+  };
+  socket?: WebSocket;
+  response: {
+    headers: Headers;
+  };
+}>();