primate 0.15.6 → 0.16.0

package/README.md

@@ -1,6 +1,6 @@
 # Primate 
 
-Expressive, minimal and extensible framework for JavaScript.
+Expressive, minimal and extensible web framework
 
 ## Getting started
 
@@ -14,10 +14,9 @@ export default {
     return "Hello, world!";
   },
 };
-
 ```
 
-Run `npm i && npm start` and visit `localhost:6161` in your browser.
+Run `npm i && npm start` and visit http://localhost:6161 in your browser.
 
 ## Table of Contents
 

package/package.json

@@ -1,27 +1,22 @@
 {
   "name": "primate",
-  "version": "0.15.6",
-  "description": "Expressive, minimal and extensible framework for JavaScript",
+  "version": "0.16.0",
+  "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
   "license": "MIT",
   "files": [
     "src/**",
-    "!src/**/*.spec.js",
-    "!readme/**"
+    "!src/**/*.spec.js"
   ],
   "bin": "src/bin.js",
-  "repository": "https://github.com/primatejs/primate",
-  "scripts": {
-    "docs": "scripts/docs.sh",
-    "test": "npx debris",
-    "lint": "npx eslint ."
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primatejs/primate",
+    "directory": "packages/primate"
   },
   "dependencies": {
-    "runtime-compat": "^0.15.0"
-  },
-  "devDependencies": {
-    "maximin": "^0.1.2"
+    "runtime-compat": "^0.16.3"
   },
   "type": "module",
   "exports": "./src/exports.js"

package/src/Logger.js

@@ -27,13 +27,13 @@ const levels = new Map([
 const print = (...messages) => process.stdout.write(messages.join(" "));
 
 const Logger = class Logger {
-  #level; #traceStack;
+  #level; #trace;
 
-  constructor({level = Error, traceStack = false} = {}) {
+  constructor({level = Error, trace = false} = {}) {
     assert(level !== undefined && levels.get(level) <= info);
-    is(traceStack).boolean();
+    is(trace).boolean();
     this.#level = level;
-    this.#traceStack = traceStack;
+    this.#trace = trace;
   }
 
   static get Error() {
@@ -51,7 +51,7 @@ const Logger = class Logger {
   #print(pre, error) {
     if (error instanceof Error) {
       print(colors.bold(pre), error.message, "\n");
-      if (this.#traceStack) {
+      if (this.#trace) {
         console.log(error);
       }
     } else {

package/src/app.js

@@ -0,0 +1,157 @@
+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";
+
+const qualify = (root, paths) =>
+  Object.keys(paths).reduce((sofar, key) => {
+    const value = paths[key];
+    sofar[key] = typeof value === "string"
+      ? new Path(root, value)
+      : qualify(`${root}/${key}`, value);
+    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 => {
+  const name = "index.html";
+  try {
+    // user-provided file
+    return await File.read(`${app.paths.static.join(name)}`);
+  } catch (error) {
+    // fallback
+    return src.join("defaults", name).text();
+  }
+};
+
+const hash = async (string, algorithm = "sha-384") => {
+  const encoder = new TextEncoder();
+  const bytes = await crypto.subtle.digest(algorithm, encoder.encode(string));
+  const algo = algorithm.replace("-", () => "");
+  return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
+};
+
+export default async (filename = configName) => {
+  is(filename).string();
+  const root = await getRoot();
+  const config = await getConfig(root, filename);
+
+  const {name, version} = await src.up(1).join("package.json").json();
+
+  // if ssl activated, resolve key and cert early
+  if (config.http.ssl) {
+    config.http.ssl.key = root.join(config.http.ssl.key);
+    config.http.ssl.cert = root.join(config.http.ssl.cert);
+  }
+
+  const app = {
+    config,
+    secure: config.http?.ssl !== undefined,
+    name, version,
+    library: {},
+    identifiers: {},
+    replace(code) {
+      const joined = Object.keys(app.identifiers).join("|");
+      const re = `(?<=import (?:.*) from ['|"])(${joined})(?=['|"])`;
+      return code.replaceAll(new RegExp(re, "gus"), (_, p1) => {
+        if (app.library[p1] === undefined) {
+          app.library[p1] = app.identifiers[p1];
+        }
+        return app.identifiers[p1];
+      });
+    },
+    resources: [],
+    entrypoints: [],
+    paths: qualify(root, config.paths),
+    root,
+    log: new Logger(config.logger),
+    handlers: {...handlers},
+    render: async ({body = "", head = ""} = {}) => {
+      const html = await index(app);
+      const heads = app.resources.map(({src, code, type, inline, integrity}) => {
+        const tag = type === "style" ? "link" : "script";
+        const pre = type === "style"
+          ? `<${tag} rel="stylesheet"`
+          : `<${tag} type="${type}" integrity="${integrity}"`;
+        const middle = type === "style"
+          ? ` href="${src}">`
+          : ` src="${src}">`;
+        const post = type === "style" ? "" : `</${tag}>`;
+        return inline ? `${pre}>${code}${post}` : `${pre}${middle}${post}`;
+      }).join("\n");
+      return html
+        .replace("%body%", () => body)
+        .replace("%head%", () => `${head}${heads}`);
+    },
+    publish: async ({src, code, type = "", inline = false}) => {
+      if (type === "module") {
+        code = app.replace(code);
+      }
+      // while integrity is only really needed for scripts, it is also later
+      // used for the etag header
+      const integrity = await hash(code);
+      const _src = new Path(config.http.static.root).join(src ?? "");
+      app.resources.push({src: `${_src}`, code, type, inline, integrity});
+      return integrity;
+    },
+    bootstrap: ({type, code}) => {
+      app.entrypoints.push({type, code});
+    },
+    resolve: (pkg, name) => {
+      const exports = Object.fromEntries(Object.entries(pkg.exports)
+        .filter(([, _export]) => _export.import !== undefined)
+        .map(([key, value]) => [
+          key.replace(".", name),
+          value.import.replace(".", `./${name}`),
+        ]));
+      app.identifiers = {...exports, ...app.identifiers};
+    },
+    modules: [...config.modules],
+  };
+  print(colors.blue(colors.bold(name)), colors.blue(version), "");
+  const type = app.secure ? "https" : "http";
+  const address = `${type}://${config.http.host}:${config.http.port}`;
+  print(colors.gray(`at ${address}`), "\n");
+  // modules may load other modules
+  await Promise.all(app.modules
+    .filter(module => module.load !== undefined)
+    .map(module => module.load({...app, load(dependent) {
+      app.modules.push(dependent);
+    }})));
+
+  return app;
+};

package/src/commands/create.js

@@ -1,6 +1,6 @@
 import {Path} from "runtime-compat/fs";
 
-const createModule = async env => {
+const createModule = async app => {
   const space = 2;
   try {
     // will throw if cannot find a package.json up the filesystem hierarchy
@@ -10,7 +10,7 @@ const createModule = async env => {
       name: "primate-app",
       private: true,
       dependencies: {
-        primate: `^${env.version}`,
+        primate: `^${app.version}`,
       },
       scripts: {
         start: "npx primate",
@@ -23,20 +23,20 @@ const createModule = async env => {
   }
 };
 
-const createConfig = async env => {
+const createConfig = async app => {
   const name = "primate.config.js";
   const template = "export default {};";
   const root = (await Path.root()).join(name);
   if (await root.exists) {
-    env.log.warn(`${root} already exists`);
+    app.log.warn(`${root} already exists`);
   } else {
     await root.file.write(template);
-    env.log.info(`created config at ${root}`);
+    app.log.info(`created config at ${root}`);
   }
 };
 
-export default async env => {
-  await createModule(env);
-  await createConfig(env);
+export default async app => {
+  await createModule(app);
+  await createConfig(app);
 };
 

package/src/commands/dev.js

@@ -1,3 +1,3 @@
 import start from "../start.js";
 
-export default async env => start(env);
+export default app => start(app);

package/src/commands/help.js

@@ -1,3 +1,3 @@
-export default env => {
-  env.log.info("available commands: create dev serve");
+export default app => {
+  app.log.info("available commands: create dev serve");
 };

package/src/commands/serve.js

@@ -1,3 +1,3 @@
 import start from "../start.js";
 
-export default async env => start(env, {bundle: true});
+export default app => start(app, {bundle: true});

package/src/{primate.config.js → defaults/primate.config.js}

@@ -1,4 +1,4 @@
-import {Logger} from "primate";
+import Logger from "../Logger.js";
 
 export default {
   base: "/",
@@ -15,10 +15,14 @@ export default {
       "form-action": "'self'",
       "base-uri": "'self'",
     },
+    static: {
+      root: "/",
+      pure: false,
+    },
   },
   paths: {
-    public: "public",
     static: "static",
+    public: "public",
     routes: "routes",
     components: "components",
   },

package/src/exports.js

@@ -1,5 +1,9 @@
 import run from "./run.js";
 
 export * from "./handlers/exports.js";
+
 export {default as Logger} from "./Logger.js";
+
+export {URL, Response} from "runtime-compat/http";
+
 export default command => run(command);

package/src/fromNull.js

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

package/src/handlers/html.js

@@ -1,9 +1,13 @@
-export default (body, {status = 200, partial = false} = {}) =>
-  async (env, headers) => {
-    return [
-      partial ? body : await env.render({body}), {
-        status,
-        headers: {...headers, "Content-Type": "text/html"},
-      },
-    ];
+export default (component, flags = {}) => {
+  const {status = 200, partial = false, load = false} = flags;
+
+  return async (app, headers) => {
+    const body = load ?
+      await app.paths.components.join(component).text() : component;
+
+    return [partial ? body : await app.render({body}), {
+      status,
+      headers: {...headers, "Content-Type": "text/html"},
+    }];
   };
+};

package/src/handlers/view.js

@@ -1,9 +1,8 @@
-export default (name, props, options) =>
-  async (env, headers) => {
-    const ending = name.slice(name.lastIndexOf(".") + 1);
-    const handler = env.handlers[ending];
-    if (handler === undefined) {
-      return env.log.error(new Error(`no handler for ${ending} components`));
-    }
-    return handler(name, props, options)(env, headers);
-  };
+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);
+};

package/src/hooks/bundle.js

@@ -0,0 +1,29 @@
+import {File} from "runtime-compat/fs";
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+
+const pre = async app => {
+  const {paths} = app;
+
+  // remove public directory in case exists
+  if (await paths.public.exists) {
+    await paths.public.file.remove();
+  }
+  await paths.public.file.create();
+
+  if (await paths.static.exists) {
+    // copy static files to public
+    const filter = file => app.config.http.static.pure
+      ? true
+      : !file.endsWith(".js") && !file.endsWith(".css");
+    await File.copy(paths.static, paths.public, filter);
+  }
+};
+
+export default async (app, bundle) => {
+  await pre(app);
+  if (bundle) {
+    app.log.info("running bundle hooks");
+    await [...filter("bundle", app.modules), _ => _]
+      .reduceRight((acc, handler) => input => handler(input, acc))(app);
+  }
+};

package/src/hooks/compile.js

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

package/src/hooks/exports.js

@@ -0,0 +1,6 @@
+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";

package/src/hooks/handle/exports.js

@@ -0,0 +1,4 @@
+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/{mimes.js → hooks/handle/mime.js}

@@ -1,12 +1,18 @@
-export default {
+const mimes = {
   binary: "application/octet-stream",
   css: "text/css",
   html: "text/html",
   jpg: "image/jpeg",
   js: "text/javascript",
+  mjs: "text/javascript",
   json: "application/json",
   png: "image/png",
   svg: "image/svg+xml",
   woff2: "font/woff2",
   webp: "image/webp",
 };
+
+const regex = /\.(?<extension>[a-z1-9]*)$/u;
+const match = filename => filename.match(regex)?.groups.extension;
+
+export default filename => mimes[match(filename)] ?? mimes.binary;

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

@@ -0,0 +1,13 @@
+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/{respond.js → hooks/handle/respond.js}

@@ -1,13 +1,13 @@
 import {Blob} from "runtime-compat/fs";
-import {text, json, stream} from "./handlers/exports.js";
+import {URL} from "runtime-compat/http";
+import {text, json, stream, redirect} from "primate";
 import {isResponse as isResponseDuck} from "./duck.js";
-import RouteError from "./errors/Route.js";
 
 const isText = value => {
   if (typeof value === "string") {
     return text(value);
   }
-  throw new RouteError(`no handler found for ${value}`);
+  throw new Error(`no handler found for ${value}`);
 };
 
 const isNonNullObject = value => typeof value === "object" && value !== null;
@@ -19,6 +19,8 @@ const isStream = value => value instanceof ReadableStream
   ? stream(value) : isResponse(value);
 const isBlob = value => value instanceof Blob
   ? stream(value) : isStream(value);
-const guess = value => isBlob(value);
+const isURL = value => value instanceof URL
+  ? redirect(value.href) : isBlob(value);
+const guess = value => isURL(value);
 
 export default result => typeof result === "function" ? result : guess(result);

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

@@ -0,0 +1,12 @@
+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);
+  });
+};

package/src/{serve.js → hooks/handle.js}

@@ -1,36 +1,33 @@
 import {Path} from "runtime-compat/fs";
-import {serve, Response} from "runtime-compat/http";
-import statuses from "./http-statuses.js";
-import mimes from "./mimes.js";
-import {http404} from "./handlers/http.js";
-import {isResponse} from "./duck.js";
-import respond from "./respond.js";
-import {colors, print} from "./Logger.js";
-
-const regex = /\.([a-z1-9]*)$/u;
-const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
+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";
 
 const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
 const contents = {
   "application/x-www-form-urlencoded": body =>
-    Object.fromEntries(body.split("&").map(part => part.split("=")
-      .map(subpart => decodeURIComponent(subpart).replaceAll("+", " ")))),
+    fromNull(Object.fromEntries(body.split("&").map(part => part.split("=")
+      .map(subpart => decodeURIComponent(subpart).replaceAll("+", " "))))),
   "application/json": body => JSON.parse(body),
 };
 
-export default env => {
+export default async app => {
+  const {config} = app;
+  const {http} = config;
+
   const _respond = async request => {
-    const csp = Object.keys(env.http.csp).reduce((policy_string, key) =>
-      `${policy_string}${key} ${env.http.csp[key]};`, "");
-    const scripts = env.resources
+    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 = env.resources.length - 1; i >= 0; i--) {
-      const resource = env.resources[i];
+    for (let i = app.resources.length - 1; i >= 0; i--) {
+      const resource = app.resources[i];
       if (resource.inline) {
-        env.resources.splice(i, 1);
+        app.resources.splice(i, 1);
       }
     }
 
@@ -40,15 +37,15 @@ export default env => {
     };
 
     try {
-      const {router} = env;
-      const modules = filter("route", env.modules);
+      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, env}))(env, headers);
+      return await respond(await handlers(request))(app, headers);
     } catch (error) {
-      env.log.auto(error);
-      return http404()(env, headers);
+      app.log.auto(error);
+      return http404()(app, headers);
     }
   };
 
@@ -57,7 +54,7 @@ export default env => {
     return isResponse(response) ? response : new Response(...response);
   };
 
-  const resource = async file => new Response(file.readable, {
+  const staticResource = async file => new Response(file.readable, {
     status: statuses.OK,
     headers: {
       "Content-Type": mime(file.name),
@@ -66,8 +63,8 @@ export default env => {
   });
 
   const publishedResource = request => {
-    const published = env.resources.find(resource =>
-      `/${resource.src}` === request.pathname);
+    const published = app.resources.find(({src}) =>
+      src === request.url.pathname);
     if (published !== undefined) {
       return new Response(published.code, {
         status: statuses.OK,
@@ -81,16 +78,23 @@ export default env => {
     return route(request);
   };
 
-  const _serve = async request => {
-    const path = new Path(env.paths.public, request.pathname);
-    return await path.isFile ? resource(path.file) : publishedResource(request);
+  const resource = async request => {
+    const {pathname} = request.url;
+    const {root} = http.static;
+    if (pathname.startsWith(root)) {
+      const path = app.paths.public.join(pathname.replace(root, ""));
+      return await path.isFile
+        ? staticResource(path.file)
+        : publishedResource(request);
+    }
+    return route(request);
   };
 
   const handle = async request => {
     try {
-      return await _serve(request);
+      return await resource(request);
     } catch (error) {
-      env.log.auto(error);
+      app.log.auto(error);
       return new Response(null, {status: statuses.InternalServerError});
     }
   };
@@ -104,21 +108,14 @@ export default env => {
     try {
       return parseContentType(request.headers.get("content-type"), body);
     } catch (error) {
-      env.log.warn(error);
+      app.log.warn(error);
       return body;
     }
   };
 
-  const {http} = env;
-  const modules = filter("serve", env.modules);
-
-  // handle is the last module to be executed
-  const handlers = [...modules, handle].reduceRight((acc, handler) =>
-    input => handler(input, acc));
-
   const decoder = new TextDecoder();
-  serve(async request => {
-    // preprocess request
+
+  const parseBody = async request => {
     const reader = request.body.getReader();
     const chunks = [];
     let result;
@@ -129,11 +126,26 @@ export default env => {
       }
     } while (!result.done);
 
-    const body = chunks.length === 0 ? undefined
-      : parseContent(request, chunks.join());
+    return chunks.length === 0 ? null : parseContent(request, chunks.join());
+  };
+
+  const parseRequest = async request => {
+    const cookies = request.headers.get("cookie");
+
+    return {
+      request,
+      url: new URL(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)),
+    };
+  };
 
-    const {pathname, search} = new URL(`https://example.com${request.url}`);
+  // handle is the last module to be executed
+  const handlers = [...filter("handle", app.modules), handle]
+    .reduceRight((acc, handler) => input => handler(input, acc));
 
-    return handlers({original: request, pathname: pathname + search, body});
-  }, http);
+  serve(async request => handlers(await parseRequest(request)), config.http);
 };

package/src/hooks/publish.js

@@ -0,0 +1,36 @@
+import {Path} from "runtime-compat/fs";
+
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+
+const post = async app => {
+  // after hook, publish a zero assumptions app.js (no css imports)
+  const code = app.entrypoints.filter(({type}) => type === "script")
+    .map(entrypoint => entrypoint.code).join("");
+  await app.publish({src: `${app.config.dist}.js`, code, type: "module"});
+
+  if (!app.config.http.static.pure) {
+    const memoryFiles = await Path.collect(app.paths.static, /\.(?:js|css)$/u,
+      {recursive: false});
+    await Promise.all(memoryFiles.map(async file => {
+      const code = await file.text();
+      const src = file.name;
+      await app.publish({src, code, type: file.extension === ".js" ?
+        "module" : "style"});
+      if (file.extension === ".css") {
+        app.bootstrap({type: "style", code: `import "./${file.name}";`});
+      }
+    }));
+  }
+  await Promise.all(Object.entries(app.library).map(async libfile => {
+    const [, src] = libfile;
+    const code = await Path.resolve().join("node_modules", src).text();
+    await app.publish({src, code, type: "module"});
+  }));
+};
+
+export default async app => {
+  app.log.info("running publish hooks");
+  await [...filter("publish", app.modules), _ => _]
+    .reduceRight((acc, handler) => input => handler(input, acc))(app);
+  await post(app);
+};

package/src/hooks/register.js

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

package/src/hooks/route.js

@@ -0,0 +1,69 @@
+import {Path} from "runtime-compat/fs";
+import {Logger} from "primate";
+import fromNull from "../fromNull.js";
+
+// insensitive-case equal
+const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
+// HTTP verbs
+const verbs = [
+  // CRUD
+  "post", "get", "put", "delete",
+  // extended
+  "delete", "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}>.*?)`)
+  ;
+  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 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);
+    },
+  };
+  return router;
+};

package/src/run.js

@@ -1,4 +1,4 @@
-import config from "./config.js";
+import app from "./app.js";
 import command from "./commands/exports.js";
 
-export default async name => command(name)(await config());
+export default async name => command(name)(await app());

package/src/start.js

@@ -1,27 +1,20 @@
-import register from "./register.js";
-import compile from "./compile.js";
-import publish from "./publish.js";
-import bundle from "./bundle.js";
-import route from "./route.js";
-import serve from "./serve.js";
+import {register, compile, publish, bundle, route, handle}
+  from "./hooks/exports.js";
 
-export default async (env, operations = {}) => {
+export default async (app, operations = {}) => {
   // register handlers
-  await register(env);
+  await register({...app, register(name, handler) {
+    app.handlers[name] = handler;
+  }});
+
   // compile server-side code
-  await compile(env);
+  await compile(app);
   // publish client-side code
-  await publish(env);
+  await publish(app);
 
-  // after publish hook, publish a zero assumptions app.js (no css imports)
-  const code = env.entrypoints.filter(({type}) => type === "script")
-    .map(({code}) => code).join("");
-  await env.publish({src: `${env.dist}.js`, code, type: "module"});
+  // bundle client-side code
+  await bundle(app, operations?.bundle);
 
-  if (operations?.bundle) {
-    // bundle client-side code
-    await bundle(env);
-  }
-  // serve
-  serve({router: await route(env), ...env});
+  // handle
+  await handle({router: await route(app), ...app});
 };

package/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) Terrablue <terrablue@proton.me> and contributors.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/src/bundle.js

@@ -1,23 +0,0 @@
-import {File} from "runtime-compat/fs";
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
-
-const makePublic = async env => {
-  const {paths} = env;
-
-  // remove public directory in case exists
-  if (await paths.public.exists) {
-    await paths.public.file.remove();
-  }
-  await paths.public.file.create();
-
-  if (await paths.static.exists) {
-    // copy static files to public
-    await File.copy(paths.static, paths.public);
-  }
-};
-
-export default async env => {
-  await makePublic(env);
-  [...filter("bundle", env.modules), _ => _].reduceRight((acc, handler) =>
-    input => handler(input, acc))(env);
-};

package/src/cache.js

@@ -1,17 +0,0 @@
-const Cache = class Cache {
-  static #caches = [];
-
-  static get(object, property) {
-    return Cache.#caches.find(entry =>
-      entry.object === object && entry.property === property)?.value;
-  }
-
-  static put(object, property, cacher) {
-    const value = cacher();
-    Cache.#caches.push({object, property, value});
-    return value;
-  }
-};
-
-export default (object, property, cacher) =>
-  Cache.get(object, property) ?? Cache.put(object, property, cacher);

package/src/compile.js

@@ -1,5 +0,0 @@
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
-
-export default async env =>
-  [...filter("compile", env.modules), _ => _].reduceRight((acc, handler) =>
-    input => handler(input, acc))(env);

package/src/config.js

@@ -1,111 +0,0 @@
-import crypto from "runtime-compat/crypto";
-import {is} from "runtime-compat/dyndef";
-import {File, Path} from "runtime-compat/fs";
-import cache from "./cache.js";
-import extend from "./extend.js";
-import defaults from "./primate.config.js";
-import {colors, print, default as Logger} from "./Logger.js";
-import * as handlers from "./handlers/exports.js";
-
-const qualify = (root, paths) =>
-  Object.keys(paths).reduce((sofar, key) => {
-    const value = paths[key];
-    sofar[key] = typeof value === "string"
-      ? new Path(root, value)
-      : qualify(`${root}/${key}`, value);
-    return sofar;
-  }, {});
-
-const getConfig = async (root, filename) => {
-  try {
-    return extend(defaults, (await import(root.join(filename))).default);
-  } catch (error) {
-    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 index = async env => {
-  const name = "index.html";
-  try {
-    // user-provided file
-    return await File.read(`${env.paths.static.join(name)}`);
-  } catch (error) {
-    // fallback
-    return new Path(import.meta.url).directory.join(name).file.read();
-  }
-};
-
-const hash = async (string, algorithm = "sha-384") => {
-  const encoder = new TextEncoder();
-  const bytes = await crypto.subtle.digest(algorithm, encoder.encode(string));
-  const algo = algorithm.replace("-", () => "");
-  return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
-};
-
-export default async (filename = "primate.config.js") => {
-  is(filename).string();
-  const root = await getRoot();
-  const config = await getConfig(root, filename);
-
-  const {name, version} = JSON.parse(await new Path(import.meta.url)
-    .directory.directory.join("package.json").file.read());
-
-  const env = {
-    ...config,
-    name, version,
-    resources: [],
-    entrypoints: [],
-    paths: qualify(root, config.paths),
-    root,
-    log: new Logger(config.logger),
-    register: (name, handler) => {
-      env.handlers[name] = handler;
-    },
-    handlers: {...handlers},
-    render: async ({body = "", head = ""} = {}) => {
-      const html = await index(env);
-      const heads = env.resources.map(({src, code, type, inline, integrity}) => {
-        const tag = type === "style" ? "link" : "script";
-        const pre = type === "style"
-          ? `<${tag} rel="stylesheet" integrity="${integrity}"`
-          : `<${tag} type="${type}" integrity="${integrity}"`;
-        const middle = type === "style"
-          ? ` href="${src}">`
-          : ` src="${src}">`;
-        const post = type === "style" ? "" : `</${tag}>`;
-        return inline ? `${pre}>${code}${post}` : `${pre}${middle}${post}`;
-      }).join("\n");
-      return html
-        .replace("%body%", () => body)
-        .replace("%head%", () => `${head}${heads}`);
-    },
-    publish: async ({src, code, type = "", inline = false}) => {
-      const integrity = await hash(code);
-      env.resources.push({src, code, type, inline, integrity});
-      return integrity;
-    },
-    bootstrap: ({type, code}) => {
-      env.entrypoints.push({type, code});
-    },
-  };
-  print(colors.blue(colors.bold(name)), colors.blue(version), "");
-  print(colors.gray(`at http://${config.http.host}:${config.http.port}`), "\n");
-  const {modules} = config;
-  // modules may load other modules
-  const loads = await Promise.all(modules
-    .filter(module => module.load !== undefined)
-    .map(module => module.load()));
-
-  return cache("config", filename, () => ({...env,
-    modules: modules.concat(loads.flat())}));
-};

package/src/errors/Info.js

@@ -1 +0,0 @@
-export default class InfoError extends Error {}

package/src/errors/InternalServer.js

@@ -1 +0,0 @@
-export default class InternalServerError extends Error {}

package/src/errors/Predicate.js

@@ -1 +0,0 @@
-export default class PredicateError extends Error {}

package/src/errors/Route.js

@@ -1 +0,0 @@
-export default class RouteError extends Error {}

package/src/errors.js

@@ -1,2 +0,0 @@
-export {default as InternalServerError} from "./errors/InternalServer.js";
-export {default as PredicateError} from "./errors/Predicate.js";

package/src/publish.js

@@ -1,5 +0,0 @@
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
-
-export default async env =>
-  [...filter("publish", env.modules), _ => _].reduceRight((acc, handler) =>
-    input => handler(input, acc))(env);

package/src/register.js

@@ -1,5 +0,0 @@
-const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
-
-export default async env =>
-  [...filter("register", env.modules), _ => _].reduceRight((acc, handler) =>
-    input => handler(input, acc))(env);

package/src/route.js

@@ -1,63 +0,0 @@
-import {Path} from "runtime-compat/fs";
-import Logger from "./Logger.js";
-
-// insensitive-case equal
-const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
-// HTTP verbs
-const verbs = [
-  // CRUD
-  "post", "get", "put", "delete",
-  // extended
-  "delete", "connect", "options", "trace", "patch",
-];
-export default async env => {
-  const routes = [];
-  const find = (method, path, fallback = {handler: r => r}) =>
-    routes.find(route =>
-      ieq(route.method, method) && route.path.test(path)) ?? fallback;
-
-  const router = {
-    route: async ({request}) => {
-      const {method} = request.original;
-      const url = new URL(`https://primatejs.com${request.pathname}`);
-      const {pathname, searchParams} = url;
-      const params = Object.fromEntries(searchParams);
-      const verb = find(method, pathname, {handler: () => {
-        throw new Logger.Info(`no ${method.toUpperCase()} route to ${pathname}`);
-      }});
-      const path = pathname.split("/").filter(part => part !== "");
-      const named = verb.path?.exec(pathname)?.groups ?? {};
-
-      return verb.handler(await find("map", pathname)
-        .handler({...request, pathname, params, path, named}));
-    },
-  };
-  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}>.*?)`)
-    ;
-    return new RegExp(`^/${route}$`, "u");
-  };
-  for (const route of await Path.collect(env.paths.routes, /^.*.js$/u)) {
-    const imported = (await import(route)).default;
-    const file = `${route}`.replace(env.paths.routes, "").slice(1);
-    if (imported === undefined) {
-      env.log.warn(`empty route file at ${file}`);
-    } else {
-      const valids = Object.entries(imported)
-        .filter(([verb]) => verbs.includes(verb));
-      for (const [method, handler] of valids) {
-        routes.push({method, path: toRoute(file), handler});
-      }
-    }
-  }
-  return router;
-};