primate 0.8.0 → 0.9.0

package/source/domain/Field.js

@@ -1,113 +0,0 @@
-import DomainType from "../types/Domain.js";
-import Predicate from "./Predicate.js";
-import {PredicateError} from "../errors.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 as_array = field => ({"type": field[0], "predicates": field.slice(1)});
-
-const as_object = field => field instanceof Array ? as_array(field) : field;
-
-const as_function = field => ({"in": field,
-  "type": field(undefined, {}).constructor});
-
-const as_non_constructible =
-  field => typeof field === "function" ? as_function(field) : as_object(field);
-
-const parse = field => constructible(field)
-  ? {"type": field}
-  : as_non_constructible(field);
-
-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.Type);
-    is.subclass(this.type, Storeable);
-    maybe.array(this.definition.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.Type] ?? this.custom;
-  }
-
-  get custom() {
-    return this.is_domain ? DomainType : this.Type;
-  }
-
-  get is_domain() {
-    return this.Type.prototype instanceof DomainType.instance;
-  }
-
-  get Type() {
-    return this.definition.type;
-  }
-
-  get predicates() {
-    return cache(this, "predicates", () => {
-      const predicates = this.definition.predicates ?? [];
-      return predicates.map(name => new Predicate(name));
-    });
-  }
-
-  by_id(id) {
-    return this.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;
-  }
-
-  verify_undefined() {
-    return this.options.optional ? true : "Must not be empty";
-  }
-
-  async verify_defined(property, document) {
-    try {
-      await this.type.verify(property, document, this.predicates, this.Type);
-      return true;
-    } catch (error) {
-      if (error instanceof PredicateError) {
-        return error.message;
-      }
-      throw error;
-    }
-  }
-
-  async verify(property, document) {
-    document[property] = await this.in(property, document);
-    return document[property] === undefined
-      ? this.verify_undefined()
-      : this.verify_defined(property, document);
-  }
-
-  serialize(value) {
-    return value === undefined ? undefined : this.type.serialize(value);
-  }
-
-  deserialize(value) {
-    return value === undefined ? undefined : this.type.deserialize(value);
-  }
-}

package/source/domain/Predicate.js

@@ -1,24 +0,0 @@
-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/handlers/DOM/Node.js

@@ -1,179 +0,0 @@
-import Parser from "./Parser.js";
-
-const replacement_regex = /^\$([0-9]*)$/;
-const data_regex = /\${([^}]*)}/g;
-const attributes_regex = /([-a-z]*="[^"]+")/g;
-const replace = (attribute, source) => {
-  if (attribute.includes(".")) {
-    const index = attribute.indexOf(".");
-    const left = attribute.slice(0, index);
-    const rest = attribute.slice(index+1);
-    if (source[left] !== undefined) {
-      return replace(rest, source[left]);
-    }
-  } else {
-    return source[attribute];
-  }
-};
-const fulfill = (attribute, source) => {
-  if (source === undefined) {
-    return undefined;
-  }
-  let value = attribute;
-  const matches = [...attribute.matchAll(data_regex)];
-  if (matches.length > 0) {
-    for (const match of matches) {
-      const [key] = match;
-      const new_value = replace(match[1], source);
-      if (attribute === key) {
-        return new_value;
-      }
-      value = attribute.replace(key, new_value);
-    }
-  }
-  return value;
-};
-
-export default class Node {
-  #data;
-
-  constructor(parent, content = "div", data) {
-    if (parent !== undefined) {
-      this.parent = parent;
-      this.parent.attach(this);
-    }
-    this.#data = data;
-    this.attributes = {};
-    if (content !== undefined) {
-      const [tag_name] = content.split(" ");
-      const attributes = content.match(attributes_regex) ?? [];
-      this.tag_name = tag_name;
-      for (const attribute of attributes
-        .map(a => a.replaceAll("\"", ""))
-        .filter(a => a.includes("="))) {
-        const position = attribute.indexOf("=");
-        const key = attribute.slice(0, position);
-        const value = attribute.slice(position+1);
-        this.attributes[key] = value;
-        if (this.data) {
-          const result = replacement_regex.exec(value);
-          if (result !== null) {
-            this.attributes[key] = this.data[result[1]];
-          }
-        }
-      }
-    }
-    this.children = [];
-  }
-
-  get data() {
-    return this.#data ?? this.parent?.data;
-  }
-
-  set data(value) {
-    this.#data = value;
-  }
-
-  attach(child) {
-    this.children.push(child);
-    child.parent = this;
-  }
-
-  replace(child, replacement) {
-    for (let i = 0; i < this.children.length; i++) {
-      if (child === this.children[i]) {
-        replacement.parent = this;
-        this.children.splice(i, 1, replacement);
-      }
-    }
-  }
-
-  async render() {
-    let tag = "<" + this.tag_name;
-    for (const [key, value] of Object.entries(this.attributes)) {
-      if (value === undefined) {
-        continue;
-      }
-      tag += " " + key + "=";
-      if (!value.startsWith("\"")) {
-        tag += "\"";
-      }
-      tag += value;
-      if (!value.endsWith("\"")) {
-        tag += "\"";
-      }
-    }
-    if (this.auto_closing) {
-      tag += "/>";
-    } else {
-      tag += ">";
-      for (const child of this.children) {
-        tag += await child.render();
-      }
-      if (this.text) {
-        tag += await this.text;
-      }
-      tag += "</" + this.tag_name + ">";
-    }
-    return tag;
-  }
-
-  async compose(components) {
-    if (components[this.tag_name]) {
-      return Parser.parse(components[this.tag_name], this.attributes)
-        .compose(components);
-    }
-    this.children = await Promise.all(this.children.map(child =>
-      child.compose(components)));
-    return this;
-  }
-
-  clone(parent, data) {
-    const cloned = new Node(parent, this.tag_name, data);
-    cloned.text = this.text;
-    for (const attribute in this.attributes) {
-      cloned.attributes[attribute] = this.attributes[attribute];
-    }
-    for (const child of this.children) {
-      child.clone(cloned, child.data !== this.data ? child.data : undefined);
-    }
-  }
-
-  async expand() {
-    if (this.attributes["for"] !== undefined) {
-      const key = this.attributes["for"];
-      delete this.attributes["for"];
-      const value = await fulfill(key, this.data);
-      const arr = Array.isArray(value) ? value : [value];
-      const newparent = new Node();
-      for (const val of arr) {
-        this.clone(newparent, val);
-      }
-      this.parent.replace(this, newparent);
-      return newparent.expand();
-    }
-    for (const attribute in this.attributes) {
-      const fulfilled = fulfill(this.attributes[attribute], this.data);
-      switch(attribute) {
-        case "value":
-          if (this.tag_name === "input") {
-            this.attributes.value = fulfilled;
-          } else {
-            this.text = fulfilled;
-          }
-          break;
-        default:
-          this.attributes[attribute] = fulfilled;
-          break;
-      }
-    }
-    for (let i = 0; i < this.children.length; i++) {
-      this.children[i] = await this.children[i].expand();
-    }
-    return this;
-  }
-
-  async unfold(components) {
-    return (await this.compose(components)).expand();
-  }
-}

package/source/handlers/DOM/Parser.js

@@ -1,135 +0,0 @@
-import Node from "./Node.js";
-
-const open_tag = "open_tag";
-const close_tag = "close_tag";
-const open_and_close_tag = "open_and_close_tag";
-const last_index = -1;
-
-export default class Parser {
-  constructor(html, data) {
-    this.html = html;
-    this.index = 0;
-    this.result = [];
-    this.buffer = "";
-    this.balance = 0;
-    this.reading_tag = false;
-    this.node = new Node(undefined, undefined, data);
-    this.tree = this.node;
-  }
-
-  remove_whitespace() {
-    this.html = this.html.replace(/[\n\t\r]/gu, "");
-  }
-
-  get previous() {
-    return this.at(this.index+last_index);
-  }
-
-  get current() {
-    return this.at(this.index);
-  }
-
-  get next() {
-    return this.at(this.index+1);
-  }
-
-  at(index) {
-    return this.html[index];
-  }
-
-  open_tag() {
-    this.node = new Node(this.node, this.buffer);
-  }
-
-  close_tag() {
-    if (this.node.parent !== undefined) {
-      this.node = this.node.parent;
-    }
-  }
-
-  open_and_close_tag() {
-    this.open_tag();
-    this.node.auto_closing = true;
-    this.close_tag();
-  }
-
-  // currently inside tag
-  process_reading_tag() {
-    if (this.current === ">") {
-      // mark as outside tag
-      this.reading_tag = false;
-      // if the previous character is '/', it's an open and close tag
-      if (this.previous === "/") {
-        this.tag = open_and_close_tag;
-        this.balance--;
-        this.buffer = this.buffer.slice(0, last_index);
-      }
-
-      // execute the function associated with this kind of tag
-      this[this.tag]();
-      // empty buffer
-      this.buffer = "";
-    } else {
-      this.buffer += this.current;
-    }
-  }
-
-  try_create_text_node() {
-    if (this.buffer.length > 0) {
-      const child = new Node(this.node, "span");
-      child.text = this.buffer;
-      this.buffer = "";
-    }
-  }
-
-  // currently outside of a tag
-  process_not_reading_tag() {
-    // encountered '<'
-    if (this.current === "<") {
-      this.try_create_text_node();
-      // mark as inside tag
-      this.reading_tag = true;
-      if (this.next === "/") {
-        // next character is slash, this is a close tag
-        this.tag = close_tag;
-        this.balance--;
-      } else {
-        // this is an open tag (or open-and-close)
-        this.tag = open_tag;
-        this.balance++;
-      }
-    } else {
-      this.buffer += this.current;
-    }
-  }
-
-  read() {
-    if (this.reading_tag) {
-      this.process_reading_tag();
-    } else {
-      this.process_not_reading_tag();
-    }
-    this.index++;
-
-    return this.current !== undefined;
-  }
-
-  return_checked() {
-    if (this.balance !== 0) {
-      throw Error(`unbalanced DOM tree: ${this.balance}`);
-    }
-    // anything left at the end could be potentially a text node
-    this.try_create_text_node();
-    return this.tree;
-  }
-
-  parse() {
-    this.remove_whitespace();
-    do {} while (this.read());
-    return this.return_checked();
-  }
-
-  static parse(html, data) {
-    return new Parser(html, data).parse();
-  }
-}

package/source/handlers/html.js

@@ -1,29 +0,0 @@
-import {File} from "runtime-compat";
-import Parser from "./DOM/Parser.js";
-import {index} from "../Bundler.js";
-import _conf from "../conf.js";
-const conf = _conf();
-
-const last = -1;
-const {"paths": {"components": path}} = conf;
-const components = {};
-if (await File.exists(path)) {
-  const names = await File.list(path);
-  for (const name of names) {
-    components[name.slice(0, -5)] = await File.read(`${path}/${name}`);
-  }
-}
-
-export default async (strings, ...keys) => {
-  const awaited_keys = await Promise.all(keys);
-  const rendered = await (await (await Parser.parse(strings
-    .slice(0, last)
-    .map((string, i) => `${string}$${i}`)
-    .join("") + strings[strings.length+last], awaited_keys)
-    .unfold(components)))
-    .render();
-  const body = (await index(conf)).replace("<body>", () => `<body>${rendered}`);
-  const code = 200;
-  const headers = {"Content-Type": "text/html"};
-  return {code, body, headers};
-};

package/source/handlers/http.js

@@ -1,6 +0,0 @@
-const http404 = () => {
-  const headers = {"Content-Type": "text/html"};
-  return {"code": 404, "body": "Page not found", headers};
-};
-
-export {http404};

package/source/handlers/json.js

@@ -1,6 +0,0 @@
-export default async (strings, ...keys) => {
-  const body = JSON.stringify(await keys[0]);
-  const headers = {"Content-Type": "application/json"};
-  const code = 200;
-  return {body, code, headers};
-};

package/source/handlers/redirect.js

@@ -1,10 +0,0 @@
-const last = -1;
-
-export default async (strings, ...keys) => {
-  const awaited_keys = await Promise.all(keys);
-  const Location = strings
-    .slice(0, last)
-    .map((string, i) => string + awaited_keys[i])
-    .join("") + strings[strings.length+last];
-  return {"code": 302, "headers": {Location}};
-};

package/source/invariants.js

@@ -1,36 +0,0 @@
-import {constructible, nullish} from "./attributes.js";
-
-const errored = error => {
-  if (typeof error === "function") {
-    // fallback
-    error();
-  } else {
-    // error
-    throw new Error(error);
-  }
-};
-
-const assert = (predicate, error) => Boolean(predicate) || errored(error);
-const is = {
-  "array": value => assert(Array.isArray(value), "must be array"),
-  "string": value => assert(typeof value === "string", "must be string"),
-  "object": value => assert(typeof value === "object" && value !== null,
-    "must be object"),
-  "function": value => assert(typeof value === "function", "must be function"),
-  "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;
-
-// too early to use map_entries here, as it relies on invariants
-const maybe = Object.fromEntries(Object.entries(is).map(([key, value]) =>
-  [key, (...args) => nullish(args[0]) || value(...args)]));
-
-const invariant = predicate => predicate();
-
-export {assert, defined, is, maybe, invariant};

package/source/map_entries.js

@@ -1,6 +0,0 @@
-import {is, invariant} from "./invariants.js";
-
-export default (object = {}, mapper = (...args) => args) =>
-  invariant(() => is.object(object) && is.function(mapper))
-  && Object.fromEntries(Object.entries(object).map(([key, value]) =>
-    mapper(key, value)));

package/source/sanitize.js

@@ -1,8 +0,0 @@
-import {is} from "./invariants.js";
-import map_entries from "./map_entries.js";
-
-export default (dirty = {}) => is.object(dirty)
-  && map_entries(dirty, (key, value) => {
-    const trimmed = value.toString().trim();
-    return [key, trimmed === "" ? undefined : trimmed];
-  });

package/source/store/Memory.js

@@ -1,60 +0,0 @@
-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/store/Store.js

@@ -1,30 +0,0 @@
-import {Path} from "runtime-compat";
-const preset = "../preset/stores";
-
-export default class Store {
-  constructor(conf = {}) {
-    this.conf = conf;
-  }
-
-  get name() {
-    return this.conf.name;
-  }
-
-  get path() {
-    return this.conf.path;
-  }
-
-  open() {
-    return this;
-  }
-
-  static async get(directory, file) {
-    let store;
-    try {
-      store = await import(Path.resolve(`${directory}/${file}`));
-    } catch(error) {
-      store = await import(`${preset}/${file}`);
-    }
-    return store.default.open();
-  }
-}

package/source/types/Array.js

@@ -1,33 +0,0 @@
-import InstanceType from "./Instance.js";
-import errors from "./errors/Array.json" assert {"type": "json"};
-
-export default class ArrayType extends InstanceType {
-  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);
-  }
-}