feat: added handling of next versioning

Author: dawson-david-salesforce

messages/bundle_version_create.md

@@ -37,3 +37,11 @@ No bundle found with name: %s
 # invalidVersionNumberFormat
 
 Invalid version number format: %s
+
+# majorVersionMismatch
+
+Major version mismatch: expected %s, found %s
+
+# invalidMinorVersionInExisting
+
+Invalid minor version in existing record: %s

scripts/Icon

@@ -204,6 +204,53 @@ export class PackageBundleVersionCreate {
     if (!major || !minor) {
       throw new Error(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
     }
+
+    // Check if major is an integer
+    const majorInt = parseInt(major, 10);
+    if (isNaN(majorInt) || majorInt.toString() !== major) {
+      throw new Error(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
+    }
+
+    // Check if minor is either an integer or "next"
+    if (minor === 'NEXT') {
+      // Query existing bundle versions to find the highest minor version for this major version
+      const bundleVersionQuery =
+        'SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased ' +
+        'FROM PackageBundleVersion ' +
+        `WHERE PackageBundle.BundleName = '${bundleName}' AND MajorVersion = ${major} ` +
+        'ORDER BY MinorVersion DESC LIMIT 1';
+
+      const queryResult = await connection.tooling.query<{
+        Id: string;
+        PackageBundle: { Id: string; BundleName: string };
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        IsReleased: boolean;
+      }>(bundleVersionQuery);
+
+      if (queryResult.records && queryResult.records.length > 0) {
+        const highestRecord = queryResult.records[0];
+
+        // Get the highest minor version and add 1
+        const highestMinorVersion = parseInt(highestRecord.MinorVersion, 10);
+        if (isNaN(highestMinorVersion)) {
+          throw new Error(messages.getMessage('invalidMinorVersionInExisting', [highestRecord.MinorVersion]));
+        }
+
+        const nextMinorVersion = (highestMinorVersion + 1).toString();
+        return { MajorVersion: major, MinorVersion: nextMinorVersion };
+      } else {
+        // No existing versions found for this major version, start with .0
+        return { MajorVersion: major, MinorVersion: '0' };
+      }
+    } else {
+      const minorInt = parseInt(minor, 10);
+      if (isNaN(minorInt) || minorInt.toString() !== minor) {
+        throw new Error(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
+      }
+    }
+
     return { MajorVersion: major, MinorVersion: minor };
   }
 }

src/package/packageBundleVersionCreate.ts

@@ -14,6 +14,15 @@ import { PackageBundleVersion } from '../../src/package/packageBundleVersion';
 import { PackageBundleVersionCreate } from '../../src/package/packageBundleVersionCreate';
 import { BundleVersionCreateOptions, BundleSObjects } from '../../src/interfaces';
 
+// Type for accessing private methods in tests
+interface PackageBundleVersionCreateWithPrivates {
+  getPackageVersion(
+    options: BundleVersionCreateOptions,
+    project: SfProject,
+    connection: Connection
+  ): Promise<{ MajorVersion: string; MinorVersion: string }>;
+}
+
 async function setupProject(setup: (project: SfProject) => void = () => {}) {
   const project = await SfProject.resolve();
 
@@ -543,4 +552,210 @@ describe('PackageBundleVersion.create', () => {
       fs.unlinkSync(componentsPath);
     });
   });
+
+  describe('getPackageVersion NEXT functionality', () => {
+    it('should resolve 0.NEXT to 0.2 when existing version 0.1 exists', async () => {
+      const testBundleName = 'testBundle';
+      const testBundleId = '0Ho000000000000';
+
+      // Restore the getPackageVersion stub so we can test the real method
+      testContext.SANDBOX.restore();
+
+      // Re-stub parsePackageBundleId since we still need it
+      testContext.SANDBOX.stub(
+        PackageBundleVersionCreate,
+        'parsePackageBundleId' as keyof typeof PackageBundleVersionCreate
+      ).returns(testBundleId);
+
+      // Mock project's getSfProjectJson().getPackageBundles() to return a bundle with version "0.NEXT"
+      testContext.SANDBOX.stub(project.getSfProjectJson(), 'getPackageBundles').returns([
+        {
+          name: testBundleName,
+          versionName: 'ver 0.NEXT',
+          versionNumber: '0.NEXT',
+        },
+      ]);
+
+      // Mock connection tooling queries
+      const queryStub = testContext.SANDBOX.stub(connection.tooling, 'query');
+
+      // First query: Get bundle name from bundle ID
+      queryStub.onFirstCall().resolves({
+        totalSize: 1,
+        done: true,
+        records: [{ BundleName: testBundleName }],
+      });
+
+      // Second query: Get existing bundle versions (returns version 0.1)
+      queryStub.onSecondCall().resolves({
+        totalSize: 1,
+        done: true,
+        records: [
+          {
+            Id: '0Ho000000000001',
+            PackageBundle: { Id: testBundleId, BundleName: testBundleName },
+            VersionName: 'testBundle@0.1',
+            MajorVersion: '0',
+            MinorVersion: '1',
+            IsReleased: true,
+          },
+        ],
+      });
+
+      const options: BundleVersionCreateOptions = {
+        connection,
+        project,
+        PackageBundle: testBundleName,
+        MajorVersion: '0',
+        MinorVersion: 'NEXT',
+        Ancestor: null,
+        BundleVersionComponentsPath: '',
+      };
+
+      // Call the private method through reflection for testing
+      const result = await (
+        PackageBundleVersionCreate as unknown as PackageBundleVersionCreateWithPrivates
+      ).getPackageVersion(options, project, connection);
+
+      expect(result).to.deep.equal({
+        MajorVersion: '0',
+        MinorVersion: '2',
+      });
+
+      // Verify the queries were called correctly
+      expect(queryStub.firstCall.args[0]).to.include(
+        `SELECT BundleName FROM PackageBundle WHERE Id = '${testBundleId}'`
+      );
+      expect(queryStub.secondCall.args[0]).to.include(
+        `SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased FROM PackageBundleVersion WHERE PackageBundle.BundleName = '${testBundleName}' AND MajorVersion = 0 ORDER BY MinorVersion DESC LIMIT 1`
+      );
+    });
+
+    it('should resolve 0.NEXT to 0.0 when no existing versions exist', async () => {
+      const testBundleName = 'newBundle';
+      const testBundleId = '0Ho000000000000';
+
+      // Restore the getPackageVersion stub so we can test the real method
+      testContext.SANDBOX.restore();
+
+      // Re-stub parsePackageBundleId since we still need it
+      testContext.SANDBOX.stub(
+        PackageBundleVersionCreate,
+        'parsePackageBundleId' as keyof typeof PackageBundleVersionCreate
+      ).returns(testBundleId);
+
+      // Mock project's getSfProjectJson().getPackageBundles() to return a bundle with version "0.NEXT"
+      testContext.SANDBOX.stub(project.getSfProjectJson(), 'getPackageBundles').returns([
+        {
+          name: testBundleName,
+          versionName: 'ver 0.NEXT',
+          versionNumber: '0.NEXT',
+        },
+      ]);
+
+      // Mock connection tooling queries
+      const queryStub = testContext.SANDBOX.stub(connection.tooling, 'query');
+
+      // First query: Get bundle name from bundle ID
+      queryStub.onFirstCall().resolves({
+        totalSize: 1,
+        done: true,
+        records: [{ BundleName: testBundleName }],
+      });
+
+      // Second query: Get existing bundle versions (returns empty - no existing versions)
+      queryStub.onSecondCall().resolves({
+        totalSize: 0,
+        done: true,
+        records: [],
+      });
+
+      const options: BundleVersionCreateOptions = {
+        connection,
+        project,
+        PackageBundle: testBundleName,
+        MajorVersion: '0',
+        MinorVersion: 'NEXT',
+        Ancestor: null,
+        BundleVersionComponentsPath: '',
+      };
+
+      // Call the private method through reflection for testing
+      const result = await (
+        PackageBundleVersionCreate as unknown as PackageBundleVersionCreateWithPrivates
+      ).getPackageVersion(options, project, connection);
+
+      expect(result).to.deep.equal({
+        MajorVersion: '0',
+        MinorVersion: '0',
+      });
+
+      // Verify the queries were called correctly
+      expect(queryStub.firstCall.args[0]).to.include(
+        `SELECT BundleName FROM PackageBundle WHERE Id = '${testBundleId}'`
+      );
+      expect(queryStub.secondCall.args[0]).to.include(
+        `SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased FROM PackageBundleVersion WHERE PackageBundle.BundleName = '${testBundleName}' AND MajorVersion = 0 ORDER BY MinorVersion DESC LIMIT 1`
+      );
+    });
+
+    it('should handle numeric minor versions without NEXT', async () => {
+      const testBundleName = 'simpleBundle';
+      const testBundleId = '0Ho000000000000';
+
+      // Restore the getPackageVersion stub so we can test the real method
+      testContext.SANDBOX.restore();
+
+      // Re-stub parsePackageBundleId since we still need it
+      testContext.SANDBOX.stub(
+        PackageBundleVersionCreate,
+        'parsePackageBundleId' as keyof typeof PackageBundleVersionCreate
+      ).returns(testBundleId);
+
+      // Mock project's getSfProjectJson().getPackageBundles() to return a bundle with version "1.5"
+      testContext.SANDBOX.stub(project.getSfProjectJson(), 'getPackageBundles').returns([
+        {
+          name: testBundleName,
+          versionName: 'ver 1.5',
+          versionNumber: '1.5',
+        },
+      ]);
+
+      // Mock connection tooling queries
+      const queryStub = testContext.SANDBOX.stub(connection.tooling, 'query');
+
+      // First query: Get bundle name from bundle ID
+      queryStub.onFirstCall().resolves({
+        totalSize: 1,
+        done: true,
+        records: [{ BundleName: testBundleName }],
+      });
+
+      const options: BundleVersionCreateOptions = {
+        connection,
+        project,
+        PackageBundle: testBundleName,
+        MajorVersion: '1',
+        MinorVersion: '5',
+        Ancestor: null,
+        BundleVersionComponentsPath: '',
+      };
+
+      // Call the private method through reflection for testing
+      const result = await (
+        PackageBundleVersionCreate as unknown as PackageBundleVersionCreateWithPrivates
+      ).getPackageVersion(options, project, connection);
+
+      expect(result).to.deep.equal({
+        MajorVersion: '1',
+        MinorVersion: '5',
+      });
+
+      // Verify only the first query was called (no need to query existing versions for numeric minor)
+      expect(queryStub.calledOnce).to.be.true;
+      expect(queryStub.firstCall.args[0]).to.include(
+        `SELECT BundleName FROM PackageBundle WHERE Id = '${testBundleId}'`
+      );
+    });
+  });
 });