primate 0.0.1 → 0.3.0

package/source/server/File.js

@@ -0,0 +1,117 @@
+import fs from "fs";
+import {join} from "path";
+import Directory from "./Directory.js";
+import EagerPromise from "./promises/Eager.js";
+
+const array = maybe => Array.isArray(maybe) ? maybe : [maybe];
+
+const filter_files = (files, filter) =>
+  files.filter(file => array(filter).some(ending => file.endsWith(ending)));
+
+export default class File {
+  constructor(...args) {
+    this.path = join(...args);
+    return EagerPromise.resolve(new Promise(resolve => {
+      fs.lstat(this.path, (error, stats) => {
+        this.stats = stats;
+        resolve(this);
+      });
+    }));
+  }
+
+  get modified() {
+    return Math.round(this.stats.mtimeMs);
+  }
+
+  get exists() {
+    return this.stats !== undefined;
+  }
+
+  get is_file() {
+    return this.exists && !this.stats.isDirectory();
+  }
+
+  get read_stream() {
+    return fs.createReadStream(this.path, {"flags": "r"});
+  }
+
+  get write_stream() {
+    return fs.createWriteStream(this.path);
+  }
+
+  remove() {
+    return new Promise((resolve, reject) => fs.rm(this.path,
+      {"recursive": true, "force": true},
+      error => error === null ? resolve(this) : reject(error)
+    ));
+  }
+
+  create() {
+    return new Promise((resolve, reject) => fs.mkdir(this.path, error =>
+      error === null ? resolve(this) : reject(error)
+    ));
+  }
+
+  async copy(to, recreate = true) {
+    if (this.stats.isDirectory()) {
+      if (recreate) {
+        await new File(`${to}`).recreate();
+      }
+      // copy all files
+      return Promise.all((await this.list()).map(file =>
+        new File(`${this.path}/${file}`).copy(`${to}/${file}`)
+      ));
+    } else {
+      return new Promise((resolve, reject) => fs.copyFile(this.path, to,
+        error => error === null ? resolve(this) : reject(error)));
+    }
+  }
+
+  async list(filter) {
+    if (!this.exists) {
+      return [];
+    }
+    const files = await Directory.list(this.path);
+    return filter !== undefined ? filter_files(files, filter) : files;
+  }
+
+  async recreate() {
+    return (await this.remove()).create();
+  }
+
+  read(options = {"encoding": "utf8"}) {
+    return new Promise((resolve, reject) =>
+      fs.readFile(this.path, options, (error, nonerror) =>
+        error === null ? resolve(nonerror) : reject(error)));
+  }
+
+  write(data, options = {"encoding": "utf8"}) {
+    return new Promise((resolve, reject) => fs.writeFile(this.path, data,
+      options,
+      error => error === null ? resolve(this) : reject(error)));
+  }
+
+  static read_sync(path, options = {"encoding": "utf8"}) {
+    return fs.readFileSync(path, options);
+  }
+
+  static exists(...args) {
+    return new File(...args).exists;
+  }
+
+  static read(...args) {
+    return new File(...args).read();
+  }
+
+  static write(path, data, options) {
+    return new File(path).write(data, options);
+  }
+
+  static remove(...args) {
+    return new File(...args).remove();
+  }
+
+  static copy(from, to, recreate) {
+    return new File(from).copy(to, recreate);
+  }
+}

package/source/server/Router.js

@@ -0,0 +1,61 @@
+export default class Router {
+  constructor(routes = [], conf) {
+    this.conf = conf;
+    this.routes = {};
+    routes.forEach(({from, to, contexts}) =>
+      contexts.forEach(context => {
+        this.routes[context] = this.routes[context] ?? [];
+        this.routes[context].push({"from": new RegExp("^"+from+"$", "u"), to});
+      }));
+  }
+
+  context(context) {
+    return context ?? this.conf.defaults.context;
+  }
+
+  debase(pathname) {
+    return pathname.replace(this.conf.base, "/");
+  }
+
+  route_by_context(context, path) {
+    return this.routes[context]?.find(({from}) => from.test(path)) ?? [];
+  }
+
+  resolve_by_context(pathname, context) {
+    const [path, search = ""] = pathname.split("?");
+
+    const route = this.route_by_context(context, path);
+    if (route !== undefined) {
+      const replace = path.replace(route.from, route.to);
+      return `${replace}${replace.includes("?") ? "&" : "?&"}${search}`;
+    } else {
+      return pathname;
+    }
+  }
+
+  resolve(pathname, context) {
+    return this.context(context) !== undefined
+      ? this.resolve_by_context(pathname, context)
+      : pathname;
+  }
+
+  async route(pathname, context) {
+    const resolved = await this.resolve(this.debase(pathname), context);
+    const url = new URL(`https://primatejs.com/${resolved}`);
+    const parts = url.pathname.split("/").filter(part => part !== "");
+    const {namespace, action} = this.conf.defaults;
+    return {
+      "pathname": url.pathname,
+      "resolved": resolved,
+      "parts": parts,
+      "path": {
+        "namespace": parts[0] ?? namespace,
+        "action": parts[1] ?? action,
+        "_id": parts[2],
+      },
+      "params": {
+        ...Object.fromEntries(url.searchParams),
+      },
+    };
+  }
+}

package/source/server/Session.js

@@ -0,0 +1,69 @@
+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];
+
+export default class Session extends Domain {
+  static get fields() {
+    const default_context = this.conf.defaults.context;
+    return {
+      "?data": Object,
+      "context" : value => value ?? default_context,
+      "created": value => value ?? new Date(),
+    };
+  }
+
+  async log(color, message) {
+    (await this.actual_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) {
+    const session = await Session.touch({"_id": extract_id(cookie_header)});
+    if (session.new) {
+      await session.save();
+      session.has_cookie = false;
+    }
+    return session;
+  }
+
+  get cookie() {
+    return `session_id=${this._id}; Secure; HttpOnly; Path=/`;
+  }
+
+  async switch_context(context, data = {}) {
+    await this.save({context, data});
+    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;
+  }
+}

package/source/server/attributes.js

@@ -0,0 +1,11 @@
+export const constructible = value => {
+  try {
+    Reflect.construct(String, [], value);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+export const numeric = value => !isNaN(parseFloat(value)) && isFinite(value);
+export const boolish = value => value === "true" || value === "false";

package/source/server/cache.js

@@ -0,0 +1,17 @@
+const Cache = class Cache {
+  static #caches = [];
+
+  static get(object, property) {
+    return Cache.#caches.find(entry =>
+      entry.object === object && entry.property === property)?.value;
+  }
+
+  static put(object, property, cacher) {
+    const value = cacher();
+    Cache.#caches.push({object, property, value});
+    return value;
+  }
+};
+
+export default (object, property, cacher) =>
+  Cache.get(object, property) ?? Cache.put(object, property, cacher);

package/source/server/conf.js

@@ -0,0 +1,33 @@
+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 primate_json from "../preset/primate.json" assert {"type": "json" };
+
+const qualify = (root, paths) => {
+  const object = {};
+  for (const key in paths) {
+    const value = paths[key];
+    if (typeof value === "string") {
+      object[key] = join(root, value);
+    } else {
+      object[key] = qualify(`${root}/${key}`, value);
+    }
+  }
+  return object;
+}
+
+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
+  });

package/source/server/domain/Domain.js

@@ -0,0 +1,277 @@
+import Base from "../Base.js";
+import Field from "./Field.js";
+import {PredicateError} from "../errors.js";
+import {EagerPromise} from "../promises.js";
+import cache from "../cache.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 extends Base {
+  constructor(document) {
+    super();
+
+    const errors = {};
+    return new Proxy(this, {get}).set({...document, errors}).define("_id", {
+      "type": String,
+      "predicates": ["unique"],
+      "in": value => value ?? random(length).toString("hex"),
+    });
+  }
+
+  get Class() {
+    return this.constructor;
+  }
+
+  static get fields() {
+    return {};
+  }
+
+  static get _fields() {
+    // initialize programmatic defines
+    cache(this, "initialized", () => {new this();});
+    Object.keys(this.fields).map(name => this.define(name, this.fields[name]));
+    return cache(this, "fields", () => ({}));
+  }
+
+  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;
+  }
+
+  static get collection() {
+    return this.name.toLowerCase();
+  }
+
+  static get properties() {
+    const properties = [];
+    const fields = this._fields;
+    for (const key in fields) {
+      const field = fields[key];
+      if (!field.options.transient) {
+        properties.push(key);
+      }
+    }
+    return properties;
+  }
+
+  static define(name, definition) {
+    const fields = cache(this, "fields", () => ({}));
+    const {property, options} = Field.resolve(name);
+    if (fields[property] === undefined) {
+      fields[property] = new Field(property, definition, options);
+    }
+  }
+
+  define(name, definition) {
+    this.Class.define(name, definition);
+    return this;
+  }
+
+  get() {
+    return this.properties
+      .filter(property => property !== "_id")
+      .reduce((document, property) => {
+        document[property] = this[property];
+        return document;
+      }, {});
+  }
+
+  set(document = {}) {
+    return Object.assign(this, document);
+  }
+
+  // #as_foreign
+  as_foreign(name) {
+    const field = this.fields[`${name}_id`];
+    return field?.is_domain ? field.by_id(this[`${name}_id`]) : undefined;
+  }
+
+  // #serialize
+  // Serializing is done from the instance's point of view.
+  async serialize() {
+    const {properties, fields} = this;
+    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;
+        return document;
+      }, {});
+  }
+
+  // #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)
+      .map(property =>
+        ({property,
+        "value": fields[property].deserialize(serialized[property])}))
+      .reduce((document, {property, value}) => {
+        document[property] = value;
+        return document;
+      }, {}));
+  }
+
+  get fields() {
+    return this.Class._fields;
+  }
+
+  get collection() {
+    return this.Class.collection;
+  }
+  get properties() {
+    return this.Class.properties;
+  }
+
+  get store() {
+    return this.Class.store;
+  }
+
+  get new() {
+    return this._id === undefined;
+  }
+
+  async verify(delta) {
+    this.set(delta);
+    const fields = this.fields;
+    this.errors = (await Promise.all(Object.keys(fields).map(async property =>
+      ({property, "value": await fields[property].verify(property, this)}))))
+      .filter(result => typeof result.value === "string")
+      .reduce((errors, result) => {
+        errors[result.property] = result.value;
+        return errors;
+      }, {});
+
+    return Object.keys(this.errors).length === 0;
+  }
+
+  save(delta) {
+    return this.new ? this.insert(delta) : this.update(delta);
+  }
+
+  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 after();
+    }
+    return verified;
+  }
+
+  insert(delta) {
+    delete this._id;
+    return this.savewith(delta, () => this.inserted());
+  }
+
+  inserted() {
+    return this;
+  }
+
+  async update(delta) {
+    const old = await this.Class.by_id(this._id);
+    return this.savewith(delta, () => this.updated(old));
+  }
+
+  updated() {
+    return this;
+  }
+
+  async delete() {
+    const store = await this.store;
+    return store.delete(this.collection, {"_id": this._id});
+  }
+
+  static async delete(criteria) {
+    const store = await this.store;
+    return 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));
+    });
+  }
+
+  static first(criteria) {
+    return new EagerPromise(async resolve => {
+      const result = await (await this.store).one(this.collection, criteria);
+      resolve(result === undefined ? undefined : this.deserialize(result));
+    });
+  }
+
+  static one(criteria) {
+    return this[typeof criteria === "object" ? "first" : "by_id"](criteria);
+  }
+
+  static async touch(criteria) {
+    return await this.one(criteria) ?? new this();
+  }
+
+  static async find(criteria, options) {
+    const store = await this.store;
+    const results = await 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 async exists(criteria) {
+    return await this.count(criteria) > 0;
+  }
+
+  async exists(property) {
+    if (!await this.Class.exists({[property]: this[property]})) {
+      throw new PredicateError(`No document exists with this ${property}`);
+    }
+  }
+
+  static async unique(criteria, _id) {
+    const one = await this.count({...criteria, _id});
+    const count = await this.count(criteria);
+    return count-one === 0;
+  }
+
+  async unique(property) {
+    if (!await this.Class.unique({[property]: this[property]}, this._id)) {
+      throw new PredicateError("Must be unique");
+    }
+  }
+
+  async unique_by(property, by_property) {
+    if (!await this.Class.unique({
+      [property]: await this[property],
+      [by_property]: await this[by_property],
+    }, this._id)) {
+      throw new PredicateError(`Must be unique in respect to ${by_property}`);
+    }
+  }
+
+  static insert(document) {
+    return new this(document).save();
+  }
+}

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