primate 0.16.3 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.16.3",
+  "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,98 +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;
-
-// Error natively provided
-const Warn = class Warn extends Error {};
-const Info = class Info extends Error {};
+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 levels = new Map([
-  [Error, error],
-  [Warn, warn],
-  [Info, info],
-]);
+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 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;
   }
 
-  #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");
+  get class() {
+    return this.constructor;
+  }
+
+  #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};
+export {print, bye};

package/src/app.js

@@ -1,10 +1,9 @@
 import crypto from "runtime-compat/crypto";
-import {is} from "runtime-compat/dyndef";
 import {File, Path} from "runtime-compat/fs";
-import extend from "./extend.js";
-import defaults from "./defaults/primate.config.js";
-import {colors, print, default as Logger} from "./Logger.js";
+import {bold, blue} from "runtime-compat/colors";
+import errors from "./errors.js";
 import * as handlers from "./handlers/exports.js";
+import * as hooks from "./hooks/exports.js";
 
 const qualify = (root, paths) =>
   Object.keys(paths).reduce((sofar, key) => {
@@ -15,36 +14,6 @@ const qualify = (root, paths) =>
     return sofar;
   }, {});
 
-const configName = "primate.config.js";
-
-const getConfig = async (root, filename) => {
-  const config = root.join(filename);
-  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;
-    }
-  } else {
-    return defaults;
-  }
-};
-
-const getRoot = async () => {
-  try {
-    // use module root if possible
-    return await Path.root();
-  } catch (error) {
-    // fall back to current directory
-    return Path.resolve();
-  }
-};
-
 const src = new Path(import.meta.url).up(1);
 
 const index = async app => {
@@ -65,23 +34,48 @@ const hash = async (string, algorithm = "sha-384") => {
   return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
 };
 
-export default async (filename = configName) => {
-  is(filename).string();
-  const root = await getRoot();
-  const config = await getConfig(root, filename);
-
-  const {name, version} = await src.up(1).join("package.json").json();
+export default async (config, root, log) => {
+  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);
+
+  const ending = ".js";
+  const routes = paths.routes === undefined ? [] : await Promise.all(
+    (await Path.collect(paths.routes, /^.*.js$/u))
+      .map(async route => [
+        `${route}`.replace(paths.routes, "").slice(1, -ending.length),
+        (await import(route)).default,
+      ]));
+
+  const modules = config.modules === undefined ? [] : config.modules;
+
+  modules.every((module, n) => module.name !== undefined ||
+    errors.ModulesMustHaveNames.throw({n}));
+
+  new Set(modules.map(({name}) => name)).size !== modules.length &&
+    errors.DoubleModule.throw({
+      modules: modules.map(({name}) => name),
+      config: root.join("primate.config.js"),
+    });
+
+  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,
-    secure: config.http?.ssl !== undefined,
-    name, version,
+    routes,
+    secure: http?.ssl !== undefined,
+    name,
+    version,
     library: {},
     identifiers: {},
     replace(code) {
@@ -96,9 +90,28 @@ export default async (filename = configName) => {
     },
     resources: [],
     entrypoints: [],
-    paths: qualify(root, config.paths),
+    paths,
     root,
-    log: new Logger(config.logger),
+    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);
@@ -124,7 +137,7 @@ export default async (filename = configName) => {
       // 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;
     },
@@ -140,12 +153,10 @@ export default async (filename = configName) => {
         ]));
       app.identifiers = {...exports, ...app.identifiers};
     },
-    modules: [...config.modules],
+    modules,
   };
-  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/defaults/primate.config.js

@@ -25,6 +25,7 @@ export default {
     public: "public",
     routes: "routes",
     components: "components",
+    types: "types",
   },
   modules: [],
   dist: "app",

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

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

package/src/handlers/exports.js

@@ -4,3 +4,4 @@ export {default as stream} from "./stream.js";
 export {default as redirect} from "./redirect.js";
 export {default as html} from "./html.js";
 export {default as view} from "./view.js";
+export {default as error} from "./error.js";

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";