primate 0.31.13 → 0.32.0

package/src/errors.json

@@ -1,130 +0,0 @@
-{
-  "module": "primate",
-  "errors": {
-    "DoubleFileExtension": {
-      "message": "double file extension {0}",
-      "fix": "unload one of the two handlers registering the file extension",
-      "level": "Error"
-    },
-    "DoubleModule": {
-      "message": "double module {0} in {1}",
-      "fix": "load {0} only once",
-      "level": "Error"
-    },
-    "DoublePathParameter": {
-      "message": "double path parameter {0} in route {1}",
-      "fix": "disambiguate path parameters in route names",
-      "level": "Error"
-    },
-    "DoubleRoute": {
-      "message": "double route of the form {0}",
-      "fix": "disambiguate routes",
-      "level": "Error"
-    },
-    "EmptyConfigFile": {
-      "message": "empty config file at {0}",
-      "fix": "add configuration options to the file or remove it",
-      "level": "Warn"
-    },
-    "EmptyPathParameter": {
-      "message": "empty path parameter {0} in route {1}",
-      "fix": "name the parameter or remove it",
-      "level": "Error"
-    },
-    "EmptyRouteFile": {
-      "message": "empty route file at {0}",
-      "fix": "add routes to the file or remove it",
-      "level": "Warn"
-    },
-    "EmptyDirectory": {
-      "message": "empty {0} directory",
-      "fix": "populate {1} or remove it",
-      "level": "Warn"
-    },
-    "ErrorInConfigFile": {
-      "message": "error in config file: {0}",
-      "fix": "check errors in config file by running {1}",
-      "level": "Error"
-    },
-    "InvalidBodyReturned": {
-      "message": "invalid body returned from route, got {0}",
-      "fix": "return a proper body from route",
-      "level": "Error"
-    },
-    "InvalidDefaultExport": {
-      "message": "invalid default export at {0}",
-      "fix": "use only functions for the default export",
-      "level": "Error"
-    },
-    "InvalidPath": {
-      "message": "invalid path {0}",
-      "fix": "use only letters, digits, '_', '[', ']' or '=' in path filenames",
-      "level": "Error"
-    },
-    "InvalidTypeExport": {
-      "message": "invalid type export at {0}",
-      "fix": "export object with a `base` string and a `validate` function",
-      "level": "Error"
-    },
-    "InvalidTypeName": {
-      "message": "invalid type name {0}",
-      "fix": "use lowercase-first latin letters and decimals in type names",
-      "level": "Error"
-    },
-    "MismatchedBody": {
-      "message": "{0}: {1}",
-      "fix": "make sure the body payload corresponds to the used content type",
-      "level": "Error"
-    },
-    "MismatchedPath": {
-      "message": "mismatched path {0}: {1}",
-      "fix": "fix the type or the caller",
-      "level": "Info"
-    },
-    "MismatchedType": {
-      "message": "mismatched type: {0}",
-      "fix": "fix the type or the caller",
-      "level": "Info"
-    },
-    "ModuleHasNoHooks": {
-      "message": "module {0} has no hooks",
-      "fix": "ensure every module uses at least one hook or deactivate it",
-      "level": "Warn"
-    },
-    "ModuleHasNoName": {
-      "message": "module at index {0} has no name",
-      "fix": "update module at index {0} and inform maintainer",
-      "level": "Error"
-    },
-    "ModulesMustBeArray" :{
-      "message": "the {0} config property must be an array",
-      "fix": "change {0} to an array in the config or remove this property",
-      "level": "Error"
-    },
-    "NoHandlerForComponent": {
-      "message": "no handler for {0}",
-      "fix": "add handler module for this component or remove {0}",
-      "level": "Error"
-    },
-    "NoRouteToPath": {
-      "message": "no {0} route to {1}",
-      "fix": "create a {0} route function at {2}.js",
-      "level": "Info"
-    },
-    "OptionalRoute": {
-      "message": "optional route {0} must be a leaf",
-      "fix": "move route to leaf (last) position in filesystem hierarchy",
-      "level": "Error"
-    },
-    "ReservedTypeName": {
-      "message": "reserved type name {0}",
-      "fix": "do not use any reserved type names",
-      "level": "Error"
-    },
-    "RestRoute": {
-      "message": "rest route {0} must be a leaf",
-      "fix": "move route to leaf (last) position in filesystem hierarchy",
-      "level": "Error"
-    }
-  }
-}

package/src/exports.js

@@ -1,9 +0,0 @@
-import run from "./run.js";
-
-export * from "./handlers.js";
-
-export { default as Logger } from "./Logger.js";
-
-export { URL, Response, Status, MediaType } from "rcompat/http";
-
-export default command => run(command);

package/src/handlers.js

@@ -1,93 +0,0 @@
-import FS from "rcompat/fs";
-import { MediaType, Status } from "rcompat/http";
-import { identity } from "rcompat/function";
-import { HTML } from "rcompat/string";
-import errors from "./errors.js";
-
-const handle = (mediatype, mapper = identity) => (body, options) => app =>
-  app.respond(mapper(body), app.media(mediatype, options));
-
-// {{{ text
-const text = handle(MediaType.TEXT_PLAIN);
-// }}}
-// {{{ json
-const json = handle(MediaType.APPLICATION_JSON, JSON.stringify);
-// }}}
-// {{{ stream
-const stream = handle(MediaType.APPLICATION_OCTET_STREAM);
-// }}}
-// {{{ ws
-const ws = implementation => ({ server }, _, { original }) =>
-  server.upgrade(original, implementation);
-// }}}
-// {{{ sse
-const sse = handle(MediaType.TEXT_EVENT_STREAM, implementation =>
-  new ReadableStream({
-    start(controller) {
-      implementation.open({
-        send(name, data) {
-          const event = data === undefined ? "" : `event: ${name}\n`;
-          const $data = data === undefined ? name : data;
-          controller.enqueue(`${event}data:${JSON.stringify($data)}\n\n`);
-        },
-      });
-    },
-    cancel() {
-      implementation.close?.();
-    },
-  }));
-// }}}
-// {{{ redirect
-const redirect = (Location, { status = Status.FOUND } = {}) => app =>
-  /* no body */
-  app.respond(null, { status, headers: { Location } });
-// }}}
-// {{{ error
-const error = (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
-  app => app.view({ body, status, page: page ?? app.get("pages.error") });
-// }}}
-// {{{ html
-const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
-const style_re = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
-const remove = /<(?<tag>script|style)>.*?<\/\k<tag>>/gus;
-const render = (component, props = {}) => {
-  const encoded = JSON.parse(HTML.escape(JSON.stringify(props)));
-  const keys = Object.keys(encoded);
-  const values = Object.values(encoded);
-  return new Function(...keys, `return \`${component}\`;`)(...values);
-};
-const html = (name, props, options = {}) => async app => {
-  const location = app.get("location");
-  const components = app.runpath(location.server, location.components);
-  const component = await components.join(name).text();
-  const { head: xhead = [], csp = {}, headers, ...rest } = options;
-  const { script_src: xscript_src = [], style_src: xstyle_src = [] } = csp;
-  const scripts = await Promise.all([...component.matchAll(script_re)]
-    .map(({ groups: { code } }) => app.inline(code, "module")));
-  const styles = await Promise.all([...component.matchAll(style_re)]
-    .map(({ groups: { code } }) => app.inline(code, "style")));
-  const style_src = styles.map(asset => asset.integrity).concat(xstyle_src);
-  const script_src = scripts.map(asset => asset.integrity).concat(xscript_src);
-  const head = [...scripts, ...styles].map(asset => asset.head);
-
-  return app.view({
-    body: render(component.replaceAll(remove, _ => ""), props),
-    head: [...head, ...xhead].join("\n"),
-    headers: {
-      ...app.headers({ "style-src": style_src, "script-src": script_src }),
-      ...headers,
-    },
-    ...rest,
-  });
-};
-// }}}
-// {{{ view
-const extensions = ["fullExtension", "extension"];
-const view = (name, props, options) => (app, ...rest) => extensions
-  .map(extension => app.extensions[new FS.File(name)[extension]])
-  .find(extension => extension?.handle)
-  ?.handle(name, props, options)(app, ...rest)
-    ?? errors.NoHandlerForComponent.throw(name);
-// }}}
-
-export { text, json, stream, redirect, error, html, view, ws, sse };

package/src/hooks/copy_includes.js

@@ -1,20 +0,0 @@
-import FS from "rcompat/fs";
-
-export default async (app, type, post = () => undefined) => {
-  const includes = app.get("build.includes");
-  const reserved = Object.values(app.get("location"));
-
-  if (Array.isArray(includes)) {
-    await Promise.all(includes
-      .filter(include => !reserved.includes(include))
-      .filter(include => /^[^/]*$/u.test(include))
-      .map(async include => {
-        const path = app.root.join(include);
-        if (await path.exists()) {
-          const target = FS.File.join(type, include);
-          await app.stage(path, target);
-          await post(target);
-        }
-      }));
-  }
-};

package/src/hooks/exports.js

@@ -1,7 +0,0 @@
-export { default as init } from "./init.js";
-export { default as stage } from "./stage.js";
-export { default as register } from "./register.js";
-export { default as publish } from "./publish.js";
-export { default as route } from "./route.js";
-export { default as handle } from "./handle.js";
-export { default as parse } from "./parse.js";

package/src/hooks/handle.js

@@ -1,113 +0,0 @@
-import { Response, Status, MediaType, fetch } from "rcompat/http";
-import { cascade, tryreturn } from "rcompat/async";
-import respond from "./respond.js";
-import { error as clientError } from "../handlers.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 error => {
-      app.log.auto(error);
-
-      // the +error.js page itself could fail
-      return tryreturn(_ => respond(error_handler(request))(app, {}, request))
-        .orelse(_ => clientError()(app, {}, request));
-    });
-  };
-
-  const as_asset = async path => new Response(path.stream(), {
-    status: Status.OK,
-    headers: {
-      "Content-Type": MediaType.resolve(path.name),
-      Etag: await path.modified(),
-    },
-  });
-
-  const location = app.get("location");
-  const root = app.get("http.static.root");
-  const client = app.runpath(location.client);
-  const handle = async request => {
-    const { pathname } = request.url;
-    if (pathname.startsWith(root)) {
-      const debased = pathname.replace(root, _ => "");
-      // try static first
-      const asset = client.join(location.static, debased);
-      if (await asset.isFile) {
-        return as_asset(asset);
-      }
-      const path = client.join(debased);
-      if (await path.isFile) {
-        return as_asset(path);
-      }
-    }
-    return as_route(request);
-  };
-  // 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 hotreload = (request, next) => app.mode === "development"
-    ? app.build.proxy(request, next)
-    : next(request);
-
-  return cascade([pass, hotreload, ...app.modules.handle], handle);
-};

package/src/hooks/init.js

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

package/src/hooks/parse.js

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

package/src/hooks/publish.js

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

package/src/hooks/register.js

@@ -1,60 +0,0 @@
-import FS from "rcompat/fs";
-import { cascade } from "rcompat/async";
-import copy_includes from "./copy_includes.js";
-
-const html = /^.*.html$/u;
-const defaults = new FS.File(import.meta.url).up(2).join("defaults");
-
-const pre = async app => {
-  const pages = app.get("location.pages");
-
-  // copy framework pages
-  await app.stage(defaults, pages, html);
-  // overwrite transformed pages to build
-  await app.path.pages.exists() && await app.stage(app.path.pages, pages, html);
-
-  return app;
-};
-
-const post = async app => {
-  const _static = app.path.static;
-  const location = app.get("location");
-
-  if (await _static.exists()) {
-    // copy static files to build/server/static
-    await app.stage(_static, FS.File.join(location.server, location.static));
-
-    // copy static files to build/client/static
-    await app.stage(_static, FS.File.join(location.client, location.static));
-
-    // copy static files to build/static
-    await app.stage(_static, FS.File.join(location.static));
-
-    // publish JavaScript and CSS files
-    const imports = await FS.File.collect(_static, /\.(?:css)$/u);
-    await Promise.all(imports.map(async file => {
-      const src = file.debase(_static);
-      app.build.export(`import "./${location.static}${src}";`);
-    }));
-  }
-
-  // copy additional subdirectories to build/server
-  await copy_includes(app, location.server);
-  // copy additional subdirectories to build
-  await copy_includes(app, "");
-
-  if (await app.path.components.exists()) {
-    // copy components to build/components
-    await app.stage(app.path.components, FS.File.join(location.components));
-
-    const components = await app.runpath(location.components).collect();
-
-    // from the build directory, compile to server and client
-    await Promise.all(components.map(component => app.compile(component)));
-  }
-
-  return app;
-};
-
-export default async app =>
-  post(await (await cascade(app.modules.register))(await pre(app)));

package/src/hooks/respond.js

@@ -1,29 +0,0 @@
-import FS from "rcompat/fs";
-import { URL, Response } from "rcompat/http";
-import { identity } from "rcompat/function";
-import o from "rcompat/object";
-import { text, json, stream, redirect } from "primate";
-import errors from "../errors.js";
-
-const not_found = value => errors.InvalidBodyReturned.throw(value);
-const is_text = value => typeof value === "string";
-const is_instance = of => value => value instanceof of;
-const is_response = is_instance(globalThis.Response);
-const is_fake_response = is_instance(Response);
-const is_streamable =
-  value => value instanceof FS.Blob || value?.streamable === FS.s_streamable;
-
-// [if, then]
-const guesses = [
-  [is_instance(URL), redirect],
-  [is_streamable, value => stream(value.stream())],
-  [is_instance(ReadableStream), stream],
-  [value => is_response(value) || is_fake_response(value), value => _ => value],
-  [o.proper, json],
-  [is_text, text],
-  [not_found, identity],
-];
-
-const guess = value => guesses.find(([check]) => check(value))?.[1](value);
-
-export default result => typeof result === "function" ? result : guess(result);

package/src/hooks/route.js

@@ -1,49 +0,0 @@
-import o from "rcompat/object";
-import { tryreturn } from "rcompat/sync";
-import { Body } from "rcompat/http";
-import $errors from "../errors.js";
-import validate from "../validate.js";
-
-const { MismatchedBody, MismatchedPath, NoRouteToPath } = $errors;
-
-const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
-  ? pathname.slice(0, -1) : pathname;
-
-const parse_body = (request, url) =>
-  tryreturn(async _ => await Body.parse(request) ?? {})
-    .orelse(error => MismatchedBody.throw(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) ?? NoRouteToPath
-      .throw(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 }) => MismatchedPath.throw(pathname, message))));
-    const path = app.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 = [] } = o.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/hooks/stage.js

@@ -1,64 +0,0 @@
-import FS from "rcompat/fs";
-import { cascade } from "rcompat/async";
-import dispatch from "../dispatch.js";
-import * as loaders from "../loaders/exports.js";
-import { doubled } from "../loaders/common.js";
-import errors from "../errors.js";
-
-const pre = async app => {
-  // remove build directory in case exists
-  await app.path.build.remove();
-  await app.path.build.create();
-  await Promise.all(["server", "client", "pages", "components"]
-    .map(directory => app.runpath(directory).create()));
-
-  return { ...app };
-};
-
-const post = async app => {
-  const $location = app.get("location");
-
-  // stage routes
-  if (await app.path.routes.exists()) {
-    await app.stage(app.path.routes, $location.routes);
-  }
-  if (await app.path.types.exists()) {
-    await app.stage(app.path.types, $location.types);
-  }
-  const user_types = await loaders.types(app.log, app.runpath($location.types));
-  const types = { ...app.types, ...user_types };
-
-  const directory = app.runpath($location.routes);
-  for (const path of await directory.collect()) {
-    await app.extensions[path.extension]
-      ?.route(directory, path.debase(`${directory}/`), types);
-  }
-
-  let router;
-
-  try {
-    router = await FS.Router.load({
-        directory,
-        specials: {
-          guard: { recursive: true },
-          error: { recursive: false },
-          layout: { recursive: true },
-        },
-        predicate(route, request) {
-          return route.default[request.method.toLowerCase()] !== undefined;
-        },
-      });
-  } catch (error) {
-    const { DoubleRoute, OptionalRoute, RestRoute } = FS.Router.Error;
-    error instanceof DoubleRoute && errors.DoubleRoute.throw(error.route);
-    error instanceof OptionalRoute && errors.OptionalRoute.throw(error.route);
-    error instanceof RestRoute && errors.RestRoute.throw(error.route);
-    // rethrow original error
-    throw error;
-  }
-  const layout = { depth: router.depth("layout") };
-  return { ...app, types, dispatch: dispatch(types), layout, router };
-};
-
-export default async app =>
-  post(await (await cascade(app.modules.stage))(await pre(app)));

package/src/loaders/common.js

@@ -1,32 +0,0 @@
-import FS from "rcompat/fs";
-import { identity } from "rcompat/function";
-import errors from "../errors.js";
-
-const ending = ".js";
-
-const empty = log => (objects, name, path) =>
-  Object.keys(objects).length === 0
-    && errors.EmptyDirectory.warn(log, name, path);
-
-export default async ({
-  log,
-  directory,
-  name = "routes",
-  filter = identity,
-  recursive = true,
-  warn = true,
-} = {}) => {
-  const objects = directory === undefined ? [] : await Promise.all(
-    (await FS.File.collect(directory, /^.*.js$/u, { recursive }))
-      .filter(filter)
-      .map(async file => [
-        `${file}`.replace(directory, _ => "").slice(1, -ending.length),
-        await file.import(),
-      ]));
-  warn && await directory.exists() && empty(log)(objects, name, directory);
-
-  return objects;
-};
-
-export const doubled = set => set.find((part, i, array) =>
-  array.filter((_, j) => i !== j).includes(part));

package/src/loaders/exports.js

@@ -1,2 +0,0 @@
-export { default as modules } from "./modules.js";
-export { default as types } from "./types.js";

package/src/loaders/modules.js

@@ -1,33 +0,0 @@
-import * as hooks from "../hooks/exports.js";
-import { doubled } from "./common.js";
-import errors from "../errors.js";
-
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
-
-const load = (modules = []) => modules.map(module =>
-  [module, load(module.load?.() ?? [])]).flat();
-
-export default async (log, root, modules) => {
-  Array.isArray(modules) || errors.ModulesMustBeArray.throw("modules");
-
-  modules.some(({ name }, n) => name === undefined &&
-    errors.ModuleHasNoName.throw(n));
-
-  const names = modules.map(({ name }) => name);
-  new Set(names).size !== modules.length &&
-    errors.DoubleModule.throw(doubled(names), root.join("primate.config.js"));
-
-  const hookless = modules.filter(module => !Object.keys(module).some(key =>
-    [...Object.keys(hooks), "load", "context"].includes(key)));
-  hookless.length > 0 && errors.ModuleHasNoHooks.warn(log,
-    hookless.map(({ name }) => name).join(", "));
-
-  // 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)])),
-  };
-};