primate 0.3.1 → 0.5.1

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

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) {

package/source/server/domain/Field.js

@@ -1,28 +1,30 @@
-import * as types from "../types.js";
 import DomainType from "../types/Domain.js";
-import Storeable from "../types/Storeable.js";
+import Predicate from "./Predicate.js";
 import {PredicateError} from "../errors.js";
-import {defined, is_array, instances, is_constructible} from "../invariants.js";
+import Storeable from "../types/Storeable.js";
+import * as types from "../types.js";
+import cache from "../cache.js";
 import {constructible} from "../attributes.js";
+import {defined, is, maybe} from "../invariants.js";
 
 const builtins = Object.values(types).reduce((aggregate, Type) => {
   aggregate[Type.instance] = Type;
   return aggregate;
 }, {});
 
-const parse = field => constructible(field)
-  ? {"type": field}
-  : as_non_constructible(field);
+const as_array = field => ({"type": field[0], "predicates": field.slice(1)});
 
-const as_non_constructible =
-  field => typeof field === "function" ? as_function(field) : as_object(field);
+const as_object = field => field instanceof Array ? as_array(field) : field;
 
 const as_function = field => ({"in": field,
   "type": field(undefined, {}).constructor});
 
-const as_object = field => field instanceof Array ? as_array(field) : field;
+const as_non_constructible =
+  field => typeof field === "function" ? as_function(field) : as_object(field);
 
-const as_array = field => ({"type": field[0], "predicates": field.slice(1)});
+const parse = field => constructible(field)
+  ? {"type": field}
+  : as_non_constructible(field);
 
 export default class Field {
   constructor(property, definition, options) {
@@ -30,9 +32,9 @@ export default class Field {
     this.property = property;
     this.definition = parse(definition);
     this.options = options ?? {"transient": false, "optional": false};
-    is_constructible(this.definition.type);
-    instances(this.type.prototype, Storeable, "type must extend Storeable");
-    is_array(this.predicates);
+    is.constructible(this.Type);
+    is.subclass(this.type, Storeable);
+    maybe.array(this.definition.predicates);
   }
 
   static resolve(name) {
@@ -46,23 +48,30 @@ export default class Field {
   }
 
   get type() {
-    return builtins[this.definition.type] ?? this.custom;
+    return builtins[this.Type] ?? this.custom;
   }
 
   get custom() {
-    return this.is_domain ? DomainType : this.definition.type;
+    return this.is_domain ? DomainType : this.Type;
   }
 
   get is_domain() {
-    return this.definition.type.prototype instanceof DomainType.instance;
+    return this.Type.prototype instanceof DomainType.instance;
+  }
+
+  get Type() {
+    return this.definition.type;
   }
 
   get predicates() {
-    return this.definition.predicates ?? [];
+    return cache(this, "predicates", () => {
+      const predicates = this.definition.predicates ?? [];
+      return predicates.map(name => new Predicate(name));
+    });
   }
 
   by_id(id) {
-    return this.definition.type.by_id(id);
+    return this.Type.by_id(id);
   }
 
   in(property, document) {
@@ -71,24 +80,13 @@ export default class Field {
     return in_function !== undefined ? in_function(value, document) : value;
   }
 
-  override_predicates(document) {
-    return this.predicates.map(predicate => {
-      const [name, ...params] = predicate.split(":");
-      return document[name] !== undefined
-        ? {"function": document[name].bind(document), params}
-        : predicate;
-    });
-  }
-
   verify_undefined() {
     return this.options.optional ? true : "Must not be empty";
   }
 
-  async verify_defined(property, value, document) {
+  async verify_defined(property, document) {
     try {
-      const predicates = this.override_predicates(document);
-      document[property] = await this.type.verify(property, value, predicates,
-        this.definition.type);
+      await this.type.verify(property, document, this.predicates, this.Type);
       return true;
     } catch (error) {
       if (error instanceof PredicateError) {
@@ -99,17 +97,17 @@ export default class Field {
   }
 
   async verify(property, document) {
-    const value = await this.in(property, document);
-    return value === undefined
+    document[property] = await this.in(property, document);
+    return document[property] === undefined
       ? this.verify_undefined()
-      : this.verify_defined(property, value, document);
+      : this.verify_defined(property, document);
   }
 
   serialize(value) {
-    return value !== undefined ? this.type.serialize(value) : value;
+    return value === undefined ? undefined : this.type.serialize(value);
   }
 
   deserialize(value) {
-    return value !== undefined ? this.type.deserialize(value) : value;
+    return value === undefined ? undefined : this.type.deserialize(value);
   }
 }

package/source/server/domain/Predicate.js

@@ -0,0 +1,24 @@
+import Domain from "./Domain.js";
+import Storeable from "../types/Storeable.js";
+import {is} from "../invariants.js";
+
+export default class Predicate {
+  constructor(definition) {
+    is.string(definition);
+    const [name, ...params] = definition.split(":");
+    this.name = name;
+    this.params = params;
+  }
+
+  async check(property, document, Type) {
+    is.string(property);
+    is.instance(document, Domain);
+    const {name, params} = this;
+    if (document[name] === undefined) {
+      is.subclass(Type, Storeable);
+      await Type.has(name, document[property], params);
+    } else {
+      await document[name](property, ...params);
+    }
+  }
+}

package/source/server/domain/domains.js

@@ -1,9 +1,10 @@
 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.data.domains;
+const base = conf().paths.domains;
 
 for (const domain of await new File(base).list(".js")) {
   const name = domain.slice(0, -3);
@@ -12,4 +13,19 @@ for (const domain of await new File(base).list(".js")) {
   });
 }
 
+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;

package/source/server/errors/InternalServer.js

@@ -1 +1 @@
-export default class extends Error {}
+export default class InternalServerError extends Error {}

package/source/server/errors/Predicate.js

@@ -1 +1 @@
-export default class extends Error {}
+export default class PredicateError extends Error {}

package/source/server/errors.js

@@ -1,3 +1,2 @@
-export {default as FallbackError} from "./errors/Fallback.js";
 export {default as InternalServerError} from "./errors/InternalServer.js";
 export {default as PredicateError} from "./errors/Predicate.js";

package/source/server/exports.js

@@ -1,27 +1,28 @@
+import conf from "./conf.js";
+import App from "./App.js";
+
+export {App};
 export {default as Action} from "./Action.js";
 export {default as Bundler} from "./Bundler.js";
 export {default as Context} from "./Context.js";
 export {default as Directory} from "./Directory.js";
 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";
-export * from "./promises.js" ;
+export * from "./invariants.js";
 
 export {default as MemoryStore} from "./store/Memory.js";
 export {default as Store} from "./store/Store.js";
 
-export {assert, defined} from "./invariants.js";
 export {default as log} from "./log.js";
-export {default as extend_object} from "./utils/extend_object.js";
-export {default as fallback} from "./fallback.js";
-
-import App from "./App.js";
+export {default as extend_object} from "./extend_object.js";
+export {default as sanitize} from "./sanitize.js";
 
-const app = new App();
-const conf = app.conf;
+const app = new App(conf());
 
-export {app, conf};
+export {app};

package/source/server/invariants.js

@@ -1,19 +1,32 @@
-import {FallbackError} from "./errors.js";
-import {constructible} from "./attributes.js";
+import {constructible, nullish} from "./attributes.js";
 
 const errored = error => {
-  if (typeof error === "function") { // fallback
+  if (typeof error === "function") {
+    // fallback
     error();
-    throw new FallbackError();
-  } else { // error
+  } else {
+    // error
     throw new Error(error);
   }
 };
 
 const assert = (predicate, error) => Boolean(predicate) || errored(error);
-const defined = (value, error) => assert(value !== undefined, error);
-const is_array = value => assert(Array.isArray(value), "must be array");
-const instances = (sub, parent, error) => assert(sub instanceof parent, error);
-const is_constructible = (value, error) => assert(constructible(value), error);
+const is = {
+  "array": value => assert(Array.isArray(value), "must be array"),
+  "string": value => assert(typeof value === "string", "must be string"),
+  "defined": (value, error) => assert(value !== undefined, error),
+  "undefined": value => assert(value === undefined, "must be undefined"),
+  "constructible": (value, error) => assert(constructible(value), error),
+  "instance": (object, Class) => assert(object instanceof Class,
+    `must instance ${Class.name}`),
+  "subclass": (object, Class) => assert(object?.prototype instanceof Class,
+    `must subclass ${Class.name}`),
+};
+const {defined} = is;
+
+const maybe = Object.keys(is).reduce((aggregator, property) => {
+  aggregator[property] = value => nullish(value) || is[property](value);
+  return aggregator;
+}, {});
 
-export {assert, defined, is_array, instances, is_constructible};
+export {assert, defined, is, maybe};

package/source/server/sanitize.js

@@ -0,0 +1,10 @@
+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;
+  }, {});