primate 0.3.1 → 0.5.1

package/source/server/Action.js

@@ -1,118 +1,100 @@
-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;
+import {resolve} from "path";
+import {default as EagerPromise, eager} from "./EagerPromise.js";
+import View from "./view/View.js";
+import Projector from "./Projector.js";
+import {InternalServerError} from "./errors.js";
+import {assert, defined} from "./invariants.js";
+import sanitize from "./sanitize.js";
+
+export default class Action {
+  static action = "index";
+  static namespace = "default";
+  static layout = "default";
+
+  constructor(request, session, context) {
+    this.request = request;
     this.session = session;
+    this.context = EagerPromise.resolve(context);
   }
 
-  static get layout() {
-    return "default";
-  }
-
-  static async load(data, session, context) {
-    let module;
-    const server = this.conf.paths.server;
-    const {namespace, action} = data.path;
+  static async new(request, session, context) {
+    const {namespace = this.namespace, action = this.action} = request.path;
+    assert(!namespace.includes("."), () => {
+      throw new InternalServerError("namespace may not include a dot");
+    });
     const route = `${namespace}/${action}`;
+    const path = resolve(`${context.directory}/${route}.js`);
     try {
-      module = (await import(`${server}/${context}/${route}.js`)).default;
+      const {"default": UserAction} = await import(path);
+      return new UserAction(request, session, context);
     } catch (error) {
-      throw new Error(`route '${route}' missing`);
+      throw new Error(`route \`${route}\` missing`);
     }
-    return new module(data, session);
+  }
+
+  get Class() {
+    return this.constructor;
   }
 
   get layout() {
-    return this.Class().layout;
+    return this.Class.layout;
   }
 
   get path() {
-    return this._data.path;
+    const {path} = this.request;
+    const namespace = path.namespace ?? this.Class.namespace;
+    const action = path.action ?? this.Class.action;
+    const {_id} = path;
+    return {action, namespace, _id};
   }
 
   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;}, {});
+    return this.request.params;
   }
 
   async run(type) {
+    defined(this[type]);
     this.before && await this.before();
-    await this[type](this.Class().sanitize(this._data.payload));
+    await this[type](sanitize(this.request.payload));
   }
 
-  get response() {
-    return this[_response]();
-  }
-
-  return(data = {}) {
-    this.respond("return", () => ({"payload": data}));
+  return(payload = {}) {
+    this.respond("return", () => ({payload}));
   }
 
   view(data = {}, layout = true) {
     this.respond("view", async () => {
-      const _view = await this._view();
-      const payload = await this.prepare(data, _view);
+      const {_view, payload} = await this.prepare(data);
       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};
-    });
+    this.respond("update", async () =>
+      ({"payload": (await this.prepare(data)).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));
+  async prepare(data = {}) {
+    const route = `${this.path.namespace}/${this.path.action}`;
+    const path = await eager`${this.context.directory}/${route}`;
+    const _view = await View.new(path, await this.context.layouts);
+    await this.context.Class.prepare(this, data);
+    const payload = await new Projector(data,
+      await _view.elements(this.layout)).project(route);
+    return {payload, _view};
   }
 
-  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;
+  respond(type, how) {
+    this.response = async () => {
+      const context = await this.context.name;
+      const {url} = this.request;
+      return {...await how(), type, context, ...this.path, url};
     };
   }
 }

package/source/server/App.js

@@ -1,24 +1,37 @@
 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 cache from "./cache.js";
 import log from "./log.js";
+import package_json from "../../package.json" assert {"type": "json"};
 
-export default class App extends Base {
-  constructor() {
-    super();
-    this.router = new Router(this.routes, this.conf);
+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() {
-    log.reset("Primate").yellow(this.package.version);
+    log.reset("Primate").yellow(package_json.version);
 
+    this.router = new Router(await this.routes, this.conf);
     const {index, hashes} = await new this.Bundler(this.conf).bundle();
-    const router = this.router;
+    const {router} = this;
 
     const conf = {index, hashes, router,
       "serve_from": this.conf.paths.public,
@@ -26,17 +39,23 @@ export default class App extends Base {
         "key": File.read_sync(resolve(this.conf.http.ssl.key)),
         "cert": File.read_sync(resolve(this.conf.http.ssl.cert)),
       },
+      "context": this.conf.defaults.context,
     };
     this.static_server = new StaticServer(conf);
     await this.static_server.run();
 
     this.dynamic_server = new DynamicServer({router,
-      "path": this.base,
+      "path": this.conf.base,
       "server": this.static_server.server,
+      "context": this.conf.defaults.context,
     });
     await this.dynamic_server.run();
 
     const {port, host} = this.conf.http;
     this.static_server.listen(port, host);
   }
+
+  stop() {
+    this.static_server.close();
+  }
 }

package/source/server/Bundler.js

@@ -2,7 +2,7 @@ import {dirname} from "path";
 import {fileURLToPath} from "url";
 import Directory from "./Directory.js";
 import File from "./File.js";
-import {algorithm, hash} from "./Crypto.js";
+import {algorithm, hash} from "./crypto.js";
 
 const meta_url = fileURLToPath(import.meta.url);
 const directory = dirname(meta_url);
@@ -25,17 +25,18 @@ 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`
+const stringify_domain = (context, domain, i, j) =>
+  `routes["${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_domains = ({context, domains}, i) =>
+  domains.reduce((s, domain, j) =>
+    s + stringify_domain(context, 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`
+  `import context${i} from "./${context.context}/context.js";\n`
++ `contexts["${context.context}"] = context${i};\n`
++ `routes["${context.context}"] = {};\n`
 + stringify_domains(context, i) + "\n";
 
 const s_exports = () =>
@@ -93,18 +94,16 @@ export default class Bundler {
     const index_html = await File.read(`${paths.public}/${this.index}`);
     await File.remove(`${paths.public}/${this.index}`);
 
-    const body = "return `"+index_html+"`";
+    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))
+      this.register(script, await File.read(this.conf.paths.public, script))
     ));
   }
 
@@ -139,7 +138,7 @@ export default class Bundler {
       client += `<script type="module" integrity="${integrity}" src="${src}">`
               + "</script>\n";
     }
-    return client + "<first-view />";
+    return `${client}<first-view />`;
   }
 
   async write_exports() {
@@ -173,8 +172,6 @@ export default class Bundler {
             .map(action => action.slice(0, -ending)),
         })))));
 
-    return actions.length === 1 && actions[0].length === 0
-      ? [context_domains]
-      : actions;
+    return context_domains;
   }
 }

package/source/server/Context.js

@@ -1,40 +1,18 @@
-import Base from "./Base.js";
+import {resolve} from "path";
 import File from "./File.js";
-import View from "./view/View.js";
 import Action from "./Action.js";
 import {InternalServerError} from "./errors.js";
+import {assert} from "./invariants.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 {
+export default class Context {
+  static directory = "server";
+
   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;
   }
@@ -45,46 +23,75 @@ export default class Context extends Base {
 
   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 directory = resolve(`${this.directory}/${name}`);
+      assert(await File.exists(directory), () => {
+        throw new InternalServerError(`missing context directory \`${name}\``);
+      });
+      try {
+        return new (await import(`${directory}/context.js`)).default(name);
+      } catch (error) {
+        return new this(name);
       }
-      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}`;
+  get Class() {
+    return this.constructor;
   }
 
-  async view(path) {
-    const file = await new File(`${this.base_path}/${path}.html`).read();
-    return new View(path, file, await this.layouts());
+  get directory() {
+    return `${this.Class.directory}/${this.name}`;
   }
 
-  layouts() {
-    return cache(this, "layouts", async () => {
-      const path = `${this.base_path}/layouts`;
+  get layouts() {
+    return cache(this, "layouts", () => {
+      const ending = -5;
+      const path = `${this.directory}/layouts`;
 
-      const layouts = {};
-      for (const file of await new File(path).list()) {
-        layouts[file.slice(0, -5)] = await File.read(`${path}/${file}`);
-      }
-
-      return layouts;
+      return new File(path).list().reduce(async (sofar, file) => {
+        const layouts = await sofar;
+        layouts[file.slice(0, ending)] = 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;
+  log(color, message) {
+    log[color](this.name).reset(message).nl();
+  }
+
+  async handle(error, action) {
+    if (this.Class.error !== undefined) {
+      this.Class.error(action);
+      const response = await action.response();
+      assert(action.request.pathname !== response.location, () => {
+        throw new InternalServerError("redirect loop detected");
+      });
+      this.log("red", "handling error with context error handler");
+      return response;
+    } else {
+      throw new InternalServerError(error.message);
+    }
+  }
+
+  catch(error, action) {
+    if (error instanceof InternalServerError) {
+      // cannot proceed, throw up
+      throw error;
+    } else {
+      return this.handle(error, action);
+    }
+  }
+
+  async run(request, session) {
+    const {type = "read"} = request;
+    try {
+      const action = await Action.new(request, session, this);
+      await this.Class.before(action);
+      await action.run(type);
+      return action.response();
+    } catch(error) {
+      return this.catch(error, new Action(request, session, this));
+    }
   }
 }

package/source/server/{promises/Eager.js → EagerPromise.js}

@@ -1,7 +1,9 @@
+import {inconstructible_function} from "./attributes.js";
+
 const $promise = Symbol("#promise");
 
 const handler = {
-  "get": function(target, property) {
+  "get": (target, property) => {
     const promise = target[$promise];
 
     if (["then", "catch"].includes(property)) {
@@ -12,7 +14,7 @@ const handler = {
       if (property === "bind") {
         return result;
       }
-      return typeof result[property] === "function"
+      return inconstructible_function(result[property])
         ? result[property].bind(result)
         : result[property];
     }));

package/source/server/File.js

@@ -1,7 +1,7 @@
 import fs from "fs";
 import {join} from "path";
 import Directory from "./Directory.js";
-import EagerPromise from "./promises/Eager.js";
+import EagerPromise from "./EagerPromise.js";
 
 const array = maybe => Array.isArray(maybe) ? maybe : [maybe];
 
@@ -31,6 +31,10 @@ export default class File {
     return this.exists && !this.stats.isDirectory();
   }
 
+  get stream() {
+    return this.read_stream;
+  }
+
   get read_stream() {
     return fs.createReadStream(this.path, {"flags": "r"});
   }

package/source/server/Projector.js

@@ -0,0 +1,86 @@
+import Domain from "./domain/Domain.js";
+import {actuals} from "./domain/domains.js";
+import log from "./log.js";
+
+const scalar = async (document, property) => {
+  const value = await document[property];
+  return value instanceof Domain ? {} : value;
+};
+
+export default class Projector {
+  constructor(documents, projection = []) {
+    this.cache = {};
+    for (const actual in actuals) {
+      this.cache[actual] = {};
+    }
+    this.documents = documents;
+    this.projection = projection.reduce((sofar, domain) => {
+      const [key] = Object.keys(domain);
+      sofar[key] = domain[key];
+      return sofar;
+    }, {});
+  }
+
+  many(documents, projection) {
+    return Promise.all(documents.map(d => this.resolve(d, projection)));
+  }
+
+  async by_store(key, document, projection) {
+    return this.resolve(await document[key], projection[key]);
+  }
+
+  async by_cache(space, key, document, projection) {
+    const cache = this.cache[space];
+    const key_id = document[`${key}_id`];
+    if (cache[key_id] === undefined) {
+      cache[key_id] = await this.by_store(key, document, projection);
+    }
+    return cache[key_id];
+  }
+
+  object(document, projection, key, fields) {
+    return fields?.[key] === undefined
+      ? this.by_store(key, document, projection)
+      : this.by_cache(fields[key], key, document, projection);
+  }
+
+  async one(document, projection) {
+    if (document === undefined) {
+      return undefined;
+    }
+    const resolved = {};
+    let fields = undefined;
+    if (document instanceof Domain && document.Class.name !== "default") {
+      fields = actuals[document.Class.name];
+    }
+    for (const property of projection) {
+      if (typeof property === "string") {
+        resolved[property] = await scalar(document, property);
+      } else if (typeof property === "object") {
+        const [key] = Object.keys(property);
+        resolved[key] = await this.object(document, property, key, fields);
+      }
+    }
+    return resolved;
+  }
+
+  resolve(document, projection) {
+    return this[Array.isArray(document) ? "many" : "one"](document, projection);
+  }
+
+  async project() {
+    return (await Promise.all(Object.keys(this.documents).map(async key => {
+      const resolved = this.projection[key] === undefined
+        ? undefined
+        : await this.resolve(await this.documents[key], this.projection[key]);
+      return {key, resolved};
+    }))).reduce((projected, {key, resolved}) => {
+      if (resolved === undefined) {
+        log.yellow(`  \`${key}\` not projected`).nl();
+      } else {
+        projected[key] = resolved;
+      }
+      return projected;
+    }, {});
+  }
+}

package/source/server/Router.js

@@ -2,11 +2,10 @@ export default class Router {
   constructor(routes = [], conf) {
     this.conf = conf;
     this.routes = {};
-    routes.forEach(({from, to, contexts}) =>
-      contexts.forEach(context => {
-        this.routes[context] = this.routes[context] ?? [];
-        this.routes[context].push({"from": new RegExp("^"+from+"$", "u"), to});
-      }));
+    routes.forEach(({from, to, contexts}) => contexts.forEach(context => {
+      this.routes[context] = this.routes[context] ?? [];
+      this.routes[context].push({"from": new RegExp(`^${from}$`, "u"), to});
+    }));
   }
 
   context(context) {
@@ -25,37 +24,29 @@ export default class Router {
     const [path, search = ""] = pathname.split("?");
 
     const route = this.route_by_context(context, path);
-    if (route !== undefined) {
-      const replace = path.replace(route.from, route.to);
-      return `${replace}${replace.includes("?") ? "&" : "?&"}${search}`;
-    } else {
+    if (route === undefined) {
       return pathname;
     }
+
+    const replace = path.replace(route.from, route.to);
+    return `${replace}${replace.includes("?") ? "" : "?"}&${search}`;
   }
 
   resolve(pathname, context) {
-    return this.context(context) !== undefined
-      ? this.resolve_by_context(pathname, context)
-      : pathname;
+    return this.context(context) === undefined
+      ? pathname
+      : this.resolve_by_context(pathname, context);
   }
 
   async route(pathname, context) {
     const resolved = await this.resolve(this.debase(pathname), context);
     const url = new URL(`https://primatejs.com/${resolved}`);
     const parts = url.pathname.split("/").filter(part => part !== "");
-    const {namespace, action} = this.conf.defaults;
+    const [namespace, action, _id] = parts;
     return {
-      "pathname": url.pathname,
-      "resolved": resolved,
-      "parts": parts,
-      "path": {
-        "namespace": parts[0] ?? namespace,
-        "action": parts[1] ?? action,
-        "_id": parts[2],
-      },
-      "params": {
-        ...Object.fromEntries(url.searchParams),
-      },
+      "pathname": url.pathname, resolved, parts,
+      "path": {namespace, action, _id},
+      "params": {...Object.fromEntries(url.searchParams)},
     };
   }
 }