primate 0.0.1 → 0.3.0

package/source/client/View.js

@@ -0,0 +1,90 @@
+// We do not import Element directly from "./Element.js", rather the otherwise
+// preset user version of it, to allow for the user overriding attributes.
+import Element from "../Element.js";
+import Node from "./Node.js";
+
+const data_regex = /\${([^}]*)}/g;
+
+export default class View {
+  constructor(data, action, root) {
+    this.sources = {};
+    this.store = data.payload;
+    this.action = action;
+    this.paint_into(data, root);
+  }
+
+  paint_into(data, root = document.body) {
+    root.innerHTML = data.view;
+    root.classList.add(data.context);
+    this.unfold(root);
+    if (root === document.body) {
+      window.scrollTo(0, 0);
+    }
+  }
+
+  unfold(node) {
+    this.expand_attributes(new Node(node));
+    new Node(node).children.forEach(child => this.unfold(child));
+  }
+
+  expand_attributes(node) {
+    node.attributes.filter(attribute => attribute.name === "data-scope")
+      .map(attribute => attribute.value)
+      .forEach(scope => this.expand(node.node, this.store[scope], scope));
+  }
+
+  expand(node, data, name, from_update) {
+    if (data instanceof Array) {
+      if (from_update) {
+        return;
+      }
+      const blueprint = document.createElement("div");
+      while (node.children.length > 0) {
+        blueprint.appendChild(node.firstChild);
+      }
+      for (const datum of data) {
+        const element = blueprint.cloneNode(true);
+        this.sources[`${name}-${datum._id}`] = element;
+        node.appendChild(element);
+        this.populate(element, datum, `${name}-${datum._id}`);
+      }
+    } else {
+      this.sources[name] = node;
+      if (data !== undefined) {
+        this.populate(node, data, name);
+      }
+    }
+  }
+
+  populate(node, data, key, from_update) {
+    const regex = /^data-/u;
+    new Node(node).children.forEach(child => {
+      let populate = true;
+      for (let i = 0; i < child.attributes.length; i++) {
+        const attribute = child.attributes[i];
+        const {name, value} = attribute;
+        if (regex.test(name)) {
+          if (name === "data-scope") {
+            this.expand(child, data[value], `${key}-${value}`, from_update);
+            populate = false;
+          } else {
+            Element.evaluate(attribute, child, data);
+          }
+        }
+      }
+      child.children.length !== 0 && populate &&
+        this.populate(child, data, key, from_update);
+    });
+  }
+
+  update(data) {
+    Object.keys(data).forEach(key =>
+      this.sources[key] !== undefined &&
+      this.populate(this.sources[key], data[key], key, true)
+    );
+  }
+
+  write(pathname, payload) {
+    return this.action.write(pathname, payload);
+  }
+}

package/source/client/document.js

@@ -0,0 +1,6 @@
+const {baseURI} = document;
+const {host, href, origin} = document.location;
+const base = baseURI === href ? "/" : baseURI.replace(origin, "");
+const origin_base = `${origin}${base}`;
+
+export {base, origin_base, host};

package/source/client/exports.js

@@ -0,0 +1,15 @@
+const timeout = (callback, delay = 0) => new Promise(resolve =>
+  window.setTimeout(() => resolve(callback()), delay));
+
+// This comes first, as Action > View > ../Element.js for user overrideability.
+export {default as Element} from "./Element.js";
+export {default as Action} from "./Action.js";
+export {default as Context} from "./Context.js";
+export {contexts, routes} from "../exports.js";
+export {timeout};
+
+import App from "./App.js";
+
+const app = new App();
+
+export {app};

package/source/preset/client/Element.js

@@ -0,0 +1,2 @@
+import {Element} from "./primate/exports.js";
+export default class extends Element {}

package/source/preset/client/app.js

@@ -0,0 +1,2 @@
+import {app} from "./primate/exports.js";
+app.run();

package/source/preset/data/stores/default.js

@@ -0,0 +1,2 @@
+import MemoryStore from "../../../server/store/Memory.js";
+export default new MemoryStore();

package/source/preset/primate.json

@@ -0,0 +1,31 @@
+{
+  "base": "/",
+  "debug": false,
+  "defaults": {
+    "action": "index",
+    "context": "guest",
+    "namespace": "default",
+    "store": "default.js"
+  },
+  "files": {
+    "index": "index.html"
+  },
+  "http": {
+    "host": "localhost",
+    "port": 9999,
+    "ssl": {
+      "key": "ssl/default.key",
+      "cert": "ssl/default.crt"
+    }
+  },
+  "paths": {
+    "client": "client",
+    "data": {
+      "domains": "domains",
+      "stores": "stores"
+    },
+    "public": "public",
+    "server": "server",
+    "static": "static"
+  }
+}

package/source/preset/static/index.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Primate app</title>
+    <base href="${conf.base}" />
+    <meta charset="utf-8" />
+    ${client}
+  </head>
+  <body></body>
+</html>

package/source/server/Action.js

@@ -0,0 +1,118 @@
+import Base from "./Base.js";
+import {MetaPromise} from "./promises.js";
+
+const _response = Symbol("#response");
+
+export default class Action extends Base {
+  constructor(data, session) {
+    super();
+    this._data = data;
+    this.session = session;
+  }
+
+  static get layout() {
+    return "default";
+  }
+
+  static async load(data, session, context) {
+    let module;
+    const server = this.conf.paths.server;
+    const {namespace, action} = data.path;
+    const route = `${namespace}/${action}`;
+    try {
+      module = (await import(`${server}/${context}/${route}.js`)).default;
+    } catch (error) {
+      throw new Error(`route '${route}' missing`);
+    }
+    return new module(data, session);
+  }
+
+  get layout() {
+    return this.Class().layout;
+  }
+
+  get path() {
+    return this._data.path;
+  }
+
+  get params() {
+    return this._data.params;
+  }
+
+  async _view(path) {
+    const {namespace, action} = this.path;
+    const view_path = path !== undefined ? path : `${namespace}/${action}`;
+    return (await this.context).view(view_path);
+  }
+
+  static sanitize(payload = {}) {
+    //assert(typeof payload === "object");
+    return Object.keys(payload)
+      .map(key => ({key, "value": payload[key].toString().trim()}))
+      .map(({key, value}) => ({key, "value":
+        value === "" ? undefined : value}))
+      .reduce((o, {key, value}) => {o[key] = value; return o;}, {});
+  }
+
+  async run(type) {
+    this.before && await this.before();
+    await this[type](this.Class().sanitize(this._data.payload));
+  }
+
+  get response() {
+    return this[_response]();
+  }
+
+  return(data = {}) {
+    this.respond("return", () => ({"payload": data}));
+  }
+
+  view(data = {}, layout = true) {
+    this.respond("view", async () => {
+      const _view = await this._view();
+      const payload = await this.prepare(data, _view);
+      const view = layout ? _view.file(this.layout) : _view.content;
+      return {view, payload};
+    });
+  }
+
+  update(data) {
+    this.respond("update", async () => {
+      const _view = await this._view();
+      const payload = await this.prepare(data, _view);
+      return {payload};
+    });
+  }
+
+  redirect(location) {
+    this.respond("redirect", () => ({location}));
+  }
+
+  get context() {
+    return this.session.actual_context;
+  }
+
+  switch_context(name, parameters) {
+    return this.session.switch_context(name, parameters);
+  }
+
+  async prepare(data = {}, view) {
+    (await this.context).Class().prepare(this, data);
+    return MetaPromise(data, await view.elements(this.layout));
+  }
+
+  respond(type, response) {
+    this[_response] = async () => {
+      const data = await response();
+      data.context = (await this.context).name;
+      data.namespace = this.path.namespace;
+      data.action = this.path.action;
+      if (data.pathname === undefined) {
+        data.pathname = this._data.pathname.replace(this.conf.base, "")
+          + (this._data.search ?? "");
+      }
+      data.type = type;
+      return data;
+    };
+  }
+}

package/source/server/App.js

@@ -0,0 +1,42 @@
+import {resolve} from "path";
+import Base from "./Base.js";
+import Bundler from "./Bundler.js";
+import File from "./File.js";
+import Router from "./Router.js";
+import DynamicServer from "./servers/Dynamic.js";
+import StaticServer from "./servers/Static.js";
+import log from "./log.js";
+
+export default class App extends Base {
+  constructor() {
+    super();
+    this.router = new Router(this.routes, this.conf);
+    this.Bundler = Bundler;
+  }
+
+  async run() {
+    log.reset("Primate").yellow(this.package.version);
+
+    const {index, hashes} = await new this.Bundler(this.conf).bundle();
+    const router = this.router;
+
+    const conf = {index, hashes, router,
+      "serve_from": this.conf.paths.public,
+      "http": {
+        "key": File.read_sync(resolve(this.conf.http.ssl.key)),
+        "cert": File.read_sync(resolve(this.conf.http.ssl.cert)),
+      },
+    };
+    this.static_server = new StaticServer(conf);
+    await this.static_server.run();
+
+    this.dynamic_server = new DynamicServer({router,
+      "path": this.base,
+      "server": this.static_server.server,
+    });
+    await this.dynamic_server.run();
+
+    const {port, host} = this.conf.http;
+    this.static_server.listen(port, host);
+  }
+}

package/source/server/Base.js

@@ -0,0 +1,35 @@
+import conf from "./conf.js";
+import log from "./log.js";
+import package_json from "../../package.json" assert {"type": "json" };
+
+const _conf = conf();
+let routes;
+try {
+  routes = await import(`${_conf.root}/routes.json`, {
+    "assert": {"type": "json"}
+  });
+} catch (error) {
+  // local routes.json not required
+}
+
+export default class Base {
+  static get conf() {
+    return _conf;
+  }
+
+  get conf() {
+    return this.Class().conf;
+  }
+
+  get package() {
+    return package_json;
+  }
+
+  get routes() {
+    return routes?.default ?? [];
+  }
+
+  Class() {
+    return this.constructor;
+  }
+}

package/source/server/Bundler.js

@@ -0,0 +1,180 @@
+import {dirname} from "path";
+import {fileURLToPath} from "url";
+import Directory from "./Directory.js";
+import File from "./File.js";
+import {algorithm, hash} from "./Crypto.js";
+
+const meta_url = fileURLToPath(import.meta.url);
+const directory = dirname(meta_url);
+const preset = `${directory}/../preset`;
+
+const ending = 3;
+
+const s_declarations = () =>
+  "// Declarations\n"
++ "const contexts = {};\n"
++ "const routes = {};\n\n";
+
+const stringify_action = (context, domain, action, i, j, k) => {
+  const import_name = `route{i}_${j}_${k}`;
+  return `import ${import_name} from "./${context}/${domain}/${action}.js";\n`
+  + `routes["${context}"]["${domain}"]["${action}"] = ${import_name};\n`;
+};
+
+const stringify_actions = ({context, domain, actions = []}, i, j) =>
+  actions.reduce((s, action, k) =>
+    s + stringify_action(context, domain, action, i, j, k), "");
+
+const stringify_domain = (domain, i, j) =>
+  `routes["${domain.context}"]["${domain.domain}"] = {};\n`
++ stringify_actions(domain, i, j);
+
+const stringify_domains = (domains, i) =>
+  domains.reduce((s, domain, j) => s + stringify_domain(domain, i, j), "");
+
+const stringify_context = (context, i) =>
+  `import context${i} from "./${context[0].context}/context.js";\n`
++ `contexts["${context[0].context}"] = context${i};\n`
++ `routes["${context[0].context}"] = {};\n`
++ stringify_domains(context, i) + "\n";
+
+const s_exports = () =>
+  "// Exports\n"
++ "export {contexts, routes};\n";
+
+const stringify = actions =>
+  actions.reduce((s, context, i) => s + stringify_context(context, i), "");
+
+export default class Bundler {
+  constructor(conf) {
+    this.conf = conf;
+    this.debug = conf.debug;
+    this.index = conf.files.index;
+    this.scripts = [];
+    this.hashes = new Set();
+  }
+
+  async copy_with_preset(subdirectory, to) {
+    const {paths} = this.conf;
+
+    // copy files preset files first
+    await File.copy(`${preset}/${subdirectory}`, to);
+
+    // copy any user code over it, not recreating the folder
+    try {
+      await File.copy(paths[subdirectory], to, false);
+    } catch(error) {
+      // directory doesn't exist
+    }
+  }
+
+  async bundle() {
+    const {paths} = this.conf;
+    const client_directory = `${paths.public}/client`;
+
+    // copy static files to public
+    await this.copy_with_preset("static", paths.public);
+
+    // copy client files to public/client
+    await this.copy_with_preset("client", client_directory);
+
+    const primate_js = new File(`${client_directory}/primate.js`);
+    await primate_js.write("export * from \"./primate/exports.js\";");
+
+    // write dynamic exports to public/client/exports.js
+    await this.write_exports();
+
+    // copy framework code to public/client/primate
+    await File.copy(`${directory}/../client`, `${client_directory}/primate`);
+
+    await this.register_scripts();
+
+    // 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}`);
+
+    const body = "return `"+index_html+"`";
+    const index = new Function("conf", "client", body)(this.conf, this.client);
+
+    return {index, "hashes": this.hashes};
+  }
+
+  async register_scripts() {
+    const {paths} = this.conf;
+
+    const scripts = await this.collect("client");
+    Promise.all(scripts.map(async script =>
+      this.register(script, await File.read(paths.public, script))
+    ));
+  }
+
+  async collect(path) {
+    // scan public/client and collect scripts to be added as tags
+    let scripts = [];
+    const files = await Directory.list(`${this.conf.paths.public}/${path}`);
+    for (const file of files) {
+      if (file.endsWith(".js")) {
+        scripts.push(`${path}/${file}`);
+      } else {
+        scripts = scripts.concat(await this.collect(`${path}/${file}`));
+      }
+    }
+
+    return scripts;
+  }
+
+  register(src, source) {
+    const integrity = `${algorithm}-${hash(source)}`;
+    this.scripts.push({"src": `${this.conf.base}${src}`, integrity});
+    this.hashes.add(integrity);
+  }
+
+  get public_client() {
+    return `${this.conf.paths.public}/client`;
+  }
+
+  get client() {
+    let client = "";
+    for (const {integrity, src} of this.scripts) {
+      client += `<script type="module" integrity="${integrity}" src="${src}">`
+              + "</script>\n";
+    }
+    return client + "<first-view />";
+  }
+
+  async write_exports() {
+    const exports = new File(this.public_client, "exports.js");
+
+    let export_string = s_declarations();
+    export_string += stringify(await this.read());
+    export_string += s_exports();
+
+    await exports.write(export_string);
+  }
+
+  async read() {
+    const path = this.public_client;
+
+    const contexts = (await Directory.list(path))
+      .filter(file => !file.endsWith(".js"))
+      .map(context => ({context}));
+
+    const context_domains = await Promise.all(contexts.map(async ({context}) =>
+      ({context, "domains": (await Directory.list(path, context))
+        .filter(file => !file.endsWith(".js"))
+        .map(domain => ({domain})),
+      })));
+
+    const actions = await Promise.all(context_domains
+      .map(({context, domains}) =>
+        Promise.all(domains.map(async ({domain}) => ({
+          context, domain,
+          "actions": (await Directory.list(path, context, domain))
+            .map(action => action.slice(0, -ending)),
+        })))));
+
+    return actions.length === 1 && actions[0].length === 0
+      ? [context_domains]
+      : actions;
+  }
+}

package/source/server/Context.js

@@ -0,0 +1,90 @@
+import Base from "./Base.js";
+import File from "./File.js";
+import View from "./view/View.js";
+import Action from "./Action.js";
+import {InternalServerError} from "./errors.js";
+import cache from "./cache.js";
+import {defined} from "./invariants.js";
+import fallback from "./fallback.js";
+import log from "./log.js";
+
+export default class Context extends Base {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+
+  log(color, message) {
+    log[color](this.name).reset(message).nl();
+  }
+
+  async errored(data, error, session) {
+    if (this.Class().error !== undefined) {
+      const action = new Action(data, session);
+      this.Class().error(action);
+      const response = await action.response;
+      if (data.pathname === response.location) {
+        throw new InternalServerError("redirect loop detected");
+      }
+      this.log("red", "handling error");
+      return response;
+    } else {
+      const {namespace, action} = data.path;
+      const route = `${namespace}/${action}`;
+      throw new InternalServerError(`${data.type} /${route} missing`);
+    }
+  }
+
+  static before(action) {
+    return action;
+  }
+
+  static prepare(action, data) {
+    return {action, data};
+  }
+
+  static get(name) {
+    return cache(this, name, async () => {
+      const exists = await File.exists(`${this.conf.paths.server}/${name}`);
+      if (!exists) {
+        throw new InternalServerError("missing context directory");
+      }
+      const path = `${this.conf.paths.server}/${name}/context.js`;
+      const context = await fallback(
+        async () => (await import(path)).default,
+        () => Context);
+      return new context(name);
+    });
+  }
+
+  get base_path() {
+    return `${this.conf.paths.server}/${this.name}`;
+  }
+
+  async view(path) {
+    const file = await new File(`${this.base_path}/${path}.html`).read();
+    return new View(path, file, await this.layouts());
+  }
+
+  layouts() {
+    return cache(this, "layouts", async () => {
+      const path = `${this.base_path}/layouts`;
+
+      const layouts = {};
+      for (const file of await new File(path).list()) {
+        layouts[file.slice(0, -5)] = await File.read(`${path}/${file}`);
+      }
+
+      return layouts;
+    });
+  }
+
+  async run(data, session) {
+    const {type = "read"} = data;
+    const action = await Action.load(data, session, this.name);
+    defined(action[type]);
+    await this.Class().before(action);
+    await action.run(type);
+    return action.response;
+  }
+}

package/source/server/Crypto.js

@@ -0,0 +1,8 @@
+import {createHash, randomBytes} from "crypto";
+
+export const algorithm = "sha256";
+
+export const hash = (payload, digest = "base64") =>
+  createHash(algorithm).update(payload, "utf8").digest(digest);
+
+export const random = length => randomBytes(length);

package/source/server/Directory.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+import {join} from "path";
+
+const options = {"encoding": "utf8"};
+
+const readdir = path => new Promise((resolve, reject) =>
+  fs.readdir(path, options,
+    (error, files) => error === null ? resolve(files) : reject(error)
+  ));
+
+const rm = path => new Promise((resolve, reject) =>
+  fs.rm(path, {"recursive": true, "force": true},
+    error => error === null ? resolve(true) : reject(error)
+  ));
+
+const mkdir = path => new Promise((resolve, reject) =>
+  fs.mkdir(path, error => error === null ? resolve(true) : reject(error)));
+
+export default class Directory {
+  static list(...args) {
+    return readdir(join(...args));
+  }
+
+  static remove(...args) {
+    return rm(join(...args));
+  }
+
+  static make(...args) {
+    return mkdir(join(...args));
+  }
+
+  static async remake(...args) {
+    await this.remove(...args) && this.make(...args);
+  }
+}