primate 0.6.1 → 0.6.4

package/README.md

@@ -7,9 +7,77 @@ expressive code.
 ## Installing
 
 ```
-npm install primate
+$ npm install primate
 ```
 
+## Quick start
+
+Lay out your app
+
+```
+$ mkdir -p primate-app/{routes,components,ssl} && cd primate-app
+```
+
+Create a route for `/`
+
+```
+// routes/site.js
+
+import {router, html} from "primate";
+
+router.get("/", () => html`<site-index date=${new Date()} />`);
+```
+
+Create component for your route
+
+```
+// components/site-index.html
+
+Today's date is <span data-value="date"></span>.
+```
+
+Generate SSL key/certificate
+
+```
+openssl req -x509 -out ssl/default.crt -keyout ssl/default.key -newkey rsa:2048 -nodes -sha256 -batch
+```
+
+Add an entry file
+
+```
+// app.js
+
+import {app} from "primate";
+app.run();
+```
+
+Create and start script and enable ES modules
+
+```
+// package.json
+
+{
+  "scripts": {
+    "start": "node --experimental-json-modules app.js"
+  },
+  "type": "module"
+}
+```
+
+Install Primate
+
+```
+$ npm install primate
+```
+
+Run app
+
+```
+$ npm start
+```
+
+Visit `https://localhost:9999`
+
 ## Highlights
 
 * Flexible HTTP routing, returning HTML, JSON or a custom handler
@@ -17,15 +85,15 @@ npm install primate
 * Built-in support for sessions with secure cookies
 * Input verification using data domains
 * Many different data store modules: In-Memory (built-in),
-[File][primate-store-file], [JSON][primate-store-json],
-[MongoDB][primate-store-mongodb]
+[File][primate-file-store], [JSON][primate-json-store],
+[MongoDB][primate-mongodb-store]
 * Easy modelling of`1:1`, `1:n` and `n:m` relationships
 * Minimally opinionated with sane, overrideable defaults
 * No dependencies
 
-## Getting started
+## Resources
 
-See the [getting started][getting-started] guide.
+* [Getting started guide]
 
 ## License
 
@@ -34,6 +102,6 @@ BSD-3-Clause
 [getting-started]: https://primatejs.com/getting-started
 [source-code]: https://github.com/primatejs/primate
 [issues]: https://github.com/primatejs/primate/issues
-[primate-store-file]: https://npmjs.com/primate-store-file
-[primate-store-json]: https://npmjs.com/primate-store-json
-[primate-store-mongodb]: https://npmjs.com/primate-store-mongodb
+[primate-file-store]: https://npmjs.com/primate-file-store
+[primate-json-store]: https://npmjs.com/primate-json-store
+[primate-mongodb-store]: https://npmjs.com/primate-mongodb-store

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "primate",
-  "version": "0.6.1",
+  "version": "0.6.4",
   "author": "Primate core team <core@primatejs.com>",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
   "repository": "https://github.com/primatejs/primate",
-  "description": "Server-client framework",
+  "description": "Full-stack JavaScript framework",
   "license": "BSD-3-Clause",
   "scripts": {
     "copy": "rm -rf output && mkdir output && cp source/* output -a",

package/source/App.js

@@ -4,26 +4,12 @@ import File from "./File.js";
 import Directory from "./Directory.js";
 import Router from "./Router.js";
 import Server from "./Server.js";
-import cache from "./cache.js";
 import log from "./log.js";
 import package_json from "../package.json" assert {"type": "json"};
 
 export default class App {
   constructor(conf) {
     this.conf = conf;
-    this.Bundler = Bundler;
-  }
-
-  get routes() {
-    return cache(this, "routes", async () => {
-      try {
-        const path = `${this.conf.root}/routes.json`;
-        return (await import(path, {"assert": {"type": "json"}})).default;
-      } catch (error) {
-        // local routes.json not required
-        return [];
-      }
-    });
   }
 
   async run() {
@@ -33,9 +19,9 @@ export default class App {
     for (const route of routes) {
       await import(`${this.conf.paths.routes}/${route}`);
     }
-    const index = await new this.Bundler(this.conf).bundle();
+    await new Bundler(this.conf).bundle();
 
-    const conf = {index, "router": Router,
+    const conf = {"router": Router,
       "serve_from": this.conf.paths.public,
       "http": {
         ...this.conf.http,
@@ -45,12 +31,6 @@ export default class App {
     };
     this.server = new Server(conf);
     await this.server.run();
-
-    const {port, host} = this.conf.http;
-    this.server.listen(port, host);
-  }
-
-  stop() {
-    this.server.close();
+    this.server.listen();
   }
 }

package/source/Bundler.js

@@ -35,9 +35,17 @@ export default class Bundler {
     await this.copy_with_preset("static", paths.public);
 
     // read index.html from public, then remove it (we serve it dynamically)
-    const index_html = await File.read(`${paths.public}/${this.index}`);
     await File.remove(`${paths.public}/${this.index}`);
-
-    return index_html;
   }
 }
+
+export const index = async conf => {
+  let file;
+  const subdirectory = "static";
+  try {
+    file = await File.read(`${conf.paths[subdirectory]}/${conf.files.index}`);
+  } catch (error) {
+    file = await File.read(`${preset}/${subdirectory}/${conf.files.index}`);
+  }
+  return file;
+};

package/source/EagerPromise.js

@@ -10,14 +10,12 @@ const handler = {
       return promise[property].bind(promise);
     }
 
-    return EagerPromise.resolve(promise.then(result => {
-      if (property === "bind") {
-        return result;
-      }
-      return inconstructible_function(result[property])
+    return EagerPromise.resolve(promise.then(result => property === "bind"
+      ? result
+      : inconstructible_function(result[property])
         ? result[property].bind(result)
-        : result[property];
-    }));
+        : result[property]
+    ));
   },
   "apply": (target, that, args) =>
     EagerPromise.resolve(target[$promise].then(result =>
@@ -46,6 +44,6 @@ const last = -1;
 const eager = async (strings, ...keys) =>
   (await Promise.all(strings.slice(0, last).map(async (string, i) =>
     strings[i] + await keys[i]
-  ))).join("") + strings[strings.length+last];
+  ))).join("") + strings.at(last);
 
 export {eager};

package/source/Server.js

@@ -1,14 +1,13 @@
 import zlib from "zlib";
-import {Readable} from "stream";
 import {createServer} from "https";
 import {join} from "path";
 import {parse} from "url";
 import Session from "./Session.js";
 import File from "./File.js";
-import {algorithm, hash} from "./crypto.js";
 import log from "./log.js";
 import codes from "./http-codes.json" assert {"type": "json"};
 import mimes from "./mimes.json" assert {"type": "json"};
+import {http404} from "./handlers/http.js";
 
 const regex = /\.([a-z1-9]*)$/u;
 const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
@@ -59,7 +58,6 @@ export default class Server {
       await this.serve(url, request, response, payload);
     } catch (error) {
       console.log(error);
-//      await response.session.log("red", error.message);
       response.writeHead(codes.InternalServerError);
       response.end();
     }
@@ -77,26 +75,30 @@ export default class Server {
     const file = await new File(filename);
     return await file.is_file
       ? this.serve_file(url, filename, file, response, payload)
-      : this.serve_data(url, request, response, payload);
+      : this.serve_route(url, request, response, payload);
   }
 
-  async serve_data(pathname, request, response, payload) {
-    const {session} = response;
-    const request2 = {pathname, "method": request.method.toLowerCase(), payload};
-    const res = await this.conf.router.process(request2);
-    const {body, code, headers} = res;
-
-    const result = this.conf.index.replace("<body>", () => `<body>${body}`);
-    for (const [key, value] of Object.entries(headers)) {
-      response.setHeader(key, value);
+  async serve_route(pathname, request, response, payload) {
+    const req = {pathname, "method": request.method.toLowerCase(), payload};
+    let result;
+    try {
+      result = await this.conf.router.process(req);
+      for (const [key, value] of Object.entries(result.headers)) {
+        response.setHeader(key, value);
+      }
+    } catch (error) {
+      console.log(error);
+      result = http404``;
     }
+    const {body, code} = result;
     response.setHeader("Content-Security-Policy", this.csp);
     response.setHeader("Referrer-Policy", "same-origin");
     response.writeHead(code);
-    response.end(result);
+    response.end(body);
   }
 
-  listen(port, host) {
+  listen() {
+    const {port, host} = this.conf.http;
     log.reset("on").yellow(`https://${host}:${port}`).nl();
     this.server.listen(port, host);
   }

package/source/exports.js

@@ -8,7 +8,6 @@ export {default as File} from "./File.js";
 export {default as EagerPromise, eager} from "./EagerPromise.js" ;
 
 export {default as Domain} from "./domain/Domain.js";
-export {default as domains} from "./domain/domains.js";
 export {default as Storeable} from "./types/Storeable.js";
 
 export * from "./errors.js";
@@ -22,7 +21,9 @@ export {default as extend_object} from "./extend_object.js";
 export {default as sanitize} from "./sanitize.js";
 
 export {default as html} from "./handlers/html.js";
+export {default as json} from "./handlers/json.js";
 export {default as redirect} from "./handlers/redirect.js";
+
 export {default as router} from "./Router.js";
 
 const app = new App(conf());

package/source/handlers/DOM/Node.js

@@ -164,9 +164,8 @@ export default class Node {
               this.text = fulfilled;
             }
             break;
-          case "data-href":
-            fulfill(this.attributes[attribute], this.data);
-            this.attributes.href = fulfilled;
+          default:
+            this.attributes[attribute.slice(5)] = fulfilled;
             break;
         }
         delete this.attributes[attribute];

package/source/handlers/DOM/Parser.js

@@ -74,12 +74,19 @@ export default class Parser {
     }
   }
 
+  try_create_text_node() {
+    if (this.buffer.length > 0) {
+      const child = new Node(this.node, "span");
+      child.text = this.buffer;
+      this.buffer = "";
+    }
+  }
+
   // currently outside of a tag
   process_not_reading_tag() {
     // encountered '<'
     if (this.current === "<") {
-      this.node.text = this.buffer;
-      this.buffer = "";
+      this.try_create_text_node();
       // mark as inside tag
       this.reading_tag = true;
       if (this.next === "/") {
@@ -111,6 +118,8 @@ export default class Parser {
     if (this.balance !== 0) {
       throw Error(`unbalanced DOM tree: ${this.balance}`);
     }
+    // anything left at the end could be potentially a text node
+    this.try_create_text_node();
     return this.tree;
   }
 

package/source/handlers/html.js

@@ -1,10 +1,12 @@
 import Parser from "./DOM/Parser.js";
-import conf from "../conf.js";
 import Directory from "../Directory.js";
 import File from "../File.js";
+import {index} from "../Bundler.js";
+import _conf from "../conf.js";
+const conf = _conf();
 
 const last = -1;
-const {paths: {"components": path}} = conf();
+const {"paths": {"components": path}} = conf;
 const components = {};
 if (await File.exists(path)) {
   const names = await Directory.list(path);
@@ -15,12 +17,13 @@ if (await File.exists(path)) {
 
 export default async (strings, ...keys) => {
   const awaited_keys = await Promise.all(keys);
-  const body = await (await Parser.parse(strings
+  const rendered = await (await Parser.parse(strings
     .slice(0, last)
     .map((string, i) => `${string}$${i}`)
     .join("") + strings[strings.length+last], awaited_keys)
     .unfold(components))
     .render();
+  const body = (await index(conf)).replace("<body>", () => `<body>${rendered}`);
   const code = 200;
   const headers = {"Content-Type": "text/html"};
   return {code, body, headers};

package/source/handlers/json.js

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

package/source/invariants.js

@@ -1,4 +1,5 @@
 import {constructible, nullish} from "./attributes.js";
+import map_entries from "./map_entries.js";
 
 const errored = error => {
   if (typeof error === "function") {
@@ -14,6 +15,9 @@ const assert = (predicate, error) => Boolean(predicate) || errored(error);
 const is = {
   "array": value => assert(Array.isArray(value), "must be array"),
   "string": value => assert(typeof value === "string", "must be string"),
+  "object": value => assert(typeof value === "object" && value !== null,
+    "must be object"),
+  "function": value => assert(typeof value === "function", "must be function"),
   "defined": (value, error) => assert(value !== undefined, error),
   "undefined": value => assert(value === undefined, "must be undefined"),
   "constructible": (value, error) => assert(constructible(value), error),
@@ -24,9 +28,10 @@ const is = {
 };
 const {defined} = is;
 
-const maybe = Object.keys(is).reduce((aggregator, property) => {
-  aggregator[property] = value => nullish(value) || is[property](value);
-  return aggregator;
-}, {});
+// too early to use map_entries here, as it relies on invariants
+const maybe = Object.fromEntries(Object.entries(is).map(([key, value]) =>
+  [key, (...args) => nullish(args[0]) || value(...args)]));
 
-export {assert, defined, is, maybe};
+const invariant = predicate => predicate();
+
+export {assert, defined, is, maybe, invariant};

package/source/map_entries.js

@@ -0,0 +1,6 @@
+import {is, invariant} from "./invariants.js";
+
+export default (object = {}, mapper = (...args) => args) =>
+  invariant(() => is.object(object) && is.function(mapper))
+  && Object.fromEntries(Object.entries(object).map(([key, value]) =>
+    mapper(key, value)));

package/source/preset/primate.json

@@ -1,9 +1,6 @@
 {
   "base": "/",
   "debug": false,
-  "defaults": {
-    "context": "guest"
-  },
   "files": {
     "index": "index.html"
   },
@@ -24,7 +21,6 @@
     "same-site": "Strict"
   },
   "paths": {
-    "domains": "domains",
     "public": "public",
     "static": "static",
     "routes": "routes",

package/source/sanitize.js

@@ -1,10 +1,8 @@
-export default (payload = {}) => Object.keys(payload)
-  .map(key => ({key, "value": payload[key].toString().trim()}))
-  .map(datum => {
-    datum.value = datum.value === "" ? undefined : datum.value;
-    return datum;
-  })
-  .reduce((data, {key, value}) => {
-    data[key] = value;
-    return data;
-  }, {});
+import {is} from "./invariants.js";
+import map_entries from "./map_entries.js";
+
+export default (dirty = {}) => is.object(dirty)
+  && map_entries(dirty, (key, value) => {
+    const trimmed = value.toString().trim();
+    return [key, trimmed === "" ? undefined : trimmed];
+  });

package/source/domain/domains.js

@@ -1,31 +0,0 @@
-import conf from "../conf.js";
-import File from "../File.js";
-import Field from "./Field.js";
-import Domain from "./Domain.js";
-
-const domains = {};
-const base = conf().paths.domains;
-
-for (const domain of await new File(base).list(".js")) {
-  const name = domain.slice(0, -3);
-  import(`${base}/${domain}`).then(module => {
-    domains[name] = module.default;
-  });
-}
-
-export const actuals = {};
-for (const domain in domains) {
-  if (domains[domain].prototype instanceof Domain) {
-    const fields = {};
-    for (const field in domains[domain]._fields) {
-      const Type = domains[domain]._fields[field].Type;
-      if(Type.prototype instanceof Domain) {
-        fields[field.slice(0, -3)] = Type.name;
-      }
-    }
-    actuals[domain] = fields;
-  }
-}
-
-
-export default domains;