primate 0.16.3 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",

package/src/Logger.js

@@ -14,6 +14,7 @@ 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 {};
@@ -24,6 +25,10 @@ const levels = new Map([
   [Info, info],
 ]);
 
+const abort = message => {
+  throw new Abort(message);
+};
+
 const print = (...messages) => process.stdout.write(messages.join(" "));
 
 const Logger = class Logger {
@@ -36,6 +41,14 @@ const Logger = class Logger {
     this.#trace = trace;
   }
 
+  static get colors() {
+    return colors;
+  }
+
+  static print(...args) {
+    print(...args);
+  }
+
   static get Error() {
     return Error;
   }
@@ -48,6 +61,10 @@ const Logger = class Logger {
     return Info;
   }
 
+  get class() {
+    return this.constructor;
+  }
+
   #print(pre, error) {
     if (error instanceof Error) {
       print(colors.bold(pre), error.message, "\n");
@@ -95,4 +112,4 @@ const Logger = class Logger {
 
 export default Logger;
 
-export {colors, levels, print};
+export {colors, levels, print, abort, Abort};

package/src/app.js

@@ -1,10 +1,7 @@
 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 * as handlers from "./handlers/exports.js";
+import {abort} from "./Logger.js";
 
 const qualify = (root, paths) =>
   Object.keys(paths).reduce((sofar, key) => {
@@ -15,36 +12,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,11 +32,7 @@ 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);
-
+export default async (config, root, log) => {
   const {name, version} = await src.up(1).join("package.json").json();
 
   // if ssl activated, resolve key and cert early
@@ -78,8 +41,32 @@ export default async (filename = configName) => {
     config.http.ssl.cert = root.join(config.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 => module.name !== undefined ||
+    abort("all modules must have names"));
+
+  if (new Set(modules.map(module => module.name)).size !== modules.length) {
+    abort("same module twice");
+  }
+
+  modules.every(module => Object.entries(module).length > 1) || (() => {
+    log.warn("some modules haven't subscribed to any hooks");
+  })();
+
   const app = {
     config,
+    routes,
     secure: config.http?.ssl !== undefined,
     name, version,
     library: {},
@@ -96,9 +83,9 @@ export default async (filename = configName) => {
     },
     resources: [],
     entrypoints: [],
-    paths: qualify(root, config.paths),
+    paths,
     root,
-    log: new Logger(config.logger),
+    log,
     handlers: {...handlers},
     render: async ({body = "", head = ""} = {}) => {
       const html = await index(app);
@@ -140,8 +127,9 @@ export default async (filename = configName) => {
         ]));
       app.identifiers = {...exports, ...app.identifiers};
     },
-    modules: [...config.modules],
+    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}`;

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/handlers/error.js

@@ -0,0 +1,8 @@
+const _404 = "Not Found";
+
+export default (body = _404, {status = 404} = {}) => 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/hooks/handle.js

@@ -1,6 +1,5 @@
-import {Path} from "runtime-compat/fs";
-import {serve, Response, URL} from "runtime-compat/http";
-import {http404} from "../handlers/http.js";
+import {Response, URL} 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";
 
@@ -14,12 +13,11 @@ const contents = {
 };
 
 export default async app => {
-  const {config} = app;
-  const {http} = config;
+  const {http} = app.config;
 
   const _respond = async request => {
-    const csp = Object.keys(config.http.csp).reduce((policy_string, key) =>
-      `${policy_string}${key} ${config.http.csp[key]};`, "");
+    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};`;
@@ -37,15 +35,14 @@ export default async app => {
     };
 
     try {
-      const {router} = app;
       const modules = filter("route", app.modules);
-      // handle is the last module to be executed
-      const handlers = [...modules, router.route].reduceRight((acc, handler) =>
+      // 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);
     } catch (error) {
       app.log.auto(error);
-      return http404()(app, headers);
+      return clientError()(app, headers);
     }
   };
 
@@ -116,6 +113,9 @@ export default async app => {
   const decoder = new TextDecoder();
 
   const parseBody = async request => {
+    if (request.body === null) {
+      return null;
+    }
     const reader = request.body.getReader();
     const chunks = [];
     let result;
@@ -126,21 +126,23 @@ export default async app => {
       }
     } while (!result.done);
 
-    return chunks.length === 0 ? null : parseContent(request, chunks.join());
+    return parseContent(request, chunks.join());
   };
 
   const parseRequest = async request => {
     const cookies = request.headers.get("cookie");
-    const {url} = request;
+    const _url = request.url;
+    const url = new URL(_url.endsWith("/") ? _url.slice(0, -1) : _url);
 
     return {
-      request,
-      url: new URL(url.endsWith("/") ? url.slice(0, -1) : url),
+      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)),
     };
   };
 
@@ -148,5 +150,5 @@ export default async app => {
   const handlers = [...filter("handle", app.modules), handle]
     .reduceRight((acc, handler) => input => handler(input, acc));
 
-  serve(async request => handlers(await parseRequest(request)), config.http);
+  return async request => handlers(await parseRequest(request));
 };

package/src/hooks/handle.spec.js

@@ -0,0 +1,88 @@
+import handle from "./handle.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 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))]));
+})();
+
+export default test => {
+  test.case("no body => null", async assert => {
+    assert((await r.get("/")).body).null();
+    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"});
+  });
+  test.case("body is application/x-www-form-urlencoded", async assert => {
+    assert((await r.post("/", {
+      body: encodeURI("foo=bar &bar=baz"),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+    })).body).equals({foo: "bar ", bar: "baz"});
+  });
+  test.case("no query => {}", async assert => {
+    assert((await r.get("/")).query).equals({});
+  });
+  test.case("query", async assert => {
+    assert((await r.get("/?key=value")).query).equals({key: "value"});
+  });
+  test.case("no cookies => {}", async assert => {
+    assert((await r.get("/")).cookies).equals({});
+  });
+  test.case("cookies", async assert => {
+    assert((await r.get("/?key=value", {
+      headers: {
+        Cookie: "key=value;key2=value2",
+      },
+    })).cookies).equals({key: "value", key2: "value2"});
+  });
+  test.case("no headers => {}", async assert => {
+    assert((await r.get("/")).headers).equals({});
+  });
+  test.case("headers", async assert => {
+    assert((await r.get("/?key=value", {
+      headers: {
+        "X-User": "Donald",
+      },
+    })).headers).equals({"x-user": "Donald"});
+  });
+  test.case("cookies double as headers", async assert => {
+    const response = await r.get("/?key=value", {
+      headers: {
+        Cookie: "key=value",
+      },
+    });
+    assert(response.headers).equals({cookie: "key=value"});
+    assert(response.cookies).equals({key: "value"});
+  });
+};

package/src/hooks/route.js

@@ -1,6 +1,4 @@
-import {Path} from "runtime-compat/fs";
-import {Logger} from "primate";
-import fromNull from "../fromNull.js";
+import {default as Logger, abort} from "../Logger.js";
 
 // insensitive-case equal
 const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
@@ -9,61 +7,82 @@ const verbs = [
   // CRUD
   "post", "get", "put", "delete",
   // extended
-  "delete", "connect", "options", "trace", "patch",
+  "connect", "options", "trace", "patch",
 ];
 
 const toRoute = file => {
-  const ending = -3;
   const route = file
-    // remove ending
-    .slice(0, ending)
     // transform /index -> ""
     .replace("/index", "")
     // transform index -> ""
     .replace("index", "")
     // prepare for regex
-    .replaceAll(/\{(?<named>.*)\}/gu, (_, name) => `(?<${name}>.*?)`)
+    .replaceAll(/\{(?<named>.*?)\}/gu, (_, named) => {
+      try {
+        const {name, type} = /^(?<name>\w*)(?<type>:\w+)?$/u.exec(named).groups;
+        const param = type === undefined ? name : `${name}$${type.slice(1)}`;
+        return `(?<${param}>[^/]{1,}?)`;
+      } catch (error) {
+        abort(`invalid parameter "${named}"`);
+      }
+    })
   ;
-  return new RegExp(`^/${route}$`, "u");
+  try {
+    return new RegExp(`^/${route}$`, "u");
+  } catch (error) {
+    abort("same parameter twice");
+  }
 };
 
-export default async app => {
-  const routes = (await Promise.all(
-    (await Path.collect(app.paths.routes, /^.*.js$/u))
-      .map(async route => {
-        const imported = (await import(route)).default;
-        const file = `${route}`.replace(app.paths.routes, "").slice(1);
-        if (imported === undefined) {
-          app.log.warn(`empty route file at ${file}`);
-          return [];
-        }
+const reentry = (object, mapper) =>
+  Object.fromEntries(mapper(Object.entries(object ?? {})));
 
-        const path = toRoute(file);
-        return Object.entries(imported)
-          .filter(([verb]) => verbs.includes(verb))
-          .map(([method, handler]) => ({method, handler, path}));
-      }))).flat();
-  const find = (method, path) => routes.find(route =>
-    ieq(route.method, method) && route.path.test(path));
+export default app => {
+  const {types = {}} = app;
+  Object.entries(types).every(([name]) => /^(?:\w*)$/u.test(name) ||
+    abort(`invalid type "${name}"`));
+  const routes = app.routes
+    .map(([route, imported]) => {
+      if (imported === undefined) {
+        app.log.warn(`empty route file at ${route}.js`);
+        return [];
+      }
+
+      const path = toRoute(route);
+      return Object.entries(imported)
+        .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 router = {
-    async route({request, url, ...rest}) {
-      const {method} = request;
-      const {pathname, searchParams} = url;
-      const verb = find(method, pathname) ?? (() => {
-        throw new Logger.Warn(`no ${method} route to ${pathname}`);
-      })();
+  const isType = groups => Object
+    .entries(groups ?? {})
+    .map(([name, value]) =>
+      [types[name] === undefined ? name : `${name}$${name}`, value])
+    .filter(([name]) => name.includes("$"))
+    .map(([name, value]) => [name.split("$")[1], value])
+    .every(([name, value]) => types?.[name](value) === true)
+  ;
+  const isPath = ({route, path}) => {
+    const result = route.path.exec(path);
+    return result === null ? false : isType(result.groups);
+  };
+  const isMethod = ({route, method, path}) => ieq(route.method, method)
+    && isPath({route, path});
+  const find = (method, path) => routes.find(route =>
+    isMethod({route, method, path}));
 
-      const data = {
-        request,
-        url,
-        path: verb.path?.exec(pathname)?.groups ?? Object.create(null),
-        query: fromNull(Object.fromEntries(searchParams)),
-        ...rest,
-      };
+  return request => {
+    const {original: {method}, url: {pathname}} = request;
+    const verb = find(method, pathname) ?? (() => {
+      throw new Logger.Warn(`no ${method} route to ${pathname}`);
+    })();
+    const path = reentry(verb.path?.exec(pathname).groups,
+      object => object.map(([key, value]) => [key.split("$")[0], value]));
 
-      return verb.handler(data);
-    },
+    return verb.handler({...request, path});
   };
-  return router;
 };

package/src/hooks/route.spec.js

@@ -0,0 +1,143 @@
+import route from "./route.js";
+
+const app = {
+  routes: [
+    "index",
+    "user",
+    "users/{userId}a",
+    "comments/{commentId:comment}",
+    "users/{userId}/comments/{commentId}",
+    "users/{userId:user}/comments/{commentId}/a",
+    "users/{userId:user}/comments/{commentId:comment}/b",
+    "users/{_userId}/comments/{commentId}/d",
+    "users/{_userId}/comments/{_commentId}/e",
+    "comments2/{_commentId}",
+    "users2/{_userId}/{commentId}",
+    "users3/{_userId}/{_commentId:_commentId}",
+    "users4/{_userId}/{_commentId}",
+    "users5/{truthy}",
+    "{uuid}/{Uuid}/{UUID}",
+  ].map(pathname => [pathname, {get: request => request}]),
+  types: {
+    user: id => /^\d*$/u.test(id),
+    comment: id => /^\d*$/u.test(id),
+    _userId: id => /^\d*$/u.test(id),
+    _commentId: id => /^\d*$/u.test(id),
+    truthy: () => 1,
+    uuid: _ => _ === "uuid",
+    Uuid: _ => _ === "Uuid",
+    UUID: _ => _ === "UUID",
+  },
+};
+
+export default test => {
+  const router = route(app);
+  const p = "https://p.com";
+  const r = pathname => {
+    const original = new Request(`${p}${pathname}`, {method: "GET"});
+    const {url} = original;
+    return router({
+      original,
+      url: new URL(url.endsWith("/") ? url.slice(0, -1) : url),
+    });
+  };
+
+  test.reassert(assert => ({
+    match: (url, result) => {
+      assert(r(url).url.pathname).equals(result ?? url);
+    },
+    fail: (url, result) =>
+      assert(() => r(url)).throws(`no GET route to ${result ?? url}`),
+    path: (url, result) => assert(r(url).path).equals(result),
+    assert,
+  }));
+
+  const get = () => null;
+  /* abort {{{ */
+  test.case("must not contain the same route twice", ({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\"");
+  });
+  /* }}} */
+
+  test.case("index route", ({match}) => {
+    match("/");
+  });
+  test.case("simple route", ({match}) => {
+    match("/user");
+  });
+  test.case("param match/fail", ({match, fail}) => {
+    match("/users/1a");
+    match("/users/aa");
+    match("/users/ba?key=value", "/users/ba");
+    fail("/user/1a");
+    fail("/users/a");
+    fail("/users/aA");
+    fail("/users//a");
+    fail("/users/?a", "/users/");
+  });
+  test.case("no params", ({path}) => {
+    path("/", {});
+  });
+  test.case("single param", ({path}) => {
+    path("/users/1a", {userId: "1"});
+  });
+  test.case("params", ({path, fail}) => {
+    path("/users/1/comments/2", {userId: "1", commentId: "2"});
+    path("/users/1/comments/2/b", {userId: "1", commentId: "2"});
+    fail("/users/d/comments/2/b");
+    fail("/users/1/comments/d/b");
+    fail("/users/d/comments/d/b");
+  });
+  test.case("single typed param", ({path, fail}) => {
+    path("/comments/1", {commentId: "1"});
+    fail("/comments/ ", "/comments");
+    fail("/comments/1d");
+  });
+  test.case("mixed untyped and typed params", ({path, fail}) => {
+    path("/users/1/comments/2/a", {userId: "1", commentId: "2"});
+    fail("/users/d/comments/2/a");
+  });
+  test.case("single implicit typed param", ({path, fail}) => {
+    path("/comments2/1", {_commentId: "1"});
+    fail("/comments2/d");
+  });
+  test.case("mixed implicit and untyped params", ({path, fail}) => {
+    path("/users2/1/2", {_userId: "1", commentId: "2"});
+    fail("/users2/d/2");
+    fail("/users2/d");
+  });
+  test.case("mixed implicit and explicit params", ({path, fail}) => {
+    path("/users3/1/2", {_userId: "1", _commentId: "2"});
+    fail("/users3/d/2");
+    fail("/users3/1/d");
+    fail("/users3");
+  });
+  test.case("implicit params", ({path, fail}) => {
+    path("/users4/1/2", {_userId: "1", _commentId: "2"});
+    fail("/users4/d/2");
+    fail("/users4/1/d");
+    fail("/users4");
+  });
+  test.case("fail not strictly true implicit params", ({fail}) => {
+    fail("/users5/any");
+  });
+  test.case("different case params", ({path, fail}) => {
+    path("/uuid/Uuid/UUID", {uuid: "uuid", Uuid: "Uuid", UUID: "UUID"});
+    fail("/uuid/uuid/uuid");
+    fail("/Uuid/UUID/uuid");
+    fail("/UUID/uuid/Uuid");
+  });
+};

package/src/run.js

@@ -1,4 +1,47 @@
+import {Path} from "runtime-compat/fs";
 import app from "./app.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";
 
-export default async name => command(name)(await app());
+const getRoot = async () => {
+  try {
+    // use module root if possible
+    return await Path.root();
+  } catch (error) {
+    // fall back to current directory
+    return Path.resolve();
+  }
+};
+
+const configName = "primate.config.js";
+const getConfig = async root => {
+  const config = root.join(configName);
+  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;
+  }
+};
+
+export default async name => {
+  const root = await getRoot();
+  const config = await getConfig(root);
+  try {
+    command(name)(await app(config, root, new Logger(config.logger)));
+  } catch (error) {
+    if (error instanceof Abort) {
+      throw error;
+    }
+  }
+};

package/src/start.js

@@ -1,3 +1,4 @@
+import {serve} from "runtime-compat/http";
 import {register, compile, publish, bundle, route, handle}
   from "./hooks/exports.js";
 
@@ -16,5 +17,5 @@ export default async (app, operations = {}) => {
   await bundle(app, operations?.bundle);
 
   // handle
-  await handle({router: await route(app), ...app});
+  serve(await handle({route: route(app), ...app}), app.config.http);
 };

package/src/handlers/http.js

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

package/src/handlers/http404.js

@@ -1,6 +0,0 @@
-export default (body = "Not found") => (_, headers) => [
-  body, {
-    status: 404,
-    headers: {...headers, "Content-Type": "text/html"},
-  },
-];