primate 0.13.0 → 0.13.2

package/README.md

@@ -190,32 +190,29 @@ export default router => {
 ### Sharing logic across requests
 
 ```js
-import html from "@primate/html";
-import redirect from "@primate/redirect";
-
 export default router => {
-  // declare `"edit-user"` as alias of `"/user/edit/([0-9])+"`
+  // Declare `"edit-user"` as alias of `"/user/edit/([0-9])+"`
   router.alias("edit-user", "/user/edit/([0-9])+");
 
-  // pass user instead of request to all verbs with this route
-  router.map("edit-user", () => ({name: "Donald"}));
+  // Pass user instead of request to all verbs on this route
+  router.map("edit-user", ({body}) => body?.name ?? "Donald");
 
-  // show user edit form
-  router.get("edit-user", user => html("user-edit", {user}));
+  // Show user as plain text
+  router.get("edit-user", user => user);
 
-  // verify form and save, or show errors
-  router.post("edit-user", async user => await user.save()
-    ? redirect("/users")
-    : html`<user-edit user="${user}" />`);
+  // Verify or show error
+  router.post("edit-user", user => user === "Donald"
+    ? "Hi Donald!"
+    : {message: "Error saving user"});
 };
 
 ```
 
 ### Explicit handlers
 
-Most often we can figure the content type to respond with based on the return
-type from the handler. To handle content not automatically detected, use the
-second argument of the exported function.
+Most often we can figure out the content type to respond with based on the
+return type from the handler. To handle content not automatically detected, use
+the second argument of the exported function.
 
 ```js
 export default (router, {redirect}) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Expressive, minimal and extensible framework for JavaScript",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",

package/readme/routing/sharing-logic-across-requests.js

@@ -1,18 +1,15 @@
-import html from "@primate/html";
-import redirect from "@primate/redirect";
-
 export default router => {
-  // declare `"edit-user"` as alias of `"/user/edit/([0-9])+"`
+  // Declare `"edit-user"` as alias of `"/user/edit/([0-9])+"`
   router.alias("edit-user", "/user/edit/([0-9])+");
 
-  // pass user instead of request to all verbs with this route
-  router.map("edit-user", () => ({name: "Donald"}));
+  // Pass user instead of request to all verbs on this route
+  router.map("edit-user", ({body}) => body?.name ?? "Donald");
 
-  // show user edit form
-  router.get("edit-user", user => html("user-edit", {user}));
+  // Show user as plain text
+  router.get("edit-user", user => user);
 
-  // verify form and save, or show errors
-  router.post("edit-user", async user => await user.save()
-    ? redirect("/users")
-    : html`<user-edit user="${user}" />`);
+  // Verify or show error
+  router.post("edit-user", user => user === "Donald"
+    ? "Hi Donald!"
+    : {message: "Error saving user"});
 };

package/readme/template.md

@@ -117,9 +117,9 @@ to the content type sent along the request. Currently supported are
 
 ### Explicit handlers
 
-Most often we can figure the content type to respond with based on the return
-type from the handler. To handle content not automatically detected, use the
-second argument of the exported function.
+Most often we can figure out the content type to respond with based on the
+return type from the handler. To handle content not automatically detected, use
+the second argument of the exported function.
 
 ```js
 // routing/explicit-handlers.js

package/src/bundle.js

@@ -16,6 +16,8 @@ const makePublic = async env => {
   }
 };
 
-export default async env => await makePublic(env) &&
+export default async env => {
+  await makePublic(env);
   [...filter("bundle", env.modules), _ => _].reduceRight((acc, handler) =>
     input => handler(input, acc))(env);
+};

package/src/config.js

@@ -1,5 +1,6 @@
-import {File, Path} from "runtime-compat/fs";
+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";
@@ -45,11 +46,19 @@ const index = async env => {
   }
 };
 
+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 resources = [];
   const env = {
     ...config,
     paths: qualify(root, config.paths),
@@ -59,7 +68,23 @@ export default async (filename = "primate.config.js") => {
       env.handlers[name] = handler;
     },
     handlers: {...handlers},
-    render: async html => (await index(env)).replace("%body%", () => html),
+    render: async ({body = "", head = ""} = {}) => {
+      const html = await index(env);
+      const heads = resources.map(({src, code, type, inline, integrity}) => {
+        const tag = "script";
+        const pre = `<${tag} type="${type}" integrity="${integrity}"`;
+        const post = `</${tag}>`;
+        return inline ? `${pre}>${code}${post}` : `${pre} src="${src}">${post}`;
+      }).join("\n");
+      return html
+        .replace("%body%", () => body)
+        .replace("%head%", () => `${head}${heads}`);
+    },
+    publish: async ({src, code, type = "", inline = false}) => {
+      const integrity = await hash(code);
+      resources.push({src, code, type, inline, integrity});
+      return integrity;
+    },
   };
   env.log.info(`${package_json.name} \x1b[34m${package_json.version}\x1b[0m`);
   const modules = await Promise.all(config.modules.map(module => module(env)));
@@ -68,6 +93,6 @@ export default async (filename = "primate.config.js") => {
     .filter(module => module.load !== undefined)
     .map(module => module.load()(env)));
 
-  return cache("config", filename, () => ({...env,
+  return cache("config", filename, () => ({...env, resources,
     modules: modules.concat(loads)}));
 };

package/src/handlers/html.js

@@ -8,9 +8,9 @@ const getContent = async (env, name) => {
 
 export default (content, {status = 200, partial = false, adhoc = false} = {}) =>
   async (env, headers) => {
-    const html = adhoc ? content : await getContent(env, content);
+    const body = adhoc ? content : await getContent(env, content);
     return [
-      partial ? html : await env.render(html), {
+      partial ? body : await env.render({body}), {
         status,
         headers: {...headers, "Content-Type": "text/html"},
       },

package/src/index.html

@@ -3,6 +3,7 @@
   <head>
     <title>Primate app</title>
     <meta charset="utf-8" />
+    %head%
   </head>
   <body>%body%</body>
 </html>

package/src/publish.js

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

@@ -1,14 +1,21 @@
 import config from "./config.js";
 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";
 
 export default async () => {
   const env = await config();
+  // register handlers
   await register(env);
+  // compile server-side code
   await compile(env);
+  // publish client-side code
+  await publish(env);
+  // bundle client-side code
   await bundle(env);
+  // serve
   serve({router: await route(env.paths.routes, env.handlers), ...env});
 };

package/src/serve.js

@@ -22,8 +22,19 @@ export default env => {
   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
+      .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];
+      if (resource.inline) {
+        env.resources.splice(i, 1);
+      }
+    }
+
     const headers = {
-      "Content-Security-Policy": csp,
+      "Content-Security-Policy": _csp,
       "Referrer-Policy": "same-origin",
     };
 
@@ -53,9 +64,24 @@ export default env => {
     },
   });
 
+  const publishedResource = request => {
+    const published = env.resources.find(resource =>
+      `/${resource.src}` === request.pathname);
+    if (published !== undefined) {
+      return new Response(published.code, {
+        status: statuses.OK,
+        headers: {
+          "Content-Type": mime(published.src),
+        },
+      });
+    }
+
+    return route(request);
+  };
+
   const _serve = async request => {
     const path = new Path(env.paths.public, request.pathname);
-    return await path.isFile ? resource(path.file) : route(request);
+    return await path.isFile ? resource(path.file) : publishedResource(request);
   };
 
   const handle = async request => {
@@ -67,11 +93,20 @@ export default env => {
     }
   };
 
-  const parseContent = (request, body) => {
-    const type = contents[request.headers.get("content-type")];
+  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) {
+      env.log.warn(error);
+      return body;
+    }
+  };
+
   const {http} = env;
   const modules = filter("serve", env.modules);