primate 0.2.0 → 0.5.0

package/source/server/domain/Domain.js

@@ -1,29 +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 "../EagerPromise.js";
 import Store from "../store/Store.js";
-import {PredicateError, InternalServerError} from "../errors.js";
-import {EagerPromise} from "../promises.js";
-import {assert} from "../invariants.js";
 import cache from "../cache.js";
-import {random} from "../Crypto.js";
-import fallback from "../fallback.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() {
@@ -42,15 +47,9 @@ export default class Domain extends Base {
   }
 
   static get store() {
-    return cache(this, "store", async () => {
-      const logic = path => import(`${path}/${this.store_file}`);
-      const store = await fallback(this.conf.paths.data.stores, preset, logic);
-      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() {
@@ -95,18 +94,32 @@ 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.
-  serialize() {
+  async serialize() {
     const {properties, fields} = this;
-    return properties.map(property =>
-      ({property, "value": fields[property].serialize(this[property])}))
+    return (await Promise.all(properties.map(async property =>
+      ({property, "value": await fields[property].serialize(this[property])}))))
       .filter(({value}) => value !== undefined)
       .reduce((document, {property, value}) => {
         document[property] = value;
@@ -114,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;
@@ -136,6 +148,7 @@ export default class Domain extends Base {
   get collection() {
     return this.Class.collection;
   }
+
   get properties() {
     return this.Class.properties;
   }
@@ -169,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 = this.serialize();
-      await store.save(this.collection, {"_id": document._id}, document);
+      const document = await this.serialize();
+      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;
@@ -195,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));
     });
   }
@@ -228,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,6 +1,7 @@
 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;
@@ -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;
+  }, {});

package/source/server/servers/Dynamic.js

@@ -12,7 +12,8 @@ export default class DynamicServer extends Server {
   }
 
   async connected(socket, request) {
-    socket.session = await Session.get(request.headers.cookie);
+    const {context} = this.conf;
+    socket.session = await Session.get(request.headers.cookie, context);
     socket.on("message", event => this.try(socket, event));
     // inform client that we're connected and it can start sending messages
     socket.send("open");
@@ -20,31 +21,36 @@ export default class DynamicServer extends Server {
 
   async try(socket, event) {
     const {session} = socket;
-    const parsed = JSON.parse(event);
-    const url = parsed.pathname + (parsed.search ?? "");
+    const request = JSON.parse(event);
     try {
-      await this.onmessage(socket, parsed, url);
-      await session.log("green", `${parsed.type} ${url}`);
+      await this.serve(request, socket);
+      await session.log("green", `${request.type} ${request.url}`);
     } catch(error) {
       await session.log("red", error.message);
     }
   }
 
-  async onmessage(socket, parsed, url) {
+  async serve(request, socket) {
     const {router} = this.conf;
     const {session} = socket;
-    const {path, params} = await session.route(router, url);
-    const data = await session.run({...parsed, path, params});
-    return this[data.type]?.(socket, data) ?? socket.send(JSON.stringify(data));
+    const {path, params} = await session.route(router, request.url);
+    const response = await session.run({...request, path, params});
+    const {type} = response;
+    return this[type]?.(socket, response)
+      ?? DynamicServer.serve(socket, response);
   }
 
-  redirect(socket, data) {
-    if (data.location.startsWith("https://")) {
+  static serve(socket, response) {
+    socket.send(JSON.stringify(response));
+  }
+
+  redirect(socket, {location}) {
+    if (location.startsWith("https://")) {
       // redirect externally
       return undefined;
     } else {
-      const pathname = data.location;
-      this.try(socket, JSON.stringify({pathname, "type": "read"}));
+      const url = location;
+      this.try(socket, JSON.stringify({"pathname": url, url, "type": "read"}));
       return true;
     }
   }

package/source/server/servers/Server.js

@@ -1,4 +1,4 @@
-export default class StaticServer {
+export default class Server {
   constructor(conf) {
     this.conf = conf;
   }

package/source/server/servers/Static.js

@@ -6,7 +6,8 @@ import {parse} from "url";
 import Server from "./Server.js";
 import Session from "../Session.js";
 import File from "../File.js";
-import {algorithm, hash} from "../Crypto.js";
+import {algorithm, hash} from "../crypto.js";
+import {assert} from "../invariants.js";
 import log from "../log.js";
 import codes from "./http-codes.json" assert {"type": "json"};
 import mimes from "./mimes.json" assert {"type": "json"};
@@ -28,46 +29,50 @@ const stream = (from, response) => {
 
 export default class StaticServer extends Server {
   async run() {
-    const {http} = this.conf;
+    const {http, context} = this.conf;
 
     this.server = await createServer(http, async (request, response) => {
-      const session = await Session.get(request.headers.cookie);
+      const session = await Session.get(request.headers.cookie, context);
       if (!session.has_cookie) {
         response.setHeader("Set-Cookie", session.cookie);
       }
+      response.session = session;
       request.on("end", () =>
-        this.try(parse(request.url).path, session, request, response)
+        this.try(parse(request.url).path, request, response)
       ).resume();
     });
   }
 
-  async try(url, session, request, response) {
+  async try(url, request, response) {
     try {
-      await this.serve(url, session, request, response);
+      await this.serve(url, request, response);
     } catch (error) {
-      await session.log("red", error.message);
+      await response.session.log("red", error.message);
       response.writeHead(codes.InternalServerError);
       response.end();
     }
   }
 
-  async serve(url, session, request, response) {
+  async serve_file(url, filename, file, response) {
+    response.setHeader("Content-Type", mime(filename));
+    response.setHeader("Etag", file.modified);
+    await response.session.log("green", url);
+    return stream(file.read_stream, response);
+  }
+
+  async serve(url, request, response) {
     const filename = join(this.conf.serve_from, url);
     const file = await new File(filename);
-    if (file.is_file) {
-      response.setHeader("Content-Type", mime(filename));
-      response.setHeader("Etag", file.modified);
-      await session.log("green", url);
-      return stream(file.stream, response);
-    } else {
-      return this.serve_data(url, session, request, response);
-    }
+    return await file.is_file
+      ? this.serve_file(url, filename, file, response)
+      : this.serve_data(url, request, response);
   }
 
-  async serve_data(pathname, session, request, response) {
+  async serve_data(pathname, request, response) {
+    const {session} = response;
     const {path, params} = await session.route(this.conf.router, pathname);
     await session.log("green", `read ${pathname}`);
-    const data = await session.run({path, params, pathname});
+    const data = await session.run({path, params, pathname, "url": pathname});
     const handler = StaticServer[data.type] ?? this.index.bind(this);
     return handler(data, response);
   }
@@ -75,11 +80,11 @@ export default class StaticServer extends Server {
   index(data, response) {
     const {hashes, index} = this.conf;
     const src = "import {app} from './client/primate.js';"
-      + `app.client.execute(${JSON.stringify(data)});`;
+      + `app.client.session.run(${JSON.stringify(data)});`;
     const integrity = `${algorithm}-${hash(src)}`;
     const view = `<script type="module" integrity="${integrity}">${src}`
                + "</script>";
-    const file = new Function("view", "return `"+index+"`")(view);
+    const file = index.replace("<first-view />", () => view);
     const script_src = Array.from(hashes)
       .concat([integrity])
       .reduce((hash_string, next_hash) => hash_string + ` '${next_hash}'`, "");

package/source/server/servers/content-security-policy.json

@@ -1,7 +1,6 @@
 {
   "default-src": "'self'",
   "object-src": "'none'",
-  "img-src": "'self' https:",
   "frame-ancestors": "'none'",
   "form-action": "'self'",
   "base-uri": "'self'"