refactor: refactor release tags

Author: zdm

lib/git.js

@@ -1,4 +1,5 @@
 import CoreGit from "#core/api/git";
+import SemanticVersion from "#core/semantic-version";
 import GitChangelog from "./git/changelog.js";
 
 export default class Git extends CoreGit {
@@ -59,4 +60,117 @@ export default class Git extends CoreGit {
 
         return res;
     }
+
+    async getReleaseTags ( { allowMajorTag } = {} ) {
+        const res = await this.getTags();
+        if ( !res.ok ) return res;
+
+        const tags = {};
+
+        if ( res.data ) {
+            for ( const [ tag, commit ] of Object.entries( res.data ) ) {
+                const isMajorTag = /^v\d+$/.test( tag );
+
+                // release tag
+                if ( /^v\d+\.\d+\.\d+/.test( tag ) ) {
+                    if ( !SemanticVersion.isValid( tag ) ) continue;
+
+                    const releaseVersion = new SemanticVersion( tag );
+
+                    // next
+                    tags.next ??= {};
+                    tags.next.version ??= releaseVersion;
+                    if ( releaseVersion.gt( tags.next.version ) ) {
+                        tags.next.version = releaseVersion;
+                    }
+
+                    // major.next
+                    const majorNextTag = `v${ releaseVersion.majorNumber }.next`;
+                    tags[ majorNextTag ] ??= {};
+                    tags[ majorNextTag ].version ??= releaseVersion;
+                    if ( releaseVersion.gt( tags[ majorNextTag ].version ) ) {
+                        tags[ majorNextTag ].version = releaseVersion;
+                    }
+
+                    // stable release
+                    if ( releaseVersion.isStableRelease ) {
+
+                        // latest
+                        tags.latest ??= {};
+                        tags.latest.version ??= releaseVersion;
+                        if ( releaseVersion.gt( tags.latest.version ) ) {
+                            tags.latest.version = releaseVersion;
+                        }
+
+                        // major.latest
+                        const majorLatestTag = `v${ releaseVersion.majorNumber }.latest`;
+                        tags[ majorLatestTag ] ??= {};
+                        tags[ majorLatestTag ].version ??= releaseVersion;
+                        if ( releaseVersion.gt( tags[ majorLatestTag ].version ) ) {
+                            tags[ majorLatestTag ].version = releaseVersion;
+                        }
+
+                        // major
+                        const majorTag = `v${ releaseVersion.majorNumber }`;
+                        tags[ majorTag ] ??= {
+                            "isMajorTag": true,
+                        };
+                        tags[ majorTag ].version = tags[ majorLatestTag ].version;
+                    }
+                }
+                else if ( tag === "latest" || tag === "next" || /^v\d+\.(?:latest|next)$/.test( tag ) || isMajorTag ) {
+                    tags[ tag ] ??= {
+                        isMajorTag,
+                    };
+
+                    if ( commit.isRelease ) {
+                        tags[ tag ].current = commit.releaseVersion.version;
+                    }
+                    else {
+                        tags[ tag ].current = false;
+                    }
+                }
+            }
+        }
+
+        const releaseTags = {};
+
+        for ( const tag in tags ) {
+            releaseTags[ tag ] = {
+                "version": tags[ tag ].version?.version,
+                "action": null,
+            };
+
+            // tag is not set
+            if ( tags[ tag ].current == null ) {
+                if ( tags[ tag ].version ) {
+                    if ( !tags[ tag ].isMajorTag || allowMajorTag ) {
+                        releaseTags[ tag ].action = "update";
+                    }
+                }
+            }
+
+            // major tag is set, but not allowed
+            else if ( tags[ tag ].isMajorTag && !allowMajorTag ) {
+                releaseTags[ tag ].action = "delete";
+            }
+
+            // tag is set, but has no version
+            else if ( !tags[ tag ].version ) {
+                releaseTags[ tag ].action = "delete";
+            }
+
+            // tag is set incorrectly
+            else if ( tags[ tag ].current === false ) {
+                releaseTags[ tag ].action = "update";
+            }
+
+            // tag is set, but version is not valid
+            else if ( tags[ tag ].current !== tags[ tag ].version.version ) {
+                releaseTags[ tag ].action = "update";
+            }
+        }
+
+        return result( 200, releaseTags );
+    }
 }

lib/package.js

@@ -482,19 +482,21 @@ export default class Package {
             if ( !res.ok ) return res;
         }
 
-        res = await this.git.getReleaseTags();
+        res = await this.git.getReleaseTags( { "allowMajorTag": this.cliConfig?.release.allowMajorTag } );
         if ( !res.ok ) return res;
         const tags = res.data;
 
         for ( const tag in tags ) {
 
             // update tag
             if ( tags[ tag ].action === "update" ) {
-                res = await this.git.exec( [ "tag", "--force", "--annotate", "--message", this.createReleaseTagAnnotation( tag ), tag, tags[ tag ].version ] );
+                const annotation = this.createReleaseTagAnnotation( tag );
+
+                res = await this.git.exec( [ "tag", "--force", "--annotate", "--message", annotation, tag, "v" + tags[ tag ].version ] );
                 if ( !res.ok ) return res;
 
                 if ( this.git.upstream ) {
-                    res = await this.git.exec( [ "push", "--atomic", "--force", "origin", tag ] );
+                    res = await this.git.exec( [ "push", "--force", "origin", tag ] );
                     if ( !res.ok ) return res;
                 }
 
@@ -1181,7 +1183,23 @@ export default class Package {
     }
 
     createReleaseTagAnnotation ( tag ) {
-        TAG_MESSAGES[ tag ] || `Latest stable release for the branch: ${ tag }`;
+        var majorVersion;
+
+        if ( tag.includes( "." ) ) {
+            [ majorVersion, tag ] = tag.split( "." );
+        }
+        else if ( /^v\d+$/.test( tag ) ) {
+            majorVersion = tag;
+            tag = "latest";
+        }
+
+        var annotation = TAG_MESSAGES[ tag ];
+
+        if ( majorVersion != null ) {
+            annotation += ` for the branch: ${ majorVersion }`;
+        }
+
+        return annotation;
     }
 
     clearCache () {

lib/package/npm.js

@@ -1,5 +1,6 @@
 import ansi from "#core/ansi";
 import NpmApi from "#core/api/npm";
+import SemanticVersion from "#core/semantic-version";
 import { TmpDir } from "#core/tmp";
 import { repeatAction } from "#core/utils";
 
@@ -222,24 +223,35 @@ export default class Npm {
 
         res = await this.pkg.git.getReleaseTags();
         if ( !res.ok ) return res;
+        const releaseTags = res.data;
 
-        const tags = {
-            "latest": res.data.latest.version,
-            "next": res.data.next.version,
-        };
+        const tags = {};
 
         res = await this.api.getPackageTags( this.pkg.name );
         if ( !res.ok ) return res;
         const remoteTags = res.data || {};
 
-        for ( const [ tag, version ] of Object.entries( tags ) ) {
+        for ( const [ tag, { version } ] of Object.entries( releaseTags ) ) {
+
+            // skip semantic versions
+            if ( SemanticVersion.isValid( tag ) ) continue;
+
+            if ( version ) {
+                tags[ tag ] = version;
+            }
 
             // set
             if ( version && remoteTags[ tag ] !== version ) {
                 res = await this.api.setPackageTag( this.pkg.name, version, tag );
-                if ( !res.ok ) return res;
 
-                updated = true;
+                if ( !res.ok ) {
+                    if ( res.data?.error?.code !== "E404" ) {
+                        return res;
+                    }
+                }
+                else {
+                    updated = true;
+                }
             }
 
             // delete