@primate/core 0.1.0

package/src/serve/hook/handle.js

@@ -0,0 +1,120 @@
+import log from "#log";
+import client_error from "@primate/core/handler/error";
+import cascade from "@rcompat/async/cascade";
+import tryreturn from "@rcompat/async/tryreturn";
+import reload_defaults from "@rcompat/build/reload/defaults";
+import reload_path from "@rcompat/build/reload/path";
+import { resolve } from "@rcompat/http/mime";
+import { OK } from "@rcompat/http/status";
+import respond from "./respond.js";
+
+const guard_error = Symbol("guard_error");
+const guard = (app, guards) => async (request, next) => {
+  // handle guards
+  try {
+    for (const guard of guards) {
+      const result = await guard(request);
+      if (result !== true) {
+        const error = new Error();
+        error.result = result;
+        error.type = guard_error;
+        throw error;
+      }
+    }
+
+    return next(request);
+  } catch (error) {
+    if (error.type === guard_error) {
+      return { request, response: respond(error.result)(app) };
+    }
+    // rethrow if not guard error
+    throw error;
+  }
+};
+
+const get_layouts = async (layouts, request) => {
+  const stop_at = layouts.findIndex(({ recursive }) => recursive === false);
+  return Promise.all(layouts
+    .slice(stop_at === -1 ? 0 : stop_at)
+    .map(layout => layout(request)));
+};
+// last handler, preserve final request form
+const last = handler => async request => {
+  const response = await handler(request);
+  return { request, response };
+};
+
+export default app => {
+  const route = request => app.route(request);
+
+  const as_route = async request => {
+    // if tryreturn throws, this will default
+    let error_handler = app.error.default;
+
+    return tryreturn(async _ => {
+      const { body, path, guards, errors, layouts, handler } =
+        await route(request);
+
+      error_handler = errors?.at(-1);
+
+      const hooks = [...app.modules.route, guard(app, guards), last(handler)];
+
+      // handle request
+      const routed = await (await cascade(hooks))({ ...request, body, path });
+
+      const $layouts = { layouts: await get_layouts(layouts, routed.request) };
+      return respond(routed.response)(app, $layouts, routed.request);
+    }).orelse(async () => {
+      // the +error.js page itself could fail
+      return tryreturn(_ => respond(error_handler(request))(app, {}, request))
+        .orelse(_ => client_error()(app, {}, request));
+    });
+  };
+
+  const as_asset = async (pathname, code) => new Response(code, {
+    status: OK,
+    headers: {
+      "Content-Type": resolve(pathname),
+//      Etag: await path.modified(),
+    },
+  });
+
+  const handle = async request => {
+    const { pathname } = request.url;
+
+    const asset = app.loader.asset(pathname)?.code;
+
+    return asset === undefined ? as_route(request) : as_asset(pathname, asset);
+  };
+  // first hook
+  const pass = (request, next) => next({
+    ...request,
+    pass(to) {
+      const { method, headers, body } = request.original;
+      const input = `${to}${request.url.pathname}`;
+
+      return fetch(input, { headers, method, body, duplex: "half" });
+    },
+  });
+
+  const paths = [reload_path].concat(app.assets
+    .filter(asset => asset.type !== "importmap")
+    .map(asset => asset.src));
+  const http = app.get("http");
+  const url = `http://${http.host}:${reload_defaults.port}`;
+
+  const proxy = (request, fallback) => {
+    const { pathname } = new URL(request.url);
+    const { method, headers, body } = request;
+
+    return paths.includes(pathname)
+      ? fetch(`${url}${pathname}`, { headers, method, body, duplex: "half" })
+      : fallback();
+  };
+
+  const hotreload = (request, next) => app.mode === "development"
+    ? proxy(request.original, () => next(request))
+    : next(request);
+
+  return cascade([pass, hotreload, ...app.modules.handle], handle);
+};

package/src/serve/hook/init.js

@@ -0,0 +1,3 @@
+import cascade from "@rcompat/async/cascade";
+
+export default async app => (await cascade(app.modules.init))(app);

package/src/serve/hook/parse.js

@@ -0,0 +1,17 @@
+import dispatch from "#dispatch";
+import valmap from "@rcompat/object/valmap";
+
+export default () => async original => {
+  const { headers } = original;
+
+  const url = new URL(original.url);
+  const cookies = headers.get("cookie");
+
+  return { original, url,
+  ...valmap({
+    query: [Object.fromEntries(url.searchParams), url.search],
+    headers: [Object.fromEntries(headers), headers, false],
+    cookies: [Object.fromEntries(cookies?.split(";").map(cookie =>
+      cookie.trim().split("=")) ?? []), cookies],
+  }, value => dispatch(...value)) };
+};

package/src/serve/hook/respond.js

@@ -0,0 +1,28 @@
+import bad_body from "#error/bad-body";
+import json from "@primate/core/handler/json";
+import redirect from "@primate/core/handler/redirect";
+import stream from "@primate/core/handler/stream";
+import text from "@primate/core/handler/text";
+import streamable from "@rcompat/fs/streamable";
+import identity from "@rcompat/function/identity";
+import proper from "@rcompat/object/proper";
+
+const is_instance = of => value => value instanceof of;
+const is_response = is_instance(Response);
+const is_streamable =
+  value => value instanceof Blob || value?.streamable === streamable;
+
+// [if, then]
+const guesses = [
+  [is_instance(URL), redirect],
+  [is_streamable, value => stream(value.stream())],
+  [is_instance(ReadableStream), stream],
+  [value => is_response(value), value => _ => value],
+  [proper, json],
+  [value => typeof value === "string", text],
+  [bad_body, identity],
+];
+
+const guess = value => guesses.find(([check]) => check(value))?.[1](value);
+
+export default result => typeof result === "function" ? result : guess(result);

package/src/serve/hook/route.js

@@ -0,0 +1,50 @@
+import dispatch from "#dispatch";
+import mismatched_body from "#error/mismatched-body";
+import mismatched_path from "#error/mismatched-path";
+import no_route_to_path from "#error/no-route-to-path";
+import validate from "#validate";
+import Body from "@rcompat/http/body";
+import map from "@rcompat/object/map";
+import tryreturn from "@rcompat/sync/tryreturn";
+
+const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
+  ? pathname.slice(0, -1) : pathname;
+
+const parse_body = (request, url) =>
+  tryreturn(async _ => await Body.parse(request) ?? {})
+    .orelse(error => mismatched_body(url.pathname, error.message));
+
+export default app => {
+  const $request_body_parse = app.get("request.body.parse");
+  const $location = app.get("location");
+
+  const index = path => `${$location.routes}${path === "/" ? "/index" : path}`;
+  // remove excess slashes
+  const deslash = url => url.replaceAll(/\/{2,}/gu, _ => "/");
+
+  return async ({ original, url }) => {
+    const pathname = deroot(deslash(url.pathname));
+    const route = await app.router.match(original) ??
+      no_route_to_path(original.method.toLowerCase(), pathname, index(pathname));
+    const { params } = route;
+    const untyped_path = Object.fromEntries(Object.entries(params)
+      .filter(([name]) => !name.includes("="))
+      .map(([key, value]) => [key, value]));
+    const typed_path = Object.fromEntries(Object.entries(params)
+      .filter(([name]) => name.includes("="))
+      .map(([name, value]) => [name.split("="), value])
+      .map(([[name, type], value]) =>
+        tryreturn(_ => {
+          validate(app.types[type], value, name);
+          return [name, value];
+        }).orelse(({ message }) => mismatched_path(pathname, message))));
+    const path = dispatch({ ...untyped_path, ...typed_path });
+    const local_parse_body = route.file.body?.parse ?? $request_body_parse;
+    const body = local_parse_body ? await parse_body(original, url) : null;
+    const { guards = [], errors = [], layouts = [] } = map(route.specials,
+      ([key, value]) => [`${key}s`, value.map(i => i.default)]);
+    const handler = route.file.default[original.method.toLowerCase()];
+
+    return { body, path, guards, errors, layouts, handler };
+  };
+};

package/src/serve/hook/serve.js

@@ -0,0 +1,53 @@
+import log from "#log";
+import cascade from "@rcompat/async/cascade";
+import tryreturn from "@rcompat/async/tryreturn";
+import dim from "@rcompat/cli/color/dim";
+import Router from "@rcompat/fs/router";
+import serve from "@rcompat/http/serve";
+import { INTERNAL_SERVER_ERROR } from "@rcompat/http/status";
+import * as hook from "./exports.js";
+
+const post = async app => {
+  const types = Object.fromEntries(app.files.types.map(([key, value]) =>
+    [key, value.default]));
+  let router;
+
+  try {
+    router = await Router.init({
+        specials: {
+          guard: { recursive: true },
+          error: { recursive: false },
+          layout: { recursive: true },
+        },
+        predicate(route, request) {
+          return route.default[request.method.toLowerCase()] !== undefined;
+        },
+      }, app.files.routes);
+  } catch {}
+
+  app.create_csp();
+
+  const $app = { ...app, types, router };
+  $app.route = hook.route($app);
+  $app.parse = hook.parse($app);
+  const $handle = await hook.handle($app);
+
+  $app.server = await serve(async request =>
+    tryreturn(async _ => $handle(await $app.parse(request)))
+      .orelse(error => {
+        log.auto(error);
+        return new Response(null, { status: INTERNAL_SERVER_ERROR });
+      }), $app.get("http"));
+  const { host, port } = $app.get("http");
+  const address = `http${$app.secure ? "s" : ""}://${host}:${port}`;
+  log.system(`started ${dim("->")} ${dim(address)}`);
+
+  app.set("server", $app.server);
+
+  return $app;
+};
+
+export default async app => {
+  log.system("in startup");
+  return post(await (await cascade(app.modules.serve))(app));
+};

package/src/serve/index.js

@@ -0,0 +1,9 @@
+import defaults from "#config";
+import override from "@rcompat/object/override";
+import app from "./app.js";
+import { init, serve } from "./hook/exports.js";
+
+export default async (root, { config, ...options }) => serve(
+  await init(
+    await app(root, { config: override(defaults, config), ...options }),
+  ));

package/src/serve/module_loader.js

@@ -0,0 +1,16 @@
+import * as hooks from "./hook/exports.js";
+
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+const load = (modules = []) => modules.map(module =>
+  [module, load(module.load?.() ?? [])]).flat();
+
+export default async (root, modules) => {
+  // collect modules
+  const loaded = load(modules).flat(2);
+
+  return {
+    names: loaded.map(module => module.name),
+    ...Object.fromEntries([...Object.keys(hooks), "context"]
+      .map(hook => [hook, filter(hook, loaded)])),
+  };
+};

package/src/serve/to_sorted.js

@@ -0,0 +1 @@
+export default (array, compareFn) => [...array].sort(compareFn);