@primate/core 0.1.0

package/src/private/depend.js

@@ -0,0 +1,20 @@
+import filter from "@rcompat/object/filter";
+import manifest from "@rcompat/package/manifest";
+import packager from "@rcompat/package/packager";
+import errors from "./errors.js";
+
+const { MissingDependencies } = errors;
+
+export default async (library_manifest, desired, from) => {
+  const app_dependencies = (await manifest()).dependencies;
+  const keys = Object.keys(app_dependencies);
+  const library_peers = filter(library_manifest.peerDependencies, ([key]) =>
+    desired.includes(key));
+  const missing = desired.filter(peer => !keys.includes(peer));
+
+  if (missing.length > 0) {
+    const to_install = missing.map(key => `${key}@${library_peers[key]}`);
+    const install = `${packager()} install ${to_install.join(" ")}`;
+    MissingDependencies.throw(missing.join(", "), from, install);
+  }
+};

package/src/private/dispatch.js

@@ -0,0 +1,18 @@
+import is from "@rcompat/invariant/is";
+
+export default (object, raw, cased = true) => {
+  return Object.assign(Object.create(null), {
+    get(key) {
+      is(key).string();
+
+      return object[cased ? key : key.toLowerCase()];
+    },
+    json() {
+      return JSON.parse(JSON.stringify(object));
+    },
+    toString() {
+      return JSON.stringify(object);
+    },
+    raw,
+  });
+};

package/src/private/error/bad-body.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "bad body returned from route, got {0}",
+  fix: "return a proper body from route",
+});

package/src/private/error/bad-default-export.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "bad default export at {0}",
+  fix: "use only functions for the default export",
+});

package/src/private/error/bad-path.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "bad path {0}",
+  fix: "use only letters, digits, '_', '[', ']' or '=' in path filenames",
+});

package/src/private/error/bad-type-export.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "bad type export at {0}",
+  fix: "export object with a `base` string and a `validate` function",
+});

package/src/private/error/bad-type-name.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "bad type name {0}",
+  fix: "use lowercase-first latin letters and decimals in type names",
+});

package/src/private/error/double-extension.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "double file extension {0}",
+  fix: "unload one of the two handlers registering the file extension",
+});

package/src/private/error/double-module.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "double module {0} in {1}",
+  fix: "load {0} only once",
+});

package/src/private/error/double-path-parameter.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "double path parameter {0} in route {1}",
+  fix: "disambiguate path parameters in route names",
+});

package/src/private/error/double-route.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "double route of the form {0}",
+  fix: "disambiguate routes",
+});

package/src/private/error/empty-config-file.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "empty config file at {0}",
+  fix: "add configuration options to the file or remove it",
+});

package/src/private/error/empty-directory.js

@@ -0,0 +1,6 @@
+import { warn } from "#error";
+
+export default warn(import.meta.url, {
+  message: "empty {0} directory",
+  fix: "populate {1} or remove it",
+});

package/src/private/error/empty-path-parameter.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "empty path parameter {0} in route {1}",
+  fix: "name the parameter or remove it",
+});

package/src/private/error/empty-route-file.js

@@ -0,0 +1,6 @@
+import { warn } from "#error";
+
+export default warn(import.meta.url, {
+  message: "empty route file at {0}",
+  fix: "add routes to the file or remove it",
+});

package/src/private/error/error-in-config-file.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "error in config file: {0}",
+  fix: "check errors in config file by running {1}",
+});

package/src/private/error/mismatched-body.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "{0}: {1}",
+  fix: "make sure the body payload corresponds to the used content type",
+});

package/src/private/error/mismatched-path.js

@@ -0,0 +1,6 @@
+import { info } from "#error";
+
+export default info(import.meta.url, {
+  message: "mismatched path {0}: {1}",
+  fix: "fix the type or the caller",
+});

package/src/private/error/mismatched-type.js

@@ -0,0 +1,6 @@
+import { info } from "#error";
+
+export default info(import.meta.url, {
+  message: "mismatched type: {0}",
+  fix: "fix the type or the caller",
+});

package/src/private/error/module-no-name.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "module at index {0} has no name",
+  fix: "update module at index {0} and inform maintainer",
+});

package/src/private/error/modules-array.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "the {0} config property must be an array",
+  fix: "change {0} to an array in the config or remove this property",
+});

package/src/private/error/no-handler.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "no handler for {0}",
+  fix: "add handler module for this component or remove {0}",
+});

package/src/private/error/no-route-to-path.js

@@ -0,0 +1,6 @@
+import { info } from "#error";
+
+export default info(import.meta.url, {
+  message: "no {0} route to {1}",
+  fix: "create a {0} route function at {2}.js",
+});

package/src/private/error/optional-route.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "optional route {0} must be a leaf",
+  fix: "move route to leaf (last) position in filesystem hierarchy",
+});

package/src/private/error/reserved-type-name.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "reserved type name {0}",
+  fix: "do not use any reserved type names",
+});

package/src/private/error/rest-route.js

@@ -0,0 +1,6 @@
+import { error } from "#error";
+
+export default error(import.meta.url, {
+  message: "rest route {0} must be a leaf",
+  fix: "move route to leaf (last) position in filesystem hierarchy",
+});

package/src/private/error.js

@@ -0,0 +1,15 @@
+import log from "@primate/core/log";
+import file from "@rcompat/fs/file";
+
+const base = level => (url, args) => (...params) => log[level]({
+  params,
+  name: file(url).base,
+  module: "@primate/core",
+  ...args,
+});
+
+const info = base("info");
+const warn = base("warn");
+const error = base("error");
+
+export { error, info, warn };

package/src/private/log.js

@@ -0,0 +1,69 @@
+import loglevel from "#loglevel";
+import mark from "#mark";
+import blue from "@rcompat/cli/color/blue";
+import dim from "@rcompat/cli/color/dim";
+import green from "@rcompat/cli/color/green";
+import red from "@rcompat/cli/color/red";
+import yellow from "@rcompat/cli/color/yellow";
+import print from "@rcompat/cli/print";
+
+const url = "https://primatejs.com/errors";
+const slice_length = "@primate/".length;
+const helpat = (name, error) => `${url}/${name.slice(slice_length)}#${error}`;
+
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+};
+const level = levels[loglevel];
+
+const make_error = (level, { message, fix, name, params, module }) => ({
+  level,
+  fix: mark(fix, ...params),
+  message: mark(message, ...params),
+  name,
+  module,
+});
+
+const normalize = (level, message) => typeof message === "string"
+  ? { message }
+  : make_error(level, message);
+
+const log = (pre, color, error, override) => {
+  const { fix, module, name, message } = { ...error, ...override };
+  print(color(pre), `${module !== undefined ? `${color(module)} ` : ""}${message}`, "\n");
+  if (fix) {
+    print(blue("++"), fix);
+    name && print(dim(`\n   -> ${helpat(module, name)}`), "\n");
+  }
+};
+
+export default {
+  system(message) {
+    log("++", blue, { message });
+  },
+
+  info(error, override) {
+    // info prints only on info level
+    level === levels.info && log("--", green, normalize("info", error), override);
+  },
+
+  warn(error, override) {
+    // warn prints on info and warn levels
+    level >= levels.warn && log("??", yellow, normalize("warn", error), override);
+  },
+
+  error(error, override, toss = true) {
+    // error always prints
+    log("!!", red, normalize("error", error));
+    if (toss) {
+      error.level = "error";
+      throw error;
+    }
+  },
+
+  auto(error) {
+    Object.keys(levels).includes(error.level) && this[error.level](error, {}, false);
+  },
+};

package/src/private/loglevel.js

@@ -0,0 +1,9 @@
+import args from "@rcompat/args";
+
+const default_level = "warn";
+const flag = "--loglevel=";
+const levels = ["error", "warn", "info"];
+
+const loglevel = args.find(arg => arg.startsWith(flag))?.slice(flag.length);
+
+export default levels.includes(loglevel) ? loglevel : default_level;

package/src/private/mark.js

@@ -0,0 +1,5 @@
+import bold from "@rcompat/cli/color/bold";
+
+export default (format, ...params) => params.reduce((formatted, param, i) =>
+  formatted.replace(`{${i}}`, bold(param)), format);
+

package/src/private/validate.js

@@ -0,0 +1,11 @@
+import is from "@rcompat/invariant/is";
+import maybe from "@rcompat/invariant/maybe";
+
+export default (type, value, name) => {
+  maybe(type.validate).function();
+  if (type.validate) {
+    return type.validate(value, name);
+  }
+  is(type).function();
+  return type(value, name);
+};

package/src/serve/app.js

@@ -0,0 +1,191 @@
+import double_extension from "#error/double-extension";
+import crypto from "@rcompat/crypto";
+import join from "@rcompat/fs/join";
+import { html } from "@rcompat/http/mime";
+import { OK } from "@rcompat/http/status";
+import is from "@rcompat/invariant/is";
+import empty from "@rcompat/object/empty";
+import get from "@rcompat/object/get";
+import valmap from "@rcompat/object/valmap";
+import module_loader from "./module_loader.js";
+import to_sorted from "./to_sorted.js";
+
+const to_csp = (config_csp, assets, csp) => config_csp
+  // only csp entries in the config will be enriched
+  .map(([key, directives]) =>
+    // enrich with application assets
+    [key, assets[key] ? directives.concat(...assets[key]) : directives])
+  .map(([key, directives]) =>
+    // enrich with explicit csp
+    [key, csp[key] ? directives.concat(...csp[key]) : directives])
+  .map(([key, directives]) => `${key} ${directives.join(" ")}`)
+  .join(";");
+
+const encoder = new TextEncoder();
+
+const attribute = attributes => empty(attributes)
+  ? ""
+  : " ".concat(Object.entries(attributes)
+    .map(([key, value]) => `${key}="${value}"`).join(" "))
+  ;
+const tag = (name, { attributes = {}, code = "", close = true }) =>
+  `<${name}${attribute(attributes)}${close ? `>${code}</${name}>` : "/>"}`;
+const nctag = (name, properties) => tag(name, { ...properties, close: false });
+const tags = {
+  // inline: <script type integrity>...</script>
+  // outline: <script type integrity src></script>
+  script({ inline, code, type, integrity, src }) {
+    return inline
+      ? tag("script", { attributes: { type, integrity }, code })
+      : tag("script", { attributes: { type, integrity, src } });
+  },
+  // inline: <style>...</style>
+  // outline: <link rel="stylesheet" href />
+  style({ inline, code, href, rel = "stylesheet" }) {
+    return inline
+      ? tag("style", { code })
+      : nctag("link", { attributes: { rel, href } });
+  },
+  font({ href, rel = "preload", as = "font", type, crossorigin = true }) {
+    return nctag("link", { attributes: { rel, href, as, type, crossorigin } });
+  },
+};
+
+const render_head = (assets, fonts, head) =>
+  to_sorted(assets, ({ type }) => -1 * (type === "importmap"))
+    .map(({ src, code, type, inline, integrity }) =>
+      type === "style"
+        ? tags.style({ inline, code, href: src })
+        : tags.script({ inline, code, type, integrity, src }),
+    ).join("\n").concat("\n", head ?? "").concat("\n", fonts.map(href =>
+      tags.font({ href, type: "font/woff2" }),
+    ).join("\n"));
+
+export default async (root, { config, assets, files, components, loader, target, mode }) => {
+  const { http } = config;
+  const secure = http?.ssl !== undefined;
+  const path = valmap(config.location, value => root.join(value));
+
+  // if ssl activated, resolve key and cert early
+  if (secure) {
+    http.ssl.key = root.join(http.ssl.key);
+    http.ssl.cert = root.join(http.ssl.cert);
+  }
+
+  const $components = Object.fromEntries(components ?? []);
+  const error = await path.routes.join("+error.js");
+
+  return {
+    secure,
+    importmaps: {},
+    assets,
+    files,
+    path,
+    root,
+    get_component(name) {
+      const component = $components[name];
+      return component?.default ?? component;
+    },
+    // pseudostatic thus arrowbound
+    get: (config_key, fallback) => get(config, config_key) ?? fallback,
+    set: (key, value) => {
+      config[key] = value;
+    },
+    error: {
+      default: await error.exists() ? await error.import("default") : undefined,
+    },
+    handlers: {},
+    modules: await module_loader(root, config.modules ?? []),
+    fonts: [],
+    headers(csp = {}) {
+      const http_csp = Object.entries(this.get("http.csp", {}));
+
+      return {
+        ...this.get("http.headers", {}),
+        ...http_csp.length === 0 ? {} : {
+          "Content-Security-Policy": to_csp(http_csp, this.asset_csp, csp),
+        },
+      };
+    },
+    runpath(...directories) {
+      return this.root.join(...directories);
+    },
+    async render(content) {
+      const { body, head, partial, placeholders = {}, page } = content;
+      ["body", "head"].every(used => is(placeholders[used]).undefined());
+
+      return partial ? body : Object.entries(placeholders)
+        // replace given placeholders, defaulting to ""
+        .reduce((html, [key, value]) => html.replace(`%${key}%`, value ?? ""),
+          this.loader.page(page))
+        // replace non-given placeholders, aside from %body% / %head%
+        .replaceAll(/(?<keep>%(?:head|body)%)|%.*?%/gus, "$1")
+        // replace body and head
+        .replace("%body%", body)
+        .replace("%head%", render_head(this.assets, this.fonts, head));
+    },
+    respond(body, { status = OK, headers = {} } = {}) {
+      return new Response(body, { status, headers: {
+        "Content-Type": html, ...this.headers(), ...headers },
+      });
+    },
+    async view(options) {
+      // split render and respond options
+      const { status, headers, ...rest } = options;
+      return this.respond(await this.render(rest), { status, headers });
+    },
+    media(type, { status, headers } = {}) {
+      return { status, headers: { ...headers, "Content-Type": type } };
+    },
+    async inline(code, type) {
+      const integrity = await this.hash(code);
+      const tag_name = type === "style" ? "style" : "script";
+      const head = tags[tag_name]({ code, type, inline: true, integrity });
+      return { head, integrity: `'${integrity}'` };
+    },
+    async publish({ src, code, type = "", inline = false }) {
+      if (inline || type === "style") {
+        this.assets.push({
+          src: join(http.static.root, src ?? "").path,
+          code: inline ? code : "",
+          type,
+          inline,
+          integrity: await this.hash(code),
+        });
+      }
+
+      // rehash assets_csp
+      this.asset_csp = this.assets.map(({ type: directive, integrity }) => [
+        `${directive === "style" ? "style" : "script"}-src`, integrity])
+        .reduce((csp, [directive, hash]) =>
+          ({ ...csp, [directive]: csp[directive].concat(`'${hash}'`) } ),
+          { "style-src": [], "script-src": [] },
+        );
+    },
+    create_csp() {
+      this.asset_csp = this.assets.map(({ type: directive, integrity }) => [
+        `${directive === "style" ? "style" : "script"}-src`, integrity])
+        .reduce((csp, [directive, hash]) =>
+          ({ ...csp, [directive]: csp[directive].concat(`'${hash}'`) } ),
+          { "style-src": [], "script-src": [] },
+        );
+    },
+    register(extension, handle) {
+      this.handlers[extension] !== undefined && double_extension(extension);
+      this.handlers[extension] = handle;
+    },
+    async hash(data, algorithm = "sha-384") {
+      const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
+      const prefix = algorithm.replace("-", _ => "");
+      return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
+    },
+    // noop
+    target(name, handler) {},
+    build_target: target,
+    loader,
+    stop() {
+      this.get("server").stop();
+    },
+    mode,
+  };
+};

package/src/serve/handler/error.js

@@ -0,0 +1,10 @@
+import { NOT_FOUND } from "@rcompat/http/status";
+
+/**
+ * Render an error page
+ * @param {string} body replacement for %body%
+ * @param {ErrorOptions} options rendering options
+ * @return {ResponseFn}
+ */
+export default (body = "Not Found", { status = NOT_FOUND, page } = {}) =>
+  app => app.view({ body, status, page: page ?? app.get("pages.error") });

package/src/serve/handler/json.js

@@ -0,0 +1,10 @@
+import { json } from "@rcompat/http/mime";
+import base from "./shared/base.js";
+
+/**
+ * Issue a JSON response
+ * @param {object} body object
+ * @param {MinOptions} options rendering options
+ * @return {ResponseFn}
+ */
+export default base(json, JSON.stringify);

package/src/serve/handler/redirect.js

@@ -0,0 +1,11 @@
+import { FOUND } from "@rcompat/http/status";
+
+/**
+ * Redirect request
+ * @param {string} Location location to redirect to
+ * @param {MinOptions} options handler options
+ * @return {ResponseFn}
+ */
+export default (Location, { status = FOUND } = {}) => app =>
+  // no body
+  app.respond(null, { status, headers: { Location } });

package/src/serve/handler/shared/base.js

@@ -0,0 +1,4 @@
+import identity from "@rcompat/function/identity";
+
+export default (mediatype, mapper = identity) => (body, options) => app =>
+  app.respond(mapper(body), app.media(mediatype, options));

package/src/serve/handler/sse.js

@@ -0,0 +1,24 @@
+import { sse } from "@rcompat/http/mime";
+import base from "./shared/base.js";
+
+/**
+ * Open a server-sent event stream
+ * @param {object} body docs1
+ * @param {object} options docs2
+ * @return {ResponseFn}
+ */
+export default base(sse, 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?.();
+    },
+  }));

package/src/serve/handler/stream.js

@@ -0,0 +1,4 @@
+import { bin } from "@rcompat/http/mime";
+import base from "./shared/base.js";
+
+export default base(bin);

package/src/serve/handler/text.js

@@ -0,0 +1,10 @@
+import { txt } from "@rcompat/http/mime";
+import base from "./shared/base.js";
+
+/**
+ * Issue a plaintext response
+ * @param {string} body plaintext
+ * @param {MinOptions} options rendering options
+ * @return {ResponseFn}
+ */
+export default base(txt);

package/src/serve/handler/view.js

@@ -0,0 +1,15 @@
+import no_handler from "#error/no-handler";
+import file from "@rcompat/fs/file";
+
+const extensions = ["extension", "fullExtension"];
+/**
+ * Render a component using handler for the given filename extension
+ * @param {string} name component filename
+ * @param {object} props props passed to component
+ * @param {object} options rendering options
+ * @return {ResponseFn}
+ */
+export default (name, props, options) => (app, ...rest) => extensions
+  .map(extension => app.handlers[file(name)[extension]])
+  .find(extension => extension !== undefined)
+  ?.(name, props, options)(app, ...rest) ?? no_handler(name);

package/src/serve/handler/ws.js

@@ -0,0 +1,2 @@
+export default implementation => ({ server }, _, { original }) =>
+  server.upgrade(original, implementation);

package/src/serve/hook/exports.js

@@ -0,0 +1,5 @@
+export { default as handle } from "./handle.js";
+export { default as init } from "./init.js";
+export { default as parse } from "./parse.js";
+export { default as route } from "./route.js";
+export { default as serve } from "./serve.js";