primate 0.8.0 → 0.9.0

package/src/serve.js

@@ -0,0 +1,90 @@
+import {Path} from "runtime-compat/filesystem";
+import {serve, Response} from "runtime-compat/http";
+import codes from "./http-codes.json" assert {type: "json"};
+import mimes from "./mimes.json" assert {type: "json"};
+import {http404} from "./handlers/http.js";
+import log from "./log.js";
+
+const regex = /\.([a-z1-9]*)$/u;
+const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
+
+const Server = class Server {
+  constructor(conf) {
+    this.conf = conf;
+  }
+
+  async start() {
+    const {http} = this.conf;
+    const {csp, "same-site": same_site = "Strict"} = http;
+    this.csp = Object.keys(csp).reduce((policy_string, key) =>
+      `${policy_string}${key} ${csp[key]};`, "");
+
+    const decoder = new TextDecoder();
+    serve(async request => {
+      const reader = request.body.getReader();
+      const chunks = [];
+      let result;
+      do {
+        result = await reader.read();
+        if (result.value !== undefined) {
+          chunks.push(decoder.decode(result.value));
+        }
+      } while (!result.done);
+      const body = chunks.join();
+      const payload = Object.fromEntries(decodeURI(body).replaceAll("+", " ")
+        .split("&")
+        .map(part => part.split("=")));
+      const {pathname, search} = new URL(`https://example.com${request.url}`);
+      return this.try(pathname + search, request, payload);
+    }, http);
+    const {port, host} = this.conf.http;
+    log.reset("on").yellow(`https://${host}:${port}`).nl();
+  }
+
+  async try(url, request, payload) {
+    try {
+      return await this.serve(url, request, payload);
+    } catch (error) {
+      console.log(error);
+      return new Response(null, {status: codes.InternalServerError});
+    }
+  }
+
+  async serve(url, request, payload) {
+    const path = new Path(this.conf.from, url);
+    return await path.isFile
+      ? this.resource(path.file)
+      : this.route(url, request, payload);
+  }
+
+  async resource(file) {
+    return new Response(file.readable, {
+      status: codes.OK,
+      headers: {
+        "Content-Type": mime(file.name),
+        Etag: await file.modified,
+      },
+    });
+  }
+
+  async route(pathname, request, payload) {
+    const req = {pathname, method: request.method.toLowerCase(), payload};
+    let result;
+    try {
+      result = await (await this.conf.router.process(req))(this.conf);
+    } catch (error) {
+      console.log(error);
+      result = http404``;
+    }
+    return new Response(result.body, {
+      status: result.code,
+      headers: {
+        ...result.headers,
+        "Content-Security-Policy": this.csp,
+        "Referrer-Policy": "same-origin",
+      },
+    });
+  }
+};
+
+export default conf => new Server(conf).start();

package/source/App.js

@@ -1,34 +0,0 @@
-import {Path, File, log} from "runtime-compat";
-import Bundler from "./Bundler.js";
-import Router from "./Router.js";
-import Server from "./Server.js";
-import package_json from "../package.json" assert {"type": "json"};
-
-export default class App {
-  constructor(conf) {
-    this.conf = conf;
-  }
-
-  async run() {
-    log.reset("Primate").yellow(package_json.version);
-    const routes = await File.list(this.conf.paths.routes);
-    for (const route of routes) {
-      await import(`file://${this.conf.paths.routes}/${route}`);
-    }
-    await new Bundler(this.conf).bundle();
-
-    const conf = {"router": Router,
-      "serve_from": this.conf.paths.public,
-      "http": {
-        ...this.conf.http,
-        "key": File.read_sync(Path.resolve(this.conf.http.ssl.key)),
-        "cert": File.read_sync(Path.resolve(this.conf.http.ssl.cert)),
-        "keyFile": Path.resolve(this.conf.http.ssl.key),
-        "certFile": Path.resolve(this.conf.http.ssl.cert),
-      },
-    };
-    this.server = new Server(conf);
-    await this.server.run();
-    this.server.listen();
-  }
-}

package/source/EagerPromise.js

@@ -1,49 +0,0 @@
-import {inconstructible_function} from "./attributes.js";
-
-const $promise = Symbol("#promise");
-
-const handler = {
-  "get": (target, property) => {
-    const promise = target[$promise];
-
-    if (["then", "catch"].includes(property)) {
-      return promise[property].bind(promise);
-    }
-
-    return EagerPromise.resolve(promise.then(result => property === "bind"
-      ? result
-      : inconstructible_function(result[property])
-        ? 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.at(last);
-
-export {eager};

package/source/Router.js

@@ -1,31 +0,0 @@
-import {http404} from "./handlers/http.js";
-
-const aliases = [];
-const routes = [];
-const dealias = path => aliases.reduce((dealiased, {key, value}) =>
-  dealiased.replace(key, () => value), path);
-const push = (type, path, handler) =>
-  routes.push({type, "path": new RegExp(`^${dealias(path)}$`, "u"), handler});
-const find = (type, path, fallback = {"handler": r => r}) => routes.find(route =>
-  route.type === type && route.path.test(path)) ?? fallback;
-
-export default {
-  "map": (path, callback) => push("map", path, callback),
-  "get": (path, callback) => push("get", path, callback),
-  "post": (path, callback) => push("post", path, callback),
-  "alias": (key, value) => aliases.push({key, value}),
-  "process": async original_request => {
-    const {method} = original_request;
-    const url = new URL(`https://primatejs.com${original_request.pathname}`);
-    const {pathname, searchParams} = url;
-    const params = Object.fromEntries(searchParams);
-    const verb = find(method, pathname, () => ({"handler": http404``}));
-    const path = pathname.split("/").filter(path => path !== "");
-    Object.entries(verb.path.exec(pathname)?.groups ?? [])
-      .filter(([key]) => path[key] === undefined)
-      .forEach(([key, value]) => Object.defineProperty(path, key, {value}));
-
-    const request = {...original_request, pathname, params, path};
-    return verb.handler(await find("map", pathname).handler(request));
-  },
-};

package/source/Server.js

@@ -1,93 +0,0 @@
-import {Path, File, WebServer, log} from "runtime-compat";
-import Session from "./Session.js";
-import codes from "./http-codes.json" assert {"type": "json"};
-import mimes from "./mimes.json" assert {"type": "json"};
-import {http404} from "./handlers/http.js";
-
-const regex = /\.([a-z1-9]*)$/u;
-const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
-
-const stream = (from, response) => {
-  response.setStatus(codes.OK);
-  return from.pipe(response).on("close", () => response.end());
-};
-
-export default class Server {
-  constructor(conf) {
-    this.conf = conf;
-  }
-
-  async run() {
-    const {http} = this.conf;
-    const {csp, "same-site": same_site = "Strict"} = http;
-    this.csp = Object.keys(csp).reduce((policy_string, key) =>
-      policy_string + `${key} ${csp[key]};`, "");
-
-    this.server = new WebServer(http, async (request, response) => {
-      const session = await Session.get(request.headers.cookie);
-      if (!session.has_cookie) {
-        const {cookie} = session;
-        response.setHeader("Set-Cookie", `${cookie}; SameSite=${same_site}`);
-      }
-      response.session = session;
-      const text = await request.text();
-      const payload = Object.fromEntries(decodeURI(text).replaceAll("+", " ")
-        .split("&")
-        .map(part => part.split("="))
-        .filter(([, value]) => value !== ""));
-      const {pathname, search} = request.url;
-      return this.try(pathname + search, request, response, payload);
-    });
-  }
-
-  async try(url, request, response, payload) {
-    try {
-      await this.serve(url, request, response, payload);
-    } catch (error) {
-      console.log(error);
-      response.setStatus(codes.InternalServerError);
-      response.end();
-    }
-  }
-
-  async serve_file(url, filename, file, response) {
-    response.setHeader("Content-Type", mime(filename));
-    response.setHeader("Etag", await file.modified);
-    //await response.session.log("green", url);
-    return stream(file.read_stream, response);
-  }
-
-  async serve(url, request, response, payload) {
-    const filename = Path.join(this.conf.serve_from, url);
-    const file = await new File(filename);
-    return await file.is_file
-      ? this.serve_file(url, filename, file, response, payload)
-      : this.serve_route(url, request, response, payload);
-  }
-
-  async serve_route(pathname, request, response, payload) {
-    const req = {pathname, "method": request.method.toLowerCase(), payload};
-    let result;
-    try {
-      result = await this.conf.router.process(req);
-      for (const [key, value] of Object.entries(result.headers)) {
-        response.setHeader(key, value);
-      }
-    } catch (error) {
-      console.log(error);
-      result = http404``;
-    }
-    const {body, code} = result;
-    response.setHeader("Content-Security-Policy", this.csp);
-    response.setHeader("Referrer-Policy", "same-origin");
-    response.setStatus(code);
-    response.setBody(body);
-    response.end();
-  }
-
-  listen() {
-    const {port, host} = this.conf.http;
-    log.reset("on").yellow(`https://${host}:${port}`).nl();
-    this.server.listen(port, host);
-  }
-}

package/source/Session.js

@@ -1,26 +0,0 @@
-import Domain from "./domain/Domain.js";
-
-const extract_id = cookie_header => cookie_header
-  ?.split(";").filter(text => text.includes("session_id="))[0]?.split("=")[1];
-
-export default class Session extends Domain {
-  static get fields() {
-    return {
-      "?data": Object,
-      "created": value => value ?? new Date(),
-    };
-  }
-
-  static async get(cookie_header) {
-    const session = await Session.touch({"_id": extract_id(cookie_header)});
-    await session.save();
-    if (session.new) {
-      session.has_cookie = false;
-    }
-    return session;
-  }
-
-  get cookie() {
-    return `session_id=${this._id}; Path=/; Secure; HttpOnly`;
-  }
-}

package/source/attributes.js

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

package/source/conf.js

@@ -1,26 +0,0 @@
-import {Path, File} from "runtime-compat";
-import cache from "./cache.js";
-import extend_object from "./extend_object.js";
-import primate_json from "./preset/primate.json" assert {"type": "json" };
-
-const qualify = (root, paths) =>
-  Object.keys(paths).reduce((sofar, key) => {
-    const value = paths[key];
-    sofar[key] = typeof value === "string"
-      ? Path.join(root, value)
-      : qualify(`${root}/${key}`, value);
-    return sofar;
-  }, {});
-
-export default (file = "primate.json") => cache("conf", file, () => {
-  let conf = primate_json;
-  const root = Path.resolve();
-  try {
-    conf = extend_object(conf, JSON.parse(File.read_sync(Path.join(root, file))));
-  } catch (error) {
-    // local primate.json not required
-  }
-  conf.paths = qualify(root, conf.paths);
-  conf.root = root;
-  return conf;
-});

package/source/domain/Domain.js

@@ -1,285 +0,0 @@
-import {Crypto} from "runtime-compat";
-import Field from "./Field.js";
-import {PredicateError} from "../errors.js";
-import EagerPromise from "../EagerPromise.js";
-import Store from "../store/Store.js";
-import cache from "../cache.js";
-import DomainType from "../types/Domain.js";
-
-const length = 12;
-
-export default class Domain {
-  static stores_directory = "stores";
-  static store_file = "default.js";
-
-  static {
-    // avoid transitive cyclic dependency between Domain and Field
-    DomainType.instance = Domain;
-    this.cache = {};
-  }
-
-  constructor(document) {
-    const errors = {};
-    this.define("_id", {
-      "type": String,
-      "predicates": ["unique"],
-      "in": value => value ?? Crypto.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() {
-    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 EagerPromise.resolve(cache(this, "store", () =>
-      Store.get(this.stores_directory, this.store_file)
-    ));
-  }
-
-  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);
-  }
-
-  #proxy(property) {
-    return typeof property === "string" ? this.#link(property) : this[property];
-  }
-
-  #link(name) {
-    const field = this.fields[`${name}_id`];
-    if (field?.is_domain) {
-      const {collection} = field.Type;
-      const {cache} = this.Class;
-      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`]];
-    }
-    return undefined;
-  }
-
-  // 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;
-      }, {});
-  }
-
-  // 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;
-    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 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;
-  }
-
-  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;
-  }
-
-  delete() {
-    return this.store.delete(this.collection, {"_id": this._id});
-  }
-
-  static delete(criteria) {
-    return this.store.delete(this.collection, criteria);
-  }
-
-  static by_id(_id) {
-    return new EagerPromise(async resolve => {
-      const result = await this.store.find(this.collection, {"_id": await _id});
-      resolve(result.length > 0 ? this.deserialize(result[0]) : undefined);
-    });
-  }
-
-  static first(criteria, options) {
-    return new EagerPromise(async resolve => {
-      const result = await this.store.one(this.collection, criteria, options);
-      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 results = await this.store.find(this.collection, criteria, options);
-    return results.map(result => this.deserialize(result));
-  }
-
-  static count(criteria) {
-    return this.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();
-  }
-}