primate 0.16.3 → 0.18.0

package/src/hooks/handle.js

@@ -1,61 +1,37 @@
-import {Path} from "runtime-compat/fs";
-import {serve, Response, URL} from "runtime-compat/http";
-import {http404} from "../handlers/http.js";
-import {statuses, mime, isResponse, respond} from "./handle/exports.js";
-import fromNull from "../fromNull.js";
+import {Response} from "runtime-compat/http";
+import {error as clientError} from "../handlers/exports.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 => {
-  const {config} = app;
-  const {http} = config;
+export default app => {
+  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 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 {router} = app;
-      const modules = filter("route", app.modules);
-      // handle is the last module to be executed
-      const handlers = [...modules, router.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 http404()(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,
@@ -67,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,
@@ -91,62 +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});
-    }
-  };
-
-  const parseContentType = (contentType, body) => {
-    const type = contents[contentType];
-    return type === undefined ? body : type(body);
+    return await resource(request);
   };
 
-  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 => {
-    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 chunks.length === 0 ? null : parseContent(request, chunks.join());
-  };
-
-  const parseRequest = async request => {
-    const cookies = request.headers.get("cookie");
-    const {url} = request;
-
-    return {
-      request,
-      url: new URL(url.endsWith("/") ? url.slice(0, -1) : url),
-      body: await parseBody(request),
-      cookies: fromNull(cookies === null
-        ? {}
-        : Object.fromEntries(cookies.split(";").map(c => c.trim().split("=")))),
-      headers: fromNull(Object.fromEntries(request.headers)),
-    };
-  };
-
-  // 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));
-
-  serve(async request => handlers(await parseRequest(request)), config.http);
 };

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/parse.spec.js

@@ -0,0 +1,72 @@
+import parse from "./parse.js";
+import Logger from "../Logger.js";
+
+const {mark} = Logger;
+
+const r = await (async () => {
+  const p = "https://p.com";
+  const request = (method, path = "/", options = {}) =>
+    new Request(`${p}${path}`, {method, ...options});
+  return Object.fromEntries(["get", "post", "put", "delete"].map(verb =>
+    [verb, (...args) => parse(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 => {
+    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("/", {
+      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/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,6 +1,6 @@
-import {Path} from "runtime-compat/fs";
-import {Logger} from "primate";
-import fromNull from "../fromNull.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();
@@ -9,61 +9,99 @@ const verbs = [
   // CRUD
   "post", "get", "put", "delete",
   // extended
-  "delete", "connect", "options", "trace", "patch",
+  "connect", "options", "trace", "patch", "head",
 ];
 
-const toRoute = file => {
-  const ending = -3;
-  const route = file
-    // remove ending
-    .slice(0, ending)
+/* 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 -> ""
     .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) {
+        return errors.InvalidPathParameter.throw({named, path});
+      }
+    });
+
+  invalid(route) && errors.InvalidRouteName.throw({path});
+
   return new RegExp(`^/${route}$`, "u");
 };
 
-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 path = toRoute(file);
-        return Object.entries(imported)
-          .filter(([verb]) => verbs.includes(verb))
-          .map(([method, handler]) => ({method, handler, path}));
-      }))).flat();
+const reentry = (object, mapper) =>
+  Object.fromEntries(mapper(Object.entries(object ?? {})));
+
+export default app => {
+  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 || Object.keys(imported).length === 0) {
+        errors.EmptyRouteFile.warn(app.log, {config: app.config, route});
+        return [];
+      }
+
+      const path = toRoute(route);
+      return Object.entries(imported)
+        .filter(([verb]) => verbs.includes(verb))
+        .map(([method, handler]) => ({method, handler, path}));
+    }).flat();
+
+  const {types = {}} = app;
+  Object.entries(types).every(([name]) => /^(?:\w*)$/u.test(name) ||
+    errors.InvalidType.throw({name}));
+
+  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 =>
-    ieq(route.method, method) && route.path.test(path));
-
-  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 data = {
-        request,
-        url,
-        path: verb.path?.exec(pathname)?.groups ?? Object.create(null),
-        query: fromNull(Object.fromEntries(searchParams)),
-        ...rest,
-      };
-
-      return verb.handler(data);
-    },
+    isMethod({route, method, path}));
+  const modules = filter("route", app.modules);
+
+  return request => {
+    const {original: {method}, url: {pathname}} = request;
+    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]));
+
+    // 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});
   };
-  return router;
 };

package/src/hooks/route.spec.js

@@ -0,0 +1,181 @@
+import Logger from "../Logger.js";
+import route from "./route.js";
+
+const {mark} = Logger;
+
+const app = {
+  config: {
+    paths: {
+      routes: "/routes",
+    },
+  },
+  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;
+    const end = -1;
+    return router({
+      original,
+      url: new URL(url.endsWith("/") ? url.slice(0, end) : url),
+    });
+  };
+
+  test.reassert(assert => ({
+    match: (url, result) => {
+      assert(r(url).url.pathname).equals(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;
+  /* errors {{{ */
+  test.case("error DoubleRouted", ({assert}) => {
+    const post = ["post", {get}];
+    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);
+  });
+  /* }}} */
+
+  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/http-statuses.js

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