primate 0.5.2 → 0.6.2

package/source/server/Bundler.js

@@ -1,177 +0,0 @@
-import {dirname} from "path";
-import {fileURLToPath} from "url";
-import Directory from "./Directory.js";
-import File from "./File.js";
-import {algorithm, hash} from "./crypto.js";
-
-const meta_url = fileURLToPath(import.meta.url);
-const directory = dirname(meta_url);
-const preset = `${directory}/../preset`;
-
-const ending = 3;
-
-const s_declarations = () =>
-  "// Declarations\n"
-+ "const contexts = {};\n"
-+ "const routes = {};\n\n";
-
-const stringify_action = (context, domain, action, i, j, k) => {
-  const import_name = `route{i}_${j}_${k}`;
-  return `import ${import_name} from "./${context}/${domain}/${action}.js";\n`
-  + `routes["${context}"]["${domain}"]["${action}"] = ${import_name};\n`;
-};
-
-const stringify_actions = ({context, domain, actions = []}, i, j) =>
-  actions.reduce((s, action, k) =>
-    s + stringify_action(context, domain, action, i, j, k), "");
-
-const stringify_domain = (context, domain, i, j) =>
-  `routes["${context}"]["${domain.domain}"] = {};\n`
-+ stringify_actions(domain, i, j);
-
-const stringify_domains = ({context, domains}, i) =>
-  domains.reduce((s, domain, j) =>
-    s + stringify_domain(context, domain, i, j), "");
-
-const stringify_context = (context, i) =>
-  `import context${i} from "./${context.context}/context.js";\n`
-+ `contexts["${context.context}"] = context${i};\n`
-+ `routes["${context.context}"] = {};\n`
-+ stringify_domains(context, i) + "\n";
-
-const s_exports = () =>
-  "// Exports\n"
-+ "export {contexts, routes};\n";
-
-const stringify = actions =>
-  actions.reduce((s, context, i) => s + stringify_context(context, i), "");
-
-export default class Bundler {
-  constructor(conf) {
-    this.conf = conf;
-    this.debug = conf.debug;
-    this.index = conf.files.index;
-    this.scripts = [];
-    this.hashes = new Set();
-  }
-
-  async copy_with_preset(subdirectory, to) {
-    const {paths} = this.conf;
-
-    // copy files preset files first
-    await File.copy(`${preset}/${subdirectory}`, to);
-
-    // copy any user code over it, not recreating the folder
-    try {
-      await File.copy(paths[subdirectory], to, false);
-    } catch(error) {
-      // directory doesn't exist
-    }
-  }
-
-  async bundle() {
-    const {paths} = this.conf;
-    const client_directory = `${paths.public}/client`;
-
-    // copy static files to public
-    await this.copy_with_preset("static", paths.public);
-
-    // copy client files to public/client
-    await this.copy_with_preset("client", client_directory);
-
-    const primate_js = new File(`${client_directory}/primate.js`);
-    await primate_js.write("export * from \"./primate/exports.js\";");
-
-    // write dynamic exports to public/client/exports.js
-    await this.write_exports();
-
-    // copy framework code to public/client/primate
-    await File.copy(`${directory}/../client`, `${client_directory}/primate`);
-
-    await this.register_scripts();
-
-    // read index.html from public, then remove it (we serve it dynamically)
-    const index_html = await File.read(`${paths.public}/${this.index}`);
-    await File.remove(`${paths.public}/${this.index}`);
-
-    const body = `return \`${index_html}\``;
-    const index = new Function("conf", "client", body)(this.conf, this.client);
-
-    return {index, "hashes": this.hashes};
-  }
-
-  async register_scripts() {
-    const scripts = await this.collect("client");
-    Promise.all(scripts.map(async script =>
-      this.register(script, await File.read(this.conf.paths.public, script))
-    ));
-  }
-
-  async collect(path) {
-    // scan public/client and collect scripts to be added as tags
-    let scripts = [];
-    const files = await Directory.list(`${this.conf.paths.public}/${path}`);
-    for (const file of files) {
-      if (file.endsWith(".js")) {
-        scripts.push(`${path}/${file}`);
-      } else {
-        scripts = scripts.concat(await this.collect(`${path}/${file}`));
-      }
-    }
-
-    return scripts;
-  }
-
-  register(src, source) {
-    const integrity = `${algorithm}-${hash(source)}`;
-    this.scripts.push({"src": `${this.conf.base}${src}`, integrity});
-    this.hashes.add(integrity);
-  }
-
-  get public_client() {
-    return `${this.conf.paths.public}/client`;
-  }
-
-  get client() {
-    let client = "";
-    for (const {integrity, src} of this.scripts) {
-      client += `<script type="module" integrity="${integrity}" src="${src}">`
-              + "</script>\n";
-    }
-    return `${client}<first-view />`;
-  }
-
-  async write_exports() {
-    const exports = new File(this.public_client, "exports.js");
-
-    let export_string = s_declarations();
-    export_string += stringify(await this.read());
-    export_string += s_exports();
-
-    await exports.write(export_string);
-  }
-
-  async read() {
-    const path = this.public_client;
-
-    const contexts = (await Directory.list(path))
-      .filter(file => !file.endsWith(".js"))
-      .map(context => ({context}));
-
-    const context_domains = await Promise.all(contexts.map(async ({context}) =>
-      ({context, "domains": (await Directory.list(path, context))
-        .filter(file => !file.endsWith(".js"))
-        .map(domain => ({domain})),
-      })));
-
-    const actions = await Promise.all(context_domains
-      .map(({context, domains}) =>
-        Promise.all(domains.map(async ({domain}) => ({
-          context, domain,
-          "actions": (await Directory.list(path, context, domain))
-            .map(action => action.slice(0, -ending)),
-        })))));
-
-    return context_domains;
-  }
-}

package/source/server/Context.js

@@ -1,97 +0,0 @@
-import {resolve} from "path";
-import File from "./File.js";
-import Action from "./Action.js";
-import {InternalServerError} from "./errors.js";
-import {assert} from "./invariants.js";
-import cache from "./cache.js";
-import log from "./log.js";
-
-export default class Context {
-  static directory = "server";
-
-  constructor(name) {
-    this.name = name;
-  }
-
-  static before(action) {
-    return action;
-  }
-
-  static prepare(action, data) {
-    return {action, data};
-  }
-
-  static get(name) {
-    return cache(this, name, async () => {
-      const directory = resolve(`${this.directory}/${name}`);
-      assert(await File.exists(directory), () => {
-        throw new InternalServerError(`missing context directory \`${name}\``);
-      });
-      try {
-        return new (await import(`${directory}/context.js`)).default(name);
-      } catch (error) {
-        return new this(name);
-      }
-    });
-  }
-
-  get Class() {
-    return this.constructor;
-  }
-
-  get directory() {
-    return `${this.Class.directory}/${this.name}`;
-  }
-
-  get layouts() {
-    return cache(this, "layouts", () => {
-      const ending = -5;
-      const path = `${this.directory}/layouts`;
-
-      return new File(path).list().reduce(async (sofar, file) => {
-        const layouts = await sofar;
-        layouts[file.slice(0, ending)] = await File.read(`${path}/${file}`);
-        return layouts;
-      }, {});
-    });
-  }
-
-  log(color, message) {
-    log[color](this.name).reset(message).nl();
-  }
-
-  async handle(error, action) {
-    if (this.Class.error !== undefined) {
-      this.Class.error(action);
-      const response = await action.response();
-      assert(action.request.pathname !== response.location, () => {
-        throw new InternalServerError("redirect loop detected");
-      });
-      this.log("red", "handling error with context error handler");
-      return response;
-    } else {
-      throw new InternalServerError(error.message);
-    }
-  }
-
-  catch(error, action) {
-    if (error instanceof InternalServerError) {
-      // cannot proceed, throw up
-      throw error;
-    } else {
-      return this.handle(error, action);
-    }
-  }
-
-  async run(request, session) {
-    const {type = "read"} = request;
-    try {
-      const action = await Action.new(request, session, this);
-      await this.Class.before(action);
-      await action.run(type);
-      return action.response();
-    } catch(error) {
-      return this.catch(error, new Action(request, session, this));
-    }
-  }
-}

package/source/server/Projector.js

@@ -1,86 +0,0 @@
-import Domain from "./domain/Domain.js";
-import {actuals} from "./domain/domains.js";
-import log from "./log.js";
-
-const scalar = async (document, property) => {
-  const value = await document[property];
-  return value instanceof Domain ? {} : value;
-};
-
-export default class Projector {
-  constructor(documents, projection = []) {
-    this.cache = {};
-    for (const actual in actuals) {
-      this.cache[actual] = {};
-    }
-    this.documents = documents;
-    this.projection = projection.reduce((sofar, domain) => {
-      const [key] = Object.keys(domain);
-      sofar[key] = domain[key];
-      return sofar;
-    }, {});
-  }
-
-  many(documents, projection) {
-    return Promise.all(documents.map(d => this.resolve(d, projection)));
-  }
-
-  async by_store(key, document, projection) {
-    return this.resolve(await document[key], projection[key]);
-  }
-
-  async by_cache(space, key, document, projection) {
-    const cache = this.cache[space];
-    const key_id = document[`${key}_id`];
-    if (cache[key_id] === undefined) {
-      cache[key_id] = await this.by_store(key, document, projection);
-    }
-    return cache[key_id];
-  }
-
-  object(document, projection, key, fields) {
-    return fields?.[key] === undefined
-      ? this.by_store(key, document, projection)
-      : this.by_cache(fields[key], key, document, projection);
-  }
-
-  async one(document, projection) {
-    if (document === undefined) {
-      return undefined;
-    }
-    const resolved = {};
-    let fields = undefined;
-    if (document instanceof Domain && document.Class.name !== "default") {
-      fields = actuals[document.Class.name];
-    }
-    for (const property of projection) {
-      if (typeof property === "string") {
-        resolved[property] = await scalar(document, property);
-      } else if (typeof property === "object") {
-        const [key] = Object.keys(property);
-        resolved[key] = await this.object(document, property, key, fields);
-      }
-    }
-    return resolved;
-  }
-
-  resolve(document, projection) {
-    return this[Array.isArray(document) ? "many" : "one"](document, projection);
-  }
-
-  async project() {
-    return (await Promise.all(Object.keys(this.documents).map(async key => {
-      const resolved = this.projection[key] === undefined
-        ? undefined
-        : await this.resolve(await this.documents[key], this.projection[key]);
-      return {key, resolved};
-    }))).reduce((projected, {key, resolved}) => {
-      if (resolved === undefined) {
-        log.yellow(`  \`${key}\` not projected`).nl();
-      } else {
-        projected[key] = resolved;
-      }
-      return projected;
-    }, {});
-  }
-}

package/source/server/Router.js

@@ -1,52 +0,0 @@
-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) {
-      return pathname;
-    }
-
-    const replace = path.replace(route.from, route.to);
-    return `${replace}${replace.includes("?") ? "" : "?"}&${search}`;
-  }
-
-  resolve(pathname, context) {
-    return this.context(context) === undefined
-      ? pathname
-      : this.resolve_by_context(pathname, context);
-  }
-
-  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, _id] = parts;
-    return {
-      "pathname": url.pathname, resolved, parts,
-      "path": {namespace, action, _id},
-      "params": {...Object.fromEntries(url.searchParams)},
-    };
-  }
-}

package/source/server/domain/domains.js

@@ -1,31 +0,0 @@
-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.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 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/servers/Dynamic.js

@@ -1,57 +0,0 @@
-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) {
-    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");
-  }
-
-  async try(socket, event) {
-    const {session} = socket;
-    const request = JSON.parse(event);
-    try {
-      await this.serve(request, socket);
-      await session.log("green", `${request.type} ${request.url}`);
-    } catch(error) {
-      await session.log("red", error.message);
-    }
-  }
-
-  async serve(request, socket) {
-    const {router} = this.conf;
-    const {session} = socket;
-    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.serve(socket, response);
-  }
-
-  static serve(socket, response) {
-    socket.send(JSON.stringify(response));
-  }
-
-  redirect(socket, {location}) {
-    if (location.startsWith("https://")) {
-      // redirect externally
-      return undefined;
-    } else {
-      const url = location;
-      this.try(socket, JSON.stringify({"pathname": url, url, "type": "read"}));
-      return true;
-    }
-  }
-}

package/source/server/servers/Server.js

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

package/source/server/servers/Static.js

@@ -1,117 +0,0 @@
-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"};
-
-const regex = /\.([a-z1-9]*)$/u;
-const mime = filename => mimes[filename.match(regex)[1]] ?? mimes.binary;
-
-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, context} = 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 = await createServer(http, async (request, response) => {
-      const session = await Session.get(request.headers.cookie, context);
-      if (!session.has_cookie) {
-        const {cookie} = session;
-        response.setHeader("Set-Cookie", `${cookie}; SameSite=${same_site}`);
-      }
-      response.session = session;
-      request.on("end", () =>
-        this.try(parse(request.url).path, request, response)
-      ).resume();
-    });
-  }
-
-  async try(url, request, response) {
-    try {
-      await this.serve(url, request, response);
-    } catch (error) {
-      await response.session.log("red", error.message);
-      response.writeHead(codes.InternalServerError);
-      response.end();
-    }
-  }
-
-  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);
-    return await file.is_file
-      ? this.serve_file(url, filename, file, response)
-      : this.serve_data(url, 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, "url": 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.session.run(${JSON.stringify(data)});`;
-    const integrity = `${algorithm}-${hash(src)}`;
-    const view = `<script type="module" integrity="${integrity}">${src}`
-               + "</script>";
-    const file = index.replace("<first-view />", () => view);
-    const script_src = Array.from(hashes)
-      .concat([integrity])
-      .reduce((hash_string, next_hash) => hash_string + ` '${next_hash}'`, "");
-
-    response.setHeader("Content-Security-Policy",
-      this.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);
-    }
-  }
-}