primate 0.26.3 → 0.27.0

package/README.md

@@ -1,6 +1,6 @@
 # Primate
 
-Expressive, minimal and extensible web framework. To start [read guide].
+Polymorphic development platform. To start [read guide].
 
 ## Resources
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "primate",
-  "version": "0.26.3",
-  "description": "Expressive, minimal and extensible web framework",
+  "version": "0.27.0",
+  "description": "Polymorphic development platform",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "rcompat": "^0.3.4"
+    "rcompat": "^0.5.0"
   },
   "engines": {
     "node": ">=18"

package/src/app.js

@@ -2,7 +2,7 @@ import crypto from "rcompat/crypto";
 import { tryreturn } from "rcompat/async";
 import { Path } from "rcompat/fs";
 import { is } from "rcompat/invariant";
-import { transform, valmap } from "rcompat/object";
+import { transform, valmap, to } from "rcompat/object";
 import { globify } from "rcompat/string";
 import * as runtime from "rcompat/meta";
 
@@ -43,6 +43,14 @@ const tags = {
   },
 };
 
+const render_head = (assets, 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 ?? "");
+
 const { name, version } = await new Path(import.meta.url).up(2)
   .join(runtime.manifest).json();
 
@@ -138,19 +146,13 @@ export default async (log, root, config) => {
     runpath(...directories) {
       return this.path.build.join(...directories);
     },
-    async render({ body = "", head = "", page = config.pages.index } = {}) {
-      const { location: { pages } } = this.config;
-
-      const html = await index(this.runpath(pages), page, config.pages.index);
-
-      const heads = to_sorted(this.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);
-      return html.replace("%body%", _ => body).replace("%head%", _ => heads);
+    async render({ body, head }, page = config.pages.index, placeholders = {}) {
+      const { assets, config: { location, pages } } = this;
+
+      return to({ ...placeholders, body, head: render_head(assets, head) })
+        .reduce((html, [key, value]) => html.replace(`%${key}%`, value ?? ""),
+          await index(this.runpath(location.pages), page, pages.index))
+        .replaceAll(/%.*%/gus, "");
     },
     async inline(code, type) {
       const integrity = await this.hash(code);

package/src/dispatch.js

@@ -17,7 +17,9 @@ export default (patches = {}) => (object, raw, cased = true) => {
 
       return object[cased ? property : property.toLowerCase()];
     },
-    all: () => object,
+    toString() {
+      return JSON.stringify(object);
+    },
     raw,
   });
 };

package/src/errors.json

@@ -51,11 +51,6 @@
       "fix": "use only latin letters and decimal digits in path parameters",
       "level": "Error"
     },
-    "InvalidRouteName": {
-      "message": "invalid route name {0}",
-      "fix": "do not use dots in route names",
-      "level": "Error"
-    },
     "InvalidTypeExport": {
       "message": "invalid type export at {0}",
       "fix": "export object with a `base` string and a `validate` function",
@@ -96,14 +91,9 @@
       "fix": "add configuration options or remove file",
       "level": "Warn"
     },
-    "NoFileForPath": {
-      "message": "no file for {0}",
-      "fix": "create a file at {1}{0}",
-      "level": "Info"
-    },
     "NoHandlerForExtension": {
       "message": "no handler for {0} extension",
-      "fix": "add handler module for .{0} files or remove {1}",
+      "fix": "add handler module for {0} files or remove {1}",
       "level": "Error"
     },
     "NoRouteToPath": {

package/src/handlers/error.js

@@ -1,9 +1,8 @@
 import { Response, Status, MediaType } from "rcompat/http";
 
 export default (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
-  async app => new Response(await app.render({
-    body,
-    page: page ?? app.config.pages.error }), {
+  async app =>
+    new Response(await app.render({ body }, page ?? app.config.pages.error), {
       status,
       headers: { ...app.headers(), "Content-Type": MediaType.TEXT_HTML },
     });

package/src/handlers/html.js

@@ -4,26 +4,25 @@ const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
 const style_re = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
 const remove = /<(?<tag>script|style)>.*?<\/\k<tag>>/gus;
 
-export default (name, options = {}) => {
-  const { status = Status.OK, partial = false } = options;
+const render = (body, head, { partial = false, app, page, placeholders }) =>
+  partial ? body : app.render({ body, head }, page, placeholders);
 
-  return async app => {
-    const html = await app.path.components.join(name).text();
-    const scripts = await Promise.all([...html.matchAll(script_re)]
-      .map(({ groups: { code } }) => app.inline(code, "module")));
-    const styles = await Promise.all([...html.matchAll(style_re)]
-      .map(({ groups: { code } }) => app.inline(code, "style")));
-    const assets = [...scripts, ...styles];
+export default (name, options = {}) => async app => {
+  const component = await app.path.components.join(name).text();
+  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 assets = [...scripts, ...styles];
 
-    const body = html.replaceAll(remove, _ => "");
-    const head = assets.map(asset => asset.head).join("\n");
-    const script = scripts.map(asset => asset.csp).join(" ");
-    const style = styles.map(asset => asset.csp).join(" ");
-    const headers = { script, style };
+  const body = component.replaceAll(remove, _ => "");
+  const head = assets.map(asset => asset.head).join("\n");
+  const script = scripts.map(asset => asset.csp).join(" ");
+  const style = styles.map(asset => asset.csp).join(" ");
+  const headers = { script, style };
 
-    return new Response(partial ? body : await app.render({ body, head }), {
-      status,
+  return new Response(await render(body, head, { app, ...options }), {
+      status: options.status ?? Status.OK,
       headers: { ...app.headers(headers), "Content-Type": MediaType.TEXT_HTML },
     });
-  };
 };

package/src/handlers/view.js

@@ -1,7 +1,7 @@
 import errors from "../errors.js";
 
 export default (name, props, options) => async (app, ...rest) => {
-  const extension = name.slice(name.lastIndexOf(".") + 1);
+  const extension = name.slice(name.lastIndexOf("."));
   return app.handlers[extension]?.(name, props, options)(app, ...rest)
     ?? errors.NoHandlerForExtension.throw(extension, name);
 };

package/src/hooks/handle.js

@@ -1,25 +1,21 @@
 import { Response, Status, MediaType } from "rcompat/http";
 import { cascade, tryreturn } from "rcompat/async";
 import { respond } from "./respond/exports.js";
-import { invalid } from "./route.js";
 import { error as clientError } from "../handlers/exports.js";
-import _errors from "../errors.js";
-const { NoFileForPath } = _errors;
 
 const guard_error = Symbol("guard_error");
 const guard = (app, guards) => async (request, next) => {
   // handle guards
   try {
-    guards.every(guard => {
-      const result = guard(request);
-      if (result === true) {
-        return true;
+    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;
       }
-      const error = new Error();
-      error.result = result;
-      error.type = guard_error;
-      throw error;
-    });
+    }
 
     return next(request);
   } catch (error) {
@@ -31,18 +27,23 @@ const guard = (app, guards) => async (request, next) => {
   }
 };
 
+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.default(request)));
+};
+
 export default app => {
   const { config: { http: { static: { root } }, location } } = app;
+  const route = request => app.route(request);
 
   const as_route = async request => {
-    const { pathname } = request.url;
-    // if NoFileForPath is thrown, this will remain undefined
+    // if tryreturn throws, this will default
     let error_handler = app.error.default;
 
     return tryreturn(async _ => {
-      const { path, guards, errors, layouts, handler } = invalid(pathname)
-        ? NoFileForPath.throw(pathname, location.static)
-        : await app.route(request);
+      const { path, guards, errors, layouts, handler } = await route(request);
       error_handler = errors?.at(-1);
 
       const pathed = { ...request, path };
@@ -51,9 +52,8 @@ export default app => {
 
       // handle request
       const response = (await cascade(hooks, handler))(pathed);
-      return (await respond(await response))(app, {
-        layouts: await Promise.all(layouts.map(layout => layout(request))),
-      }, pathed);
+      const $layouts = { layouts: await get_layouts(layouts, request) };
+      return (await respond(await response))(app, $layouts, pathed);
     }).orelse(async error => {
       app.log.auto(error);
 

package/src/hooks/parse.js

@@ -1,34 +1,16 @@
-import { URL, MediaType } from "rcompat/http";
-import { tryreturn } from "rcompat/sync";
-import { stringify } from "rcompat/streams";
+import { URL, Body } from "rcompat/http";
 import { from, valmap } from "rcompat/object";
-import errors from "../errors.js";
 
-const { APPLICATION_FORM_URLENCODED, APPLICATION_JSON } = MediaType;
-
-const { decodeURIComponent: decode } = globalThis;
 const deslash = url => url.replaceAll(/(?<!http:)\/{2,}/gu, _ => "/");
 
-const contents = {
-  [APPLICATION_FORM_URLENCODED]: body => from(body.split("&")
-    .map(part => part.split("=")
-      .map(subpart => decode(subpart).replaceAll("+", " ")))),
-  [APPLICATION_JSON]: body => JSON.parse(body),
-};
-
-const content = (type, body) =>
-  tryreturn(_ => contents[type?.split(";")[0]]?.(body) ?? body)
-    .orelse(_ => errors.CannotParseBody.throw(body, type));
-
 export default dispatch => async original => {
-  const { headers } = original;
-  const url = new URL(deslash(decode(original.url)));
-  const body = await stringify(original.body);
+  const { body, headers } = original;
+  const url = new URL(deslash(globalThis.decodeURIComponent(original.url)));
   const cookies = headers.get("cookie");
 
   return { original, url,
+    body: await Body.parse(body, headers.get("content-type")) ?? {},
     ...valmap({
-      body: [content(headers.get("content-type"), body), body],
       query: [from(url.searchParams), url.search],
       headers: [from(headers), headers, false],
       cookies: [from(cookies?.split(";").map(cookie => cookie.trim().split("="))

package/src/hooks/register.js

@@ -39,7 +39,7 @@ const post = async app => {
     await Promise.all(imports.map(async file => {
       const code = await file.text();
       const src = file.debase(path.static);
-      const type = file.extension === "css" ? "style" : "module";
+      const type = file.extension === ".css" ? "style" : "module";
       // already copied in `app.stage`
       await app.publish({ src, code, type, copy: false });
       type === "style" && app.export({ type,

package/src/hooks/route.js

@@ -6,9 +6,6 @@ import validate from "../validate.js";
 // insensitive-case equal
 const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
 
-/* routes may not contain dots */
-export const invalid = route => /\./u.test(route);
-
 const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
   ? pathname.slice(0, -1) : pathname;
 

package/src/hooks/stage.js

@@ -21,7 +21,7 @@ const post = async app => {
   await app.runpath(location.routes).create();
   const double = doubled((await app.path.routes.collect())
     .map(path => path.debase(app.path.routes))
-    .map(path => `${path}`.slice(1, -path.extension.length - 1)));
+    .map(path => `${path}`.slice(1, -path.extension.length)));
   double && errors.DoubleRoute.throw(double);
 
   await app.stage(app.path.routes, location.routes);

package/src/loaders/common.js

@@ -21,7 +21,7 @@ export default async ({
       .filter(filter)
       .map(async path => [
         `${path}`.replace(directory, _ => "").slice(1, -ending.length),
-        (await import(path)).default,
+        (await import(path)),
       ]));
   warn && await Path.exists(directory) && empty(log)(objects, name, directory);
 

package/src/loaders/routes/load.js

@@ -11,7 +11,7 @@ export default type => async (log, directory, load) => {
   ([a], [b]) => a.length - b.length);
 
   const resolve = name => new Path(directory, name, `+${type}.js`);
-  objects.some(([name, value]) => typeof value !== "function"
+  objects.some(([name, value]) => typeof value.default !== "function"
     && errors.InvalidDefaultExport.throw(resolve(name)));
 
   return objects;

package/src/loaders/routes.js

@@ -3,7 +3,6 @@ import { from } from "rcompat/object";
 import { default as fs, doubled } from "./common.js";
 import * as get from "./routes/exports.js";
 import errors from "../errors.js";
-import { invalid } from "../hooks/route.js";
 
 const make = path => {
   const double = doubled(path.split("/")
@@ -18,8 +17,6 @@ const make = path => {
       return `(?<${param}>[^/]{1,}?)`;
     }).orelse(_ => errors.InvalidPathParameter.throw(named, path)));
 
-  invalid(route) && errors.InvalidRouteName.throw(path);
-
   return new RegExp(`^/${route}$`, "u");
 };
 
@@ -31,18 +28,19 @@ export default async (app, load = fs) => {
     .map(async extra => [extra, await get[extra](log, directory, load)])));
 
   return (await get.routes(log, directory, load)).map(([path, imported]) => {
-    if (imported === undefined || Object.keys(imported).length === 0) {
+    const route = imported.default;
+    if (route === undefined || Object.keys(route).length === 0) {
       errors.EmptyRouteFile.warn(log, directory.join(`${path}.js`).path);
       return [];
     }
     const filtered = filter(path);
 
-    return Object.entries(imported).map(([method, handler]) => ({
+    return Object.entries(route).map(([method, handler]) => ({
       method,
       handler,
       pathname: make(path.endsWith("/") ? path.slice(0, -1) : path),
-      guards: routes.guards.filter(filtered).map(([, guard]) => guard),
-      errors: routes.errors.filter(filtered).map(([, error]) => error),
+      guards: routes.guards.filter(filtered).map(([, guard]) => guard.default),
+      errors: routes.errors.filter(filtered).map(([, error]) => error.default),
       layouts: routes.layouts.filter(filtered).map(([, layout]) => layout),
     }));
   }).flat();

package/src/loaders/types.js

@@ -6,8 +6,9 @@ import fs from "./common.js";
 
 const filter = path => /^[a-z]/u.test(path.name);
 
-export default async (log, directory, load = fs) => {
-  const types = await fs({ log, directory, name: "types", filter });
+export default async (log, directory) => {
+  const types = (await fs({ log, directory, name: "types", filter }))
+    .map(([name, type]) => [name, type.default]);
 
   const resolve = name => new Path(directory, name);
   types.every(([name, type]) => tryreturn(_ => {