rman 2.15.0 → 2.15.1

package/commands/version.command.js

@@ -286,7 +286,8 @@ function printApplied(result) {
             console.log(`${colors.green('tags')}    ${release.map(label).join(', ')} ${colors.gray('(repository release)')}`);
     }
     console.log(result.pushed
-        ? `${colors.green('push')}    pushed, with tags`
+        ? `${colors.green('push')}    pushed the branch` +
+            (result.tags.length ? ` and ${result.tags.map(t => t.name).join(', ')}, together` : '')
         : `${colors.gray('push')}    ${colors.gray('not pushed - run with --push, or push it yourself')}`);
 }
 function printPlan(entries) {

package/constants.js

@@ -1 +1 @@
-export const version = '2.15.0';
+export const version = '2.15.1';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.15.0",
+  "version": "2.15.1",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/services/version.service.js

@@ -254,8 +254,21 @@ export class VersionService extends Service {
             tagged.push({ name: releaseTag, created: true, release: true });
         }
         const pushed = !!options.push && bumped.length > 0;
-        if (pushed)
-            await git.push();
+        if (pushed) {
+            /** Every tag this release names, including one that was already there: it is this release's
+             *  tag all the same, and a remote that lacks it is missing part of the release. */
+            const tags = tagged.map(t => t.name);
+            try {
+                await git.push({ tags });
+            }
+            catch (e) {
+                throw new Error(`${e.message}\n\n` +
+                    `  Nothing was pushed - the branch and its tags go up together or not at all. Left behind ` +
+                    `locally: ${commits.map(c => c.sha).join(', ') || 'no commit'}` +
+                    (tags.length ? `, tagged ${tags.join(', ')}` : '') +
+                    `.\n  Once the cause is fixed, push them with: git push --atomic origin HEAD ${tags.join(' ')}`.trimEnd(), { cause: e });
+            }
+        }
         return { entries: plan, updated: bumped, commits, tags: tagged, pushed };
     }
 }

package/utils/git.d.ts

@@ -121,11 +121,13 @@ export declare class GitHelper {
      *  Throws if a tag with that name already exists - callers wanting idempotent tagging should
      *  check `tagExists` first. */
     createTag(name: string, message?: string): Promise<void>;
-    /** Pushes the current branch to `remote` (default `"origin"`), and its tags too unless
-     *  `options.tags` is `false`. */
+    /**
+     * Pushes the current branch to `remote` (default `"origin"`) together with `options.tags`, by
+     * name, in **one atomic push**: the branch and every tag go up, or none of them does.
+     */
     push(options?: {
         remote?: string;
-        tags?: boolean;
+        tags?: readonly string[];
     }): Promise<void>;
     /** `git remote get-url <remote>` (default `"origin"`) - `undefined` when that remote isn't
      *  configured at all, which is a perfectly normal state for a local-only repository. */

package/utils/git.js

@@ -394,14 +394,24 @@ export class GitHelper {
             throw new Error(`Unable to create tag "${name}": ${e.message}`, { cause: e });
         }
     }
-    /** Pushes the current branch to `remote` (default `"origin"`), and its tags too unless
-     *  `options.tags` is `false`. */
+    /**
+     * Pushes the current branch to `remote` (default `"origin"`) together with `options.tags`, by
+     * name, in **one atomic push**: the branch and every tag go up, or none of them does.
+     */
+    /* **Named tags, not `--tags`.** `git push <remote> --tags` sends every tag in the clone, so one
+     * stale tag from months ago - re-created locally, diverged from the remote's - failed every
+     * release from then on, and failed it *after* the new tag had already gone up. Measured on
+     * `postgrejs` with 2.15.0: `v3.13.0` pushed, `v3.10.0` rejected, exit 1, and in CI the publish
+     * step after it never ran.
+     *
+     * **One command, `--atomic`.** The branch used to go first and the tags second, so a failure in
+     * the second - GitHub's own `fatal error in commit_refs` did it to the same repository an hour
+     * earlier - left a pushed version bump with no tag, which a re-run cannot repair because it has
+     * nothing left to bump. Atomic, a failure leaves the remote exactly as it was. */
     async push(options) {
         const remote = options?.remote ?? 'origin';
         try {
-            await execFileAsync('git', ['push', remote], { cwd: this.cwd });
-            if (options?.tags !== false)
-                await execFileAsync('git', ['push', remote, '--tags'], { cwd: this.cwd });
+            await execFileAsync('git', ['push', '--atomic', remote, 'HEAD', ...(options?.tags ?? [])], { cwd: this.cwd });
         }
         catch (e) {
             throw new Error(`Unable to push to "${remote}": ${e.message}`, { cause: e });