primate 0.3.1 → 0.4.0

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.read_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,7 +80,7 @@ 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>";

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/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;
-  }
-}

package/source/server/Base.js

@@ -1,35 +0,0 @@
-import conf from "./conf.js";
-import log from "./log.js";
-import package_json from "../../package.json" assert {"type": "json" };
-
-const _conf = conf();
-let routes;
-try {
-  routes = await import(`${_conf.root}/routes.json`, {
-    "assert": {"type": "json"}
-  });
-} catch (error) {
-  // local routes.json not required
-}
-
-export default class Base {
-  static get conf() {
-    return _conf;
-  }
-
-  get conf() {
-    return this.Class().conf;
-  }
-
-  get package() {
-    return package_json;
-  }
-
-  get routes() {
-    return routes?.default ?? [];
-  }
-
-  Class() {
-    return this.constructor;
-  }
-}

package/source/server/errors/Fallback.js

@@ -1 +0,0 @@
-export default class extends Error {}

package/source/server/fallback.js

@@ -1,11 +0,0 @@
-const fallback = async (from, to, logic_from, logic_to) => {
-  try {
-    return await logic_from(from);
-  } catch (error) {
-    return logic_to(to);
-  }
-};
-
-export default (from, to, logic) => logic !== undefined
-  ? fallback(from, to, logic, logic)
-  : fallback(undefined, undefined, from, to);

package/source/server/promises/Meta.js

@@ -1,42 +0,0 @@
-import Domain from "../domain/Domain.js";
-
-const identity = value => value;
-const by = {
-  "undefined": () => undefined,
-  "boolean": identity,
-  "string": identity,
-  "number": identity,
-  "array": identity,
-  "true_object": value => value instanceof Domain ? {} : value,
-  "object": value => by[Array.isArray(value) ? "array" : "true_object"](value),
-};
-const resolve_type = async (document, property) => {
-  if (document === undefined) {
-    return undefined;
-  }
-  const resolved = await document[property];
-  return by[typeof resolved](resolved);
-};
-
-export default async function resolve(document, projection = []) {
-  const resolved = {};
-  if (Array.isArray(document)) {
-    return Promise.all(document.map(sub => resolve(sub, projection)));
-  }
-  for (const property of projection) {
-    if (typeof property === "string") {
-      const result = await resolve_type(document, property);
-      if (result !== undefined) {
-        resolved[property] = result;
-      }
-    } else if (typeof property === "object") {
-      for (const property2 in property) {
-        const value = await document[property2];
-        if (value !== undefined) {
-          resolved[property2] = await resolve(value, property[property2]);
-        }
-      }
-    }
-  }
-  return resolved;
-}

package/source/server/promises.js

@@ -1,2 +0,0 @@
-export {default as EagerPromise, eager} from "./promises/Eager.js";
-export {default as MetaPromise} from "./promises/Meta.js";