arcadible 0.0.1 → 0.1.1

package/src/schema/workflow.js

@@ -0,0 +1,119 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const z = require("zod");
+
+// [import]
+
+const cfgurl = require("../config/url");
+
+// [use]
+
+const isAbsolute = path.isAbsolute;
+const join = path.join;
+const pathExistsSync = fs.pathExistsSync; // eslint-disable-line no-sync
+const resolve = path.resolve;
+
+// [declare]
+
+const MEDIA = ".arcadible";
+
+// [function]
+
+const reference = function (field) {
+  return chalk.cyan.underline(`${cfgurl.MANIFEST}#${field}`);
+};
+
+// [function]
+
+const indent = function (text, spaces = 2) {
+  const pad = " ".repeat(spaces);
+  return text
+    .split("\n")
+    .map((line) => pad + line)
+    .join("\n");
+};
+
+// [function]
+
+const message = function (field, msg) {
+  return { message: [msg, indent(reference(field))].join("\n") };
+};
+
+// [function]
+
+const isOutPath = function (root, dir) {
+  const resolvedRoot = resolve(root);
+  const resolvedTarget = resolve(root, dir);
+  const outside =
+    resolvedTarget !== resolvedRoot &&
+    !resolvedTarget.startsWith(resolvedRoot + path.sep);
+  return outside;
+};
+
+// [function]
+
+const isMediaPath = function (root, dir) {
+  const resolvedTarget = resolve(root, dir);
+  const containsMedia = resolvedTarget.split(path.sep).includes(MEDIA);
+  return containsMedia;
+};
+
+// [function]
+
+const isRealPath = function (root, dir) {
+  return pathExistsSync(join(root, dir));
+};
+
+// [function]
+
+const zDeployDir = function (root, { skip_build: skipBuild }) {
+  const field = "workflow.deploy_dir";
+  let zz = z
+    .string()
+    .min(1)
+    .refine((dir) => !isAbsolute(dir), message(field, "Must be relative."))
+    .refine(
+      (dir) => !isOutPath(root, dir),
+      message(field, "Must be within the project."),
+    )
+    .refine(
+      (dir) => !isMediaPath(root, dir),
+      message(field, "Must not contain reserved names."),
+    );
+  if (skipBuild) {
+    zz = zz.refine(
+      (dir) => isRealPath(root, dir),
+      message(field, "Must exist."),
+    );
+  }
+  return zz;
+};
+
+// [function]
+
+const zSkipBuild = function () {
+  return z.boolean();
+};
+
+// [function]
+
+const main = function (value, { root }) {
+  /* eslint-disable camelcase */
+  return z.object({
+    deploy_dir: zDeployDir(root, value),
+    skip_build: zSkipBuild(),
+  });
+  /* eslint-enable camelcase */
+};
+
+// [export]
+
+module.exports = main;

package/src/user.js

@@ -0,0 +1,91 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const fs = require("fs-extra");
+
+// [import]
+
+const api = require("./api");
+const os = require("./util/os");
+
+// [use]
+
+const configDir = os.configDir;
+const join = path.join;
+const mkdir = fs.promises.mkdir;
+const readFile = fs.promises.readFile;
+const unlink = fs.promises.unlink;
+const writeFile = fs.promises.writeFile;
+
+// [declare]
+
+const CMD = "arc";
+const FILE = "user.json";
+
+// [define]
+
+const dir = join(configDir(), CMD);
+const file = join(dir, FILE);
+
+// [function]
+
+const expired = function (session) {
+  return session.expires_at <= Math.floor(Date.now() / 1000) + 60;
+};
+
+// [function]
+
+const save = function (user) {
+  return mkdir(dir, { recursive: true })
+    .then(() => writeFile(file, JSON.stringify(user, null, 2), "utf8"))
+    .then(() => user);
+};
+
+// [function]
+
+const refresh = function ({ session, ...user }) {
+  const form = new FormData();
+  form.append("refresh_token", session.refresh_token);
+  return api.authRefresh(form).then((data) => save({ ...user, session: data }));
+};
+
+// [function]
+
+const get = function ({ onRefresh }) {
+  return readFile(file, "utf8")
+    .then(JSON.parse)
+    .catch((ex) => {
+      if (ex.code === "ENOENT") {
+        return null;
+      }
+      throw ex;
+    })
+    .then((user) => {
+      if (!user || !user.session) {
+        return null;
+      }
+      return expired(user.session)
+        ? onRefresh((renew) => (renew ? refresh(user) : null))
+        : user;
+    });
+};
+
+// [function]
+
+const remove = function () {
+  return unlink(file).catch((ex) => {
+    if (ex.code === "ENOENT") {
+      return;
+    }
+    throw ex;
+  });
+};
+
+// [export]
+
+module.exports = { get, remove, save };

package/src/util/dom.js

@@ -0,0 +1,27 @@
+"use strict";
+
+// [import]
+
+const dompurify = require("dompurify");
+const jsdom = require("jsdom");
+
+// [use]
+
+const DOM = jsdom.JSDOM;
+
+// [function]
+
+const sanitize = function (str, cfg) {
+  const dom = dompurify(new DOM().window);
+  if (cfg) {
+    return dom.sanitize(str, {
+      ALLOWED_ATTR: cfg.ALLOWED_ATTR,
+      ALLOWED_TAGS: cfg.ALLOWED_TAGS,
+    });
+  }
+  return dom.sanitize(str);
+};
+
+// [export]
+
+module.exports = { DOM, sanitize };

package/src/util/log.js

@@ -0,0 +1,99 @@
+"use strict";
+
+// [import]
+
+const chalk = require("chalk");
+
+// [function]
+
+const log = function (
+  out,
+  message,
+  { bold = false, color = "white", nl = false } = {},
+) {
+  let text = message;
+  if (Array.isArray(text)) {
+    text = text.join("\n");
+  }
+  let marker = chalk;
+  if (bold) {
+    marker = chalk.bold;
+  }
+  out(marker[color](text.trim().concat(nl ? "\n" : "")));
+};
+
+// [function]
+
+const h = function (message) {
+  log(console.log, message, { bold: true });
+};
+
+// [function]
+
+const hnl = function (message) {
+  log(console.log, message, { bold: true, nl: true });
+};
+
+// [function]
+
+const p = function (message) {
+  log(console.log, message);
+};
+
+// [function]
+
+const pnl = function (message) {
+  log(console.log, message, { nl: true });
+};
+
+// [function]
+
+const hd = function (message) {
+  log(console.error, message, { bold: true, color: "red" });
+};
+
+// [function]
+
+const hdnl = function (message) {
+  log(console.error, message, { bold: true, color: "red", nl: true });
+};
+
+// [function]
+
+const pd = function (message) {
+  log(console.error, message, { color: "red" });
+};
+
+// [function]
+
+const pdnl = function (message) {
+  log(console.error, message, { color: "red", nl: true });
+};
+
+// [function]
+
+const hs = function (message) {
+  log(console.log, message, { bold: true, color: "green" });
+};
+
+// [function]
+
+const hsnl = function (message) {
+  log(console.log, message, { bold: true, color: "green", nl: true });
+};
+
+// [function]
+
+const ps = function (message) {
+  log(console.log, message, { color: "green" });
+};
+
+// [function]
+
+const psnl = function (message) {
+  log(console.log, message, { color: "green", nl: true });
+};
+
+// [export]
+
+module.exports = { h, hd, hdnl, hnl, hs, hsnl, p, pd, pdnl, pnl, ps, psnl };

package/src/util/md.js

@@ -0,0 +1,24 @@
+"use strict";
+
+// [import]
+
+const marked = require("marked");
+
+// [import]
+
+const dom = require("./dom");
+const strs = require("./strs");
+
+// [use]
+
+const stripLeadingInvisible = strs.stripLeadingInvisible;
+
+// [function]
+
+const parse = function (str) {
+  return dom.sanitize(marked.parse(stripLeadingInvisible(str)));
+};
+
+// [export]
+
+module.exports = { parse };

package/src/util/objs.js

@@ -0,0 +1,28 @@
+"use strict";
+
+// [function]
+
+const pruneEmpty = function (value) {
+  /* eslint-disable no-undefined */
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    const cleaned = value.map(pruneEmpty).filter((v) => v !== undefined);
+    return cleaned.length ? cleaned : undefined;
+  }
+  if (typeof value === "object") {
+    const cleaned = Object.fromEntries(
+      Object.entries(value)
+        .map(([k, v]) => [k, pruneEmpty(v)])
+        .filter(([, v]) => v !== undefined),
+    );
+    return Object.keys(cleaned).length ? cleaned : undefined;
+  }
+  return value;
+  /* eslint-enable no-undefined */
+};
+
+// [export]
+
+module.exports = { pruneEmpty };

package/src/util/os.js

@@ -0,0 +1,24 @@
+"use strict";
+
+// [import]
+
+const os = require("node:os");
+const path = require("node:path");
+
+// [use]
+
+const homedir = os.homedir;
+const join = path.join;
+
+// [function]
+
+const configDir = function () {
+  if (process.platform === "win32") {
+    return process.env.APPDATA;
+  }
+  return join(homedir(), ".config");
+};
+
+// [export]
+
+module.exports = { configDir };

package/src/util/output.js

@@ -0,0 +1,46 @@
+"use strict";
+
+// [import]
+
+const TOML = require("@iarna/toml");
+
+// [function]
+
+const write = function (data) {
+  process.stdout.write(data.trim().concat("\n"));
+};
+
+// [function]
+
+const printJson = function (data) {
+  write(JSON.stringify(data, null, 2));
+};
+
+// [function]
+
+const printToml = function (data, key = "value") {
+  const field = key.split(".").at(-1);
+  if (data === null) {
+    write(`# ${field} = null`);
+    return;
+  }
+  try {
+    write(TOML.stringify(data));
+  } catch (ex) {
+    write(TOML.stringify({ [field]: data }));
+  }
+};
+
+// [function]
+
+const print = function (data, { key, toml } = {}) {
+  if (toml) {
+    printToml(data, key);
+  } else {
+    printJson(data);
+  }
+};
+
+// [export]
+
+module.exports = { print, printJson, printToml };

package/src/util/promise.js

@@ -0,0 +1,29 @@
+"use strict";
+
+// [function]
+
+const aConcat = function (ls) {
+  return Array.prototype.concat.bind(ls);
+};
+
+// [function]
+
+const pConcat = function (fn) {
+  return (ls) => fn(ls).then(aConcat(ls));
+};
+
+// [function]
+
+const pReduce = function (p, fn) {
+  return p.then(pConcat(fn));
+};
+
+// [function]
+
+const serial = function (fns) {
+  return fns.reduce(pReduce, Promise.resolve([]));
+};
+
+// [export]
+
+module.exports = { serial };

package/src/util/rc.js

@@ -0,0 +1,41 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const rc = require("rc");
+
+// [use]
+
+const join = path.join;
+const resolve = path.resolve;
+
+// [function]
+
+const cwd = function (argv, option) {
+  let dir = ".";
+  const idx = argv.findIndex((arg) => option.includes(arg));
+  if (idx !== -1 && argv[idx + 1] && !argv[idx + 1].startsWith("-")) {
+    dir = argv[idx + 1];
+  }
+  return dir;
+};
+
+// [function]
+
+const config = function (cmd, argv, option) {
+  return join(resolve(process.cwd(), cwd(argv, option)), `.${cmd}rc`);
+};
+
+// [function]
+
+const findRc = function (cmd, subcmd, argv, option) {
+  return rc(cmd, {}, { config: config(cmd, argv, option) })[subcmd] || {};
+};
+
+// [export]
+
+module.exports = { findRc };

package/src/util/request.js

@@ -0,0 +1,62 @@
+"use strict";
+
+// [import]
+
+const pkg = require("../../package.json");
+
+// [declare]
+
+const CLIENT_ID = "cli";
+const CLIENT_VERSION = pkg.version;
+
+// [function]
+
+const parse = function (resp) {
+  return resp.json().then((json) => {
+    if (!resp.ok) {
+      throw new Error(json.data.message);
+    }
+    return json.data;
+  });
+};
+
+// [function]
+
+const send = function (method, url, body, { token } = {}) {
+  const headers = {
+    "X-Arc-Id": CLIENT_ID,
+    "X-Arc-Version": CLIENT_VERSION,
+  };
+  if (token) {
+    headers.authorization = `Bearer ${token}`;
+  }
+  return fetch(url, { body, headers, method }).then(parse);
+};
+
+// [function]
+
+const get = function (url, options) {
+  return send("GET", url, null, options);
+};
+
+// [function]
+
+const post = function (url, body, options) {
+  return send("POST", url, body, options);
+};
+
+// [function]
+
+const patch = function (url, body, options) {
+  return send("PATCH", url, body, options);
+};
+
+// [function]
+
+const del = function (url, options) {
+  return send("DELETE", url, null, options);
+};
+
+// [export]
+
+module.exports = { del, get, patch, post };

package/src/util/schema.js

@@ -0,0 +1,25 @@
+"use strict";
+
+// [function]
+
+const format = function (name, error) {
+  return error.issues.map(
+    (issue) => `${name}.${issue.path.join(".") || "value"}: ${issue.message}`,
+  );
+};
+
+// [function]
+
+const validator = function (name, schema) {
+  return function (value, conf) {
+    const result = schema(value, conf).safeParse(value);
+    if (!result.success) {
+      return { issues: format(name, result.error) };
+    }
+    return { issues: [] };
+  };
+};
+
+// [export]
+
+module.exports = { validator };

package/src/util/strs.js

@@ -0,0 +1,21 @@
+"use strict";
+
+// [function]
+
+const stripLeadingInvisible = function (str) {
+  return String(str).replace(
+    // eslint-disable-next-line no-misleading-character-class
+    /^[\u200B\u200C\u200D\u2060\u2061\u2062\u2063\uFEFF]+/u,
+    "",
+  );
+};
+
+// [function]
+
+const trimWhitespace = function (str) {
+  return String(str).trim();
+};
+
+// [export]
+
+module.exports = { stripLeadingInvisible, trimWhitespace };