arcadible 0.1.32 → 0.1.34

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

@@ -6,95 +6,83 @@ const semver = require("semver");
 
 // [import]
 
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
+const given = require("../../parser/given");
 const links = require("../../util/links");
 const phrase = require("../../phrase");
-const project = require("../../parser/project");
 const repo = require("../predeploy/git");
 
 // [use]
 
+const ArcError = error.ArcError;
+const failWith = repo.failWith;
 const git = repo.git;
 const prereleaseSemver = semver.prerelease;
 const tagOf = repo.tagOf;
 
 // [function]
 
-const createTag = function (root, version, cb) {
-  git(
-    root,
-    [
-      "tag",
-      "-a",
-      tagOf(version),
-      "-m",
-      prereleaseSemver(version) === null
-        ? phrase.versionRelease(version)
-        : phrase.versionPrerelease(version),
-    ],
-    (err) => {
-      if (err) {
-        cb(new Error(phrase.gitTagCreateFailed(version), { cause: err }));
-        return;
-      }
-      cb(null);
-    },
+const createTag = function (root, version) {
+  const message =
+    prereleaseSemver(version) === null
+      ? phrase.versionRelease(version)
+      : phrase.versionPrerelease(version);
+  return git(root, ["tag", "-a", tagOf(version), "-m", message]).then(
+    () => null,
+    failWith(cfgcode.GIT_TAG_CREATE_FAILED, phrase.gitTagCreateFailed(version)),
   );
 };
 
 // [function]
 
-// the local tag is deleted when the push fails, so trying again isn't
-// blocked by a tag that was never released.
-const pushTag = function (root, version, cb) {
-  git(root, ["push", "origin", tagOf(version)], (err) => {
-    if (err) {
-      const failed = new Error(phrase.gitTagPushFailed(version), {
-        cause: err,
-      });
-      git(root, ["tag", "-d", tagOf(version)], () => cb(failed));
-      return;
-    }
-    cb(null);
-  });
+// deletes the local tag, then fails with `failed` whether or not it could.
+const untag = function (root, version, failed) {
+  const fail = () => {
+    throw failed;
+  };
+  return git(root, ["tag", "-d", tagOf(version)]).then(fail, fail);
 };
 
 // [function]
 
-// tags the version and pushes the tag: the Arcadible GitHub App publishes
-// the release that the workflow builds from it.
-const release = function (root, version, cb) {
-  createTag(root, version, (err) => {
-    if (err) {
-      cb(err);
-      return;
-    }
-    pushTag(root, version, cb);
-  });
+// the local tag is deleted when the push fails, so trying again isn't
+// blocked by a tag that was never released.
+const pushTag = function (root, version) {
+  return git(root, ["push", "origin", tagOf(version)]).then(
+    () => null,
+    (err) =>
+      untag(
+        root,
+        version,
+        new ArcError(
+          cfgcode.GIT_TAG_PUSH_FAILED,
+          phrase.gitTagPushFailed(version),
+          {
+            cause: err,
+          },
+        ),
+      ),
+  );
 };
 
 // [function]
 
-const main = function ({ root }, { onDeployBegin }) {
+// tags the version and pushes the tag: the Arcadible GitHub App publishes
+// the release that the workflow builds from it.
+const main = function (conf, { onDeployBegin }) {
   if (onDeployBegin) {
     onDeployBegin();
   }
-  return project(root).then(
-    ({ game }) =>
-      new Promise((resolve, reject) => {
-        release(root, game.version, (err) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          resolve({
-            ...links.published(game),
-            game: game.id,
-            tag: tagOf(game.version),
-            version: { to: game.version },
-          });
-        });
-      }),
-  );
+  return given(conf)
+    .then(({ game }) => Promise.all([game, createTag(conf.root, game.version)]))
+    .then(([game]) => Promise.all([game, pushTag(conf.root, game.version)]))
+    .then(([game]) => ({
+      ...links.published(game),
+      game: game.id,
+      tag: tagOf(game.version),
+      version: { to: game.version },
+    }));
 };
 
 // [export]

package/src/action/deploy/tool.js

@@ -3,39 +3,55 @@
 // [import]
 
 const api = require("../../api");
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
+const given = require("../../parser/given");
 const links = require("../../util/links");
 const phrase = require("../../phrase");
-const project = require("../../parser/project");
 const s3 = require("../../util/s3");
 
+// [use]
+
+const ArcError = error.ArcError;
+
 // [function]
 
-const uploadBuild = function (
-  current,
-  artifact,
-  { id, version },
-  onUploadProgress,
-  cb,
-) {
+// asks the API for an upload link, then sends the zip to it, and resolves
+// with the upload.
+const uploadBuild = function (current, artifact, { id, version }, onProgress) {
   const form = new FormData();
   form.append("artifact", id);
   form.append("version", version);
   form.append("sha256", artifact.sha256);
   form.append("size", artifact.size);
-  // api
   return api
     .postUpload(form, null, api.auth(current?.session?.access_token))
     .then(
-      (upload) => {
-        s3.upload(upload.upload_url, artifact, onUploadProgress, (err) =>
-          cb(err, upload),
-        );
-      },
+      (upload) =>
+        Promise.all([
+          upload,
+          s3.upload(upload.upload_url, artifact, onProgress),
+        ]),
       (err) => {
-        // the API refuses a game that was deleted or is another account's.
-        cb(err.status === 403 ? new Error(phrase.gameUnavailable(id)) : err);
+        // the API refuses a game that was deleted or is another account's,
+        // and the same version uploaded again within 5 minutes.
+        if (err.status === 403) {
+          throw new ArcError(
+            cfgcode.GAME_UNAVAILABLE,
+            phrase.gameUnavailable(id),
+          );
+        }
+        if (err.status === 429) {
+          throw new ArcError(
+            cfgcode.UPLOAD_RATE_LIMITED,
+            phrase.uploadRateLimited(version),
+            { cause: err },
+          );
+        }
+        throw err;
       },
-    );
+    )
+    .then(([upload]) => upload);
 };
 
 // [function]
@@ -43,37 +59,27 @@ const uploadBuild = function (
 const main = function (
   current,
   artifact,
-  { root },
+  conf,
   { onDeployBegin, onUploadProgress },
 ) {
   if (onDeployBegin) {
-    onDeployBegin({ root });
+    onDeployBegin({ root: conf.root });
   }
-  return project(root).then(
-    ({ game }) =>
-      new Promise((resolve, reject) => {
-        uploadBuild(
-          current,
-          artifact,
-          game,
-          onUploadProgress,
-          (err, upload) => {
-            if (err) {
-              reject(err);
-              return;
-            }
-            // a direct deploy's release shares its upload's id, which
-            // `--wait` follows.
-            resolve({
-              ...links.published(game),
-              game: game.id,
-              release: upload.id,
-              version: { to: game.version },
-            });
-          },
-        );
-      }),
-  );
+  return given(conf)
+    .then(({ game }) =>
+      Promise.all([
+        game,
+        uploadBuild(current, artifact, game, onUploadProgress),
+      ]),
+    )
+    .then(([game, upload]) => ({
+      ...links.published(game),
+      game: game.id,
+      // a direct deploy's release shares its upload's id, which `--wait`
+      // follows.
+      release: upload.id,
+      version: { to: game.version },
+    }));
 };
 
 // [export]

package/src/action/deploy/wait.js

@@ -19,7 +19,7 @@ const sleep = delay.sleep;
 const INTERVAL = time.s(2);
 const FINAL = new Set(["failed", "published"]);
 const SELECT =
-  "id,status,reason,message,build,source,version,channel,created_at";
+  "id,game,status,reason,message,build,source,version,channel,created_at";
 // a git release is found by version among the newest few; one from before
 // this deploy (a tag deleted and pushed again) is left out, allowing for
 // the machine's clock being off.
@@ -44,16 +44,17 @@ const studioUrl = function (game) {
 // the repository's GitHub Actions page, from origin's URL, or null when
 // origin isn't on GitHub.
 const actionsUrl = function (root) {
-  return new Promise((resolve) => {
-    git(root, ["remote", "get-url", "origin"], (err, stdout) => {
-      const match = err
-        ? null
-        : /github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\s*$/u.exec(stdout);
-      resolve(
-        match ? `https://github.com/${match[1]}/${match[2]}/actions` : null,
+  return git(root, ["remote", "get-url", "origin"]).then(
+    (stdout) => {
+      const match = /github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\s*$/u.exec(
+        stdout,
       );
-    });
-  });
+      return match
+        ? `https://github.com/${match[1]}/${match[2]}/actions`
+        : null;
+    },
+    () => null,
+  );
 };
 
 // [function]
@@ -66,18 +67,26 @@ const findDirect = function (id, headers) {
 // [function]
 
 // a git deploy's release: GitHub's, for this version, made since the tag was
-// pushed. Null until GitHub Actions has built it.
-const findGit = function (game, version, since, headers) {
+// pushed. Null until GitHub Actions has built it. It's looked for among the
+// account's releases, which include one with no game: a repository that
+// isn't connected fails that way (repo_not_connected). A token's account
+// isn't known, so it looks among the game's.
+const findGit = function ({ account, game, headers, since, version }) {
+  const newest = account
+    ? () => api.accountReleases(account, { limit: 20, select: SELECT }, headers)
+    : () =>
+        api.gameReleases(game, { limit: 10, select: SELECT, version }, headers);
   return () =>
-    api
-      .gameReleases(game, { limit: 10, select: SELECT, version }, headers)
-      .then(
-        (rows) =>
-          (rows ?? []).find(
-            (r) =>
-              r.source === "github" && Date.parse(r.created_at) >= since - SKEW,
-          ) ?? null,
-      );
+    newest().then(
+      (rows) =>
+        (rows ?? []).find(
+          (r) =>
+            r.source === "github" &&
+            r.version === version &&
+            (r.game === game || r.game === null) &&
+            Date.parse(r.created_at) >= since - SKEW,
+        ) ?? null,
+    );
 };
 
 // [function]
@@ -127,7 +136,13 @@ const main = function (
   const headers = api.auth(current?.session?.access_token);
   const game = deployed.game;
   const find = isGit
-    ? findGit(game, deployed.version.to, since, headers)
+    ? findGit({
+        account: current?.user?.id ?? null,
+        game,
+        headers,
+        since,
+        version: deployed.version.to,
+      })
     : findDirect(deployed.release, headers);
   return Promise.all([
     poll(find, timeout, onRelease),

package/src/action/init/manifest.js

@@ -11,12 +11,16 @@ const fs = require("fs-extra");
 
 // [import]
 
+const cfgcode = require("../../config/code");
 const cfgproduct = require("../../config/product");
+const env = require("../../parser/env");
+const error = require("../../util/error");
 const phrase = require("../../phrase");
 const TOML = require("../../util/toml");
 
 // [use]
 
+const ArcError = error.ArcError;
 const join = path.join;
 const pathExists = fs.pathExists;
 const randomUUID = crypto.randomUUID;
@@ -34,12 +38,23 @@ const parseToml = function (buf) {
   try {
     return TOML.parse(buf);
   } catch (ex) {
-    throw new Error(phrase.unableToParse(MANIFEST, ex.message), { cause: ex });
+    throw new ArcError(
+      cfgcode.PARSE_FAILED,
+      phrase.unableToParse(MANIFEST, ex.message),
+      { cause: ex },
+    );
   }
 };
 
 // [function]
 
+// the version the project's package.json gives, if any.
+const detectVersion = function (dest) {
+  return env(dest).then(({ game }) => game?.version ?? null);
+};
+
+// [function]
+
 const pickVersion = function (version, envVersion) {
   if (version) {
     return { version };
@@ -57,10 +72,12 @@ const readManifest = function (file) {
 
 // [function]
 
-const patchGame = function (envVersion, game = {}) {
+// a new project always gets its own id: a template's, such as an existing
+// game's, belongs to that game.
+const patchGame = function (envVersion, game = {}, { fresh = false } = {}) {
   const { id, version, ...rest } = game;
   return {
-    id: id ?? randomUUID(),
+    id: fresh ? randomUUID() : (id ?? randomUUID()),
     ...pickVersion(version, envVersion),
     ...rest,
   };
@@ -77,11 +94,11 @@ const shouldWrite = function (manifest, next) {
 
 // [function]
 
-const prepare = function (dest, envVersion) {
+const prepare = function (dest, envVersion, opts) {
   const file = join(dest, MANIFEST);
   return readManifest(file).then((manifest) => {
     const { game, ...rest } = manifest;
-    const next = { game: patchGame(envVersion, game), ...rest };
+    const next = { game: patchGame(envVersion, game, opts), ...rest };
     if (shouldWrite(manifest, next)) {
       return writeFile(file, TOML.stringify(next), "utf8");
     }
@@ -91,4 +108,4 @@ const prepare = function (dest, envVersion) {
 
 // [export]
 
-module.exports = { prepare };
+module.exports = { detectVersion, prepare };

package/src/action/init/tool-patch.js

@@ -6,22 +6,16 @@ const path = require("node:path");
 
 // [import]
 
-const env = require("../../parser/env");
 const manifest = require("./manifest");
 
 // [use]
 
+const detectVersion = manifest.detectVersion;
 const prepare = manifest.prepare;
 const resolve = path.resolve;
 
 // [function]
 
-const detectVersion = function (dest) {
-  return env(dest).then(({ game }) => game?.version ?? null);
-};
-
-// [function]
-
 // an existing project: add a manifest, and copy nothing from the template.
 const main = function ({ project, root }, { onInitBegin }) {
   const dest = resolve(root, project);

package/src/action/init/tool.js

@@ -11,12 +11,15 @@ const fs = require("fs-extra");
 
 // [import]
 
-const env = require("../../parser/env");
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
 const manifest = require("./manifest");
 const phrase = require("../../phrase");
 
 // [use]
 
+const ArcError = error.ArcError;
+const detectVersion = manifest.detectVersion;
 const join = path.join;
 const prepare = manifest.prepare;
 const remove = fs.remove;
@@ -34,12 +37,6 @@ const removeLicense = function (dest) {
 
 // [function]
 
-const detectVersion = function (dest) {
-  return env(dest).then(({ game }) => game?.version ?? null);
-};
-
-// [function]
-
 const scaffold = function (src, dest, { onInitBegin }) {
   if (onInitBegin) {
     onInitBegin({ dest, src });
@@ -47,7 +44,13 @@ const scaffold = function (src, dest, { onInitBegin }) {
   return degit(src, { cache: false, force: true, verbose: false })
     .clone(dest)
     .catch((ex) => {
-      throw new Error(phrase.templateUnavailable(src), { cause: ex });
+      throw new ArcError(
+        cfgcode.TEMPLATE_UNAVAILABLE,
+        phrase.templateUnavailable(src),
+        {
+          cause: ex,
+        },
+      );
     });
 };
 
@@ -59,7 +62,7 @@ const main = function ({ project, root, template }, handler) {
   return scaffold(template, dest, handler)
     .then(() => removeLicense(dest))
     .then(() => detectVersion(dest))
-    .then((version) => prepare(dest, version))
+    .then((version) => prepare(dest, version, { fresh: true }))
     .then(() => ({ path: dest, template }));
 };
 

package/src/action/login/flow.js

@@ -7,13 +7,16 @@ const crypto = require("node:crypto");
 // [import]
 
 const api = require("../../api");
+const cfgcode = require("../../config/code");
 const cfgurl = require("../../config/url");
 const delay = require("../../util/delay");
+const error = require("../../util/error");
 const phrase = require("../../phrase");
 const time = require("../../util/time");
 
 // [use]
 
+const ArcError = error.ArcError;
 const poll = delay.poll;
 const randomUUID = crypto.randomUUID;
 
@@ -24,7 +27,8 @@ const POLL = {
   factor: 1.5,
   interval: time.s(15),
   maxDelay: time.s(5),
-  timeoutError: phrase.loginExpired(),
+  timeoutError: () =>
+    new ArcError(cfgcode.LOGIN_EXPIRED, phrase.loginExpired()),
 };
 
 // [function]
@@ -67,9 +71,9 @@ const pollFlow = function (value, onLoginPoll) {
       case "completed":
         return data;
       case "failed":
-        throw new Error(phrase.loginFailed());
+        throw new ArcError(cfgcode.LOGIN_FAILED, phrase.loginFailed());
       default:
-        throw new Error(phrase.loginExpired());
+        throw new ArcError(cfgcode.LOGIN_EXPIRED, phrase.loginExpired());
     }
   });
 };

package/src/action/pack/limits.js

@@ -2,11 +2,14 @@
 
 // [import]
 
+const cfgcode = require("../../config/code");
+const error = require("../../util/error");
 const phrase = require("../../phrase");
 const size = require("../../util/size");
 
 // [use]
 
+const ArcError = error.ArcError;
 const toMb = size.toMb;
 
 // [declare]
@@ -25,16 +28,23 @@ const MAX_TOTAL_SIZE = size.mb(256);
 const check = function (entries) {
   const large = entries.find((entry) => entry.size > MAX_FILE_SIZE);
   if (large) {
-    throw new Error(
+    throw new ArcError(
+      cfgcode.PACKAGE_FILE_TOO_LARGE,
       phrase.packageFileTooLarge(large.name, toMb(MAX_FILE_SIZE)),
     );
   }
   if (entries.length > MAX_FILES) {
-    throw new Error(phrase.packageTooManyFiles(MAX_FILES));
+    throw new ArcError(
+      cfgcode.PACKAGE_TOO_MANY_FILES,
+      phrase.packageTooManyFiles(MAX_FILES),
+    );
   }
   const total = entries.reduce((sum, entry) => sum + entry.size, 0);
   if (total > MAX_TOTAL_SIZE) {
-    throw new Error(phrase.packageUncompressedTooLarge(toMb(MAX_TOTAL_SIZE)));
+    throw new ArcError(
+      cfgcode.PACKAGE_UNCOMPRESSED_TOO_LARGE,
+      phrase.packageUncompressedTooLarge(toMb(MAX_TOTAL_SIZE)),
+    );
   }
 };
 

package/src/action/pack/tool.js

@@ -10,15 +10,18 @@ const fs = require("fs-extra");
 
 // [import]
 
+const cfgcode = require("../../config/code");
 const cfgproduct = require("../../config/product");
+const error = require("../../util/error");
+const given = require("../../parser/given");
 const limits = require("./limits");
 const phrase = require("../../phrase");
-const project = require("../../parser/project");
 const size = require("../../util/size");
 const Zip = require("../../util/zip");
 
 // [use]
 
+const ArcError = error.ArcError;
 const parse = path.parse;
 const pathExists = fs.pathExists;
 const resolve = path.resolve;
@@ -43,10 +46,16 @@ const SIZE_PARTIAL = size.mb(64);
 
 const verifyPartial = function (zip) {
   if (!zip.has(MAIN)) {
-    throw new Error(phrase.packageFileMissing(MAIN));
+    throw new ArcError(
+      cfgcode.PACKAGE_INDEX_MISSING,
+      phrase.packageFileMissing(MAIN),
+    );
   }
   if (zip.stat().size > SIZE_PARTIAL) {
-    throw new Error(phrase.packageTooLarge(size.toMb(SIZE_PARTIAL)));
+    throw new ArcError(
+      cfgcode.PACKAGE_TOO_LARGE,
+      phrase.packageTooLarge(size.toMb(SIZE_PARTIAL)),
+    );
   }
   return zip;
 };
@@ -65,7 +74,10 @@ const pack = function (name, game, { inputPath, mediaPath, outputPath }) {
   return pathExists(inputPath)
     .then((existsInput) => {
       if (!existsInput) {
-        throw new Error(phrase.unableToFind(inputPath));
+        throw new ArcError(
+          cfgcode.PATH_NOT_FOUND,
+          phrase.unableToFind(inputPath),
+        );
       }
       zip.addDir(inputPath);
       return zip;
@@ -88,8 +100,9 @@ const pack = function (name, game, { inputPath, mediaPath, outputPath }) {
 
 // [function]
 
-const main = function ({ input, output, root }) {
-  return project(root).then(({ game, workflow }) => {
+const main = function ({ input, output, ...conf }) {
+  const root = conf.root;
+  return given(conf).then(({ game, workflow }) => {
     const name = game.handle ?? game.id;
     const file = output ?? `${OUTPUT}/${name}-v${game.version}.zip`;
     return pack(parse(file).name, game, {