primate 0.1.1 → 0.4.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,22 +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);
-
-      const instance = store.default;
-
-      const message = `${instance.constructor.name} must instance Store`;
-      const error = () => { throw new InternalServerError(message); };
-      assert(instance instanceof Store, error);
-
-      return instance.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() {
@@ -102,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;
@@ -121,12 +127,11 @@ export default class Domain extends Base {
       }, {});
   }
 
-  // #deserialize
   // Deserializing is done from the class's point of view.
   static deserialize(serialized) {
     const fields = this._fields;
     return new this(Object.keys(serialized)
-      //.filter(property => fields[property] !== undefined)
+      .filter(property => fields[property] !== undefined)
       .map(property =>
         ({property,
         "value": fields[property].deserialize(serialized[property])}))
@@ -143,6 +148,7 @@ export default class Domain extends Base {
   get collection() {
     return this.Class.collection;
   }
+
   get properties() {
     return this.Class.properties;
   }
@@ -176,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;
@@ -202,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));
     });
   }
@@ -235,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

@@ -30,7 +30,7 @@ export default class Field {
     this.property = property;
     this.definition = parse(definition);
     this.options = options ?? {"transient": false, "optional": false};
-    is_constructible(this.definition.type);
+    is_constructible(this.Type);
     instances(this.type.prototype, Storeable, "type must extend Storeable");
     is_array(this.predicates);
   }
@@ -46,15 +46,19 @@ 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() {
@@ -62,7 +66,7 @@ export default class Field {
   }
 
   by_id(id) {
-    return this.definition.type.by_id(id);
+    return this.Type.by_id(id);
   }
 
   in(property, document) {
@@ -84,11 +88,10 @@ export default class Field {
     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, predicates, this.Type);
       return true;
     } catch (error) {
       if (error instanceof PredicateError) {
@@ -99,17 +102,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/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.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 {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,10 +1,8 @@
-import {FallbackError} from "./errors.js";
 import {constructible} from "./attributes.js";
 
 const errored = error => {
   if (typeof error === "function") { // fallback
     error();
-    throw new FallbackError();
   } else { // error
     throw new Error(error);
   }

package/source/server/sanitize.js

@@ -0,0 +1,5 @@
+export default (payload = {}) => Object.keys(payload)
+  .map(key => ({key, "value": payload[key].toString().trim()}))
+  .map(datum => { datum.value = datum.value !== "" ? datum.value : undefined;
+    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.onmessage(request, socket);
+      await session.log("green", `${request.type} ${request.url}`);
     } catch(error) {
       await session.log("red", error.message);
     }
   }
 
-  async onmessage(socket, parsed, url) {
+  async onmessage(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.send(socket, response);
   }
 
-  redirect(socket, data) {
-    if (data.location.startsWith("https://")) {
+  static send(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/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,8 +1,6 @@
 {
   "default-src": "'self'",
   "object-src": "'none'",
-  "style-src": "'self'",
-  "img-src": "'self' data: https:",
   "frame-ancestors": "'none'",
   "form-action": "'self'",
   "base-uri": "'self'"

package/source/server/store/Store.js

@@ -1,3 +1,6 @@
+import {resolve} from "path";
+const preset = "../../preset/data/stores";
+
 export default class Store {
   constructor(conf = {}) {
     this.conf = conf;
@@ -14,4 +17,14 @@ export default class Store {
   open() {
     return this;
   }
+
+  static async get(directory, file) {
+    let store;
+    try {
+      store = await import(resolve(`${directory}/${file}`));
+    } catch(error) {
+      store = await import(`${preset}/${file}`);
+    }
+    return store.default.open();
+  }
 }

package/source/server/types/Date.js

@@ -14,7 +14,7 @@ export default class extends Instance {
     return value instanceof this.instance;
   }
 
-  /*static deserialize(value) {
+  static deserialize(value) {
     return value instanceof this.instance ? value : new this.instance(value);
-  }*/
+  }
 }

package/source/server/types/Domain.js

@@ -1,11 +1,6 @@
 import Storeable from "./Storeable.js";
-import Domain from "../domain/Domain.js";
 
 export default class extends Storeable {
-  static get instance() {
-    return Domain;
-  }
-
   static type_error({name}) {
     return `Must be a ${name}`;
   }

package/source/server/types/Storeable.js

@@ -1,13 +1,12 @@
 import {PredicateError} from "../errors.js";
 
 export default class {
-  static async verify(property, value, predicates, type) {
-    const coerced = this.coerce(value);
-    if (!await this.is(coerced, type)) {
+  static async verify(property, document, predicates, type) {
+    document[property] = this.coerce(document[property]);
+    if (!await this.is(document[property], type)) {
       throw new PredicateError(this.type_error(type));
     }
-    await this.has(property, coerced, predicates);
-    return coerced;
+    await this.has(property, document, predicates);
   }
 
   static type_error() {
@@ -18,13 +17,13 @@ export default class {
     throw new Error("must be implemented");
   }
 
-  static async has(property, value, predicates) {
+  static async has(property, document, predicates) {
     for (const predicate of predicates) {
       if (typeof predicate === "object") {
         await predicate.function(property, ...predicate.params);
       } else {
         const [name, ...params] = predicate.split(":");
-        if (!this[name](value, ...params)) {
+        if (!this[name](document[property], ...params)) {
           let error = this.errors[name];
           for (let i = 0; i < params.length; i++) {
             error = error.replace(`$${i+1}`, params[i]);

package/source/server/view/TreeNode.js

@@ -147,7 +147,9 @@ export default class TreeNode {
         put(found_node, right);
       }
     };
+    //const flattened = [...new Set(flatten)];
     flatten.forEach(part => put(tree, part));
+    //return {tree, flattened};
     return tree;
   }
 

package/source/server/view/View.js

@@ -1,4 +1,5 @@
 import Parser from "./Parser.js";
+import File from "../File.js";
 import {InternalServerError} from "../errors.js";
 
 const $content = "${content}";
@@ -10,6 +11,10 @@ export default class View {
     this.layouts = layouts;
   }
 
+  static async new(path, layouts) {
+    return new View(path, await File.read(`${path}.html`), layouts);
+  }
+
   elements(layout) {
     try {
       return Parser.parse(layout === undefined

package/source/client/Base.js

@@ -1,5 +0,0 @@
-export default class Base {
-  Class() {
-    return this.constructor;
-  }
-}