primate 0.11.0 → 0.13.0

package/scripts/docs.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+npx -y embedme\
+  --source-root readme\
+  --strip-embed-comment\
+  --stdout readme/template.md\
+  > README.md
+

package/src/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+(await import("./run.js")).default();

package/src/bundle.js

@@ -1,14 +1,21 @@
-import {File} from "runtime-compat/filesystem";
+import {File} from "runtime-compat/fs";
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
-export default async env => {
+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) {
-    // remove public directory in case exists
-    if (await paths.public.exists) {
-      await paths.public.file.remove();
-    }
-    await paths.public.file.create();
     // 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/compile.js

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,73 @@
+import {File, Path} from "runtime-compat/fs";
+import {is} from "runtime-compat/dyndef";
+import cache from "./cache.js";
+import extend from "./extend.js";
+import defaults from "./primate.config.js";
+import * as log from "./log.js";
+import * as handlers from "./handlers/exports.js";
+import package_json from "../package.json" assert {type: "json"};
+
+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();
+  }
+};
+
+export default async (filename = "primate.config.js") => {
+  is(filename).string();
+  const root = await getRoot();
+  const config = await getConfig(root, filename);
+
+  const env = {
+    ...config,
+    paths: qualify(root, config.paths),
+    root,
+    log: {...log, error: error => log.error(error, config)},
+    register: (name, handler) => {
+      env.handlers[name] = handler;
+    },
+    handlers: {...handlers},
+    render: async html => (await index(env)).replace("%body%", () => html),
+  };
+  env.log.info(`${package_json.name} \x1b[34m${package_json.version}\x1b[0m`);
+  const modules = await Promise.all(config.modules.map(module => module(env)));
+  // modules may load other modules
+  const loads = await Promise.all(modules
+    .filter(module => module.load !== undefined)
+    .map(module => module.load()(env)));
+
+  return cache("config", filename, () => ({...env,
+    modules: modules.concat(loads)}));
+};

package/src/duck.js

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

package/src/extend.spec.js

@@ -40,20 +40,20 @@ export default test => {
   });
 
   test.case("one property of a subobject", assert => {
-    const base = {key: {"subkey": "subvalue"}};
-    const extension = {key: {"subkey": "subvalue 2"}};
+    const base = {key: {subkey: "subvalue"}};
+    const extension = {key: {subkey: "subvalue 2"}};
     assert(extend(base, extension)).equals(extension);
   });
 
   test.case("two properties of a subobject, one replaced", assert => {
-      const base = {key: {subkey: "subvalue", subkey2: "subvalue2"}};
-      const extension = {key: {subkey: "subvalue 2"}};
-      const extended = {key: {subkey: "subvalue 2", subkey2: "subvalue2"}};
-      assert(extend(base, extension)).equals(extended);
-    });
+    const base = {key: {subkey: "subvalue", subkey2: "subvalue2"}};
+    const extension = {key: {subkey: "subvalue 2"}};
+    const extended = {key: {subkey: "subvalue 2", subkey2: "subvalue2"}};
+    assert(extend(base, extension)).equals(extended);
+  });
 
-  test.case("configuration enhancement", assert => {
-    const default_conf = {
+  test.case("config enhancement", assert => {
+    const base = {
       base: "/",
       debug: false,
       defaults: {
@@ -61,16 +61,14 @@ export default test => {
         context: "guest",
       },
       paths: {
-        client: "client",
-        data: {
-          domains: "domains",
-          stores: "stores",
-        },
         public: "public",
+        static: "static",
+        routes: "routes",
+        components: "components",
       },
     };
 
-    const additional_conf = {
+    const additional = {
       debug: true,
       environment: "testing",
       defaults: {
@@ -78,11 +76,7 @@ export default test => {
         mode: "operational",
       },
       paths: {
-        client: "client_logic",
-        data: {
-          stores: "storage",
-          drivers: "drivers",
-        },
+        client: "client",
       },
     };
 
@@ -96,16 +90,14 @@ export default test => {
         mode: "operational",
       },
       paths: {
-        client: "client_logic",
-        data: {
-          domains: "domains",
-          drivers: "drivers",
-          stores: "storage",
-        },
+        client: "client",
         public: "public",
+        static: "static",
+        routes: "routes",
+        components: "components",
       },
     };
 
-    assert(extend(default_conf, additional_conf)).equals(extended);
+    assert(extend(base, additional)).equals(extended);
   });
 };

package/src/handlers/exports.js

@@ -0,0 +1,5 @@
+export {default as text} from "./text.js";
+export {default as json} from "./json.js";
+export {default as stream} from "./stream.js";
+export {default as redirect} from "./redirect.js";
+export {default as html} from "./html.js";

package/src/handlers/html.js

@@ -0,0 +1,18 @@
+const getContent = async (env, name) => {
+  try {
+    return await env.paths.components.join(`${name}.html`).file.read();
+  } catch (error) {
+    throw new Error(`cannot load component at ${name}.html`);
+  }
+};
+
+export default (content, {status = 200, partial = false, adhoc = false} = {}) =>
+  async (env, headers) => {
+    const html = adhoc ? content : await getContent(env, content);
+    return [
+      partial ? html : await env.render(html), {
+        status,
+        headers: {...headers, "Content-Type": "text/html"},
+      },
+    ];
+  };

package/src/handlers/http404.js

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

package/src/handlers/json.js

@@ -1,4 +1,6 @@
-export default (_, ...keys) => async () => [JSON.stringify(await keys[0]), {
-  status: 200,
-  headers: {"Content-Type": "application/json"},
-}];
+export default (body, {status = 200} = {}) => (_, headers) => [
+  JSON.stringify(body), {
+    status,
+    headers: {...headers, "Content-Type": "application/json"},
+  },
+];

package/src/handlers/redirect.js

@@ -0,0 +1,7 @@
+export default (Location, {status = 302} = {}) => (_, headers) => [
+  /* no body */
+  null, {
+    status,
+    headers: {...headers, Location},
+  },
+];

package/src/handlers/stream.js

@@ -1,4 +1,6 @@
-export default (_, ...keys) => async () => [await keys[0], {
-  status: 200,
-  headers: {"Content-Type": "application/octet-stream"},
-}];
+export default (body, {status = 200} = {}) => (_, headers) => [
+  body, {
+    status,
+    headers: {...headers, "Content-Type": "application/octet-stream"},
+  },
+];

package/src/handlers/text.js

@@ -1,11 +1,6 @@
-const last = -1;
-
-export default (strings, ...keys) => async () => {
-  const awaitedKeys = await Promise.all(keys);
-  const body = strings
-    .slice(0, last)
-    .map((string, i) => string + awaitedKeys[i])
-    .join("") + strings[strings.length + last];
-
-  return [body, {status: 200, headers: {"Content-Type": "text/plain"}}];
-};
+export default (body, {status = 200} = {}) => (_, headers) => [
+  body, {
+    status,
+    headers: {...headers, "Content-Type": "text/plain"},
+  },
+];

package/src/http-statuses.js

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

package/src/index.html

@@ -0,0 +1,8 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Primate app</title>
+    <meta charset="utf-8" />
+  </head>
+  <body>%body%</body>
+</html>

package/src/log.js

@@ -19,8 +19,11 @@ const log = new Proxy(Log, {
     log.paint(colors[property] ?? reset, message).paint(reset, " ")),
 });
 
-export default {
-  info: (...args) => log.green("[info]").reset(...args).nl(),
-  warn: (...args) => log.yellow("[warn]").reset(...args).nl(),
-  error: (...args) => log.red("[error]").reset(...args).nl(),
+export const info = (...args) => log.green("[info]").reset(...args).nl();
+
+export const warn = (...args) => log.yellow("[warn]").reset(...args).nl();
+
+export const error = (originalError, env) => {
+  log.red("[error]").reset(originalError.message).nl();
+  env.debug && console.log(originalError);
 };

package/src/mimes.js

@@ -0,0 +1,12 @@
+export default {
+  binary: "application/octet-stream",
+  css: "text/css",
+  html: "text/html",
+  jpg: "image/jpeg",
+  js: "text/javascript",
+  json: "application/json",
+  png: "image/png",
+  svg: "image/svg+xml",
+  woff2: "font/woff2",
+  webp: "image/webp",
+};

package/src/register.js

@@ -0,0 +1,5 @@
+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/respond.js

@@ -0,0 +1,24 @@
+import {Blob} from "runtime-compat/fs";
+import {text, json, stream} from "./handlers/exports.js";
+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}`);
+};
+
+const isNonNullObject = value => typeof value === "object" && value !== null;
+const isObject = value => isNonNullObject(value)
+  ? json(value) : isText(value);
+const isResponse = value => isResponseDuck(value)
+  ? () => value : isObject(value);
+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);
+
+export default result => typeof result === "function" ? result : guess(result);

package/src/route.js

@@ -1,29 +1,17 @@
-import {ReadableStream} from "runtime-compat/streams";
-import {Path, File} from "runtime-compat/filesystem";
+import {Path} from "runtime-compat/fs";
 import {is} from "runtime-compat/dyndef";
-import text from "./handlers/text.js";
-import json from "./handlers/json.js";
-import stream from "./handlers/stream.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}`);
-};
-const isObject = value => typeof value === "object" && value !== null
-  ? json`${value}` : isText(value);
-const isStream = value => value instanceof ReadableStream
-  ? stream`${value}` : isObject(value);
-const isFile = value => value instanceof File
-  ? stream`${value}` : isStream(value);
-const guess = value => isFile(value);
-
 // insensitive-case equal
 const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
-
-export default async definitions => {
+// HTTP verbs
+const verbs = [
+  // CRUD
+  "post", "get", "put", "delete",
+  // extended
+  "delete", "connect", "options", "trace", "patch",
+];
+export default async (definitions, handlers) => {
   const aliases = [];
   const routes = [];
   const expand = path => aliases.reduce((expanded, {key, value}) =>
@@ -43,11 +31,11 @@ export default async definitions => {
       ieq(route.method, method) && route.path.test(path)) ?? fallback;
 
   const router = {
+    ...Object.fromEntries(verbs.map(verb =>
+      [verb, (path, callback) => add(verb, path, callback)])),
     map: (path, callback) => add("map", path, callback),
-    get: (path, callback) => add("get", path, callback),
-    post: (path, callback) => add("post", path, callback),
     alias: (key, value) => aliases.push({key, value}),
-    process: async request => {
+    route: async request => {
       const {method} = request.original;
       const url = new URL(`https://primatejs.com${request.pathname}`);
       const {pathname, searchParams} = url;
@@ -58,15 +46,14 @@ export default async definitions => {
       const path = pathname.split("/").filter(part => part !== "");
       const named = verb.path?.exec(pathname)?.groups ?? {};
 
-      const result = await verb.handler(await find("map", pathname)
+      return verb.handler(await find("map", pathname)
         .handler({...request, pathname, params, path, named}));
-
-      return typeof result === "function" ? result : guess(result);
     },
   };
   if (await definitions.exists) {
     const files = (await Path.list(definitions)).map(route => import(route));
-    await Promise.all(files.map(async route => (await route).default(router)));
+    await Promise.all(files.map(async route =>
+      (await route).default(router, handlers)));
   }
   return router;
 };

package/src/run.js

@@ -1,13 +1,14 @@
-import serve from "./serve.js";
-import route from "./route.js";
+import config from "./config.js";
+import register from "./register.js";
+import compile from "./compile.js";
 import bundle from "./bundle.js";
+import route from "./route.js";
+import serve from "./serve.js";
 
-const extract = (modules, key) => modules.flatMap(module => module[key] ?? []);
-
-export default async env => {
-  const {paths} = env;
-  const router = await route(paths.routes);
+export default async () => {
+  const env = await config();
+  await register(env);
+  await compile(env);
   await bundle(env);
-
-  await serve({router, ...env, modules: extract(env.modules ?? [], "serve")});
+  serve({router: await route(env.paths.routes, env.handlers), ...env});
 };

package/src/serve.js

@@ -1,12 +1,16 @@
-import {Path} from "runtime-compat/filesystem";
+import {Path} from "runtime-compat/fs";
 import {serve, Response} from "runtime-compat/http";
-import statuses from "./http-statuses.json" assert {type: "json"};
-import mimes from "./mimes.json" assert {type: "json"};
+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";
 
 const regex = /\.([a-z1-9]*)$/u;
 const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
 
+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("=")
@@ -15,8 +19,7 @@ const contents = {
 };
 
 export default env => {
-  const route = async request => {
-    let result;
+  const _respond = async request => {
     const csp = Object.keys(env.http.csp).reduce((policy_string, key) =>
       `${policy_string}${key} ${env.http.csp[key]};`, "");
     const headers = {
@@ -25,12 +28,21 @@ export default env => {
     };
 
     try {
-      result = await (await env.router.process(request))(env, headers);
+      const {router} = env;
+      const modules = filter("route", env.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, headers);
     } catch (error) {
-      env.error(error.message);
-      result = http404(env, headers)``;
+      env.log.error(error);
+      return http404()(env, headers);
     }
-    return new Response(...result);
+  };
+
+  const route = async request => {
+    const response = await _respond(request);
+    return isResponse(response) ? response : new Response(...response);
   };
 
   const resource = async file => new Response(file.readable, {
@@ -50,7 +62,7 @@ export default env => {
     try {
       return await _serve(request);
     } catch (error) {
-      env.error(error.message);
+      env.log.error(error);
       return new Response(null, {status: statuses.InternalServerError});
     }
   };
@@ -60,7 +72,8 @@ export default env => {
     return type === undefined ? body : type(body);
   };
 
-  const {http, modules} = env;
+  const {http} = env;
+  const modules = filter("serve", env.modules);
 
   // handle is the last module to be executed
   const handlers = [...modules, handle].reduceRight((acc, handler) =>
@@ -87,5 +100,5 @@ export default env => {
     return handlers({original: request, pathname: pathname + search, body});
   }, http);
 
-  env.info(`running on ${http.host}:${http.port}`);
+  env.log.info(`running on ${http.host}:${http.port}`);
 };