primate 0.2.0 → 0.5.0

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 + "${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,10 +31,14 @@ export default class File {
     return this.exists && !this.stats.isDirectory();
   }
 
-  get stream() {
+  get read_stream() {
     return fs.createReadStream(this.path, {"flags": "r"});
   }
 
+  get write_stream() {
+    return fs.createWriteStream(this.path);
+  }
+
   remove() {
     return new Promise((resolve, reject) => fs.rm(this.path,
       {"recursive": true, "force": true},

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(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)},
     };
   }
 }

package/source/server/Session.js

@@ -1,47 +1,37 @@
 import Context from "./Context.js";
 import Domain from "./domain/Domain.js";
-import {FallbackError, InternalServerError} from "./errors.js";
 
-const extract_id = cookie_header => cookie_header === undefined
-  ? undefined
-  : cookie_header
-    .split(";")
-    .filter(cookie => cookie.includes("session_id="))[0]
-    ?.split("=")[1];
+const extract_id = cookie_header => cookie_header
+  ?.split(";").filter(text => text.includes("session_id="))[0]?.split("=")[1];
 
 export default class Session extends Domain {
   static get fields() {
-    const default_context = this.conf.defaults.context;
     return {
       "?data": Object,
-      "context" : value => value ?? default_context,
+      "context" : String,
       "created": value => value ?? new Date(),
     };
   }
 
   async log(color, message) {
-    (await this.actual_context).log(color, message);
+    (await Context.get(this.context)).log(color, message);
   }
 
   route(router, url) {
     return router.route(url, this.context);
   }
 
-  get actual_context() {
-    return Context.get(this.context);
-  }
-
-  static async get(cookie_header) {
+  static async get(cookie_header, default_context) {
     const session = await Session.touch({"_id": extract_id(cookie_header)});
     if (session.new) {
-      await session.save();
+      await session.save({"context": default_context});
       session.has_cookie = false;
     }
     return session;
   }
 
   get cookie() {
-    return `session_id=${this._id}; Secure; HttpOnly; Path=/`;
+    return `session_id=${this._id}; Secure; SameSite=Strict; HttpOnly; Path=/`;
   }
 
   async switch_context(context, data = {}) {
@@ -49,21 +39,7 @@ export default class Session extends Domain {
     return this;
   }
 
-  async run(data) {
-    let response, context;
-    try {
-      context = await this.actual_context;
-      response = await context.run(data, this);
-    } catch (error) {
-      if (error instanceof FallbackError) {
-        // do nothing
-      } else if (error instanceof InternalServerError) {
-        // cannot proceed, throw up
-        throw error;
-      } else {
-        return context.errored(data, error, this);
-      }
-    }
-    return response;
+  async run(request) {
+    return (await Context.get(this.context)).run(request, this);
   }
 }

package/source/server/attributes.js

@@ -7,5 +7,8 @@ export const constructible = value => {
   }
 };
 
+export const inconstructible_function = value =>
+  typeof value === "function" && !constructible(value);
 export const numeric = value => !isNaN(parseFloat(value)) && isFinite(value);
 export const boolish = value => value === "true" || value === "false";
+export const nullish = value => value === undefined || value === null;

package/source/server/conf.js

@@ -1,33 +1,27 @@
 import {join, resolve} from "path";
-import log from "./log.js";
 import cache from "./cache.js";
 import File from "./File.js";
-import extend_object from "./utils/extend_object.js";
+import extend_object from "./extend_object.js";
 import primate_json from "../preset/primate.json" assert {"type": "json" };
 
-const qualify = (root, paths) => {
-  const object = {};
-  for (const key in paths) {
+const qualify = (root, paths) =>
+  Object.keys(paths).reduce((sofar, key) => {
     const value = paths[key];
-    if (typeof value === "string") {
-      object[key] = join(root, value);
-    } else {
-      object[key] = qualify(`${root}/${key}`, value);
-    }
-  }
-  return object;
-}
+    sofar[key] = typeof value === "string"
+      ? join(root, value)
+      : qualify(`${root}/${key}`, value);
+    return sofar;
+  }, {});
 
-export default (file = "primate.json") =>
-  cache("conf", file, () => {
-    const root = resolve();
-    let conf = primate_json;
-    try {
-      conf = extend_object(conf, JSON.parse(File.read_sync(join(root, file))));
-    } catch (error) {
-      // local primate.json not required
-    }
-    conf.paths = qualify(root, conf.paths);
-    conf.root = root;
-    return conf
-  });
+export default (file = "primate.json") => cache("conf", file, () => {
+  let conf = primate_json;
+  const root = resolve();
+  try {
+    conf = extend_object(conf, JSON.parse(File.read_sync(join(root, file))));
+  } catch (error) {
+    // local primate.json not required
+  }
+  conf.paths = qualify(root, conf.paths);
+  conf.root = root;
+  return conf;
+});