feat: accept 15-char package version IDs in bundle definition file

Author: sf-haulakh

src/package/packageBundleVersionCreate.ts

@@ -17,6 +17,7 @@ import * as fs from 'node:fs';
 import { Connection, Messages, SfError, SfProject } from '@salesforce/core';
 import { BundleSObjects, BundleVersionCreateOptions } from '../interfaces';
 import { massageErrorMessage } from '../utils/bundleUtils';
+import { convertTo18CharId } from '../utils/packageUtils';
 
 Messages.importMessagesDirectory(__dirname);
 const messages = Messages.loadMessages('@salesforce/packaging', 'bundle_version_create');
@@ -174,11 +175,16 @@ export class PackageBundleVersionCreate {
       return bundleVersionComponents.map((component) => {
         const packageVersion = component.packageVersion;
 
-        // Check if it's already an ID (04t followed by 15 characters)
+        // Check if it's already an 18-char ID (04t followed by 15 characters)
         if (/^04t[a-zA-Z0-9]{15}$/.test(packageVersion)) {
           return packageVersion;
         }
 
+        // Check if it's a 15-char ID (04t followed by 12 characters) and convert to 18-char
+        if (/^04t[a-zA-Z0-9]{12}$/.test(packageVersion)) {
+          return convertTo18CharId(packageVersion);
+        }
+
         // Otherwise, treat it as an alias and resolve it from sfdx-project.json
         const packageVersionId = project.getPackageIdFromAlias(packageVersion);
         if (!packageVersionId) {

src/utils/packageUtils.ts

@@ -88,6 +88,33 @@ export function uniqid(options?: { template?: string; length?: number }): string
     : `${options.template}${uniqueString}`;
 }
 
+/**
+ * Converts a 15-character Salesforce ID to its 18-character case-insensitive equivalent.
+ * Returns the ID unchanged if it is not exactly 15 characters.
+ *
+ * @param id - The Salesforce ID to convert
+ * @returns The 18-character Salesforce ID
+ */
+export function convertTo18CharId(id: string): string {
+  if (!id || id.length !== 15) {
+    return id;
+  }
+
+  const suffix: string[] = [];
+  for (let i = 0; i < 3; i++) {
+    let flags = 0;
+    for (let j = 0; j < 5; j++) {
+      const char = id.charAt(i * 5 + j);
+      if (char >= 'A' && char <= 'Z') {
+        flags += 1 << j;
+      }
+    }
+    suffix.push('ABCDEFGHIJKLMNOPQRSTUVWXYZ012345'.charAt(flags));
+  }
+
+  return id + suffix.join('');
+}
+
 export function validateId(idObj: Many<IdRegistryValue>, value: string | undefined): void {
   if (!value || !validateIdNoThrow(idObj, value)) {
     throw messages.createError('invalidIdOrAlias', [

test/package/bundleVersionCreate.test.ts

@@ -585,6 +585,75 @@ describe('PackageBundleVersion.create', () => {
       fs.unlinkSync(componentsPath);
     });
 
+    it('should accept 15-char package version IDs and convert to 18-char', async () => {
+      const componentsPath = path.join(project.getPath(), 'bundle-components.json');
+      const components = [
+        { packageVersion: '04t5f000000WM9y' }, // 15-char ID
+        { packageVersion: '04t000000000000003' }, // 18-char ID (should stay unchanged)
+      ];
+      fs.writeFileSync(componentsPath, JSON.stringify(components));
+
+      let capturedRequest: { BundleVersionComponents: string } | undefined;
+      Object.assign(connection.tooling, {
+        sobject: () => ({
+          create: (req: { BundleVersionComponents: string }) => {
+            capturedRequest = req;
+            return Promise.resolve({
+              success: true,
+              id: '0Ho000000000000',
+            });
+          },
+        }),
+        query: () =>
+          Promise.resolve({
+            records: [{ BundleName: 'testBundle' }],
+          }),
+      });
+
+      Object.assign(connection, {
+        autoFetchQuery: () =>
+          Promise.resolve({
+            records: [
+              {
+                Id: '0Ho000000000000',
+                RequestStatus: BundleSObjects.PkgBundleVersionCreateReqStatus.success,
+                PackageBundle: { Id: '0Ho123456789012' },
+                PackageBundleVersion: { Id: '1Q8000000000001' },
+                VersionName: 'ver 1.0',
+                MajorVersion: '1',
+                MinorVersion: '0',
+                Ancestor: null,
+                BundleVersionComponents: JSON.stringify(components),
+                CreatedDate: '2025-01-01T00:00:00.000Z',
+                CreatedById: '005000000000000',
+                ValidationError: '',
+              },
+            ],
+          }),
+      });
+
+      const options: BundleVersionCreateOptions = {
+        connection,
+        project,
+        PackageBundle: 'testBundle',
+        MajorVersion: '1',
+        MinorVersion: '0',
+        Ancestor: null,
+        BundleVersionComponentsPath: componentsPath,
+      };
+
+      const result = await PackageBundleVersion.create(options);
+      expect(result).to.have.property('RequestStatus', BundleSObjects.PkgBundleVersionCreateReqStatus.success);
+
+      // Verify the 15-char ID was converted to 18-char in the API request
+      expect(capturedRequest).to.not.be.undefined;
+      const sentComponents = JSON.parse(capturedRequest!.BundleVersionComponents) as string[];
+      expect(sentComponents[0]).to.equal('04t5f000000WM9yAAG'); // converted from 15 to 18
+      expect(sentComponents[1]).to.equal('04t000000000000003'); // unchanged 18-char
+
+      fs.unlinkSync(componentsPath);
+    });
+
     it('should handle invalid bundle components format', async () => {
       const componentsPath = path.join(project.getPath(), 'bundle-components.json');
 

test/utils/packageUtils.test.ts

@@ -26,6 +26,7 @@ import JSZIP from 'jszip';
 import {
   applyErrorAction,
   combineSaveErrors,
+  convertTo18CharId,
   findPackageDirectory,
   resolveBuildUserPermissions,
   getPackageVersionNumber,
@@ -49,6 +50,31 @@ describe('packageUtils', () => {
     restoreContext($$);
   });
 
+  describe('convertTo18CharId', () => {
+    it('should convert a 15-char ID to 18-char', () => {
+      expect(convertTo18CharId('04t5f000000WM9y')).to.equal('04t5f000000WM9yAAG');
+    });
+
+    it('should return an 18-char ID unchanged', () => {
+      expect(convertTo18CharId('04t5f000000WM9yAAG')).to.equal('04t5f000000WM9yAAG');
+    });
+
+    it('should return empty string unchanged', () => {
+      expect(convertTo18CharId('')).to.equal('');
+    });
+
+    it('should handle all-lowercase 15-char ID', () => {
+      const result = convertTo18CharId('04t5f000000wm9y');
+      expect(result).to.have.lengthOf(18);
+      expect(result).to.equal('04t5f000000wm9yAAA');
+    });
+
+    it('should handle mixed-case 15-char ID', () => {
+      const result = convertTo18CharId('001A000001ABCDE');
+      expect(result).to.have.lengthOf(18);
+    });
+  });
+
   describe('getPackage2VersionNumber', () => {
     it('should return the correct version number', () => {
       const version = {