primate 0.20.1 → 0.20.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.20.1",
+  "version": "0.20.3",
   "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -18,7 +18,10 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "runtime-compat": "^0.20.2"
+    "runtime-compat": "^0.21.0"
+  },
+  "engines": {
+    "node": ">=18.16"
   },
   "type": "module",
   "exports": "./src/exports.js"

package/src/Logger.js

@@ -1,6 +1,6 @@
 import {assert, is} from "runtime-compat/dyndef";
 import {blue, bold, green, red, yellow, dim} from "runtime-compat/colors";
-import {map, valmap} from "runtime-compat/object";
+import {map} from "runtime-compat/object";
 
 const levels = {
   Error: 0,
@@ -17,8 +17,7 @@ const reference = "https://primatejs.com/reference/errors";
 
 const hyphenate = classCased => classCased
   .split("")
-  .map(character => character
-    .replace(/[A-Z]/u, capital => `-${capital.toLowerCase()}`))
+  .map(letter => letter.replace(/[A-Z]/u, upper => `-${upper.toLowerCase()}`))
   .join("")
   .slice(1);
 

package/src/app.js

@@ -1,5 +1,5 @@
 import crypto from "runtime-compat/crypto";
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/async";
 import {File, Path} from "runtime-compat/fs";
 import {bold, blue} from "runtime-compat/colors";
 import {transform, valmap} from "runtime-compat/object";
@@ -8,6 +8,7 @@ import * as hooks from "./hooks/exports.js";
 import * as loaders from "./loaders/exports.js";
 import dispatch from "./dispatch.js";
 import {print} from "./Logger.js";
+import toSorted from "./toSorted.js";
 
 const base = new Path(import.meta.url).up(1);
 // do not hard-depend on node
@@ -16,18 +17,18 @@ const library = import.meta.runtime?.library ?? "node_modules";
 
 // use user-provided file or fall back to default
 const index = (app, name) =>
-  tryreturn(async _ => File.read(`${app.paths.pages.join(name)}`))
-    .orelse(async _ => base.join("defaults", app.config.index).text());
+  tryreturn(_ => File.read(`${app.paths.pages.join(name)}`))
+    .orelse(_ => base.join("defaults", app.config.index).text());
 
+const encoder = new TextEncoder();
 const hash = async (string, algorithm = "sha-384") => {
-  const encoder = new TextEncoder();
   const bytes = await crypto.subtle.digest(algorithm, encoder.encode(string));
   const algo = algorithm.replace("-", _ => "");
   return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
 };
 
-const attribute = attributes => Object.keys(attributes).length > 0 ?
-  " ".concat(Object.entries(attributes)
+const attribute = attributes => Object.keys(attributes).length > 0
+  ? " ".concat(Object.entries(attributes)
     .map(([key, value]) => `${key}="${value}"`).join(" "))
   : "";
 const tag = ({name, attributes = {}, code = "", close = true}) =>
@@ -74,22 +75,25 @@ export default async (config, root, log) => {
     },
     headers: _ => {
       const csp = Object.keys(http.csp).reduce((policy_string, key) =>
-        `${policy_string}${key} ${http.csp[key]};`, "");
-      const scripts = app.assets
-        .filter(({type}) => type !== "style")
-        .map(asset => `'${asset.integrity}'`).join(" ");
-      const _csp = scripts === "" ? csp : `${csp}script-src 'self' ${scripts};`;
-      // remove inline assets
-      app.assets = app.assets.filter(({inline, type}) => !inline
-        || type === "importmap");
+        `${policy_string}${key} ${http.csp[key]};`, "")
+        .replace("script-src 'self'", `script-src 'self' ${
+          app.assets
+            .filter(({type}) => type !== "style")
+            .map(asset => `'${asset.integrity}'`).join(" ")
+        } `)
+        .replace("style-src 'self'", `style-src 'self' ${
+          app.assets
+            .filter(({type}) => type === "style")
+            .map(asset => `'${asset.integrity}'`).join(" ")
+        } `);
 
       return {
-        "Content-Security-Policy": _csp,
+        "Content-Security-Policy": csp,
         "Referrer-Policy": "same-origin",
       };
     },
     handlers: {...handlers},
-    render: async ({body = "", head = "", page} = {}) => {
+    render: async ({body = "", page} = {}) => {
       const html = await index(app, page ?? config.index);
       // inline: <script type integrity>...</script>
       // outline: <script type integrity src></script>
@@ -101,16 +105,17 @@ export default async (config, root, log) => {
       const style = ({inline, code, href, rel = "stylesheet"}) => inline
         ? tag({name: "style", code})
         : tag({name: "link", attributes: {rel, href}, close: false});
-      const heads = app.assets
-        .toSorted(({type}) => -1 * (type === "importmap"))
+      const head = toSorted(app.assets,
+        ({type}) => -1 * (type === "importmap"))
         .map(({src, code, type, inline, integrity}) =>
           type === "style"
             ? style({inline, code, href: src})
             : script({inline, code, type, integrity, src})
         ).join("\n");
-      return html
-        .replace("%body%", _ => body)
-        .replace("%head%", _ => `${head}${heads}`);
+      // remove inline assets
+      app.assets = app.assets.filter(({inline, type}) => !inline
+        || type === "importmap");
+      return html.replace("%body%", _ => body).replace("%head%", _ => head);
     },
     publish: async ({src, code, type = "", inline = false}) => {
       if (!inline) {
@@ -118,10 +123,10 @@ export default async (config, root, log) => {
         await base.directory.file.create();
         await base.file.write(code);
       }
-      const integrity = await hash(code);
-      const _src = new Path(http.static.root).join(src ?? "");
-      app.assets.push({src: `${_src}`, code: inline ? code : "", type, inline, integrity});
-      return integrity;
+      if (inline || type === "style") {
+        app.assets.push({src: new Path(http.static.root).join(src ?? "").path,
+          code: inline ? code : "", type, inline, integrity: await hash(code)});
+      }
     },
     bootstrap: ({type, code}) => {
       app.entrypoints.push({type, code});
@@ -134,10 +139,10 @@ export default async (config, root, log) => {
       const exports = pkg.exports === undefined
         ? {[module]: `/${module}/${pkg.main}`}
         : transform(pkg.exports, entry => entry
-          .filter(([, _export]) => _export.import !== undefined)
+          .filter(([, _export]) => _export.import !== undefined || _export.default !== undefined)
           .map(([key, value]) => [
             key.replace(".", module),
-            value.import.replace(".", `./${module}`),
+            value.import?.replace(".", `./${module}`) ?? value.default.replace(".", `./${module}`),
           ]));
       await Promise.all(Object.values(exports).map(async name => app.publish({
           code: await Path.resolve().join(library, name).text(),

package/src/defaults/primate.config.js

@@ -4,6 +4,7 @@ export default {
   base: "/",
   logger: {
     level: Logger.Warn,
+    trace: false,
   },
   http: {
     host: "localhost",
@@ -11,6 +12,7 @@ export default {
     csp: {
       "default-src": "'self'",
       "style-src": "'self'",
+      "script-src": "'self'",
       "object-src": "'none'",
       "frame-ancestors": "'none'",
       "form-action": "'self'",
@@ -23,12 +25,11 @@ export default {
   index: "app.html",
   paths: {
     build: "build",
-    static: "static",
     components: "components",
+    pages: "pages",
     routes: "routes",
+    static: "static",
     types: "types",
-    pages: "pages",
-    layouts: "layouts",
   },
   build: {
     includes: [],

package/src/dispatch.js

@@ -1,5 +1,5 @@
 import {is, maybe} from "runtime-compat/dyndef";
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/sync";
 import {map} from "runtime-compat/object";
 import errors from "./errors.js";
 

package/src/handlers/html.js

@@ -1,19 +1,11 @@
 const script = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
 const style = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
 
-const integrate = async (html, publish, headers) => {
-  const scripts = await Promise.all([...html.matchAll(script)]
+const integrate = async (html, publish) => {
+  await Promise.all([...html.matchAll(script)]
     .map(({groups: {code}}) => publish({code, inline: true})));
-  for (const integrity of scripts) {
-    headers["Content-Security-Policy"] = headers["Content-Security-Policy"]
-      .replace("script-src 'self' ", `script-src 'self' '${integrity}' `);
-  }
-  const styles = await Promise.all([...html.matchAll(style)]
+  await Promise.all([...html.matchAll(style)]
     .map(({groups: {code}}) => publish({code, type: "style", inline: true})));
-  for (const integrity of styles) {
-    headers["Content-Security-Policy"] = headers["Content-Security-Policy"]
-      .replace("style-src 'self'", `style-src 'self' '${integrity}' `);
-  }
   return html.replaceAll(/<(?<tag>script|style)>.*?<\/\k<tag>>/gus, _ => "");
 };
 
@@ -21,10 +13,11 @@ export default (component, options = {}) => {
   const {status = 200, partial = false, load = false} = options;
 
   return async app => {
-    const headers = app.headers();
     const body = await integrate(await load ?
       await app.paths.components.join(component).text() : component,
-    app.publish, headers);
+    app.publish);
+    // needs to happen before app.render()
+    const headers = app.headers();
 
     return [partial ? body : await app.render({body}), {
       status,

package/src/hooks/compile.js

@@ -1,8 +1,7 @@
-import copy_includes from "./copy_includes.js"
+import copy_includes from "./copy_includes.js";
 
 const pre = async app => {
-  const {paths, config} = app;
-  const build = config.build;
+  const {paths, config: {build}} = app;
 
   // remove build directory in case exists
   if (await paths.build.exists) {

package/src/hooks/handle.js

@@ -1,5 +1,5 @@
 import {Response, Status} from "runtime-compat/http";
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/async";
 import {mime, isResponse, respond} from "./respond/exports.js";
 import {invalid} from "./route.js";
 import {error as clientError} from "../handlers/exports.js";
@@ -8,7 +8,7 @@ import errors from "../errors.js";
 const guardError = Symbol("guardError");
 
 export default app => {
-  const {config: {http, build}, paths} = app;
+  const {config: {http: {static: {root}}, build}, paths} = app;
 
   const run = async request => {
     const {pathname} = request.url;
@@ -18,10 +18,10 @@ export default app => {
 
     // handle guards
     try {
-      guards.map(guard => {
+      guards.every(guard => {
         const result = guard(request);
         if (result === true) {
-          return undefined;
+          return true;
         }
         const error = new Error();
         error.result = result;
@@ -38,7 +38,7 @@ export default app => {
 
     // handle request
     const handlers = [...app.modules.route, handler]
-      .reduceRight((chain, next) => input => next(input, chain));
+      .reduceRight((next, last) => input => last(input, next));
 
     return (await respond(await handlers({...request, path})))(app, {
       layouts: await Promise.all(layouts.map(layout => layout(request))),
@@ -64,7 +64,6 @@ export default app => {
 
   const handle = async request => {
     const {pathname} = request.url;
-    const {root} = http.static;
     if (pathname.startsWith(root)) {
       const debased = pathname.replace(root, _ => "");
       // try static first
@@ -79,5 +78,5 @@ export default app => {
   };
 
   return [...app.modules.handle, handle]
-    .reduceRight((acc, handler) => input => handler(input, acc));
+    .reduceRight((next, last) => input => last(input, next));
 };

package/src/hooks/parse.js

@@ -1,5 +1,6 @@
 import {URL} from "runtime-compat/http";
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/sync";
+import {stringify} from "runtime-compat/streams";
 import errors from "../errors.js";
 
 const {fromEntries: from} = Object;
@@ -10,47 +11,28 @@ const contents = {
       .map(subpart => decodeURIComponent(subpart).replaceAll("+", " ")))),
   "application/json": body => JSON.parse(body),
 };
-const decoder = new TextDecoder();
 
-export default dispatch => async request => {
-  const parseContentType = (contentType, body) => {
-    const type = contents[contentType];
-    return type === undefined ? body : type(body);
-  };
-
-  const parseContent = async (contentType, body) =>
-    tryreturn(_ => parseContentType(contentType, body))
-      .orelse(_ => errors.CannotParseBody.throw(body, contentType));
-
-  const parseBody = async request => {
-    if (request.body === null) {
-      return null;
-    }
-    const reader = request.body.getReader();
-    const chunks = [];
-    let result;
-    do {
-      result = await reader.read();
-      if (result.value !== undefined) {
-        chunks.push(decoder.decode(result.value));
-      }
-    } while (!result.done);
-
-    return parseContent(request.headers.get("content-type"), chunks.join());
-  };
+const parse = {
+  content(content_type, body) {
+    return tryreturn(_ => {
+      const type = contents[content_type];
+      return type === undefined ? body : type(body);
+    }).orelse(_ => errors.CannotParseBody.throw(body, content_type));
+  },
+  async body({body, headers}) {
+    return body === null
+      ? null
+      : this.content(headers.get("content-type"), await stringify(body));
+  },
+};
 
-  const cookies = request.headers.get("cookie");
+export default dispatch => async request => {
+  const body = dispatch(await parse.body(request));
+  const cookies = dispatch(from(request.headers.get("cookie")?.split(";")
+    .map(cookie => cookie.trim().split("=")) ?? []));
+  const headers = dispatch(from(request.headers));
   const url = new URL(request.url);
+  const query = dispatch(from(url.searchParams));
 
-  const body = await parseBody(request);
-  return {
-    original: request,
-    url,
-    body: dispatch(body),
-    cookies: dispatch(cookies === null
-      ? {}
-      : from(cookies.split(";").map(c => c.trim().split("=")))),
-    headers: dispatch(from(request.headers)),
-    query: dispatch(from(url.searchParams)),
-  };
+  return {original: request, url, body, cookies, headers, query};
 };

package/src/hooks/publish.js

@@ -22,6 +22,7 @@ const post = async app => {
     });
   }
 
+  // copy JavaScript and CSS files from `app.paths.static`
   const imports = await Path.collect(app.paths.static, /\.(?:js|css)$/u);
   await Promise.all(imports.map(async file => {
     const code = await file.text();
@@ -40,9 +41,8 @@ const post = async app => {
   // copy additional subdirectories to build/client
   await copy_includes(app, "client", async to =>
     Promise.all((await to.collect(/\.js$/u)).map(async script => {
-      const code = await script.text();
       const src = new Path(root, script.path.replace(source, () => ""));
-      await app.publish({src, code, type: "module"});
+      await app.publish({src, code: await script.text(), type: "module"});
     }))
   );
 };

package/src/hooks/route.js

@@ -1,5 +1,5 @@
 import {keymap} from "runtime-compat/object";
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/sync";
 import errors from "../errors.js";
 
 // insensitive-case equal
@@ -18,8 +18,9 @@ export default app => {
     .filter(([name]) => name.includes("$"))
     .map(([name, value]) => [name.split("$")[1], value])
     .every(([name, value]) =>
-      tryreturn(_ => types?.[name](value) === true)
-        .orelse(({message}) => errors.MismatchedPath.throw(pathname, message)));
+      tryreturn(_ => types?.[name].type(value) === true)
+        .orelse(({message}) => errors.MismatchedPath.throw(pathname, message))
+    );
   const isPath = ({route, pathname}) => {
     const result = route.pathname.exec(pathname);
     return result === null ? false : isType(result.groups, pathname);
@@ -29,7 +30,7 @@ export default app => {
   const find = (method, pathname) => routes.find(route =>
     isMethod({route, method, pathname}));
 
-  const index = path => `${paths.routes}${path === "" ? "index" : path}`;
+  const index = path => `${paths.routes}${path === "/" ? "/index" : path}`;
   const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
     ? pathname.slice(0, -1) : pathname;
 

package/src/hooks/serve.js

@@ -1,8 +1,8 @@
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+import {identity} from "runtime-compat/function";
 
 export default async (app, server) => {
   app.log.info("running serve hooks", {module: "primate"});
-  await [...filter("serve", app.modules), _ => _]
-    .reduceRight((acc, handler) => input =>
-      handler(input, acc))({...app, server});
+  await [...app.modules.serve, identity]
+    .reduceRight((next, previous) =>
+      input => previous(input, next))({...app, server});
 };

package/src/loaders/common.js

@@ -28,7 +28,5 @@ export default async ({
   return objects;
 };
 
-export const lc_first = path => /^[a-z]/u.test(path.name);
-
 export const doubled = set => set.find((part, i, array) =>
   array.filter((_, j) => i !== j).includes(part));

package/src/loaders/routes/load.js

@@ -1,13 +1,14 @@
 import {Path} from "runtime-compat/fs";
 import errors from "../../errors.js";
+import toSorted from "../../toSorted.js";
 
 export default type => async (log, directory, load) => {
   const filter = path => new RegExp(`^\\+${type}.js$`, "u").test(path.name);
 
   const replace = new RegExp(`\\+${type}`, "u");
-  const objects = (await load({log, directory, filter, warn: false}))
-    .map(([name, object]) => [name.replace(replace, () => ""), object])
-    .toSorted(([a], [b]) => a.length - b.length);
+  const objects = toSorted((await load({log, directory, filter, warn: false}))
+    .map(([name, object]) => [name.replace(replace, () => ""), object]),
+  ([a], [b]) => a.length - b.length);
 
   const resolve = name => new Path(directory, name, `+${type}.js`);
   objects.some(([name, value]) => typeof value !== "function"

package/src/loaders/routes/routes.js

@@ -8,7 +8,8 @@ const normalize = route => {
 };
 
 // index -> ""
-const deindex = path => path.endsWith("index") ? path.replace("index", "") : path;
+const deindex = path => path.endsWith("index") ?
+  path.replace("index", "") : path;
 
 export default async (log, directory, load) => {
   const filter = path => /^[^+].*.js$/u.test(path.name);

package/src/loaders/routes.js

@@ -1,4 +1,4 @@
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/sync";
 import errors from "../errors.js";
 import {invalid} from "../hooks/route.js";
 import {default as fs, doubled} from "./common.js";

package/src/loaders/types.js

@@ -1,6 +1,8 @@
 import {Path} from "runtime-compat/fs";
 import errors from "../errors.js";
-import {default as fs, lc_first as filter} from "./common.js";
+import fs from "./common.js";
+
+const filter = path => /^[a-z]/u.test(path.name);
 
 export default async (log, directory, load = fs) => {
   const types = await load({log, directory, name: "types", filter});

package/src/run.js

@@ -1,4 +1,4 @@
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/async";
 import {Path} from "runtime-compat/fs";
 import {extend} from "runtime-compat/object";
 import app from "./app.js";

package/src/start.js

@@ -1,5 +1,5 @@
 import {serve, Response, Status} from "runtime-compat/http";
-import {tryreturn} from "runtime-compat/flow";
+import {tryreturn} from "runtime-compat/async";
 import {identity} from "runtime-compat/function";
 import * as hooks from "./hooks/exports.js";
 

package/src/toSorted.js

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