arcadible 0.1.0 → 0.1.2

package/src/action/deploy/tool.js

@@ -0,0 +1,11 @@
+"use strict";
+
+// [function]
+
+const main = function () {
+  return Promise.reject(new Error("Unimplemented command."));
+};
+
+// [export]
+
+module.exports = main;

package/src/action/deploy-git/git.js

@@ -0,0 +1,192 @@
+"use strict";
+
+// [import]
+
+const execFile = require("node:child_process").execFile;
+
+// [import]
+
+const semver = require("semver");
+
+// [import]
+
+const strs = require("../../util/strs");
+
+// [use]
+
+const compareSemver = semver.compare;
+const trimWhitespace = strs.trimWhitespace;
+const validSemver = semver.valid;
+
+// [declare]
+
+const PREFIX = "arcadible/release/v";
+
+// [function]
+
+const git = function (root, args, cb) {
+  execFile("git", ["-C", root, ...args], cb);
+};
+
+// [function]
+
+const ensureRepo = function (root, cb) {
+  const message = [
+    "Unable to find Git repository.",
+    "Run this command from a Git repository.",
+  ];
+  git(root, ["rev-parse", "--is-inside-work-tree"], (err) => {
+    if (err) {
+      cb(new Error(message.join("\n"), { cause: err }));
+      return;
+    }
+    cb();
+  });
+};
+
+// [function]
+
+const ensureRemote = function (root, cb) {
+  const message = [
+    "Unable to access Git remote 'origin'.",
+    "Verify the remote exists and you have permission to access it.",
+  ];
+  git(root, ["ls-remote", "origin"], (err) => {
+    if (err) {
+      cb(new Error(message.join("\n"), { cause: err }));
+      return;
+    }
+    cb();
+  });
+};
+
+// [function]
+
+const ensureClean = function (root, cb) {
+  const message = [
+    "Unable to continue with unstaged changes.",
+    "Stage, commit, or discard local changes before deploying.",
+  ];
+  git(root, ["diff", "--quiet"], (err) => {
+    if (err) {
+      if (err.code === 1) {
+        cb(new Error(message.join("\n"), { cause: err }));
+        return;
+      }
+      cb(err);
+      return;
+    }
+    git(root, ["diff", "--cached", "--quiet"], (err) => {
+      if (!err) {
+        cb(null, { cached: false });
+        return;
+      }
+      if (err.code === 1) {
+        cb(null, { cached: true });
+        return;
+      }
+      cb(err);
+    });
+  });
+};
+
+// [function]
+
+const fetchTags = function (root, cb) {
+  const message = [
+    "Unable to synchronize Git release tags.",
+    "Run `arc deploy` again to retry with the latest release tags.",
+  ];
+  git(
+    root,
+    ["fetch", "origin", `refs/tags/${PREFIX}*:refs/tags/${PREFIX}*`],
+    (err) => {
+      if (err) {
+        cb(new Error(message.join("\n"), { cause: err }));
+        return;
+      }
+      cb();
+    },
+  );
+};
+
+// [function]
+
+const listTags = function (root, cb) {
+  fetchTags(root, (err) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    git(root, ["tag", "--list", `${PREFIX}*`], (err, stdOut) => {
+      if (err) {
+        cb(err);
+        return;
+      }
+      const versions = trimWhitespace(stdOut)
+        .split("\n")
+        .map((tag) => tag.slice(PREFIX.length))
+        .filter(validSemver)
+        .sort(compareSemver);
+      cb(null, versions.at(-1) || "0.0.0");
+    });
+  });
+};
+
+// [function]
+
+const createTag = function (root, version, pre, cb) {
+  const message = [
+    "Unable to create Git tag.",
+    "Verify the release tag does not already exist locally.",
+  ];
+  git(
+    root,
+    [
+      "tag",
+      "-a",
+      `${PREFIX}${version}`,
+      "-m",
+      pre ? `Prerelease v${version}` : `Release v${version}`,
+    ],
+    (err) => {
+      if (err) {
+        cb(new Error(message.join("\n"), { cause: err }));
+        return;
+      }
+      cb();
+    },
+  );
+};
+
+// [function]
+
+const pushTag = function (root, version, cb) {
+  const message = [
+    "Unable to push Git tag.",
+    "Run `arc deploy` again to retry with the latest release version.",
+  ];
+  git(root, ["push", "origin", `${PREFIX}${version}`], (err) => {
+    if (err) {
+      cb(new Error(message.join("\n"), { cause: err }));
+      return;
+    }
+    cb();
+  });
+};
+
+// [function]
+
+const release = function (root, version, pre, cb) {
+  createTag(root, version, pre, (err) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    pushTag(root, version, cb);
+  });
+};
+
+// [export]
+
+module.exports = { ensureClean, ensureRemote, ensureRepo, listTags, release };

package/src/action/deploy-git/tool.js

@@ -0,0 +1,86 @@
+"use strict";
+
+// [import]
+
+const semver = require("semver");
+
+// [import]
+
+const git = require("./git");
+
+// [use]
+
+const ensureClean = git.ensureClean;
+const ensureRemote = git.ensureRemote;
+const ensureRepo = git.ensureRepo;
+const incSemver = semver.inc;
+const listTags = git.listTags;
+const release = git.release;
+
+// [function]
+
+const deployGit = function ({ pre, preId, root }, handler, cb) {
+  listTags(root, (err, from) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    const to = incSemver(from, pre ? "prerelease" : "patch", preId);
+    release(root, to, pre, (err) => {
+      if (err) {
+        cb(err);
+        return;
+      }
+      cb(null, { from, to });
+    });
+  });
+};
+
+// [function]
+
+const deploy = function ({ pre, preId, root }, { onInfo }, cb) {
+  ensureRepo(root, (err) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    ensureClean(root, (err, diff) => {
+      if (err) {
+        cb(err);
+        return;
+      }
+      if (diff.cached) {
+        onInfo({
+          level: "warn",
+          message: "Staged but uncommitted changes will not be deployed.",
+        });
+      }
+      ensureRemote(root, (err) => {
+        if (err) {
+          cb(err);
+          return;
+        }
+        deployGit({ pre, preId, root }, { onInfo }, cb);
+      });
+    });
+  });
+};
+
+// [function]
+
+const main = function ({ pre, preId, root }, { onBegin, ...handler }) {
+  onBegin({ root });
+  return new Promise((resolve, reject) => {
+    deploy({ pre, preId, root }, handler, (err, data) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(data);
+    });
+  });
+};
+
+// [export]
+
+module.exports = main;

package/src/action/init/tool.js

@@ -0,0 +1,44 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const degit = require("degit");
+const fs = require("fs-extra");
+
+// [use]
+
+const pathExists = fs.pathExists;
+const remove = fs.remove;
+const resolve = path.resolve;
+
+// [function]
+
+const init = function (src, dest, { onBegin, onInfo }) {
+  onBegin({ dest, src });
+  return degit(src, { cache: false, force: true, verbose: false })
+    .on("info", onInfo)
+    .clone(dest)
+    .then(() => remove(resolve(dest, "LICENSE")));
+};
+
+// [function]
+
+const main = function ({ force, project, root, starter }, handler) {
+  const dest = resolve(root, project);
+  return pathExists(dest)
+    .then((exists) => {
+      if (exists && !force) {
+        throw new Error("Directory exists. Run with `--force` to overwrite.");
+      }
+      return init(starter, dest, handler);
+    })
+    .then(() => ({ path: dest }));
+};
+
+// [export]
+
+module.exports = main;

package/src/action/inspect/tool.js

@@ -0,0 +1,25 @@
+"use strict";
+
+// [import]
+
+const dotProp = require("dot-prop");
+
+// [import]
+
+const project = require("../../parser/project");
+
+// [function]
+
+const inspect = function (proj, key) {
+  return key ? dotProp.get(proj, key, null) : proj;
+};
+
+// [function]
+
+const main = function ({ key, root }) {
+  return project.parse(root).then((proj) => inspect(proj, key));
+};
+
+// [export]
+
+module.exports = main;

package/src/action/login/flow.js

@@ -0,0 +1,94 @@
+"use strict";
+
+// [import]
+
+const crypto = require("node:crypto");
+
+// [import]
+
+const api = require("../../api");
+const cfgurl = require("../../config/url");
+const time = require("../../util/time");
+
+// [use]
+
+const randomUUID = crypto.randomUUID;
+
+// [function]
+
+const postFlow = function ({ expiresAt, token, type }) {
+  const form = new FormData();
+  form.append("expires_at", expiresAt.toISOString());
+  form.append("token", token);
+  form.append("type", type);
+  return api.postFlow(form);
+};
+
+// [function]
+
+const getFlow = function ({ id, token }) {
+  return api.getFlow(id, { token });
+};
+
+// [function]
+
+const createFlow = function ({ expiresAt, token, type }, onCreated) {
+  return postFlow({ expiresAt, token, type }).then(({ code, id }) => {
+    if (onCreated) {
+      onCreated({ code, url: cfgurl.LINK });
+    }
+    return { id };
+  });
+};
+
+// [function]
+
+const pollFlow = function ({ id, token }, onPoll) {
+  return getFlow({ id, token }).then(({ data, status }) => {
+    if (onPoll) {
+      onPoll({ status });
+    }
+    switch (status) {
+      case "pending":
+        return null;
+      case "completed":
+        return data;
+      case "failed":
+        throw new Error("Login flow failed.");
+      default:
+        throw new Error("Login flow expired.");
+    }
+  });
+};
+
+// [function]
+
+const main = function ({ onCreated, onPoll }) {
+  const expiresAt = new Date(Date.now() + time.m(5));
+  const token = randomUUID();
+  return createFlow(
+    {
+      expiresAt,
+      token,
+      type: "cli-login",
+    },
+    onCreated,
+  ).then(({ id }) => {
+    const timeout = Math.max(0, expiresAt.getTime() - Date.now() - time.s(15));
+    return time.poll(
+      (flow) => pollFlow(flow, onPoll),
+      { id, token },
+      {
+        delay: time.s(3),
+        factor: 2,
+        interval: time.s(30),
+        maxDelay: time.s(15),
+        timeout,
+      },
+    );
+  });
+};
+
+// [export]
+
+module.exports = main;

package/src/action/login/tool.js

@@ -0,0 +1,16 @@
+"use strict";
+
+// [import]
+
+const flow = require("./flow");
+const user = require("../../user");
+
+// [function]
+
+const main = function (conf, handler) {
+  return flow(handler).then(user.save);
+};
+
+// [export]
+
+module.exports = main;

package/src/action/logout/tool.js

@@ -0,0 +1,15 @@
+"use strict";
+
+// [import]
+
+const user = require("../../user");
+
+// [function]
+
+const main = function () {
+  return user.remove();
+};
+
+// [export]
+
+module.exports = main;

package/src/action/pack/tool.js

@@ -0,0 +1,60 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const fs = require("fs-extra");
+
+// [import]
+
+const project = require("../../parser/project");
+const Zip = require("../../util/zip");
+
+// [use]
+
+const pathExists = fs.pathExists;
+const pathParse = path.parse;
+const resolve = path.resolve;
+
+// [declare]
+
+const MANIFEST = "arcadible.json";
+const MEDIA = ".arcadible";
+
+// [function]
+
+const pack = function (name, game, { deployPath, mediaPath, zipPath }) {
+  const zip = new Zip(name);
+  return Promise.all([pathExists(deployPath), pathExists(mediaPath)])
+    .then(([existsDeploy, existsMedia]) => {
+      if (existsDeploy) {
+        zip.addDir(deployPath);
+      }
+      if (existsMedia) {
+        zip.addDir(mediaPath, MEDIA);
+      }
+      zip.addJson(MANIFEST, { game });
+      zip.write(zipPath);
+      return zip.stat();
+    })
+    .then((stat) => ({ path: zipPath, ...stat }));
+};
+
+// [function]
+
+const main = function ({ output, root }) {
+  return project.parse(root).then(({ game, workflow }) =>
+    pack(pathParse(output).name, game, {
+      deployPath: resolve(root, workflow.deploy_dir),
+      mediaPath: resolve(root, MEDIA),
+      zipPath: resolve(root, output),
+    }),
+  );
+};
+
+// [export]
+
+module.exports = main;

package/src/action/validate/tool.js

@@ -0,0 +1,39 @@
+"use strict";
+
+// [import]
+
+const game = require("../../schema/game");
+const project = require("../../parser/project");
+const schema = require("../../util/schema");
+const workflow = require("../../schema/workflow");
+
+// [use]
+
+const validator = schema.validator;
+
+// [define]
+
+const gameValidator = validator("game", game);
+const workflowValidator = validator("workflow", workflow);
+
+// [function]
+
+const validate = function (proj, { root }) {
+  const issues = [
+    gameValidator(proj.game, { root }),
+    workflowValidator(proj.workflow, { root }),
+  ]
+    .filter((result) => result.issues.length)
+    .flatMap((result) => result.issues);
+  return issues;
+};
+
+// [function]
+
+const main = function ({ root }) {
+  return project.parse(root).then((proj) => validate(proj, { root }));
+};
+
+// [export]
+
+module.exports = main;

package/src/action/whoami/tool.js

@@ -0,0 +1,15 @@
+"use strict";
+
+// [import]
+
+const user = require("../../user");
+
+// [function]
+
+const main = function (conf, handler) {
+  return user.get(handler);
+};
+
+// [export]
+
+module.exports = main;

package/src/api.js

@@ -0,0 +1,39 @@
+"use strict";
+
+// [import]
+
+const cfguri = require("./config/uri");
+const request = require("./util/request");
+
+// [declare]
+
+const API_HOST = cfguri.HOST_HTTP_API;
+const API_VERSION = "v1";
+
+// [function]
+
+const endpoint = function (path) {
+  return `${API_HOST}/${API_VERSION}${path}`;
+};
+
+// [function]
+
+const authRefresh = function (form, options) {
+  return request.post(endpoint("/auth/refresh"), form, options);
+};
+
+// [function]
+
+const getFlow = function (id, options) {
+  return request.get(endpoint(`/flows/${id}`), options);
+};
+
+// [function]
+
+const postFlow = function (form, options) {
+  return request.post(endpoint("/flows"), form, options);
+};
+
+// [export]
+
+module.exports = { authRefresh, getFlow, postFlow };

package/src/cli/deploy.js

@@ -0,0 +1,17 @@
+"use strict";
+
+// [import]
+
+const deployGitTool = require("../action/deploy-git/tool");
+const deployTool = require("../action/deploy/tool");
+
+// [function]
+
+const main = function ({ direct, handler, ...conf }) {
+  const tool = direct ? deployTool : deployGitTool;
+  return tool(conf, handler);
+};
+
+// [export]
+
+module.exports = main;

package/src/cli/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+// [import]
+
+const deploy = require("./deploy");
+const init = require("./init");
+const inspect = require("./inspect");
+const login = require("./login");
+const logout = require("./logout");
+const pack = require("./pack");
+const validate = require("./validate");
+const whoami = require("./whoami");
+
+// [export]
+
+module.exports = {
+  deploy,
+  init,
+  inspect,
+  login,
+  logout,
+  pack,
+  validate,
+  whoami,
+};

package/src/cli/init.js

@@ -0,0 +1,15 @@
+"use strict";
+
+// [import]
+
+const initTool = require("../action/init/tool");
+
+// [function]
+
+const main = function ({ handler, ...conf }) {
+  return initTool(conf, handler);
+};
+
+// [export]
+
+module.exports = main;