primate 0.3.1 → 0.4.0

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, defined} 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,76 @@ 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);
+      defined(action[type]);
+      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,3 +1,5 @@
+import {inconstructible_function} from "./attributes.js";
+
 const $promise = Symbol("#promise");
 
 const handler = {
@@ -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];
 

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)[0];
+      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_cache(fields[key], key, document, projection)
+      : this.by_store(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)[0];
+        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(route) {
+    return (await Promise.all(Object.keys(this.documents).map(async key => {
+      const resolved = this.projection[key] !== undefined
+        ? await this.resolve(this.documents[key], this.projection[key])
+        : undefined;
+      return {key, resolved};
+    }))).reduce((projected, {key, resolved}) => {
+      if (resolved !== undefined) {
+        projected[key] = resolved;
+      } else {
+        log.yellow(`  \`${key}\` not projected`).nl();
+      }
+      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) {
@@ -27,7 +26,7 @@ export default class Router {
     const route = this.route_by_context(context, path);
     if (route !== undefined) {
       const replace = path.replace(route.from, route.to);
-      return `${replace}${replace.includes("?") ? "&" : "?&"}${search}`;
+      return `${replace}${replace.includes("?") ? "" : "?"}&${search}`;
     } else {
       return pathname;
     }
@@ -43,14 +42,13 @@ export default class Router {
     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;
     return {
       "pathname": url.pathname,
       "resolved": resolved,
       "parts": parts,
       "path": {
-        "namespace": parts[0] ?? namespace,
-        "action": parts[1] ?? action,
+        "namespace": parts[0],
+        "action": parts[1],
         "_id": parts[2],
       },
       "params": {

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,7 @@ 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";

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;
+});

package/source/server/domain/Domain.js

@@ -1,26 +1,34 @@
-import Base from "../Base.js";
+import {resolve as path_resolve} from "path";
 import Field from "./Field.js";
 import {PredicateError} from "../errors.js";
-import {EagerPromise} from "../promises.js";
+import EagerPromise from "../EagerPromise.js";
+import Store from "../store/Store.js";
 import cache from "../cache.js";
-import {random} from "../Crypto.js";
+import DomainType from "../types/Domain.js";
+import {random} from "../crypto.js";
 
 const length = 12;
-const preset = "../../preset/data/stores";
 
-const get = (target, property, receiver) =>
-  Reflect.get(target, property, receiver) ?? receiver.as_foreign(property);
+export default class Domain {
+  static stores_directory = "data/stores";
+  static store_file = "default.js";
 
-export default class Domain extends Base {
-  constructor(document) {
-    super();
+  static {
+    // avoid transitive cyclic dependency between Domain and Field
+    DomainType.instance = Domain;
+    this.cache = {};
+  }
 
+  constructor(document) {
     const errors = {};
-    return new Proxy(this, {get}).set({...document, errors}).define("_id", {
+    this.define("_id", {
       "type": String,
       "predicates": ["unique"],
       "in": value => value ?? random(length).toString("hex"),
     });
+    return new Proxy(this, {"get": (target, property, receiver) =>
+      Reflect.get(target, property, receiver) ?? target.#proxy(property)
+    }).set({...document, errors})
   }
 
   get Class() {
@@ -39,20 +47,9 @@ export default class Domain extends Base {
   }
 
   static get store() {
-    return cache(this, "store", async () => {
-      const create_path = path => `${path}/${this.store_file}`;
-      let store;
-      try {
-        store = await import(create_path(this.conf.paths.data.stores));
-      } catch(error) {
-        store = await import(create_path(preset));
-      }
-      return store.default.open();
-    });
-  }
-
-  static get store_file() {
-    return this.conf.defaults.store;
+    return EagerPromise.resolve(cache(this, "store", async () =>
+      Store.get(this.stores_directory, this.store_file)
+    ));
   }
 
   static get collection() {
@@ -97,13 +94,27 @@ export default class Domain extends Base {
     return Object.assign(this, document);
   }
 
-  // #as_foreign
-  as_foreign(name) {
+  #proxy(property) {
+    return typeof property === "string" ? this.#link(property) : this[property];
+  }
+
+  #link(name) {
     const field = this.fields[`${name}_id`];
-    return field?.is_domain ? field.by_id(this[`${name}_id`]) : undefined;
+    if (field?.is_domain) {
+      const collection = field.Type.collection;
+      const cache = this.Class.cache;
+      if (cache[collection] === undefined) {
+        cache[collection] = {};
+      }
+      if (cache[collection][this[`${name}_id`]] === undefined) {
+        cache[collection][this[`${name}_id`]] = field.by_id(this[`${name}_id`]);
+      }
+      return cache[collection][this[`${name}_id`]];
+    } else {
+      return undefined
+    }
   }
 
-  // #serialize
   // Serializing is done from the instance's point of view.
   async serialize() {
     const {properties, fields} = this;
@@ -116,7 +127,6 @@ export default class Domain extends Base {
       }, {});
   }
 
-  // #deserialize
   // Deserializing is done from the class's point of view.
   static deserialize(serialized) {
     const fields = this._fields;
@@ -138,6 +148,7 @@ export default class Domain extends Base {
   get collection() {
     return this.Class.collection;
   }
+
   get properties() {
     return this.Class.properties;
   }
@@ -171,9 +182,12 @@ export default class Domain extends Base {
   async savewith(delta, after = () => undefined) {
     const verified = await this.verify(delta);
     if (verified) {
-      const store = await this.store;
       const document = await this.serialize();
-      await store.save(this.collection, {"_id": document._id}, document);
+      await this.store.save(this.collection, {"_id": document._id}, document);
+      const cache = this.Class.cache;
+      if (cache[this.collection]?.[document._id] !== undefined) {
+        delete cache[this.collection][document._id];
+      }
       await after();
     }
     return verified;
@@ -197,26 +211,24 @@ export default class Domain extends Base {
     return this;
   }
 
-  async delete() {
-    const store = await this.store;
-    return store.delete(this.collection, {"_id": this._id});
+  delete() {
+    return this.store.delete(this.collection, {"_id": this._id});
   }
 
-  static async delete(criteria) {
-    const store = await this.store;
-    return store.delete(this.collection, criteria);
+  static delete(criteria) {
+    return this.store.delete(this.collection, criteria);
   }
 
   static by_id(_id) {
     return new EagerPromise(async resolve => {
-      const result = await (await this.store).one(this.collection, _id);
-      resolve(result === undefined ? undefined : this.deserialize(result));
+      const result = await this.store.find(this.collection, {"_id": await _id});
+      resolve(result.length > 0 ? this.deserialize(result[0]) : undefined);
     });
   }
 
-  static first(criteria) {
+  static first(criteria, options) {
     return new EagerPromise(async resolve => {
-      const result = await (await this.store).one(this.collection, criteria);
+      const result = await this.store.one(this.collection, criteria, options);
       resolve(result === undefined ? undefined : this.deserialize(result));
     });
   }
@@ -230,14 +242,12 @@ export default class Domain extends Base {
   }
 
   static async find(criteria, options) {
-    const store = await this.store;
-    const results = await store.find(this.collection, criteria, options);
+    const results = await this.store.find(this.collection, criteria, options);
     return results.map(result => this.deserialize(result));
   }
 
-  static async count(criteria) {
-    const store = await this.store;
-    return store.count(this.collection, criteria);
+  static count(criteria) {
+    return this.store.count(this.collection, criteria);
   }
 
   static async exists(criteria) {