primate 0.0.1 → 0.1.0

package/source/server/domain/Field.js

@@ -0,0 +1,115 @@
+import * as types from "../types.js";
+import DomainType from "../types/Domain.js";
+import Storeable from "../types/Storeable.js";
+import {PredicateError} from "../errors.js";
+import {defined, is_array, instances, is_constructible} from "../invariants.js";
+import {constructible} from "../attributes.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_non_constructible =
+  field => typeof field === "function" ? as_function(field) : as_object(field);
+
+const as_function = field => ({"in": field,
+  "type": field(undefined, {}).constructor});
+
+const as_object = field => field instanceof Array ? as_array(field) : field;
+
+const as_array = field => ({"type": field[0], "predicates": field.slice(1)});
+
+export default class Field {
+  constructor(property, definition, options) {
+    defined(property, "`property` required");
+    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);
+  }
+
+  static resolve(name) {
+    defined(name, "`name` required");
+    const options = {
+      "optional": name.includes("?"),
+      "transient": name.includes("~"),
+    };
+    const property = name.replaceAll("~", "").replaceAll("?", "");
+    return {options, property};
+  }
+
+  get type() {
+    return builtins[this.definition.type] ?? this.custom;
+  }
+
+  get custom() {
+    return this.is_domain ? DomainType : this.definition.type;
+  }
+
+  get is_domain() {
+    return this.definition.type.prototype instanceof DomainType.instance;
+  }
+
+  get predicates() {
+    return this.definition.predicates ?? [];
+  }
+
+  by_id(id) {
+    return this.definition.type.by_id(id);
+  }
+
+  in(property, document) {
+    const value = document[property];
+    const in_function = this.definition.in;
+    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) {
+    try {
+      const predicates = this.override_predicates(document);
+      document[property] = await this.type.verify(property, value, predicates,
+        this.definition.type);
+      return true;
+    } catch (error) {
+      if (error instanceof PredicateError) {
+        return error.message;
+      }
+      throw error;
+    }
+  }
+
+  async verify(property, document) {
+    const value = await this.in(property, document);
+    return value === undefined
+      ? this.verify_undefined()
+      : this.verify_defined(property, value, document);
+  }
+
+  serialize(value) {
+    return value !== undefined ? this.type.serialize(value) : value;
+  }
+
+  deserialize(value) {
+    return value !== undefined ? this.type.deserialize(value) : value;
+  }
+}

package/source/server/domain/domains.js

@@ -0,0 +1,15 @@
+import conf from "../conf.js";
+import File from "../File.js";
+import Field from "./Field.js";
+
+const domains = {};
+const base = conf().paths.data.domains;
+
+for (const domain of await new File(base).list(".js")) {
+  const name = domain.slice(0, -3);
+  import(`${base}/${domain}`).then(module => {
+    domains[name] = module.default;
+  });
+}
+
+export default domains;

package/source/server/errors/Fallback.js

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

package/source/server/errors/InternalServer.js

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

package/source/server/errors/Predicate.js

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

package/source/server/errors.js

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,27 @@
+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 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";
+
+const app = new App();
+const conf = app.conf;
+
+export {app, conf};

package/source/server/fallback.js

@@ -0,0 +1,11 @@
+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/invariants.js

@@ -0,0 +1,19 @@
+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);
+  }
+};
+
+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);
+
+export {assert, defined, is_array, instances, is_constructible};

package/source/server/log.js

@@ -0,0 +1,22 @@
+const colors = {
+  "red": 31,
+  "green": 32,
+  "yellow": 33,
+  "blue": 34,
+};
+const reset = 0;
+
+const Log = {
+  "paint": (color, message) => {
+    process.stdout.write(`\x1b[${color}m${message}\x1b[0m`);
+    return log;
+  },
+  "nl": () => log.paint(reset, "\n"),
+};
+
+const log = new Proxy(Log, {
+  "get": (target, property) => target[property] ?? (message =>
+    log.paint(colors[property] ?? reset, message).paint(reset, " ")),
+});
+
+export default log;

package/source/server/promises/Eager.js

@@ -0,0 +1,49 @@
+const $promise = Symbol("#promise");
+
+const handler = {
+  "get": function(target, property) {
+    const promise = target[$promise];
+
+    if (["then", "catch"].includes(property)) {
+      return promise[property].bind(promise);
+    }
+
+    return EagerPromise.resolve(promise.then(result => {
+      if (property === "bind") {
+        return result;
+      }
+      return typeof result[property] === "function"
+        ? result[property].bind(result)
+        : result[property];
+    }));
+  },
+  "apply": (target, that, args) =>
+    EagerPromise.resolve(target[$promise].then(result =>
+      typeof result === "function" ? result.apply(that, args) : result
+    )),
+};
+
+export default class EagerPromise {
+  constructor(resolve, reject) {
+    const promise = new Promise(resolve, reject);
+    const callable = () => undefined;
+    callable[$promise] = promise;
+    return new Proxy(callable, handler);
+  }
+
+  static resolve(value) {
+    return new EagerPromise(resolve => resolve(value));
+  }
+
+  static reject(value) {
+    return new EagerPromise((resolve, reject) => reject(value));
+  }
+}
+
+const last = -1;
+const eager = async (strings, ...keys) =>
+  (await Promise.all(strings.slice(0, last).map(async (string, i) =>
+    strings[i] + await keys[i]
+  ))).join("") + strings[strings.length+last];
+
+export {eager};

package/source/server/promises/Meta.js

@@ -0,0 +1,42 @@
+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

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

package/source/server/servers/Dynamic.js

@@ -0,0 +1,51 @@
+import {WebSocketServer} from "ws";
+import Server from "./Server.js";
+import Session from "../Session.js";
+
+const options = {"perMessageDeflate": false};
+
+export default class DynamicServer extends Server {
+  run() {
+    const {server, path} = this.conf;
+    return new WebSocketServer({...options, server, path})
+      .on("connection", this.connected.bind(this));
+  }
+
+  async connected(socket, request) {
+    socket.session = await Session.get(request.headers.cookie);
+    socket.on("message", event => this.try(socket, event));
+    // inform client that we're connected and it can start sending messages
+    socket.send("open");
+  }
+
+  async try(socket, event) {
+    const {session} = socket;
+    const parsed = JSON.parse(event);
+    const url = parsed.pathname + (parsed.search ?? "");
+    try {
+      await this.onmessage(socket, parsed, url);
+      await session.log("green", `${parsed.type} ${url}`);
+    } catch(error) {
+      await session.log("red", error.message);
+    }
+  }
+
+  async onmessage(socket, parsed, url) {
+    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));
+  }
+
+  redirect(socket, data) {
+    if (data.location.startsWith("https://")) {
+      // redirect externally
+      return undefined;
+    } else {
+      const pathname = data.location;
+      this.try(socket, JSON.stringify({pathname, "type": "read"}));
+      return true;
+    }
+  }
+}

package/source/server/servers/Server.js

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

package/source/server/servers/Static.js

@@ -0,0 +1,113 @@
+import zlib from "zlib";
+import {Readable} from "stream";
+import {createServer} from "https";
+import {join} from "path";
+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 log from "../log.js";
+import codes from "./http-codes.json" assert {"type": "json"};
+import mimes from "./mimes.json" assert {"type": "json"};
+import policy from "./content-security-policy.json" assert {"type": "json"};
+
+const regex = /\.([a-z1-9]*)$/u;
+const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
+
+const csp = Object.keys(policy)
+  .reduce((policy_string, key) => policy_string + `${key} ${policy[key]};`, "");
+
+const stream = (from, response) => {
+  response.setHeader("Content-Encoding", "br");
+  response.writeHead(codes.OK);
+  return from.pipe(zlib.createBrotliCompress())
+    .pipe(response)
+    .on("close", () => response.end());
+};
+
+export default class StaticServer extends Server {
+  async run() {
+    const {http} = this.conf;
+
+    this.server = await createServer(http, async (request, response) => {
+      const session = await Session.get(request.headers.cookie);
+      if (!session.has_cookie) {
+        response.setHeader("Set-Cookie", session.cookie);
+      }
+      request.on("end", () =>
+        this.try(parse(request.url).path, session, request, response)
+      ).resume();
+    });
+  }
+
+  async try(url, session, request, response) {
+    try {
+      await this.serve(url, session, request, response);
+    } catch (error) {
+      await session.log("red", error.message);
+      response.writeHead(codes.InternalServerError);
+      response.end();
+    }
+  }
+
+  async serve(url, session, 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);
+    }
+  }
+
+  async serve_data(pathname, session, request, 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 handler = StaticServer[data.type] ?? this.index.bind(this);
+    return handler(data, response);
+  }
+
+  index(data, response) {
+    const {hashes, index} = this.conf;
+    const src = "import {app} from './client/primate.js';"
+      + `app.client.execute(${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 script_src = Array.from(hashes)
+      .concat([integrity])
+      .reduce((hash_string, next_hash) => hash_string + ` '${next_hash}'`, "");
+
+    response.setHeader("Content-Security-Policy",
+      csp + `script-src 'self'${script_src};`);
+    response.setHeader("Content-Type", "text/html");
+    response.setHeader("Referrer-Policy", "same-origin");
+    return stream(Readable.from([file]), response);
+  }
+
+  listen(port, host) {
+    log.reset("on").yellow(`https://${host}:${port}`).nl();
+    this.server.listen(port, host);
+  }
+
+  static redirect({location}, response) {
+    response.setHeader("Location", location);
+    response.writeHead(codes.Found);
+    return response.end();
+  }
+
+  static return({payload}, response) {
+    if (payload instanceof File) {
+      return stream(payload.stream, response);
+    } else {
+      response.setHeader("Content-Type", "application/json");
+      return stream(Readable.from([JSON.stringify(payload)]), response);
+    }
+  }
+}

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

@@ -0,0 +1,9 @@
+{
+  "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/servers/http-codes.json

@@ -0,0 +1,5 @@
+{
+  "OK": 200,
+  "Found": 302,
+  "InternalServerError": 500
+}

package/source/server/servers/mimes.json

@@ -0,0 +1,12 @@
+{
+  "binary": "application/octet-stream",
+  "css": "text/css",
+  "html": "text/html",
+  "jpg": "image/jpeg",
+  "js": "text/javascript",
+  "json": "application/json",
+  "png": "image/png",
+  "svg": "image/svg+xml",
+  "woff2": "font/woff2",
+  "webp": "image/webp"
+}

package/source/server/store/Memory.js

@@ -0,0 +1,60 @@
+import Store from "./Store.js";
+
+const not_found = -1;
+
+export default class Memory extends Store {
+  constructor(conf) {
+    super(conf);
+    this.collections = {};
+  }
+
+  some(collection, operation, criteria) {
+    const keys = Object.keys(criteria);
+    return this.use(collection)[operation](document =>
+      // ¬∃ = ∀
+      !keys.some(criterion => document[criterion] !== criteria[criterion])
+    );
+  }
+
+  index(collection, _id = "") {
+    const criteria = typeof _id === "string" ? {_id} : _id;
+    return this.some(collection, "findIndex", criteria);
+  }
+
+  use(name) {
+    this.collections[name] = this.collections[name] ?? [];
+    return this.collections[name];
+  }
+
+  count(collection, criteria) {
+    return this.find(collection, criteria).length;
+  }
+
+  one(collection, _id) {
+    const index = this.index(collection, _id);
+    return index !== not_found ? this.use(collection)[index] : undefined;
+  }
+
+  find(collection, criteria) {
+    return criteria === undefined
+      ? this.use(collection)
+      : this.some(collection, "filter", criteria);
+  }
+
+  save(collection, {_id}, document) {
+    const index = this.index(collection, _id);
+    const use = this.use(collection);
+    if (index !== not_found) {
+      use.splice(index, 1, document);
+    } else {
+      use.push(document);
+    }
+  }
+
+  delete(collection, criteria) {
+    const index = this.index(collection, criteria._id);
+    if (index !== not_found) {
+      this.use(collection).splice(index, 1);
+    }
+  }
+}

package/source/server/store/Store.js

@@ -0,0 +1,17 @@
+export default class Store {
+  constructor(conf = {}) {
+    this.conf = conf;
+  }
+
+  get name() {
+    return this.conf.name;
+  }
+
+  get path() {
+    return this.conf.path;
+  }
+
+  open() {
+    return this;
+  }
+}

package/source/server/types/Array.js

@@ -0,0 +1,33 @@
+import Instance from "./Instance.js";
+import errors from "./errors/Array.json" assert {"type": "json"};
+
+export default class extends Instance {
+  static get instance() {
+    return Array;
+  }
+
+  static get errors() {
+    return errors;
+  }
+
+  static is(value) {
+    return value instanceof this.instance;
+  }
+
+  static length(value, length) {
+    return value.length === Number(length);
+  }
+
+  static min(value, minimum) {
+    return value.length >= Number(minimum);
+  }
+
+  static max(value, maximum) {
+    return value.length <= Number(maximum);
+  }
+
+  static between(value, minimum, maximum) {
+    const length = value.length;
+    return length >= Number(minimum) && length <= Number(maximum);
+  }
+}

package/source/server/types/Boolean.js

@@ -0,0 +1,29 @@
+import Primitive from "./Primitive.js";
+import {boolish} from "../attributes.js";
+import errors from "./errors/Boolean.json" assert {"type": "json"};
+
+export default class extends Primitive {
+  static get type() {
+    return "boolean";
+  }
+
+  static get instance() {
+    return Boolean;
+  }
+
+  static get errors() {
+    return errors;
+  }
+
+  static coerce(value) {
+    return boolish(value) ? value === "true" : value;
+  }
+
+  static true(value) {
+    return value === true;
+  }
+
+  static false(value) {
+    return value === false;
+  }
+}