primate 0.17.0 → 0.19.0

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,5 @@ 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";
+export {default as serve} from "./serve.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,36 @@
-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) => {
+    const {pathname} = request.url;
+    return invalid(pathname)
+      ? errors.NoFileForPath.throw({pathname, config: app.config})
+      : (await 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 +42,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,
@@ -87,68 +65,6 @@ export default async app => {
     return route(request);
   };
 
-  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);
-  };
-
-  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), resource]
     .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 errors from "../errors.js";
+
+const contents = {
+  "application/x-www-form-urlencoded": body =>
+    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 dispatch => 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);
+
+  const body = await parseBody(request);
+  return {
+    original: request,
+    url,
+    body: dispatch(body),
+    cookies: dispatch(cookies === null
+      ? {}
+      : Object.fromEntries(cookies.split(";").map(c => c.trim().split("=")))),
+    headers: dispatch(Object.fromEntries(request.headers)),
+    query: dispatch(Object.fromEntries(url.searchParams)),
+  };
+};

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,17 +1,21 @@
-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();
-// HTTP verbs
-const verbs = [
-  // CRUD
-  "post", "get", "put", "delete",
-  // extended
-  "connect", "options", "trace", "patch",
-];
-
-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,66 +27,81 @@ 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 [];
       }
 
-      const path = toRoute(route);
       return Object.entries(imported)
-        .filter(([verb]) => verbs.includes(verb))
-        .map(([method, handler]) => ({method, handler, path}));
+        .map(([method, handler]) => ({method, handler, path: toRoute(route)}));
     }).flat();
-  const paths = routes.map(({method, path}) => `${method}${path}`);
-  if (new Set(paths).size !== paths.length) {
-    abort("same route twice");
-  }
 
-  const isType = groups => Object
+  const {types = {}} = app;
+  Object.entries(types).some(([name]) => /^(?:[^\W_]*)$/u.test(name) ||
+    errors.InvalidTypeName.throw({name}));
+  const reserved = ["get", "raw"];
+  Object.entries(types).some(([name]) => reserved.includes(name) &&
+    errors.ReservedTypeName.throw({name}));
+
+  const {explicit} = app.config.types;
+  const isType = (groups, path) => Object
     .entries(groups ?? {})
     .map(([name, value]) =>
-      [types[name] === undefined ? name : `${name}$${name}`, value])
+      [types[name] === undefined || explicit ? name : `${name}$${name}`, value])
     .filter(([name]) => name.includes("$"))
     .map(([name, value]) => [name.split("$")[1], value])
-    .every(([name, value]) => types?.[name](value) === true)
-  ;
+    .every(([name, value]) => {
+      try {
+        return types?.[name](value) === true;
+      } catch (error) {
+        return errors.MismatchedPath.throw({message: error.message, path});
+      }
+    });
   const isPath = ({route, path}) => {
     const result = route.path.exec(path);
-    return result === null ? false : isType(result.groups);
+    return result === null ? false : isType(result.groups, path);
   };
   const isMethod = ({route, method, path}) => ieq(route.method, method)
     && 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 path = reentry(verb.path?.exec(pathname).groups,
-      object => object.map(([key, value]) => [key.split("$")[0], value]));
+    const verb = find(method, pathname) ??
+      errors.NoRouteToPath.throw({method, pathname, config: app.config});
+    const path = app.dispatch(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 verb.handler({...request, path});
+    return handlers({...request, path});
   };
 };

package/src/hooks/serve.js

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

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,21 +1,36 @@
-import {serve} from "runtime-compat/http";
-import {register, compile, publish, bundle, route, handle}
-  from "./hooks/exports.js";
+import {serve, Response} from "runtime-compat/http";
+import {InternalServerError} from "./http-statuses.js";
+import * as hooks from "./hooks/exports.js";
+
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
 export default async (app, operations = {}) => {
   // register handlers
-  await register({...app, register(name, handler) {
+  await hooks.register({...app, register(name, handler) {
     app.handlers[name] = handler;
   }});
 
   // compile server-side code
-  await compile(app);
+  await hooks.compile(app);
   // publish client-side code
-  await publish(app);
+  await hooks.publish(app);
 
   // bundle client-side code
-  await bundle(app, operations?.bundle);
+  await hooks.bundle(app, operations?.bundle);
+
+  const server = await serve(async request => {
+    try {
+      // parse, handle
+      return await hooks.handle(app)(await app.parse(request));
+    } catch(error) {
+      console.log("TEST2");
+      app.log.auto(error);
+      return new Response(null, {status: InternalServerError});
+    }
+  }, app.config.http);
 
-  // handle
-  serve(await handle({route: route(app), ...app}), app.config.http);
+  await [...filter("serve", app.modules), _ => _]
+    .reduceRight((acc, handler) => input => handler(input, acc))({
+      ...app, server,
+    });
 };

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/fromNull.js

@@ -1 +0,0 @@
-export default object => Object.assign(Object.create(null), object);

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

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

package/src/hooks/handle/mime.spec.js

@@ -1,13 +0,0 @@
-import mime from "./mime.js";
-
-export default test => {
-  test.case("match", assert => {
-    assert(mime("/app.js")).equals("text/javascript");
-  });
-  test.case("no extension", assert => {
-    assert(mime("/app")).equals("application/octet-stream");
-  });
-  test.case("unknown extension", assert => {
-    assert(mime("/app.unknown")).equals("application/octet-stream");
-  });
-};

package/src/hooks/handle/respond.spec.js

@@ -1,12 +0,0 @@
-import respond from "./respond.js";
-
-export default test => {
-  test.case("guess URL", assert => {
-    const url = "https://primatejs.com/";
-    const status = 302;
-    const [body, options] = respond(new URL(url))();
-    assert(body).null();
-    assert(options.status).equals(status);
-    assert(options.headers.Location).equals(url);
-  });
-};