arcadible 0.1.32 → 0.1.34

package/src/action/play/tool.js

@@ -3,10 +3,16 @@
 // [import]
 
 const api = require("../../api");
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
 const links = require("../../util/links");
 const phrase = require("../../phrase");
 const project = require("../../parser/project");
 
+// [use]
+
+const ArcError = error.ArcError;
+
 // [function]
 
 // the game, `select`ed, or null when the API can't be reached. It rejects
@@ -15,7 +21,7 @@ const project = require("../../parser/project");
 const lookup = function (id, select) {
   return api.discoverGame(id, { select }).catch((err) => {
     if (err?.status === 404) {
-      throw new Error(phrase.gameNotFound(id));
+      throw new ArcError(cfgcode.GAME_NOT_FOUND, phrase.gameNotFound(id));
     }
     return null;
   });

package/src/action/predeploy/ac.js

@@ -3,56 +3,73 @@
 // [import]
 
 const api = require("../../api");
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
 const phrase = require("../../phrase");
 const published = require("./published");
 
+// [use]
+
+const ArcError = error.ArcError;
+
 // [function]
 
-const ensureGame = function (current, idOrHandle, id, cb) {
+// fails when `idOrHandle` is another game's, or this game's on another
+// account. A game that isn't on Arcadible yet passes.
+const ensureGame = function (current, idOrHandle, id) {
   return api.discoverGame(idOrHandle).then(
     (game) => {
       // a token's account isn't known yet, so only the id is compared; the
       // server checks ownership when it authorizes the upload.
       const owned = current?.token || game.account === current?.user?.id;
-      if (owned && game.id === id) {
-        cb(null);
-        return;
+      if (!owned || game.id !== id) {
+        throw new ArcError(cfgcode.GAME_EXISTS, phrase.gameExists(idOrHandle));
       }
-      cb(new Error(phrase.gameExists(idOrHandle)));
     },
     (err) => {
-      if (err.status === 404) {
-        cb(null);
-        return;
+      if (err.status !== 404) {
+        throw err;
       }
-      cb(err);
     },
   );
 };
 
 // [function]
 
-const ensureId = function (current, { handle, id }, cb) {
-  return ensureGame(current, id, id, (err) => {
-    if (err || (handle ?? null) === null) {
-      cb(err);
-      return;
-    }
-    ensureGame(current, handle, id, cb);
-  });
+// a game without a handle has none to check.
+const ensureHandle = function (current, { handle, id }) {
+  if ((handle ?? null) === null) {
+    return Promise.resolve(null);
+  }
+  return ensureGame(current, handle, id);
+};
+
+// [function]
+
+// resolves with the game once its id, and its handle if it has one, are
+// free or already its own.
+const ensureId = function (current, game) {
+  return ensureGame(current, game.id, game.id)
+    .then(() => ensureHandle(current, game))
+    .then(() => game);
 };
 
 // [function]
 
-// fails when the version is already published.
-const ensureUnpublished = function (current, { id, version }, cb) {
+// resolves with the game, or fails when its version is already published.
+const ensureUnpublished = function (current, game) {
+  const { id, version } = game;
   return api
     .gameBuild(id, version, null, api.auth(current?.session?.access_token))
     .then(
-      () => published.versionPublished(id, version),
-      (err) => (err.status === 404 ? null : err),
+      () => published.refuse(id, version),
+      (err) => {
+        if (err.status !== 404) {
+          throw err;
+        }
+      },
     )
-    .then(cb);
+    .then(() => game);
 };
 
 // [export]

package/src/action/predeploy/git.js

@@ -6,22 +6,46 @@ const cp = require("node:child_process");
 
 // [import]
 
+const cfgcode = require("../../config/code");
 const cfgproduct = require("../../config/product");
+const error = require("../../util/error");
 const phrase = require("../../phrase");
 
 // [use]
 
+const ArcError = error.ArcError;
 const execFile = cp.execFile;
 
 // [declare]
 
 const HANDLE = cfgproduct.handle;
 const PREFIX = `${HANDLE}/release/v`;
+// the release workflow, which builds the release on GitHub Actions.
+const WORKFLOW = ".github/workflows/arcadible-release.yml";
 
 // [function]
 
-const git = function (root, args, cb) {
-  execFile("git", ["-C", root, ...args], cb);
+// runs git in `root`, and resolves with its stdout.
+const git = function (root, args) {
+  return new Promise((resolve, reject) => {
+    execFile("git", ["-C", root, ...args], (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+};
+
+// [function]
+
+// a rejection handler that replaces git's error with `code` and `message`,
+// keeping it as the cause.
+const failWith = function (code, message) {
+  return (err) => {
+    throw new ArcError(code, message, { cause: err });
+  };
 };
 
 // [function]
@@ -36,90 +60,75 @@ const tagOf = function (version) {
 // fails on any change that isn't committed: staged, unstaged, or untracked.
 // ignored files don't count. The release is built from HEAD, so anything
 // uncommitted wouldn't be part of it.
-const ensureClean = function (root, cb) {
-  git(root, ["status", "--porcelain"], (err, stdout) => {
-    if (err) {
-      cb(err);
-      return;
-    }
+const ensureClean = function (root) {
+  return git(root, ["status", "--porcelain"]).then((stdout) => {
     if (stdout.trim()) {
-      cb(new Error(phrase.gitChangesPresent()));
-      return;
+      throw new ArcError(cfgcode.GIT_UNCOMMITTED, phrase.gitChangesPresent());
     }
-    cb(null);
   });
 };
 
 // [function]
 
-const ensureRemote = function (root, cb) {
-  git(root, ["ls-remote", "origin"], (err) => {
-    if (err) {
-      cb(new Error(phrase.gitRemoteMissing(), { cause: err }));
-      return;
-    }
-    cb(null);
-  });
+const ensureRemote = function (root) {
+  return git(root, ["ls-remote", "origin"]).then(
+    () => null,
+    failWith(cfgcode.GIT_REMOTE_UNAVAILABLE, phrase.gitRemoteMissing()),
+  );
 };
 
 // [function]
 
-const ensureRepo = function (root, cb) {
-  git(root, ["rev-parse", "--is-inside-work-tree"], (err) => {
-    if (err) {
-      cb(new Error(phrase.gitRepoMissing(), { cause: err }));
-      return;
-    }
-    cb(null);
-  });
+const ensureRepo = function (root) {
+  return git(root, ["rev-parse", "--is-inside-work-tree"]).then(
+    () => null,
+    failWith(cfgcode.GIT_REPO_MISSING, phrase.gitRepoMissing()),
+  );
 };
 
 // [function]
 
-const hasTagLocal = function (root, tag, cb) {
-  git(root, ["tag", "--list", tag], (err, stdout) => {
-    if (err) {
-      cb(err);
-      return;
-    }
-    cb(null, Boolean(stdout.trim()));
-  });
+// fails when HEAD has no release workflow, which Arcadible checks for when the
+// tag arrives (workflow_missing).
+const ensureWorkflow = function (root) {
+  return git(root, ["cat-file", "-e", `HEAD:${WORKFLOW}`]).then(
+    () => null,
+    failWith(cfgcode.WORKFLOW_MISSING, phrase.workflowMissing(WORKFLOW)),
+  );
 };
 
 // [function]
 
-const hasTagRemote = function (root, tag, cb) {
-  git(
-    root,
-    ["ls-remote", "--tags", "origin", `refs/tags/${tag}`],
-    (err, stdout) => {
-      if (err) {
-        cb(new Error(phrase.gitRemoteMissing(), { cause: err }));
-        return;
-      }
-      cb(null, Boolean(stdout.trim()));
-    },
+const hasTagLocal = function (root, tag) {
+  return git(root, ["tag", "--list", tag]).then((stdout) =>
+    Boolean(stdout.trim()),
+  );
+};
+
+// [function]
+
+const hasTagRemote = function (root, tag) {
+  return git(root, ["ls-remote", "--tags", "origin", `refs/tags/${tag}`]).then(
+    (stdout) => Boolean(stdout.trim()),
+    failWith(cfgcode.GIT_REMOTE_UNAVAILABLE, phrase.gitRemoteMissing()),
   );
 };
 
 // [function]
 
 // fails when the version's tag exists, locally or on origin.
-const ensureTagFree = function (root, version, cb) {
+const ensureTagFree = function (root, version) {
   const tag = tagOf(version);
-  hasTagLocal(root, tag, (err, local) => {
-    if (err || local) {
-      cb(err ?? new Error(phrase.gitVersionExists(version)));
-      return;
-    }
-    hasTagRemote(root, tag, (err, remote) => {
-      if (err || remote) {
-        cb(err ?? new Error(phrase.gitVersionExists(version)));
-        return;
+  return hasTagLocal(root, tag)
+    .then((local) => local || hasTagRemote(root, tag))
+    .then((exists) => {
+      if (exists) {
+        throw new ArcError(
+          cfgcode.GIT_TAG_EXISTS,
+          phrase.gitVersionExists(version),
+        );
       }
-      cb(null);
     });
-  });
 };
 
 // [export]
@@ -129,6 +138,8 @@ module.exports = {
   ensureRemote,
   ensureRepo,
   ensureTagFree,
+  ensureWorkflow,
+  failWith,
   git,
   tagOf,
 };

package/src/action/predeploy/pm.js

@@ -7,33 +7,40 @@ const path = require("node:path");
 
 // [import]
 
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
 const phrase = require("../../phrase");
 
 // [use]
 
+const ArcError = error.ArcError;
 const existsSync = fs.existsSync; // eslint-disable-line no-sync
 const join = path.join;
 
+// [declare]
+
+const LOCK_FILES = [
+  // npm
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  // pnpm
+  "pnpm-lock.yaml",
+  // yarn
+  "yarn.lock",
+];
+
 // [function]
 
-const ensureLockFile = function (root, cb) {
-  if (!existsSync(join(root, "package.json"))) {
-    cb(null);
-    return;
-  }
-  if (
-    // npm
-    existsSync(join(root, "package-lock.json")) ||
-    existsSync(join(root, "npm-shrinkwrap.json")) ||
-    // pnpm
-    existsSync(join(root, "pnpm-lock.yaml")) ||
-    // yarn
-    existsSync(join(root, "yarn.lock"))
-  ) {
-    cb(null);
-    return;
+// fails when there's a package.json without a lockfile: the release workflow
+// installs exactly what the lockfile pins.
+const ensureLockFile = function (root) {
+  const has = (file) => existsSync(join(root, file));
+  if (has("package.json") && !LOCK_FILES.some(has)) {
+    return Promise.reject(
+      new ArcError(cfgcode.LOCKFILE_MISSING, phrase.noLockFile()),
+    );
   }
-  cb(new Error(phrase.noLockFile()));
+  return Promise.resolve();
 };
 
 // [export]

package/src/action/predeploy/published.js

@@ -7,11 +7,14 @@ const semver = require("semver");
 // [import]
 
 const api = require("../../api");
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
 const links = require("../../util/links");
 const phrase = require("../../phrase");
 
 // [use]
 
+const ArcError = error.ArcError;
 const inc = semver.inc;
 const prerelease = semver.prerelease;
 const rcompare = semver.rcompare;
@@ -55,7 +58,8 @@ const versionPublished = function (id, version) {
     latest(id, links.STAGING),
   ]).then(([production, staging]) => {
     const found = { production, staging };
-    return new Error(
+    return new ArcError(
+      cfgcode.VERSION_EXISTS,
       phrase.versionPublished(version, {
         ...found,
         next: next(version, found),
@@ -64,6 +68,15 @@ const versionPublished = function (id, version) {
   });
 };
 
+// [function]
+
+// rejects with versionPublished's error.
+const refuse = function (id, version) {
+  return versionPublished(id, version).then((err) => {
+    throw err;
+  });
+};
+
 // [export]
 
-module.exports = { next, versionPublished };
+module.exports = { next, refuse };

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

@@ -3,28 +3,33 @@
 // [import]
 
 const api = require("../../api");
+const cfgcode = require("../../config/code");
+const cfguri = require("../../config/uri");
+const error = require("../../util/error");
 const git = require("./git");
+const given = require("../../parser/given");
 const phrase = require("../../phrase");
 const pm = require("./pm");
-const project = require("../../parser/project");
 const published = require("./published");
 
 // [use]
 
+const ArcError = error.ArcError;
 const ensureClean = git.ensureClean;
 const ensureLockFile = pm.ensureLockFile;
 const ensureRemote = git.ensureRemote;
 const ensureRepo = git.ensureRepo;
 const ensureTagFree = git.ensureTagFree;
+const ensureWorkflow = git.ensureWorkflow;
 
 // [function]
 
-// a public lookup's answer: found (200), missing (404), or null for any
-// other answer, such as when the API can't be reached.
+// a public lookup's answer: found (200, with its data), missing (404), or
+// null for any other answer, such as when the API can't be reached.
 const lookup = function (request) {
   return request.then(
-    () => 200,
-    (err) => (err.status === 404 ? 404 : null),
+    (data) => ({ data, status: 200 }),
+    (err) => (err.status === 404 ? { status: 404 } : null),
   );
 };
 
@@ -35,113 +40,96 @@ const lookup = function (request) {
 // that's already published. The lookups are public, so this needs no login.
 // when Arcadible can't be reached, it warns and pushes anyway: a release
 // shouldn't depend on the API, and Arcadible still checks.
-const ensurePublishable = function ({ handle, id, version }, handler, cb) {
+// resolves with the game's owner, or null when Arcadible can't be reached.
+const ensurePublishable = function ({ handle, id, version }, handler) {
   return Promise.all([
     lookup(api.discoverGame(id)),
     lookup(api.discoverGameBuild(id, version)),
-  ])
-    .then(([game, build]) => {
-      if (game === 404) {
-        return new Error(phrase.gameNotDeployed(handle ?? id));
-      }
-      if (game === null || build === null) {
-        if (handler.onLogInfo) {
-          handler.onLogInfo({
-            level: "warn",
-            message: phrase.versionUnchecked(version),
-          });
-        }
-        return null;
-      }
-      return build === 200 ? published.versionPublished(id, version) : null;
-    })
-    .then(cb);
-};
-
-// [function]
-
-const deployRelease = function (game, { root }, handler, cb) {
-  ensureTagFree(root, game.version, (err) => {
-    if (err) {
-      cb(err);
-      return;
+  ]).then(([game, build]) => {
+    if (game?.status === 404) {
+      throw new ArcError(
+        cfgcode.GAME_NOT_DEPLOYED,
+        phrase.gameNotDeployed(handle ?? id),
+      );
     }
-    ensurePublishable(game, handler, (err) => {
-      if (err) {
-        cb(err);
-        return;
+    if (game === null || build === null) {
+      if (handler.onLogInfo) {
+        handler.onLogInfo({
+          level: "warn",
+          message: phrase.versionUnchecked(version),
+        });
       }
-      cb(null, { to: game.version });
-    });
-  });
-};
-
-// [function]
-
-const deployEnsureGit = function ({ root }, handler, cb) {
-  ensureRepo(root, (err) => {
-    if (err) {
-      cb(err);
-      return;
+      return null;
     }
-    ensureClean(root, (err) => {
-      if (err) {
-        cb(err);
-        return;
-      }
-      ensureRemote(root, cb);
-    });
+    return build.status === 200
+      ? published.refuse(id, version)
+      : (game.data?.account ?? null);
   });
 };
 
 // [function]
 
-const deployEnsurePm = function ({ root }, handler, cb) {
-  ensureLockFile(root, cb);
+// the project's checks: a lockfile when there's a package.json, and a clean
+// repository with the release workflow and a reachable origin.
+const ensureProject = function (root) {
+  return ensureLockFile(root)
+    .then(() => ensureRepo(root))
+    .then(() => ensureClean(root))
+    .then(() => ensureWorkflow(root))
+    .then(() => ensureRemote(root));
 };
 
 // [function]
 
-const deployEnsure = function (conf, handler, cb) {
-  deployEnsurePm(conf, handler, (err) => {
-    if (err) {
-      cb(err);
-      return;
-    }
-    deployEnsureGit(conf, handler, cb);
-  });
+// fails when the game has no repository connected, which Arcadible would
+// refuse (repo_not_connected) after GitHub Actions had built it. Only the
+// game's owner can see its repository, so it's checked only when they're
+// logged in, and skipped when Arcadible can't be reached.
+const ensureConnected = function (current, { handle, id }, owner) {
+  if (!owner || current?.token || current?.user?.id !== owner) {
+    return Promise.resolve();
+  }
+  const headers = api.auth(current.session?.access_token);
+  return api.gameRepos(id, { select: "id" }, headers).then(
+    (repos) => {
+      if (!repos?.length) {
+        throw new ArcError(
+          cfgcode.REPO_NOT_CONNECTED,
+          phrase.gameRepoMissing(
+            handle ?? id,
+            `${cfguri.HOST_HTTP_STUDIO}/games/${id}/repository`,
+          ),
+        );
+      }
+    },
+    () => null,
+  );
 };
 
 // [function]
 
-const deploy = function (game, conf, handler, cb) {
-  deployEnsure(conf, handler, (err) => {
-    if (err) {
-      cb(err);
-      return;
-    }
-    deployRelease(game, conf, handler, cb);
-  });
+// the release's checks: its tag is free, Arcadible would publish it, and its
+// repository is connected. resolves with the version, and the game's owner,
+// who alone can wait for the release.
+const ensureRelease = function (root, current, game, handler) {
+  return ensureTagFree(root, game.version)
+    .then(() => ensurePublishable(game, handler))
+    .then((owner) =>
+      Promise.all([owner, ensureConnected(current, game, owner)]),
+    )
+    .then(([owner]) => ({ owner, to: game.version }));
 };
 
 // [function]
 
-const main = function ({ root }, { onPredeployBegin, ...handler }) {
+const main = function (current, conf, { onPredeployBegin, ...handler }) {
+  const root = conf.root;
   if (onPredeployBegin) {
     onPredeployBegin();
   }
-  return project(root).then(
-    ({ game }) =>
-      new Promise((resolve, reject) => {
-        deploy(game, { root }, handler, (err, data) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          resolve(data);
-        });
-      }),
-  );
+  return given(conf)
+    .then(({ game }) => Promise.all([game, ensureProject(root)]))
+    .then(([game]) => ensureRelease(root, current, game, handler));
 };
 
 // [export]