primate 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -16,7 +16,7 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "runtime-compat": "^0.16.3"
+    "runtime-compat": "^0.17.0"
   },
   "type": "module",
   "exports": "./src/exports.js"

package/src/Logger.js

@@ -1,115 +1,126 @@
 import {assert, is} from "runtime-compat/dyndef";
+import {blue, bold, green, red, yellow, dim} from "runtime-compat/colors";
 
-const colors = {
-  black: msg => `\x1b[0m${msg}\x1b[0m`,
-  bold: msg => `\x1b[1m${msg}\x1b[0m`,
-  red: msg => `\x1b[31m${msg}\x1b[0m`,
-  green: msg => `\x1b[32m${msg}\x1b[0m`,
-  yellow: msg => `\x1b[33m${msg}\x1b[0m`,
-  blue: msg => `\x1b[34m${msg}\x1b[0m`,
-  gray: msg => `\x1b[2m${msg}\x1b[0m`,
+const errors = {
+  Error: 0,
+  Warn: 1,
+  Info: 2,
 };
 
-const error = 0;
-const warn = 1;
-const info = 2;
-
-const Abort = class Abort extends Error {};
-// Error natively provided
-const Warn = class Warn extends Error {};
-const Info = class Info extends Error {};
-
-const levels = new Map([
-  [Error, error],
-  [Warn, warn],
-  [Info, info],
-]);
+const print = (...messages) => process.stdout.write(messages.join(" "));
+const bye = () => print(dim(yellow("~~ bye\n")));
+const mark = (format, ...params) => params.reduce((formatted, param) =>
+  formatted.replace("%", bold(param)), format);
 
-const abort = message => {
-  throw new Abort(message);
-};
+const reference = "https://primatejs.com/reference/errors";
 
-const print = (...messages) => process.stdout.write(messages.join(" "));
+const hyphenate = classCased => classCased
+  .split("")
+  .map(character => character
+    .replace(/[A-Z]/u, capital => `-${capital.toLowerCase()}`))
+  .join("")
+  .slice(1);
 
 const Logger = class Logger {
   #level; #trace;
 
-  constructor({level = Error, trace = false} = {}) {
-    assert(level !== undefined && levels.get(level) <= info);
+  static throwable(type, name, module) {
+    return {
+      throw(args = {}) {
+        const {message, level, fix} = type(args);
+        const error = new Error(mark(...message));
+        error.level = level;
+        error.fix = mark(...fix);
+        error.name = name;
+        error.module = module;
+        throw error;
+      },
+      warn(logger, ...args) {
+        const {message, level, fix} = type(...args);
+        const error = {level, message: mark(...message), fix: mark(...fix)};
+        logger.auto({...error, name, module});
+      },
+    };
+  }
+
+  constructor({level = errors.Error, trace = false} = {}) {
+    assert(level !== undefined && level <= errors.Info);
     is(trace).boolean();
     this.#level = level;
     this.#trace = trace;
   }
 
-  static get colors() {
-    return colors;
-  }
-
   static print(...args) {
     print(...args);
   }
 
+  static get mark() {
+    return mark;
+  }
+
   static get Error() {
-    return Error;
+    return errors.Error;
   }
 
   static get Warn() {
-    return Warn;
+    return errors.Warn;
   }
 
   static get Info() {
-    return Info;
+    return errors.Info;
   }
 
   get class() {
     return this.constructor;
   }
 
-  #print(pre, error) {
-    if (error instanceof Error) {
-      print(colors.bold(pre), error.message, "\n");
-      if (this.#trace) {
-        console.log(error);
-      }
-    } else {
-      print(colors.bold(pre), error, "\n");
+  #print(pre, color, message, {fix, module, name} = {}, error) {
+    print(pre, `${module !== undefined ? `${color(module)} ` : ""}${message}`, "\n");
+    if (fix && this.level >= errors.Warn) {
+      print(blue("++"), fix);
+      name && print(dim(`\n   -> ${reference}/${module ?? "primate"}#${hyphenate(name)}`), "\n");
+    }
+    if (this.#trace && error) {
+      print(pre, color(module), "trace follows\n");
+      console.log(error);
     }
   }
 
   get level() {
-    return levels.get(this.#level);
+    return this.#level;
   }
 
-  info(message) {
-    if (this.level >= levels.get(Info)) {
-      this.#print(colors.green("--"), message);
+  info(message, args) {
+    if (this.level >= errors.Info) {
+      this.#print(green("--"), green, message, args);
     }
   }
 
-  warn(message) {
-    if (this.level >= levels.get(Warn)) {
-      this.#print(colors.yellow("??"), message);
+  warn(message, args) {
+    if (this.level >= errors.Warn) {
+      this.#print(yellow("??"), yellow, message, args);
     }
   }
 
-  error(message) {
-    if (this.level >= levels.get(Error)) {
-      this.#print(colors.red("!!"), message);
+  error(message, args, error) {
+    if (this.level >= errors.Warn) {
+      this.#print(red("!!"), red, message, args, error);
     }
   }
 
-  auto(message) {
-    if (message instanceof Info) {
-      return this.info(message.message);
+  auto(error) {
+    const {level, message, ...args} = error;
+    if (level === errors.Info) {
+      return this.info(message, args, error);
     }
-    if (message instanceof Warn) {
-      return this.warn(message.message);
+    if (level === errors.Warn) {
+      return this.warn(message, args, error);
     }
 
-    return this.error(message);
+    return this.error(message, args, error);
   }
 };
 
 export default Logger;
 
-export {colors, levels, print, abort, Abort};
+export {print, bye};

package/src/app.js

@@ -1,7 +1,9 @@
 import crypto from "runtime-compat/crypto";
 import {File, Path} from "runtime-compat/fs";
+import {bold, blue} from "runtime-compat/colors";
+import errors from "./errors.js";
 import * as handlers from "./handlers/exports.js";
-import {abort} from "./Logger.js";
+import * as hooks from "./hooks/exports.js";
 
 const qualify = (root, paths) =>
   Object.keys(paths).reduce((sofar, key) => {
@@ -33,12 +35,12 @@ const hash = async (string, algorithm = "sha-384") => {
 };
 
 export default async (config, root, log) => {
-  const {name, version} = await src.up(1).join("package.json").json();
+  const {http} = config;
 
   // if ssl activated, resolve key and cert early
-  if (config.http.ssl) {
-    config.http.ssl.key = root.join(config.http.ssl.key);
-    config.http.ssl.cert = root.join(config.http.ssl.cert);
+  if (http.ssl) {
+    http.ssl.key = root.join(http.ssl.key);
+    http.ssl.cert = root.join(http.ssl.cert);
   }
 
   const paths = qualify(root, config.paths);
@@ -53,22 +55,27 @@ export default async (config, root, log) => {
 
   const modules = config.modules === undefined ? [] : config.modules;
 
-  modules.every(module => module.name !== undefined ||
-    abort("all modules must have names"));
+  modules.every((module, n) => module.name !== undefined ||
+    errors.ModulesMustHaveNames.throw({n}));
 
-  if (new Set(modules.map(module => module.name)).size !== modules.length) {
-    abort("same module twice");
-  }
+  new Set(modules.map(({name}) => name)).size !== modules.length &&
+    errors.DoubleModule.throw({
+      modules: modules.map(({name}) => name),
+      config: root.join("primate.config.js"),
+    });
 
-  modules.every(module => Object.entries(module).length > 1) || (() => {
-    log.warn("some modules haven't subscribed to any hooks");
-  })();
+  const hookless = modules.filter(module =>
+    !Object.keys(module).some(key => Object.keys(hooks).includes(key)));
+  hookless.length > 0 && errors.ModuleHasNoHooks.warn(log, {hookless});
+
+  const {name, version} = await src.up(1).join("package.json").json();
 
   const app = {
     config,
     routes,
-    secure: config.http?.ssl !== undefined,
-    name, version,
+    secure: http?.ssl !== undefined,
+    name,
+    version,
     library: {},
     identifiers: {},
     replace(code) {
@@ -86,6 +93,25 @@ export default async (config, root, log) => {
     paths,
     root,
     log,
+    generateHeaders: () => {
+      const csp = Object.keys(http.csp).reduce((policy_string, key) =>
+        `${policy_string}${key} ${http.csp[key]};`, "");
+      const scripts = app.resources
+        .map(resource => `'${resource.integrity}'`).join(" ");
+      const _csp = scripts === "" ? csp : `${csp}script-src 'self' ${scripts};`;
+      // remove inline resources
+      for (let i = app.resources.length - 1; i >= 0; i--) {
+        const resource = app.resources[i];
+        if (resource.inline) {
+          app.resources.splice(i, 1);
+        }
+      }
+
+      return {
+        "Content-Security-Policy": _csp,
+        "Referrer-Policy": "same-origin",
+      };
+    },
     handlers: {...handlers},
     render: async ({body = "", head = ""} = {}) => {
       const html = await index(app);
@@ -111,7 +137,7 @@ export default async (config, root, log) => {
       // while integrity is only really needed for scripts, it is also later
       // used for the etag header
       const integrity = await hash(code);
-      const _src = new Path(config.http.static.root).join(src ?? "");
+      const _src = new Path(http.static.root).join(src ?? "");
       app.resources.push({src: `${_src}`, code, type, inline, integrity});
       return integrity;
     },
@@ -129,11 +155,8 @@ export default async (config, root, log) => {
     },
     modules,
   };
-  const {print, colors} = log.class;
-  print(colors.blue(colors.bold(name)), colors.blue(version), "");
-  const type = app.secure ? "https" : "http";
-  const address = `${type}://${config.http.host}:${config.http.port}`;
-  print(colors.gray(`at ${address}`), "\n");
+  log.class.print(blue(bold(name)), blue(version),
+    `at http${app.secure ? "s" : ""}://${http.host}:${http.port}\n`);
   // modules may load other modules
   await Promise.all(app.modules
     .filter(module => module.load !== undefined)

package/src/commands/exports.js

@@ -1,11 +1,8 @@
 import {default as dev} from "./dev.js";
 import {default as serve} from "./serve.js";
-import {default as build} from "./build.js";
-import {default as create} from "./create.js";
-import {default as help} from "./help.js";
 
-const commands = {dev, serve, build, create, help};
+const commands = {dev, serve};
 
-const run = name => commands[name] ?? help;
+const run = name => commands[name] ?? dev;
 
 export default name => name === undefined ? dev : run(name);

package/src/errors.js

@@ -0,0 +1,112 @@
+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,
+    };
+  },
+  ErrorInConfigFile({config, message}) {
+    return {
+      message: ["error in config %", message],
+      fix: ["check errors in config file by running %", `node ${config}`],
+      level: Logger.Error,
+    };
+  },
+  ModuleHasNoHooks({hookless}) {
+    return {
+      message: ["module % has no hooks", hookless.join(", ")],
+      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" : ""}.js`;
+    return {
+      message: ["no % route to %", method, pathname],
+      fix: ["if unintentional create a route at %", route],
+      level: Logger.Info,
+    };
+  },
+  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 latin letters and decimal digits in types"],
+      level: Logger.Error,
+    };
+  },
+}).map(([name, error]) => [name, Logger.throwable(error, name, "primate")]));

package/src/handlers/error.js

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

package/src/handlers/redirect.js

@@ -1,4 +1,6 @@
-export default (Location, {status = 302} = {}) => (_, headers) => [
+import {Found} from "../http-statuses.js";
+
+export default (Location, {status = Found} = {}) => (_, headers) => [
   /* no body */
   null, {
     status,

package/src/handlers/view.js

@@ -1,8 +1,8 @@
+import errors from "../errors.js";
+
 export default (name, props, options) => async (app, headers) => {
   const ending = name.slice(name.lastIndexOf(".") + 1);
   const handler = app.handlers[ending];
-  if (handler === undefined) {
-    return app.log.error(new Error(`no handler for ${ending} components`));
-  }
-  return handler(name, {load: true, ...props}, options)(app, headers);
+  return handler?.(name, {load: true, ...props}, options)(app, headers)
+    ?? errors.NoHandlerForExtension.throw({name, ending});
 };

package/src/hooks/bundle.js

@@ -22,7 +22,7 @@ const pre = async app => {
 export default async (app, bundle) => {
   await pre(app);
   if (bundle) {
-    app.log.info("running bundle hooks");
+    app.log.info("running bundle hooks", {module: "primate"});
     await [...filter("bundle", app.modules), _ => _]
       .reduceRight((acc, handler) => input => handler(input, acc))(app);
   }

package/src/hooks/compile.js

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

package/src/hooks/exports.js

@@ -4,3 +4,4 @@ export {default as publish} from "./publish.js";
 export {default as bundle} from "./bundle.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/exports.js

@@ -1,4 +1,3 @@
-export {default as statuses} from "./http-statuses.js";
 export {default as mime} from "./mime.js";
 export {isResponse} from "./duck.js";
 export {default as respond} from "./respond.js";

package/src/hooks/handle.js

@@ -1,58 +1,37 @@
-import {Response, URL} from "runtime-compat/http";
+import {Response} from "runtime-compat/http";
 import {error as clientError} from "../handlers/exports.js";
-import {statuses, mime, isResponse, respond} from "./handle/exports.js";
-import fromNull from "../fromNull.js";
+import {mime, isResponse, respond} from "./handle/exports.js";
+import {invalid} from "./route.js";
+import errors from "../errors.js";
+import {OK} from "../http-statuses.js";
 
 const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
-const contents = {
-  "application/x-www-form-urlencoded": body =>
-    fromNull(Object.fromEntries(body.split("&").map(part => part.split("=")
-      .map(subpart => decodeURIComponent(subpart).replaceAll("+", " "))))),
-  "application/json": body => JSON.parse(body),
-};
-
-export default async app => {
+export default app => {
   const {http} = app.config;
 
-  const _respond = async request => {
-    const csp = Object.keys(http.csp).reduce((policy_string, key) =>
-      `${policy_string}${key} ${http.csp[key]};`, "");
-    const scripts = app.resources
-      .map(resource => `'${resource.integrity}'`).join(" ");
-    const _csp = scripts === "" ? csp : `${csp}script-src 'self' ${scripts};`;
-    // remove inline resources
-    for (let i = app.resources.length - 1; i >= 0; i--) {
-      const resource = app.resources[i];
-      if (resource.inline) {
-        app.resources.splice(i, 1);
-      }
+  const _respond = async (request, headers) => {
+    if (invalid(request.url.pathname)) {
+      errors.NoFileForPath.throw({pathname: request.url.pathname, config: app.config});
+      return;
     }
+    return respond(await app.route(request))(app, headers);
+  };
 
-    const headers = {
-      "Content-Security-Policy": _csp,
-      "Referrer-Policy": "same-origin",
-    };
+  const route = async request => {
+    const headers = app.generateHeaders();
 
     try {
-      const modules = filter("route", app.modules);
-      // app.route is the last module to be executed
-      const handlers = [...modules, app.route].reduceRight((acc, handler) =>
-        input => handler(input, acc));
-      return await respond(await handlers(request))(app, headers);
+      const response = await _respond(request, headers);
+      return isResponse(response) ? response : new Response(...response);
     } catch (error) {
       app.log.auto(error);
-      return clientError()(app, headers);
+      return new Response(...await clientError()(app, {}));
     }
   };
 
-  const route = async request => {
-    const response = await _respond(request);
-    return isResponse(response) ? response : new Response(...response);
-  };
-
   const staticResource = async file => new Response(file.readable, {
-    status: statuses.OK,
+    status: OK,
     headers: {
       "Content-Type": mime(file.name),
       Etag: await file.modified,
@@ -64,7 +43,7 @@ export default async app => {
       !inline && src === request.url.pathname);
     if (published !== undefined) {
       return new Response(published.code, {
-        status: statuses.OK,
+        status: OK,
         headers: {
           "Content-Type": mime(published.src),
           Etag: published.integrity,
@@ -88,67 +67,9 @@ export default async app => {
   };
 
   const handle = async request => {
-    try {
-      return await resource(request);
-    } catch (error) {
-      app.log.auto(error);
-      return new Response(null, {status: statuses.InternalServerError});
-    }
+    return await resource(request);
   };
 
-  const parseContentType = (contentType, body) => {
-    const type = contents[contentType];
-    return type === undefined ? body : type(body);
-  };
-
-  const parseContent = (request, body) => {
-    try {
-      return parseContentType(request.headers.get("content-type"), body);
-    } catch (error) {
-      app.log.warn(error);
-      return body;
-    }
-  };
-
-  const decoder = new TextDecoder();
-
-  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, chunks.join());
-  };
-
-  const parseRequest = async request => {
-    const cookies = request.headers.get("cookie");
-    const _url = request.url;
-    const url = new URL(_url.endsWith("/") ? _url.slice(0, -1) : _url);
-
-    return {
-      original: request,
-      url,
-      body: await parseBody(request),
-      cookies: fromNull(cookies === null
-        ? {}
-        : Object.fromEntries(cookies.split(";").map(c => c.trim().split("=")))),
-      headers: fromNull(Object.fromEntries(request.headers)),
-      query: fromNull(Object.fromEntries(url.searchParams)),
-    };
-  };
-
-  // handle is the last module to be executed
-  const handlers = [...filter("handle", app.modules), handle]
+  return [...filter("handle", app.modules), handle]
     .reduceRight((acc, handler) => input => handler(input, acc));
-
-  return async request => handlers(await parseRequest(request));
 };

package/src/hooks/parse.js

@@ -0,0 +1,59 @@
+import {URL} from "runtime-compat/http";
+import fromNull from "../fromNull.js";
+import errors from "../errors.js";
+
+const contents = {
+  "application/x-www-form-urlencoded": body =>
+    fromNull(Object.fromEntries(body.split("&").map(part => part.split("=")
+      .map(subpart => decodeURIComponent(subpart).replaceAll("+", " "))))),
+  "application/json": body => JSON.parse(body),
+};
+const decoder = new TextDecoder();
+
+export default async request => {
+  const parseContentType = (contentType, body) => {
+    const type = contents[contentType];
+    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 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, chunks.join());
+  };
+
+  const cookies = request.headers.get("cookie");
+  const _url = request.url;
+  const url = new URL(_url.endsWith("/") ? _url.slice(0, -1) : _url);
+
+  return {
+    original: request,
+    url,
+    body: await parseBody(request),
+    cookies: fromNull(cookies === null
+      ? {}
+      : Object.fromEntries(cookies.split(";").map(c => c.trim().split("=")))),
+    headers: fromNull(Object.fromEntries(request.headers)),
+    query: fromNull(Object.fromEntries(url.searchParams)),
+  };
+};

package/src/hooks/{handle.spec.js → parse.spec.js}

@@ -1,32 +1,14 @@
-import handle from "./handle.js";
+import parse from "./parse.js";
 import Logger from "../Logger.js";
 
-const app = {
-  log: new Logger({
-    level: Logger.Warn,
-  }),
-  config: {
-    http: {},
-  },
-  modules: [{
-    handle(request) {
-      return request;
-    },
-  }],
-  routes: [
-    ["index", {get: () => "/"}],
-    ["user", {get: () => "/user"}],
-    ["users/{userId}a", {get: request => request}],
-  ],
-};
+const {mark} = Logger;
 
 const r = await (async () => {
   const p = "https://p.com";
   const request = (method, path = "/", options = {}) =>
     new Request(`${p}${path}`, {method, ...options});
-  const handler = await handle(app);
   return Object.fromEntries(["get", "post", "put", "delete"].map(verb =>
-    [verb, (...args) => handler(request(verb.toUpperCase(), ...args))]));
+    [verb, (...args) => parse(request(verb.toUpperCase(), ...args))]));
 })();
 
 export default test => {
@@ -35,12 +17,14 @@ export default test => {
     assert((await r.post("/")).body).null();
   });
   test.case("body is application/json", async assert => {
-    assert((await r.post("/", {
-      body: JSON.stringify({foo: "bar"}),
-      headers: {
-        "Content-Type": "application/json",
-      },
-    })).body).equals({foo: "bar"});
+    const body = JSON.stringify({foo: "bar"});
+    const contentType = "application/json";
+    const headers = {"Content-Type": contentType};
+    assert((await r.post("/", {body, headers})).body).equals({foo: "bar"});
+
+    const faulty = `${body}%`;
+    assert(() => r.post("/", {body: faulty, headers}))
+      .throws(mark("cannot parse body % as %", faulty, contentType));
   });
   test.case("body is application/x-www-form-urlencoded", async assert => {
     assert((await r.post("/", {

package/src/hooks/publish.js

@@ -29,7 +29,7 @@ const post = async app => {
 };
 
 export default async app => {
-  app.log.info("running publish hooks");
+  app.log.info("running publish hooks", {module: "primate"});
   await [...filter("publish", app.modules), _ => _]
     .reduceRight((acc, handler) => input => handler(input, acc))(app);
   await post(app);

package/src/hooks/register.js

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

package/src/hooks/route.js

@@ -1,4 +1,6 @@
-import {default as Logger, abort} from "../Logger.js";
+import errors from "../errors.js";
+
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
 // insensitive-case equal
 const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
@@ -7,11 +9,20 @@ const verbs = [
   // CRUD
   "post", "get", "put", "delete",
   // extended
-  "connect", "options", "trace", "patch",
+  "connect", "options", "trace", "patch", "head",
 ];
 
-const toRoute = file => {
-  const route = file
+/* routes may not contain dots */
+export const invalid = route => /\./u.test(route);
+const toRoute = path => {
+  const double = path.split("/")
+    .filter(part => part.startsWith("{") && part.endsWith("}"))
+    .map(part => part.slice(1, part.indexOf(":")))
+    .find((part, i, array) =>
+      array.filter((_, j) => i !== j).includes(part));
+  double && errors.DoublePathParameter.throw({path, double});
+
+  const route = path
     // transform /index -> ""
     .replace("/index", "")
     // transform index -> ""
@@ -23,28 +34,32 @@ const toRoute = file => {
         const param = type === undefined ? name : `${name}$${type.slice(1)}`;
         return `(?<${param}>[^/]{1,}?)`;
       } catch (error) {
-        abort(`invalid parameter "${named}"`);
+        return errors.InvalidPathParameter.throw({named, path});
       }
-    })
-  ;
-  try {
-    return new RegExp(`^/${route}$`, "u");
-  } catch (error) {
-    abort("same parameter twice");
-  }
+    });
+
+  invalid(route) && errors.InvalidRouteName.throw({path});
+
+  return new RegExp(`^/${route}$`, "u");
 };
 
 const reentry = (object, mapper) =>
   Object.fromEntries(mapper(Object.entries(object ?? {})));
 
 export default app => {
-  const {types = {}} = app;
-  Object.entries(types).every(([name]) => /^(?:\w*)$/u.test(name) ||
-    abort(`invalid type "${name}"`));
+  const double = app.routes
+    .map(([route]) => route
+      .replaceAll("/index", "")
+      .replaceAll(/\{(?<name>\w*)(?<_>:\w+)?\}?/gu, (_, name) => `{${name}}`))
+    .find((part, i, array) =>
+      array.filter((_, j) => i !== j).includes(part));
+
+  double && errors.DoubleRoute.throw({double});
+
   const routes = app.routes
     .map(([route, imported]) => {
-      if (imported === undefined) {
-        app.log.warn(`empty route file at ${route}.js`);
+      if (imported === undefined || Object.keys(imported).length === 0) {
+        errors.EmptyRouteFile.warn(app.log, {config: app.config, route});
         return [];
       }
 
@@ -53,10 +68,10 @@ export default app => {
         .filter(([verb]) => verbs.includes(verb))
         .map(([method, handler]) => ({method, handler, path}));
     }).flat();
-  const paths = routes.map(({method, path}) => `${method}${path}`);
-  if (new Set(paths).size !== paths.length) {
-    abort("same route twice");
-  }
+
+  const {types = {}} = app;
+  Object.entries(types).every(([name]) => /^(?:\w*)$/u.test(name) ||
+    errors.InvalidType.throw({name}));
 
   const isType = groups => Object
     .entries(groups ?? {})
@@ -74,15 +89,19 @@ export default app => {
     && isPath({route, path});
   const find = (method, path) => routes.find(route =>
     isMethod({route, method, path}));
+  const modules = filter("route", app.modules);
 
   return request => {
     const {original: {method}, url: {pathname}} = request;
-    const verb = find(method, pathname) ?? (() => {
-      throw new Logger.Warn(`no ${method} route to ${pathname}`);
-    })();
+    const verb = find(method, pathname) ??
+      errors.NoRouteToPath.throw({method, pathname, config: app.config});
     const path = reentry(verb.path?.exec(pathname).groups,
       object => object.map(([key, value]) => [key.split("$")[0], value]));
 
-    return verb.handler({...request, path});
+    // verb.handler is the last module to be executed
+    const handlers = [...modules, verb.handler].reduceRight((acc, handler) =>
+      input => handler(input, acc));
+
+    return handlers({...request, path});
   };
 };

package/src/hooks/route.spec.js

@@ -1,6 +1,14 @@
+import Logger from "../Logger.js";
 import route from "./route.js";
 
+const {mark} = Logger;
+
 const app = {
+  config: {
+    paths: {
+      routes: "/routes",
+    },
+  },
   routes: [
     "index",
     "user",
@@ -36,9 +44,10 @@ export default test => {
   const r = pathname => {
     const original = new Request(`${p}${pathname}`, {method: "GET"});
     const {url} = original;
+    const end = -1;
     return router({
       original,
-      url: new URL(url.endsWith("/") ? url.slice(0, -1) : url),
+      url: new URL(url.endsWith("/") ? url.slice(0, end) : url),
     });
   };
 
@@ -46,29 +55,58 @@ export default test => {
     match: (url, result) => {
       assert(r(url).url.pathname).equals(result ?? url);
     },
-    fail: (url, result) =>
-      assert(() => r(url)).throws(`no GET route to ${result ?? url}`),
+    fail: (url, result) => {
+      const throws = mark("no % route to %", "GET", result ?? url);
+      assert(() => r(url)).throws(throws);
+    },
     path: (url, result) => assert(r(url).path).equals(result),
     assert,
   }));
 
   const get = () => null;
-  /* abort {{{ */
-  test.case("must not contain the same route twice", ({assert}) => {
+  /* errors {{{ */
+  test.case("error DoubleRouted", ({assert}) => {
     const post = ["post", {get}];
-    assert(() => route({routes: [post, post]})).throws("same route twice");
-  });
-  test.case("must not contain the same param twice", ({assert}) => {
-    assert(() => route({routes: [["{userId}/{userId}", {get}]]}))
-      .throws("same parameter twice");
-  });
-  test.case("must not contain invalid characters in params", ({assert}) => {
-    assert(() => route({routes: [["{user$Id}", {get}]]}))
-      .throws("invalid parameter \"user$Id\"");
-  });
-  test.case("must not contain invalid characters in types", ({assert}) => {
-    assert(() => route({routes: [], types: {us$er: () => null}}))
-      .throws("invalid type \"us$er\"");
+    const throws = mark("double route %", "post");
+    assert(() => route({routes: [post, post]})).throws(throws);
+  });
+  test.case("error DoublePathParameter", ({assert}) => {
+    const path = "{user}/{user}";
+    const throws = mark("double path parameter % in route %", "user", path);
+    assert(() => route({routes: [[path, {get}]]})).throws(throws);
+  });
+  test.case("error EmptyRoutefile", ({assert}) => {
+    const path = "user";
+    const throws = mark("empty route file at %", `/routes/${path}.js`);
+    const base = {
+      log: {
+        auto(error) {
+          throw error;
+        },
+      },
+      config: {
+        paths: {
+          routes: "/routes",
+        },
+      },
+    };
+    assert(() => route({...base, routes: [[path, undefined]]})).throws(throws);
+    assert(() => route({...base, routes: [[path, {}]]})).throws(throws);
+  });
+  test.case("error InvalidRouteName", ({assert}) => {
+    const post = ["po.st", {get}];
+    const throws = mark("invalid route name %", "po.st");
+    assert(() => route({routes: [post], types: {}})).throws(throws);
+  });
+  test.case("error InvalidParameter", ({assert}) => {
+    const path = "{us$er}";
+    const throws = mark("invalid path parameter % in route %", "us$er", path);
+    assert(() => route({routes: [[path, {get}]]})).throws(throws);
+  });
+  test.case("error InvalidType", ({assert}) => {
+    const throws = mark("invalid type %", "us$er");
+    const types = {us$er: () => false};
+    assert(() => route({routes: [], types})).throws(throws);
   });
   /* }}} */
 

package/src/http-statuses.js

@@ -0,0 +1,4 @@
+export const OK = 200;
+export const Found = 302;
+export const NotFound = 404;
+export const InternalServerError = 500;

package/src/run.js

@@ -1,9 +1,10 @@
 import {Path} from "runtime-compat/fs";
 import app from "./app.js";
+import {default as Logger, bye} from "./Logger.js";
+import extend from "./extend.js";
+import errors from "./errors.js";
 import command from "./commands/exports.js";
-import {Abort, colors, print, default as Logger} from "./Logger.js";
 import defaults from "./defaults/primate.config.js";
-import extend from "./extend.js";
 
 const getRoot = async () => {
   try {
@@ -15,19 +16,21 @@ const getRoot = async () => {
   }
 };
 
-const configName = "primate.config.js";
+const protologger = new Logger({level: Logger.Warn});
+
 const getConfig = async root => {
-  const config = root.join(configName);
+  const name = "primate.config.js";
+  const config = root.join(name);
   if (await config.exists) {
     try {
-      const imported = await import(config);
-      if (imported.default === undefined) {
-        print(`${colors.yellow("??")} ${configName} has no default export\n`);
-      }
-      return extend(defaults, imported.default);
-    } catch (error) {
-      print(`${colors.red("!!")} couldn't load config file\n`);
-      throw error;
+      const imported = (await import(config)).default;
+
+      (imported === undefined || Object.keys(imported).length === 0) &&
+        errors.EmptyConfigFile.warn(protologger, {config});
+
+      return extend(defaults, imported);
+    } catch ({message}) {
+      return errors.ErrorInConfigFile.throw({message, config});
     }
   } else {
     return defaults;
@@ -36,11 +39,16 @@ const getConfig = async root => {
 
 export default async name => {
   const root = await getRoot();
-  const config = await getConfig(root);
+  let logger = protologger;
   try {
-    command(name)(await app(config, root, new Logger(config.logger)));
+    const config = await getConfig(root);
+    logger = new Logger(config.logger);
+    await command(name)(await app(config, root, new Logger(config.logger)));
   } catch (error) {
-    if (error instanceof Abort) {
+    if (error.level === Logger.Error) {
+      logger.auto(error);
+      bye();
+    } else {
       throw error;
     }
   }

package/src/start.js

@@ -1,5 +1,6 @@
-import {serve} from "runtime-compat/http";
-import {register, compile, publish, bundle, route, handle}
+import {serve, Response} from "runtime-compat/http";
+import {InternalServerError} from "./http-statuses.js";
+import {register, compile, publish, bundle, route, handle, parse}
   from "./hooks/exports.js";
 
 export default async (app, operations = {}) => {
@@ -16,6 +17,15 @@ export default async (app, operations = {}) => {
   // bundle client-side code
   await bundle(app, operations?.bundle);
 
-  // handle
-  serve(await handle({route: route(app), ...app}), app.config.http);
+  const _route = route(app);
+
+  serve(async request => {
+    try {
+      // parse, handle
+      return await handle({...app, route: _route})(await parse(request));
+    } catch(error) {
+      app.log.auto(error);
+      return new Response(null, {status: InternalServerError});
+    }
+  }, app.config.http);
 };

package/src/commands/build.js

@@ -1 +0,0 @@
-export {default} from "./serve.js";

package/src/commands/create.js

@@ -1,42 +0,0 @@
-import {Path} from "runtime-compat/fs";
-
-const createModule = async app => {
-  const space = 2;
-  try {
-    // will throw if cannot find a package.json up the filesystem hierarchy
-    await Path.root();
-  } catch (error) {
-    const rootConfig = JSON.stringify({
-      name: "primate-app",
-      private: true,
-      dependencies: {
-        primate: `^${app.version}`,
-      },
-      scripts: {
-        start: "npx primate",
-        dev: "npx primate dev",
-        serve: "npx primate serve",
-      },
-      type: "module",
-    }, null, space);
-    await Path.resolve().join("package.json").file.write(rootConfig);
-  }
-};
-
-const createConfig = async app => {
-  const name = "primate.config.js";
-  const template = "export default {};";
-  const root = (await Path.root()).join(name);
-  if (await root.exists) {
-    app.log.warn(`${root} already exists`);
-  } else {
-    await root.file.write(template);
-    app.log.info(`created config at ${root}`);
-  }
-};
-
-export default async app => {
-  await createModule(app);
-  await createConfig(app);
-};
-

package/src/commands/help.js

@@ -1,3 +0,0 @@
-export default app => {
-  app.log.info("available commands: create dev serve");
-};

package/src/hooks/handle/http-statuses.js

@@ -1,5 +0,0 @@
-export default {
-  OK: 200,
-  Found: 302,
-  InternalServerError: 500,
-};