primate 0.24.0 → 0.26.0

package/src/hooks/exports.js

@@ -1,9 +1,9 @@
-export {default as init} from "./init.js";
-export {default as register} from "./register.js";
-export {default as compile} from "./compile.js";
-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";
+export { default as init } from "./init.js";
+export { default as stage } from "./stage.js";
+export { default as register } from "./register.js";
+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.js

@@ -1,52 +1,59 @@
-import {Response, Status, MediaType} from "runtime-compat/http";
-import {cascade, tryreturn} from "runtime-compat/async";
-import {respond} from "./respond/exports.js";
-import {invalid} from "./route.js";
-import {error as clientError} from "../handlers/exports.js";
+import { Response, Status, MediaType } from "rcompat/http";
+import { cascade, tryreturn } from "rcompat/async";
+import { respond } from "./respond/exports.js";
+import { invalid } from "./route.js";
+import { error as clientError } from "../handlers/exports.js";
 import _errors from "../errors.js";
-const {NoFileForPath} = _errors;
+const { NoFileForPath } = _errors;
 
-const guardError = Symbol("guardError");
+const guard_error = Symbol("guard_error");
+const guard = (app, guards) => async (request, next) => {
+  // handle guards
+  try {
+    guards.every(guard => {
+      const result = guard(request);
+      if (result === true) {
+        return true;
+      }
+      const error = new Error();
+      error.result = result;
+      error.type = guard_error;
+      throw error;
+    });
+
+    return next(request);
+  } catch (error) {
+    if (error.type === guard_error) {
+      return (await respond(error.result))(app);
+    }
+    // rethrow if not guard error
+    throw error;
+  }
+};
 
 export default app => {
-  const {config: {http: {static: {root}}, location}} = app;
+  const { config: { http: { static: { root } }, location } } = app;
 
   const as_route = async request => {
-    const {pathname} = request.url;
+    const { pathname } = request.url;
     // if NoFileForPath is thrown, this will remain undefined
     let error_handler = app.error.default;
 
     return tryreturn(async _ => {
-      const {path, guards, errors, layouts, handler} = invalid(pathname)
+      const { path, guards, errors, layouts, handler } = invalid(pathname)
         ? NoFileForPath.throw(pathname, location.static)
         : await app.route(request);
       error_handler = errors?.at(-1);
 
-      // handle guards
-      try {
-        guards.every(guard => {
-          const result = guard(request);
-          if (result === true) {
-            return true;
-          }
-          const error = new Error();
-          error.result = result;
-          error.type = guardError;
-          throw error;
-        });
-      } catch (error) {
-        if (error.type === guardError) {
-          return (await respond(error.result))(app);
-        }
-        // rethrow if not guard error
-        throw error;
-      }
+      const pathed = { ...request, path };
+
+      const hooks = [...app.modules.route, guard(app, guards)];
 
       // handle request
-      const response = (await cascade(app.modules.route, handler))({...request, path});
+      const response = (await cascade(hooks, handler))(pathed);
       return (await respond(await response))(app, {
         layouts: await Promise.all(layouts.map(layout => layout(request))),
-      }, request);
+      }, pathed);
     }).orelse(async error => {
       app.log.auto(error);
 
@@ -56,27 +63,27 @@ export default app => {
     });
   };
 
-  const as_asset = async file => new Response(file.readable, {
+  const as_asset = async path => new Response(path.stream(), {
     status: Status.OK,
     headers: {
-      "Content-Type": MediaType.resolve(file.name),
-      Etag: await file.modified,
+      "Content-Type": MediaType.resolve(path.name),
+      Etag: await path.modified(),
     },
   });
 
   const client = app.runpath(location.client);
   const handle = async request => {
-    const {pathname} = request.url;
+    const { pathname } = request.url;
     if (pathname.startsWith(root)) {
       const debased = pathname.replace(root, _ => "");
       // try static first
       const asset = client.join(location.static, debased);
       if (await asset.isFile) {
-        return as_asset(asset.file);
+        return as_asset(asset);
       }
       const path = client.join(debased);
       if (await path.isFile) {
-        return as_asset(path.file);
+        return as_asset(path);
       }
     }
     return as_route(request);

package/src/hooks/init.js

@@ -1,3 +1,3 @@
-import {cascade} from "runtime-compat/async";
+import { cascade } from "rcompat/async";
 
 export default async app => (await cascade(app.modules.init))(app);

package/src/hooks/parse.js

@@ -1,12 +1,12 @@
-import {URL, MediaType} from "runtime-compat/http";
-import {tryreturn} from "runtime-compat/sync";
-import {stringify} from "runtime-compat/streams";
-import {from, valmap} from "runtime-compat/object";
+import { URL, MediaType } from "rcompat/http";
+import { tryreturn } from "rcompat/sync";
+import { stringify } from "rcompat/streams";
+import { from, valmap } from "rcompat/object";
 import errors from "../errors.js";
 
-const {APPLICATION_FORM_URLENCODED, APPLICATION_JSON} = MediaType;
+const { APPLICATION_FORM_URLENCODED, APPLICATION_JSON } = MediaType;
 
-const {decodeURIComponent: decode} = globalThis;
+const { decodeURIComponent: decode } = globalThis;
 const deslash = url => url.replaceAll(/(?<!http:)\/{2,}/gu, _ => "/");
 
 const contents = {
@@ -21,12 +21,12 @@ const content = (type, body) =>
     .orelse(_ => errors.CannotParseBody.throw(body, type));
 
 export default dispatch => async original => {
-  const {headers} = original;
+  const { headers } = original;
   const url = new URL(deslash(decode(original.url)));
   const body = await stringify(original.body);
   const cookies = headers.get("cookie");
 
-  return {original, url,
+  return { original, url,
     ...valmap({
       body: [content(headers.get("content-type"), body), body],
       query: [from(url.searchParams), url.search],

package/src/hooks/publish.js

@@ -1,60 +1,26 @@
-import {Path} from "runtime-compat/fs";
-import {cascade} from "runtime-compat/async";
-import {stringify} from "runtime-compat/object";
-import copy_includes from "./copy_includes.js";
+import { Path } from "rcompat/fs";
+import { cascade } from "rcompat/async";
+import { stringify } from "rcompat/object";
 
 const post = async app => {
-  const {config: {location, http: {static: {root}}}, path} = app;
+  const { config: { http: { static: { root } } } } = app;
 
   {
     // after hook, publish a zero assumptions app.js (no css imports)
     const src = new Path(root, app.config.build.index);
 
     await app.publish({
-      code: app.exports.filter(({type}) => type === "script")
-        .map(({code}) => code).join(""),
+      code: app.exports.filter(({ type }) => type === "script")
+        .map(({ code }) => code).join(""),
       src,
       type: "module",
     });
 
-    if (await path.components.exists) {
-      // copy .js files from components to build/client/components, since
-      // frontend frameworks handle non-js files
-      const to = Path.join(location.client, location.components);
-      await app.stage(path.components, to, /^.*.js$/u);
-    }
-
-    const imports = {...app.importmaps, app: src.path};
+    const imports = { ...app.importmaps, app: src.path };
     const type = "importmap";
-    await app.publish({inline: true, code: stringify({imports}), type});
+    await app.publish({ inline: true, code: stringify({ imports }), type });
   }
 
-  if (await path.static.exists) {
-    // copy static files to build/client/static
-    await app.stage(path.static, new Path(location.client, location.static));
-
-    // publish JavaScript and CSS files
-    const imports = await Path.collect(path.static, /\.(?:js|css)$/u);
-    await Promise.all(imports.map(async file => {
-      const code = await file.text();
-      const src = file.debase(path.static);
-      const type = file.extension === ".css" ? "style" : "module";
-      // already copied in `app.stage`
-      await app.publish({src, code, type, copy: false});
-      type === "style" && app.export({type,
-        code: `import "./${location.static}${src}";`});
-    }));
-  }
-
-  // copy additional subdirectories to build/client
-  const client = app.runpath(location.client);
-  await copy_includes(app, location.client, async to =>
-    Promise.all((await to.collect(/\.js$/u)).map(async script => {
-      const src = new Path(root, script.path.replace(client, _ => ""));
-      await app.publish({src, code: await script.text(), type: "module"});
-    }))
-  );
-
   return app;
 };
 

package/src/hooks/register.js

@@ -1,3 +1,74 @@
-import {cascade} from "runtime-compat/async";
+import { Path } from "rcompat/fs";
+import { cascade } from "rcompat/async";
+import cwd from "../cwd.js";
+import copy_includes from "./copy_includes.js";
 
-export default async app => (await cascade(app.modules.register))(app);
+const html = /^.*.html$/u;
+const defaults = cwd(import.meta, 2).join("defaults");
+
+const pre = async app => {
+  const { config: { location: { pages, client, components } }, path } = app;
+
+  await Promise.all(["server", "client", "pages"]
+    .map(directory => app.runpath(directory).create()));
+
+  // copy framework pages
+  await app.stage(defaults, pages, html);
+  // overwrite transformed pages to build
+  await path.pages.exists() && await app.stage(path.pages, pages, html);
+
+  if (await path.components.exists()) {
+    // copy .js files from components to build/client/components, since
+    // frontend frameworks handle non-js files
+    const target = Path.join(client, components);
+    await app.stage(path.components, target, /^.*.js$/u);
+  }
+
+  return app;
+};
+
+const post = async app => {
+  const { config: { location, http: { static: { root } } }, path } = app;
+
+  if (await path.static.exists()) {
+    // copy static files to build/server/static
+    await app.stage(path.static, new Path(location.server, location.static));
+
+    // copy static files to build/client/static
+    await app.stage(path.static, new Path(location.client, location.static));
+
+    // publish JavaScript and CSS files
+    const imports = await Path.collect(path.static, /\.(?:js|css)$/u);
+    await Promise.all(imports.map(async file => {
+      const code = await file.text();
+      const src = file.debase(path.static);
+      const type = file.extension === "css" ? "style" : "module";
+      // already copied in `app.stage`
+      await app.publish({ src, code, type, copy: false });
+      type === "style" && app.export({ type,
+        code: `import "./${location.static}${src}";` });
+    }));
+  }
+
+  // copy additional subdirectories to build/server
+  await copy_includes(app, location.server);
+
+  // copy additional subdirectories to build/client
+  const client = app.runpath(location.client);
+  await copy_includes(app, location.client, async to =>
+    Promise.all((await to.collect(/\.js$/u)).map(async script => {
+      const src = new Path(root, script.path.replace(client, _ => ""));
+      await app.publish({ src, code: await script.text(), type: "module" });
+    })),
+  );
+
+  const components = await app.path.components.collect();
+
+  // from the build directory, compile to server and client
+  await Promise.all(components.map(component => app.compile(component)));
+
+  return app;
+};
+
+export default async app =>
+  post(await (await cascade(app.modules.register))(await pre(app)));

package/src/hooks/respond/duck.js

@@ -1,4 +1,4 @@
-import {Headers} from "runtime-compat/http";
+import { Headers } from "rcompat/http";
 
 export const isResponse = value =>
   value.body !== undefined && value.headers instanceof Headers;

package/src/hooks/respond/exports.js

@@ -1,2 +1,2 @@
-export {isResponse} from "./duck.js";
-export {default as respond} from "./respond.js";
+export { isResponse } from "./duck.js";
+export { default as respond } from "./respond.js";

package/src/hooks/respond/respond.js

@@ -1,7 +1,7 @@
-import {Blob} from "runtime-compat/fs";
-import {URL} from "runtime-compat/http";
-import {text, json, stream, redirect} from "primate";
-import {isResponse as isResponseDuck} from "./duck.js";
+import { Blob } from "rcompat/fs";
+import { URL } from "rcompat/http";
+import { text, json, stream, redirect } from "primate";
+import { isResponse as isResponseDuck } from "./duck.js";
 
 const isText = value => {
   if (typeof value === "string") {

package/src/hooks/route.js

@@ -1,5 +1,5 @@
-import {from} from "runtime-compat/object";
-import {tryreturn} from "runtime-compat/sync";
+import { from } from "rcompat/object";
+import { tryreturn } from "rcompat/sync";
 import errors from "../errors.js";
 import validate from "../validate.js";
 
@@ -13,7 +13,7 @@ const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
   ? pathname.slice(0, -1) : pathname;
 
 export default app => {
-  const {types, routes, config: {types: {explicit}, location}} = app;
+  const { types, routes, config: { types: { explicit }, location } } = app;
 
   const to_path = (route, pathname) => app.dispatch(from(Object
     .entries(route.pathname.exec(pathname)?.groups ?? {})
@@ -21,7 +21,7 @@ export default app => {
       [types[name] === undefined || explicit ? name : `${name}$${name}`, value])
     .map(([name, value]) => [name.split("$"), value])
     .map(([[name, type], value]) =>
-      [name, type === undefined ? value : validate(types[type], value, name)]
+      [name, type === undefined ? value : validate(types[type], value, name)],
     )));
 
   const is_type = (groups, pathname) => Object
@@ -32,22 +32,22 @@ export default app => {
     .map(([name, value]) => [name.split("$"), value])
     .map(([[name, type], value]) =>
       tryreturn(_ => [name, validate(types[type], value, name)])
-        .orelse(({message}) => errors.MismatchedPath.throw(pathname, message)));
-  const is_path = ({route, pathname}) => {
+        .orelse(({ message }) => errors.MismatchedPath.throw(pathname, message)));
+  const is_path = ({ route, pathname }) => {
     const result = route.pathname.exec(pathname);
     return result === null ? false : is_type(result.groups, pathname);
   };
-  const is_method = ({route, method, pathname}) => ieq(route.method, method)
-    && is_path({route, pathname});
+  const is_method = ({ route, method, pathname }) => ieq(route.method, method)
+    && is_path({ route, pathname });
   const find = (method, pathname) => routes.find(route =>
-    is_method({route, method, pathname}));
+    is_method({ route, method, pathname }));
 
   const index = path => `${location.routes}${path === "/" ? "/index" : path}`;
 
-  return ({original: {method}, url}) => {
+  return ({ original: { method }, url }) => {
     const pathname = deroot(url.pathname);
     const route = find(method, pathname) ?? errors.NoRouteToPath
       .throw(method.toLowerCase(), pathname, index(pathname));
-    return {...route, path: to_path(route, pathname)};
+    return { ...route, path: to_path(route, pathname) };
   };
 };

package/src/hooks/serve.js

@@ -1,6 +1,6 @@
-import {cascade} from "runtime-compat/async";
+import { cascade } from "rcompat/async";
 
 export default async (app, server) => {
-  app.log.info("running serve hooks", {module: "primate"});
-  await (await cascade(app.modules.serve))({...app, server});
+  app.log.info("running serve hooks", { module: "primate" });
+  await (await cascade(app.modules.serve))({ ...app, server });
 };

package/src/hooks/stage.js

@@ -0,0 +1,48 @@
+import { cascade } from "rcompat/async";
+import dispatch from "../dispatch.js";
+import * as loaders from "../loaders/exports.js";
+import { doubled } from "../loaders/common.js";
+import errors from "../errors.js";
+
+const pre = async app => {
+  // remove build directory in case exists
+  await app.path.build.remove();
+
+  return { ...app };
+};
+
+const post = async app => {
+  const { config: { location } } = app;
+
+  // stage routes
+  await app.runpath(location.routes).create();
+  const double = doubled((await app.path.routes.collect())
+    .map(path => path.debase(app.path.routes))
+    .map(path => `${path}`.slice(1, -path.extension.length - 1)));
+  double && errors.DoubleRoute.throw(double);
+
+  await app.stage(app.path.routes, location.routes);
+  if (await app.path.types.exists()) {
+    await app.stage(app.path.types, location.types);
+  }
+  const types = await loaders.types(app.log, app.runpath(location.types));
+  const staged = app.runpath(location.routes);
+  for (const path of await staged.collect()) {
+    await app.extensions[path.extension]
+      ?.route(staged, path.debase(`${staged}/`), types);
+  }
+  const routes = await loaders.routes(app);
+
+  return {
+    ...app,
+    types,
+    routes,
+    dispatch: dispatch(app.types),
+    layout: {
+      depth: Math.max(...routes.map(({ layouts }) => layouts.length)) + 1,
+    },
+  };
+};
+
+export default async app =>
+  post(await (await cascade(app.modules.stage))(await pre(app)));

package/src/loaders/common.js

@@ -1,5 +1,5 @@
-import {Path} from "runtime-compat/fs";
-import {identity} from "runtime-compat/function";
+import { Path } from "rcompat/fs";
+import { identity } from "rcompat/function";
 import errors from "../errors.js";
 
 const ending = ".js";
@@ -17,7 +17,7 @@ export default async ({
   warn = true,
 } = {}) => {
   const objects = directory === undefined ? [] : await Promise.all(
-    (await Path.collect(directory, /^.*.js$/u, {recursive}))
+    (await Path.collect(directory, /^.*.js$/u, { recursive }))
       .filter(filter)
       .map(async path => [
         `${path}`.replace(directory, _ => "").slice(1, -ending.length),

package/src/loaders/exports.js

@@ -1,3 +1,3 @@
-export {default as modules} from "./modules.js";
-export {default as routes} from "./routes.js";
-export {default as types} from "./types.js";
+export { default as modules } from "./modules.js";
+export { default as routes } from "./routes.js";
+export { default as types } from "./types.js";

package/src/loaders/modules.js

@@ -1,5 +1,5 @@
 import * as hooks from "../hooks/exports.js";
-import {doubled} from "./common.js";
+import { doubled } from "./common.js";
 import errors from "../errors.js";
 
 const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
@@ -12,21 +12,24 @@ export default async (log, root, config) => {
 
   Array.isArray(modules) || errors.ModulesMustBeArray.throw("modules");
 
-  modules.some((module, n) => module.name === undefined &&
+  modules.some(({ name }, n) => name === undefined &&
     errors.ModuleHasNoName.throw(n));
 
-  const names = modules.map(({name}) => name);
+  const names = modules.map(({ name }) => name);
   new Set(names).size !== modules.length &&
     errors.DoubleModule.throw(doubled(names), root.join("primate.config.js"));
 
   const hookless = modules.filter(module => !Object.keys(module).some(key =>
-    [...Object.keys(hooks), "load"].includes(key)));
+    [...Object.keys(hooks), "load", "context"].includes(key)));
   hookless.length > 0 && errors.ModuleHasNoHooks.warn(log,
-    hookless.map(({name}) => name).join(", "));
+    hookless.map(({ name }) => name).join(", "));
 
   // collect modules
   const loaded = load(modules).flat(2);
 
-  return Object.fromEntries(Object.keys(hooks)
-    .map(hook => [hook, filter(hook, loaded)]));
+  return {
+    names: loaded.map(module => module.name),
+    ...Object.fromEntries([...Object.keys(hooks), "context"]
+      .map(hook => [hook, filter(hook, loaded)])),
+  };
 };

package/src/loaders/routes/exports.js

@@ -1,4 +1,6 @@
-export {default as routes} from "./routes.js";
-export {default as guards} from "./guards.js";
-export {default as errors} from "./errors.js";
-export {default as layouts} from "./layouts.js";
+import load from "./load.js";
+
+export { default as routes } from "./routes.js";
+export const guards = load("guard");
+export const errors = load("error");
+export const layouts = load("layouts");

package/src/loaders/routes/load.js

@@ -1,4 +1,4 @@
-import {Path} from "runtime-compat/fs";
+import { Path } from "rcompat/fs";
 import errors from "../../errors.js";
 import to_sorted from "../../to_sorted.js";
 
@@ -6,7 +6,7 @@ export default type => async (log, directory, load) => {
   const filter = path => new RegExp(`^\\+${type}.js$`, "u").test(path.name);
 
   const replace = new RegExp(`\\+${type}`, "u");
-  const objects = to_sorted((await load({log, directory, filter, warn: false}))
+  const objects = to_sorted((await load({ log, directory, filter, warn: false }))
     .map(([name, object]) => [name.replace(replace, () => ""), object]),
   ([a], [b]) => a.length - b.length);
 

package/src/loaders/routes/routes.js

@@ -1,4 +1,4 @@
-import {doubled} from "../common.js";
+import { doubled } from "../common.js";
 import errors from "../../errors.js";
 
 const normalize = route => {
@@ -13,7 +13,7 @@ const deindex = path => path.endsWith("index") ?
 
 export default async (log, directory, load) => {
   const filter = path => /^[^+].*.js$/u.test(path.name);
-  const routes = (await load({log, directory, filter}))
+  const routes = (await load({ log, directory, filter }))
     .map(([path, handler]) => [deindex(path), handler]);
 
   const double = doubled(routes.map(([route]) => normalize(route)));

package/src/loaders/routes.js

@@ -1,9 +1,9 @@
-import {tryreturn} from "runtime-compat/sync";
-import {from} from "runtime-compat/object";
-import errors from "../errors.js";
-import {invalid} from "../hooks/route.js";
-import {default as fs, doubled} from "./common.js";
+import { tryreturn } from "rcompat/sync";
+import { from } from "rcompat/object";
+import { default as fs, doubled } from "./common.js";
 import * as get from "./routes/exports.js";
+import errors from "../errors.js";
+import { invalid } from "../hooks/route.js";
 
 const make = path => {
   const double = doubled(path.split("/")
@@ -13,7 +13,7 @@ const make = path => {
 
   const route = path.replaceAll(/\{(?<named>.*?)\}/gu, (_, named) =>
     tryreturn(_ => {
-      const {name, type} = /^(?<name>\w+)(?<type>=\w+)?$/u.exec(named).groups;
+      const { name, type } = /^(?<name>\w+)(?<type>=\w+)?$/u.exec(named).groups;
       const param = type === undefined ? name : `${name}$${type.slice(1)}`;
       return `(?<${param}>[^/]{1,}?)`;
     }).orelse(_ => errors.InvalidPathParameter.throw(named, path)));
@@ -23,26 +23,27 @@ const make = path => {
   return new RegExp(`^/${route}$`, "u");
 };
 
-const specials = ["guards", "errors", "layouts"];
-export default async (log, directory, load = fs) => {
-  const routes = await get.routes(log, directory, load);
-  const routes$ = from(await Promise.all(specials.map(async extra =>
-    [extra, await get[extra](log, directory, load)])));
+export default async (app, load = fs) => {
+  const { log } = app;
+  const directory = app.runpath(app.config.location.routes);
   const filter = path => ([name]) => path.includes(name);
+  const routes = from(await Promise.all(["guards", "errors", "layouts"]
+    .map(async extra => [extra, await get[extra](log, directory, load)])));
 
-  return routes.map(([path, imported]) => {
+  return (await get.routes(log, directory, load)).map(([path, imported]) => {
     if (imported === undefined || Object.keys(imported).length === 0) {
       errors.EmptyRouteFile.warn(log, directory.join(`${path}.js`).path);
       return [];
     }
+    const filtered = filter(path);
 
     return Object.entries(imported).map(([method, handler]) => ({
       method,
       handler,
       pathname: make(path.endsWith("/") ? path.slice(0, -1) : path),
-      guards: routes$.guards.filter(filter(path)).map(([, guard]) => guard),
-      errors: routes$.errors.filter(filter(path)).map(([, error]) => error),
-      layouts: routes$.layouts.filter(filter(path)).map(([, layout]) => layout),
+      guards: routes.guards.filter(filtered).map(([, guard]) => guard),
+      errors: routes.errors.filter(filtered).map(([, error]) => error),
+      layouts: routes.layouts.filter(filtered).map(([, layout]) => layout),
     }));
   }).flat();
 };