primate 0.19.4 → 0.20.0

package/src/errors.js

@@ -1,148 +1,8 @@
+import {Path} from "runtime-compat/fs";
 import Logger from "./Logger.js";
 
-export default Object.fromEntries(Object.entries({
-  CannotParseBody({body, contentType}) {
-    return {
-      message: ["cannot parse body % as %", body, contentType],
-      fix: ["use a different content type or fix body"],
-      level: Logger.Warn,
-    };
-  },
-  DoubleModule({modules, config}) {
-    const double = modules.find((module, i, array) =>
-      array.filter((_, j) => i !== j).includes(module));
-    return {
-      message: ["double module % in %", double, config],
-      fix: ["load % only once", double],
-      level: Logger.Error,
-    };
-  },
-  DoublePathParameter({path, double}) {
-    return {
-      message: ["double path parameter % in route %", double, path],
-      fix: ["disambiguate path parameters in route names"],
-      level: Logger.Error,
-    };
-  },
-  DoubleRoute({double}) {
-    return {
-      message: ["double route %", double],
-      fix: ["disambiguate route % and %", double, `${double}/index`],
-      level: Logger.Error,
-    };
-  },
-  EmptyRouteFile({config: {paths}, route}) {
-    return {
-      message: ["empty route file at %", `${paths.routes}/${route}.js`],
-      fix: ["add routes or remove file"],
-      level: Logger.Warn,
-    };
-  },
-  EmptyTypeDirectory({root}) {
-    return {
-      message: ["empty type directory"],
-      fix: ["populate % with types or remove it", root],
-      level: Logger.Warn,
-    };
-  },
-  ErrorInConfigFile({config, message}) {
-    return {
-      message: ["error in config %", message],
-      fix: ["check errors in config file by running %", `node ${config}`],
-      level: Logger.Error,
-    };
-  },
-  InvalidPathParameter({named, path}) {
-    return {
-      message: ["invalid path parameter % in route %", named, path],
-      fix: ["use only latin letters and decimal digits in path parameters"],
-      level: Logger.Error,
-    };
-  },
-  InvalidRouteName({path}) {
-    return {
-      message: ["invalid route name %", path],
-      fix: ["do not use dots in route names"],
-      level: Logger.Error,
-    };
-  },
-  InvalidType({name}) {
-    return {
-      message: ["invalid type %", name],
-      fix: ["use only functions for the default export of types"],
-      level: Logger.Error,
-    };
-  },
-  InvalidTypeName({name}) {
-    return {
-      message: ["invalid type name %", name],
-      fix: ["use only latin letters and decimal digits in types"],
-      level: Logger.Error,
-    };
-  },
-  MismatchedPath({path, message}) {
-    return {
-      message: [`mismatched % path: ${message}`, path],
-      fix: ["if unintentional, fix the type or the caller"],
-      level: Logger.Info,
-    };
-  },
-  MismatchedType({message}) {
-    return {
-      message: [`mismatched type: ${message}`],
-      fix: ["if unintentional, fix the type or the caller"],
-      level: Logger.Info,
-    };
-  },
-  ModuleHasNoHooks({hookless}) {
-    const modules = hookless.map(({name}) => name).join(", ");
-    return {
-      message: ["module % has no hooks", modules],
-      fix: ["ensure every module uses at least one hook or deactivate it"],
-      level: Logger.Warn,
-    };
-  },
-  ModulesMustHaveNames({n}) {
-    return {
-      message: ["modules must have names"],
-      fix: ["update module at index % and inform maintainer", n],
-      level: Logger.Error,
-    };
-  },
-  EmptyConfigFile({config}) {
-    return {
-      message: ["empty config file at %", config],
-      fix: ["add configuration options or remove file"],
-      level: Logger.Warn,
-    };
-  },
-  NoFileForPath({pathname, config: {paths}}) {
-    return {
-      message: ["no file for %", pathname],
-      fix: ["if unintentional create a file at %%", paths.static, pathname],
-      level: Logger.Info,
-    };
-  },
-  NoHandlerForExtension({name, ending}) {
-    return {
-      message: ["no handler for % extension", ending],
-      fix: ["add handler module for % files or remove %", `.${ending}`, name],
-      level: Logger.Error,
-    };
-  },
-  NoRouteToPath({method, pathname, config: {paths}}) {
-    const route = `${paths.routes}${pathname === "" ? "index" : pathname}.js`;
-    return {
-      message: ["no % route to %", method, pathname],
-      fix: ["if unintentional create a route at %", route],
-      level: Logger.Info,
-    };
-  },
-  ReservedTypeName({name}) {
-    return {
-      message: ["type name % is reserved", name],
-      fix: ["do not use any reserved type names"],
-      level: Logger.Error,
-    };
-  },
-}).map(([name, error]) => [name, Logger.throwable(error, name, "primate")]));
+const json = await new Path(import.meta.url).up(1).join("errors.json").json();
+
+const errors = Logger.err(json.errors, json.module);
+
+export default errors;

package/src/exports.js

@@ -4,6 +4,6 @@ export * from "./handlers/exports.js";
 
 export {default as Logger} from "./Logger.js";
 
-export {URL, Response} from "runtime-compat/http";
+export {URL, Response, Status} from "runtime-compat/http";
 
 export default command => run(command);

package/src/handlers/error.js

@@ -1,9 +1,9 @@
-import {NotFound} from "../http-statuses.js";
+import {Status} from "runtime-compat/http";
 
-export default (body = "Not Found", {status = NotFound} = {}) =>
-  async (app, headers) => [
+export default (body = "Not Found", {status = Status.NotFound} = {}) =>
+  async app => [
     await app.render({body}), {
       status,
-      headers: {...headers, "Content-Type": "text/html"},
+      headers: {...app.headers(), "Content-Type": "text/html"},
     },
   ];

package/src/handlers/html.js

@@ -14,20 +14,19 @@ const integrate = async (html, publish, headers) => {
     headers["Content-Security-Policy"] = headers["Content-Security-Policy"]
       .replace("style-src 'self'", `style-src 'self' '${integrity}' `);
   }
-  return html
-    .replaceAll(/<script>.*?<\/script>/gus, () => "")
-    .replaceAll(/<style>.*?<\/style>/gus, () => "");
+  return html.replaceAll(/<(?<tag>script|style)>.*?<\/\k<tag>>/gus, _ => "");
 };
 
 export default (component, options = {}) => {
-  const {status = 200, partial = false, load = false, layout} = options;
+  const {status = 200, partial = false, load = false} = options;
 
-  return async (app, headers) => {
+  return async app => {
+    const headers = app.headers();
     const body = await integrate(await load ?
       await app.paths.components.join(component).text() : component,
     app.publish, headers);
 
-    return [partial ? body : await app.render({body, layout}), {
+    return [partial ? body : await app.render({body}), {
       status,
       headers: {...headers, "Content-Type": "text/html"},
     }];

package/src/handlers/json.js

@@ -1,6 +1,6 @@
-export default (body, {status = 200} = {}) => (_, headers) => [
+export default (body, {status = 200} = {}) => app => [
   JSON.stringify(body), {
     status,
-    headers: {...headers, "Content-Type": "application/json"},
+    headers: {...app.headers(), "Content-Type": "application/json"},
   },
 ];

package/src/handlers/redirect.js

@@ -1,9 +1,9 @@
-import {Found} from "../http-statuses.js";
+import {Status} from "runtime-compat/http";
 
-export default (Location, {status = Found} = {}) => (_, headers) => [
+export default (Location, {status = Status.Found} = {}) => app => [
   /* no body */
   null, {
     status,
-    headers: {...headers, Location},
+    headers: {...app.headers(), Location},
   },
 ];

package/src/handlers/stream.js

@@ -1,6 +1,6 @@
-export default (body, {status = 200} = {}) => (_, headers) => [
+export default (body, {status = 200} = {}) => app => [
   body, {
     status,
-    headers: {...headers, "Content-Type": "application/octet-stream"},
+    headers: {...app.headers(), "Content-Type": "application/octet-stream"},
   },
 ];

package/src/handlers/text.js

@@ -1,6 +1,6 @@
-export default (body, {status = 200} = {}) => (_, headers) => [
+export default (body, {status = 200} = {}) => app => [
   body, {
     status,
-    headers: {...headers, "Content-Type": "text/plain"},
+    headers: {...app.headers(), "Content-Type": "text/plain"},
   },
 ];

package/src/handlers/view.js

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

package/src/hooks/bundle.js

@@ -1,21 +1,10 @@
 import {File} from "runtime-compat/fs";
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
 const pre = async app => {
-  const {paths} = app;
-
-  // remove public directory in case exists
-  if (await paths.public.exists) {
-    await paths.public.file.remove();
-  }
-  await paths.public.file.create();
-
+  const {paths, config} = app;
   if (await paths.static.exists) {
-    // copy static files to public
-    const filter = file => app.config.http.static.pure
-      ? true
-      : !file.endsWith(".js") && !file.endsWith(".css");
-    await File.copy(paths.static, paths.public, filter);
+    // copy static files to build/client/_static
+    await File.copy(paths.static, paths.client.join(config.build.static));
   }
 };
 
@@ -23,7 +12,7 @@ export default async (app, bundle) => {
   await pre(app);
   if (bundle) {
     app.log.info("running bundle hooks", {module: "primate"});
-    await [...filter("bundle", app.modules), _ => _]
+    await [...app.modules.bundle, _ => _]
       .reduceRight((acc, handler) => input => handler(input, acc))(app);
   }
 };

package/src/hooks/compile.js

@@ -1,7 +1,26 @@
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+import copy_includes from "./copy_includes.js"
+
+const pre = async app => {
+  const {paths, config} = app;
+  const build = config.build;
+
+  // remove build directory in case exists
+  if (await paths.build.exists) {
+    await paths.build.file.remove();
+  }
+  await paths.server.file.create();
+
+  if (await paths.components.exists) {
+    await app.copy(paths.components, paths.server.join(build.app));
+  }
+
+  // copy additional subdirectories to build/server
+  await copy_includes(app, "server");
+};
 
 export default async app => {
+  await pre(app);
   app.log.info("running compile hooks", {module: "primate"});
-  await [...filter("compile", app.modules), _ => _]
+  await [...app.modules.compile, _ => _]
     .reduceRight((acc, handler) => input => handler(input, acc))(app);
 };

package/src/hooks/copy_includes.js

@@ -0,0 +1,24 @@
+const system = ["routes", "components", "build"];
+
+export default async (app, type, post = () => undefined) => {
+  const {paths, config} = app;
+  const {build} = config;
+  const {includes} = build;
+
+  const reserved = system.concat(build.static, build.app, build.modules);
+
+  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 to = paths[type].join(include);
+          await to.file.create();
+          await app.copy(path, to);
+          await post(to);
+        }
+      }));
+  }
+};

package/src/hooks/handle.js

@@ -1,70 +1,83 @@
-import {Response} from "runtime-compat/http";
-import {error as clientError} from "../handlers/exports.js";
-import {mime, isResponse, respond} from "./handle/exports.js";
+import {Response, Status} from "runtime-compat/http";
+import {tryreturn} from "runtime-compat/flow";
+import {mime, isResponse, respond} from "./respond/exports.js";
 import {invalid} from "./route.js";
+import {error as clientError} from "../handlers/exports.js";
 import errors from "../errors.js";
-import {OK} from "../http-statuses.js";
 
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+const guardError = Symbol("guardError");
 
 export default app => {
-  const {http} = app.config;
+  const {config: {http, build}, paths} = app;
 
-  const _respond = async (request, headers) => {
+  const run = async request => {
     const {pathname} = request.url;
-    return invalid(pathname)
-      ? errors.NoFileForPath.throw({pathname, config: app.config})
-      : (await respond(await app.route(request)))(app, headers);
-  };
-
-  const route = async request => {
-    const headers = app.generateHeaders();
+    const {path, guards, layouts, handler} = invalid(pathname)
+      ? errors.NoFileForPath.throw(pathname, paths.static)
+      : await app.route(request);
 
+    // handle guards
     try {
-      const response = await _respond(request, headers);
-      return isResponse(response) ? response : new Response(...response);
+      guards.map(guard => {
+        const result = guard(request);
+        if (result === true) {
+          return undefined;
+        }
+        const error = new Error();
+        error.result = result;
+        error.type = guardError;
+        throw error;
+      });
     } catch (error) {
-      app.log.auto(error);
-      return new Response(...await clientError()(app, {}));
+      if (error.type === guardError) {
+        return (await respond(error.result))(app);
+      }
+      // rethrow if not guard error
+      throw error;
     }
+
+    // handle request
+    const handlers = [...app.modules.route, handler]
+      .reduceRight((chain, next) => input => next(input, chain));
+
+    return (await respond(await handlers({...request, path})))(app, {
+      layouts: await Promise.all(layouts.map(layout => layout(request))),
+    });
   };
 
-  const staticResource = async file => new Response(file.readable, {
-    status: OK,
+  const route = async request =>
+    tryreturn(async _ => {
+      const response = await run(request);
+      return isResponse(response) ? response : new Response(...response);
+    }).orelse(async error => {
+      app.log.auto(error);
+      return new Response(...await clientError()(app, {}));
+    });
+
+  const asset = async file => new Response(file.readable, {
+    status: Status.OK,
     headers: {
       "Content-Type": mime(file.name),
       Etag: await file.modified,
     },
   });
 
-  const publishedResource = request => {
-    const published = app.resources.find(({src, inline}) =>
-      !inline && src === request.url.pathname);
-    if (published !== undefined) {
-      return new Response(published.code, {
-        status: OK,
-        headers: {
-          "Content-Type": mime(published.src),
-          Etag: published.integrity,
-        },
-      });
-    }
-
-    return route(request);
-  };
-
-  const resource = async request => {
+  const handle = async request => {
     const {pathname} = request.url;
     const {root} = http.static;
     if (pathname.startsWith(root)) {
-      const path = app.paths.public.join(pathname.replace(root, ""));
-      return await path.isFile
-        ? staticResource(path.file)
-        : publishedResource(request);
+      const debased = pathname.replace(root, _ => "");
+      // try static first
+      const _static = paths.client.join(build.static, debased);
+      if (await _static.isFile) {
+        return asset(_static.file);
+      }
+      const _app = app.paths.client.join(debased);
+      return await _app.isFile ? asset(_app.file) : route(request);
     }
     return route(request);
   };
 
-  return [...filter("handle", app.modules), resource]
+  return [...app.modules.handle, handle]
     .reduceRight((acc, handler) => input => handler(input, acc));
 };

package/src/hooks/parse.js

@@ -1,9 +1,12 @@
 import {URL} from "runtime-compat/http";
+import {tryreturn} from "runtime-compat/flow";
 import errors from "../errors.js";
 
+const {fromEntries: from} = Object;
+
 const contents = {
-  "application/x-www-form-urlencoded": body =>
-    Object.fromEntries(body.split("&").map(part => part.split("=")
+  "application/x-www-form-urlencoded": body => from(body.split("&")
+    .map(part => part.split("=")
       .map(subpart => decodeURIComponent(subpart).replaceAll("+", " ")))),
   "application/json": body => JSON.parse(body),
 };
@@ -15,14 +18,9 @@ export default dispatch => async request => {
     return type === undefined ? body : type(body);
   };
 
-  const parseContent = async (request, body) => {
-    const contentType = request.headers.get("content-type");
-    try {
-      return parseContentType(contentType, body);
-    } catch (error) {
-      return errors.CannotParseBody.throw({body, contentType});
-    }
-  };
+  const parseContent = async (contentType, body) =>
+    tryreturn(_ => parseContentType(contentType, body))
+      .orelse(_ => errors.CannotParseBody.throw(body, contentType));
 
   const parseBody = async request => {
     if (request.body === null) {
@@ -38,12 +36,11 @@ export default dispatch => async request => {
       }
     } while (!result.done);
 
-    return parseContent(request, chunks.join());
+    return parseContent(request.headers.get("content-type"), chunks.join());
   };
 
   const cookies = request.headers.get("cookie");
-  const _url = request.url;
-  const url = new URL(_url.endsWith("/") ? _url.slice(0, -1) : _url);
+  const url = new URL(request.url);
 
   const body = await parseBody(request);
   return {
@@ -52,8 +49,8 @@ export default dispatch => async request => {
     body: dispatch(body),
     cookies: dispatch(cookies === null
       ? {}
-      : Object.fromEntries(cookies.split(";").map(c => c.trim().split("=")))),
-    headers: dispatch(Object.fromEntries(request.headers)),
-    query: dispatch(Object.fromEntries(url.searchParams)),
+      : from(cookies.split(";").map(c => c.trim().split("=")))),
+    headers: dispatch(from(request.headers)),
+    query: dispatch(from(url.searchParams)),
   };
 };

package/src/hooks/publish.js

@@ -1,36 +1,55 @@
 import {Path} from "runtime-compat/fs";
-
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+import {identity} from "runtime-compat/function";
+import copy_includes from "./copy_includes.js"
 
 const post = async app => {
-  // after hook, publish a zero assumptions app.js (no css imports)
-  const code = app.entrypoints.filter(({type}) => type === "script")
-    .map(entrypoint => entrypoint.code).join("");
-  await app.publish({src: `${app.config.dist}.js`, code, type: "module"});
+  const {config} = app;
+  const build = config.build.app;
+  {
+    // after hook, publish a zero assumptions app.js (no css imports)
+    const code = app.entrypoints.filter(({type}) => type === "script")
+      .map(entrypoint => entrypoint.code).join("");
+    const src = new Path(config.http.static.root, build, config.build.index);
+    await app.publish({src, code, type: "module"});
+
+    await app.copy(app.paths.components, app.paths.client.join(build));
 
-  if (!app.config.http.static.pure) {
-    const memoryFiles = await Path.collect(app.paths.static, /\.(?:js|css)$/u,
-      {recursive: false});
-    await Promise.all(memoryFiles.map(async file => {
-      const code = await file.text();
-      const src = file.name;
-      await app.publish({src, code, type: file.extension === ".js" ?
-        "module" : "style"});
-      if (file.extension === ".css") {
-        app.bootstrap({type: "style", code: `import "./${file.name}";`});
-      }
-    }));
+    const imports = {...app.importmaps, app: src.path};
+    await app.publish({
+      inline: true,
+      code: JSON.stringify({imports}, null, 2),
+      type: "importmap",
+    });
   }
-  await Promise.all(Object.entries(app.library).map(async libfile => {
-    const [, src] = libfile;
-    const code = await Path.resolve().join("node_modules", src).text();
-    await app.publish({src, code, type: "module"});
+
+  const imports = await Path.collect(app.paths.static, /\.(?:js|css)$/u);
+  await Promise.all(imports.map(async file => {
+    const code = await file.text();
+    const src = file.name;
+    const isCSS = file.extension === ".css";
+    await app.publish({src: `${config.build.static}/${src}`, code,
+      type: isCSS ? "style" : "module"});
+    if (isCSS) {
+      app.bootstrap({type: "style",
+        code: `import "../${config.build.static}/${file.name}";`});
+    }
   }));
+
+  const source = `${app.paths.client}`;
+  const {root} = app.config.http.static;
+  // 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"});
+    }))
+  );
 };
 
 export default async app => {
   app.log.info("running publish hooks", {module: "primate"});
-  await [...filter("publish", app.modules), _ => _]
+  await [...app.modules.publish, identity]
     .reduceRight((acc, handler) => input => handler(input, acc))(app);
   await post(app);
 };

package/src/hooks/register.js

@@ -1,7 +1,5 @@
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
-
 export default async app => {
   app.log.info("running register hooks", {module: "primate"});
-  await [...filter("register", app.modules), _ => _]
+  await [...app.modules.register, _ => _]
     .reduceRight((acc, handler) => input => handler(input, acc))(app);
 };

package/src/hooks/{handle → respond}/respond.js

@@ -14,7 +14,7 @@ const isNonNullObject = value => typeof value === "object" && value !== null;
 const isObject = value => isNonNullObject(value)
   ? json(value) : isText(value);
 const isResponse = value => isResponseDuck(value)
-  ? () => value : isObject(value);
+  ? _ => value : isObject(value);
 const isStream = value => value instanceof ReadableStream
   ? stream(value) : isResponse(value);
 const isBlob = value => value instanceof Blob