@salesforce/packaging 4.12.0 → 4.13.1

package/lib/package/packageBundleInstall.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleInstall = void 0;
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const core_1 = require("@salesforce/core");
+const interfaces_1 = require("../interfaces");
+const bundleUtils_1 = require("../utils/bundleUtils");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_install');
+class PackageBundleInstall {
+    static async getInstallStatus(installRequestId, connection) {
+        try {
+            const result = await connection.tooling.sobject('PkgBundleVersionInstallReq').retrieve(installRequestId);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToGetPackageBundleInstallStatus'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static async getInstallStatuses(connection, status, createdLastDays) {
+        let query = 'SELECT Id, InstallStatus, PackageBundleVersionID, DevelopmentOrganization, ValidationError, ' +
+            'CreatedDate, CreatedById ' +
+            'FROM PkgBundleVersionInstallReq';
+        if (status && createdLastDays) {
+            query += ` WHERE InstallStatus = '${status}' AND CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        else if (status) {
+            query += ` WHERE InstallStatus = '${status}'`;
+        }
+        else if (createdLastDays) {
+            query += ` WHERE CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        const queryResult = await connection.autoFetchQuery(query, {
+            tooling: true,
+        });
+        return queryResult.records.map((record) => ({
+            Id: record.Id,
+            InstallStatus: record.InstallStatus,
+            PackageBundleVersionID: record.PackageBundleVersionID ?? '',
+            DevelopmentOrganization: record.DevelopmentOrganization ?? '',
+            ValidationError: record.ValidationError ?? '',
+            CreatedDate: record.CreatedDate ?? '',
+            CreatedById: record.CreatedById ?? '',
+        }));
+    }
+    static async installBundle(connection, project, options) {
+        const packageBundleVersionId = PackageBundleInstall.parsePackageBundleVersionId(options.PackageBundleVersion, project);
+        const request = {
+            PackageBundleVersionID: packageBundleVersionId,
+            DevelopmentOrganization: options.DevelopmentOrganization,
+        };
+        let installResult;
+        try {
+            installResult = await connection.tooling.sobject('PkgBundleVersionInstallReq').create(request);
+        }
+        catch (err) {
+            const error = err instanceof Error
+                ? err
+                : new Error(typeof err === 'string' ? err : messages.getMessage('failedToInstallPackageBundle'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+        if (!installResult?.success) {
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToInstallPackageBundle'))));
+        }
+        if (options.polling) {
+            return PackageBundleInstall.pollInstallStatus(installResult.id, connection, options.polling);
+        }
+        return {
+            Id: installResult.id,
+            PackageBundleVersionID: packageBundleVersionId,
+            DevelopmentOrganization: options.DevelopmentOrganization,
+            InstallStatus: interfaces_1.BundleSObjects.PkgBundleVersionInstallReqStatus.queued,
+            ValidationError: '',
+            CreatedDate: new Date().toISOString(),
+            CreatedById: connection.getUsername() ?? 'unknown',
+        };
+    }
+    static parsePackageBundleVersionId(packageBundleVersion, project) {
+        // Check if it's already an ID (starts with appropriate prefix)
+        if (/^1Q8.{15}$/.test(packageBundleVersion)) {
+            return packageBundleVersion;
+        }
+        // Otherwise, treat it as an alias and resolve it from sfdx-project.json
+        const packageBundleVersionId = project.getPackageBundleIdFromAlias(packageBundleVersion);
+        if (!packageBundleVersionId) {
+            throw new core_1.SfError(messages.getMessage('noPackageBundleVersionFoundWithAlias', [packageBundleVersion]));
+        }
+        return packageBundleVersionId;
+    }
+    static async pollInstallStatus(installRequestId, connection, polling) {
+        if (polling.timeout?.milliseconds <= 0) {
+            return PackageBundleInstall.getInstallStatus(installRequestId, connection);
+        }
+        const pollingClient = await core_1.PollingClient.create({
+            poll: async () => {
+                const status = await PackageBundleInstall.getInstallStatus(installRequestId, connection);
+                if (status.InstallStatus === interfaces_1.BundleSObjects.PkgBundleVersionInstallReqStatus.success) {
+                    return { completed: true, payload: status };
+                }
+                return { completed: false, payload: status };
+            },
+            frequency: polling.frequency,
+            timeout: polling.timeout,
+        });
+        try {
+            return await pollingClient.subscribe();
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw new Error('Install request timed out');
+            }
+            throw err;
+        }
+    }
+}
+exports.PackageBundleInstall = PackageBundleInstall;
+//# sourceMappingURL=packageBundleInstall.js.map

package/lib/package/packageBundleVersion.d.ts

@@ -0,0 +1,21 @@
+import { Connection } from '@salesforce/core';
+import { SfProject } from '@salesforce/core';
+import { Duration } from '@salesforce/kit';
+import { BundleVersionCreateOptions, BundleSObjects, PackagingSObjects } from '../interfaces';
+export declare class PackageBundleVersion {
+    static create(options: BundleVersionCreateOptions, polling?: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static pollCreateStatus(createPackageVersionRequestId: string, connection: Connection, project: SfProject, polling: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static report(connection: Connection, id: string): Promise<BundleSObjects.BundleVersion | null>;
+    static list(connection: Connection): Promise<BundleSObjects.BundleVersion[]>;
+    static getComponentPackages(connection: Connection, id: string): Promise<PackagingSObjects.SubscriberPackageVersion[]>;
+    private static mapRecordToBundleVersion;
+    private static mapPackageBundle;
+    private static mapAncestor;
+    private static mapAncestorPackageBundle;
+}

package/lib/package/packageBundleVersion.js

@@ -0,0 +1,225 @@
+"use strict";
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleVersion = void 0;
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+const interfaces_1 = require("../interfaces");
+const bundleUtils_1 = require("../utils/bundleUtils");
+const packageUtils_1 = require("../utils/packageUtils");
+const packageBundleVersionCreate_1 = require("./packageBundleVersionCreate");
+core_1.Messages.importMessagesDirectory(__dirname);
+const bundleVersionMessages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_version');
+class PackageBundleVersion {
+    static async create(options, polling) {
+        const createResult = await packageBundleVersionCreate_1.PackageBundleVersionCreate.createBundleVersion(options.connection, options.project, options);
+        if (polling) {
+            return PackageBundleVersion.pollCreateStatus(createResult.Id, options.connection, options.project, polling).catch((error) => {
+                if (error.name === 'PollingClientTimeout') {
+                    const modifiedError = new core_1.SfError(error.message);
+                    modifiedError.setData({ VersionCreateRequestId: createResult.Id });
+                    modifiedError.message += ` Run 'sf package bundle version create report -i ${createResult.Id}' to check the status.`;
+                    throw (0, packageUtils_1.applyErrorAction)((0, bundleUtils_1.massageErrorMessage)(modifiedError));
+                }
+                throw (0, packageUtils_1.applyErrorAction)((0, bundleUtils_1.massageErrorMessage)(error));
+            });
+        }
+        return createResult;
+    }
+    static async pollCreateStatus(createPackageVersionRequestId, connection, project, polling) {
+        if (polling.timeout?.milliseconds <= 0) {
+            return packageBundleVersionCreate_1.PackageBundleVersionCreate.getCreateStatus(createPackageVersionRequestId, connection);
+        }
+        let remainingWaitTime = polling.timeout;
+        const pollingClient = await core_1.PollingClient.create({
+            poll: async () => {
+                const report = await packageBundleVersionCreate_1.PackageBundleVersionCreate.getCreateStatus(createPackageVersionRequestId, connection);
+                switch (report.RequestStatus) {
+                    case interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.queued:
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.enqueued, { ...report, remainingWaitTime });
+                        remainingWaitTime = kit_1.Duration.seconds(remainingWaitTime.seconds - polling.frequency.seconds);
+                        return {
+                            completed: false,
+                            payload: report,
+                        };
+                    case interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.success: {
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.success, report);
+                        return { completed: true, payload: report };
+                    }
+                    case interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.error:
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.error, report);
+                        return { completed: true, payload: report };
+                }
+            },
+            frequency: polling.frequency,
+            timeout: polling.timeout,
+        });
+        try {
+            return await pollingClient.subscribe();
+        }
+        catch (err) {
+            const report = await packageBundleVersionCreate_1.PackageBundleVersionCreate.getCreateStatus(createPackageVersionRequestId, connection);
+            await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create['timed-out'], report);
+            if (err instanceof Error) {
+                throw (0, packageUtils_1.applyErrorAction)(err);
+            }
+            throw err;
+        }
+    }
+    static async report(connection, id) {
+        const query = `SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased, PackageBundle.Description, PackageBundle.IsDeleted, PackageBundle.CreatedDate, PackageBundle.CreatedById, PackageBundle.LastModifiedDate, PackageBundle.LastModifiedById, PackageBundle.SystemModstamp, Ancestor.Id, Ancestor.PackageBundle.Id, Ancestor.PackageBundle.BundleName, Ancestor.VersionName, Ancestor.MajorVersion, Ancestor.MinorVersion, Ancestor.IsReleased, Ancestor.PackageBundle.Description, Ancestor.PackageBundle.IsDeleted, Ancestor.PackageBundle.CreatedDate, Ancestor.PackageBundle.CreatedById, Ancestor.PackageBundle.LastModifiedDate, Ancestor.PackageBundle.LastModifiedById, Ancestor.PackageBundle.SystemModstamp FROM PackageBundleVersion WHERE Id = '${id}'`;
+        const queryResult = await connection.autoFetchQuery(query, { tooling: true });
+        return queryResult.records.length > 0
+            ? PackageBundleVersion.mapRecordToBundleVersion(queryResult.records[0])
+            : null;
+    }
+    static async list(connection) {
+        const query = 'SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased, PackageBundle.Description, PackageBundle.IsDeleted, PackageBundle.CreatedDate, PackageBundle.CreatedById, PackageBundle.LastModifiedDate, PackageBundle.LastModifiedById, PackageBundle.SystemModstamp, Ancestor.Id, Ancestor.PackageBundle.Id, Ancestor.PackageBundle.BundleName, Ancestor.VersionName, Ancestor.MajorVersion, Ancestor.MinorVersion, Ancestor.IsReleased, Ancestor.PackageBundle.Description, Ancestor.PackageBundle.IsDeleted, Ancestor.PackageBundle.CreatedDate, Ancestor.PackageBundle.CreatedById, Ancestor.PackageBundle.LastModifiedDate, Ancestor.PackageBundle.LastModifiedById, Ancestor.PackageBundle.SystemModstamp FROM PackageBundleVersion';
+        const queryResult = await connection.autoFetchQuery(query, { tooling: true });
+        return queryResult.records.map((record) => PackageBundleVersion.mapRecordToBundleVersion(record));
+    }
+    static async getComponentPackages(connection, id) {
+        const query = `SELECT Component.Id, Component.Description, Component.PublisherName, Component.MajorVersion, Component.MinorVersion, Component.PatchVersion, Component.BuildNumber, Component.ReleaseState, Component.IsManaged, Component.IsDeprecated, Component.IsPasswordProtected, Component.IsBeta, Component.Package2ContainerOptions, Component.IsSecurityReviewed, Component.IsOrgDependent, Component.AppExchangePackageName, Component.AppExchangeDescription, Component.AppExchangePublisherName, Component.AppExchangeLogoUrl, Component.ReleaseNotesUrl, Component.PostInstallUrl, Component.RemoteSiteSettings, Component.CspTrustedSites, Component.Profiles, Component.Dependencies, Component.InstallValidationStatus, Component.SubscriberPackageId FROM PkgBundleVersionComponent WHERE PackageBundleVersion.Id = '${id}' ORDER BY CreatedDate`;
+        const queryResult = await connection.autoFetchQuery(query, { tooling: true });
+        // Get unique SubscriberPackageIds to query for Names
+        const subscriberPackageIds = [
+            ...new Set(queryResult.records
+                .map((record) => record.Component?.SubscriberPackageId)
+                .filter((packageId) => !!packageId)),
+        ];
+        // Query SubscriberPackage to get Names (one by one due to implementation restriction)
+        const subscriberPackageNames = new Map();
+        const packageQueries = subscriberPackageIds.map(async (packageId) => {
+            try {
+                const packageQuery = `SELECT Id, Name FROM SubscriberPackage WHERE Id='${packageId}'`;
+                const packageQueryResult = await connection.autoFetchQuery(packageQuery, { tooling: true });
+                return {
+                    packageId,
+                    name: packageQueryResult.records.length > 0 ? packageQueryResult.records[0].Name : '',
+                };
+            }
+            catch (error) {
+                // If individual query fails, return empty name for this package
+                return {
+                    packageId,
+                    name: '',
+                };
+            }
+        });
+        const packageResults = await Promise.allSettled(packageQueries);
+        packageResults.forEach((result) => {
+            if (result.status === 'fulfilled') {
+                subscriberPackageNames.set(result.value.packageId, result.value.name);
+            }
+        });
+        return queryResult.records.map((record) => {
+            const component = record.Component;
+            if (!component) {
+                throw new core_1.SfError(bundleVersionMessages.getMessage('componentRecordMissing'));
+            }
+            const packageName = subscriberPackageNames.get(component.SubscriberPackageId) ?? '';
+            return {
+                Id: component.Id,
+                SubscriberPackageId: component.SubscriberPackageId,
+                Name: packageName,
+                Description: component.Description,
+                PublisherName: component.PublisherName,
+                MajorVersion: component.MajorVersion,
+                MinorVersion: component.MinorVersion,
+                PatchVersion: component.PatchVersion,
+                BuildNumber: component.BuildNumber,
+                ReleaseState: component.ReleaseState,
+                IsManaged: component.IsManaged,
+                IsDeprecated: component.IsDeprecated,
+                IsPasswordProtected: component.IsPasswordProtected,
+                IsBeta: component.IsBeta,
+                Package2ContainerOptions: component.Package2ContainerOptions,
+                IsSecurityReviewed: component.IsSecurityReviewed,
+                IsOrgDependent: component.IsOrgDependent,
+                AppExchangePackageName: component.AppExchangePackageName,
+                AppExchangeDescription: component.AppExchangeDescription,
+                AppExchangePublisherName: component.AppExchangePublisherName,
+                AppExchangeLogoUrl: component.AppExchangeLogoUrl,
+                ReleaseNotesUrl: component.ReleaseNotesUrl,
+                PostInstallUrl: component.PostInstallUrl,
+                RemoteSiteSettings: component.RemoteSiteSettings,
+                CspTrustedSites: component.CspTrustedSites,
+                Profiles: component.Profiles,
+                Dependencies: component.Dependencies,
+                InstallValidationStatus: component.InstallValidationStatus,
+            };
+        });
+    }
+    static mapRecordToBundleVersion(record) {
+        return {
+            Id: record.Id,
+            PackageBundle: PackageBundleVersion.mapPackageBundle(record.PackageBundle),
+            VersionName: record.VersionName ?? '',
+            MajorVersion: record.MajorVersion ?? '',
+            MinorVersion: record.MinorVersion ?? '',
+            CreatedDate: record.PackageBundle?.CreatedDate ?? '',
+            CreatedById: record.PackageBundle?.CreatedById ?? '',
+            LastModifiedDate: record.PackageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: record.PackageBundle?.LastModifiedById ?? '',
+            Ancestor: record.Ancestor?.Id ? PackageBundleVersion.mapAncestor(record.Ancestor) : null,
+            IsReleased: record.IsReleased ?? false,
+        };
+    }
+    static mapPackageBundle(packageBundle) {
+        return {
+            Id: packageBundle?.Id ?? '',
+            BundleName: packageBundle?.BundleName ?? '',
+            Description: packageBundle?.Description,
+            IsDeleted: packageBundle?.IsDeleted ?? false,
+            CreatedDate: packageBundle?.CreatedDate ?? '',
+            CreatedById: packageBundle?.CreatedById ?? '',
+            LastModifiedDate: packageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: packageBundle?.LastModifiedById ?? '',
+            SystemModstamp: packageBundle?.SystemModstamp ?? '',
+        };
+    }
+    static mapAncestor(ancestor) {
+        return {
+            Id: ancestor.Id,
+            PackageBundle: PackageBundleVersion.mapAncestorPackageBundle(ancestor.PackageBundle),
+            VersionName: ancestor?.VersionName ?? '',
+            MajorVersion: ancestor?.MajorVersion ?? '',
+            MinorVersion: ancestor?.MinorVersion ?? '',
+            CreatedDate: ancestor.PackageBundle?.CreatedDate ?? '',
+            CreatedById: ancestor.PackageBundle?.CreatedById ?? '',
+            LastModifiedDate: ancestor.PackageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: ancestor.PackageBundle?.LastModifiedById ?? '',
+            Ancestor: null,
+            IsReleased: ancestor.IsReleased ?? false,
+        };
+    }
+    static mapAncestorPackageBundle(packageBundle) {
+        return {
+            Id: packageBundle?.Id ?? '',
+            BundleName: packageBundle?.BundleName ?? '',
+            Description: packageBundle?.Description,
+            IsDeleted: packageBundle?.IsDeleted ?? false,
+            CreatedDate: packageBundle?.CreatedDate ?? '',
+            CreatedById: packageBundle?.CreatedById ?? '',
+            LastModifiedDate: packageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: packageBundle?.LastModifiedById ?? '',
+            SystemModstamp: packageBundle?.SystemModstamp ?? '',
+        };
+    }
+}
+exports.PackageBundleVersion = PackageBundleVersion;
+//# sourceMappingURL=packageBundleVersion.js.map

package/lib/package/packageBundleVersionCreate.d.ts

@@ -0,0 +1,11 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { BundleSObjects, BundleVersionCreateOptions } from '../interfaces';
+export declare class PackageBundleVersionCreate {
+    static getCreateStatus(createPackageVersionRequestId: string, connection: Connection): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static getCreateStatuses(connection: Connection, status?: BundleSObjects.PkgBundleVersionCreateReqStatus, createdLastDays?: number): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult[]>;
+    static createBundleVersion(connection: Connection, project: SfProject, options: BundleVersionCreateOptions): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    private static readBundleVersionComponents;
+    private static getVersionName;
+    private static parsePackageBundleId;
+    private static getPackageVersion;
+}

package/lib/package/packageBundleVersionCreate.js

@@ -0,0 +1,248 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleVersionCreate = void 0;
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs = __importStar(require("node:fs"));
+const core_1 = require("@salesforce/core");
+const interfaces_1 = require("../interfaces");
+const bundleUtils_1 = require("../utils/bundleUtils");
+const packageBundleVersion_1 = require("./packageBundleVersion");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_version_create');
+class PackageBundleVersionCreate {
+    static async getCreateStatus(createPackageVersionRequestId, connection) {
+        try {
+            const result = await connection.tooling
+                .sobject('PkgBundleVersionCreateReq')
+                .retrieve(createPackageVersionRequestId);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToGetPackageBundleVersionCreateStatus'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static async getCreateStatuses(connection, status, createdLastDays) {
+        let query = 'SELECT Id, RequestStatus, PackageBundle.Id, PackageBundle.BundleName, PackageBundleVersion.Id, ' +
+            'VersionName, MajorVersion, MinorVersion, Ancestor.Id, BundleVersionComponents, ' +
+            'CreatedDate, CreatedById ' +
+            'FROM PkgBundleVersionCreateReq';
+        if (status && createdLastDays) {
+            query += ` WHERE RequestStatus = '${status}' AND CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        else if (status) {
+            query += ` WHERE RequestStatus = '${status}'`;
+        }
+        else if (createdLastDays) {
+            query += ` WHERE CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        const queryResult = await connection.autoFetchQuery(query, {
+            tooling: true,
+        });
+        return queryResult.records.map((record) => ({
+            Id: record.Id,
+            RequestStatus: record.RequestStatus,
+            PackageBundleId: record.PackageBundle?.Id ?? '',
+            PackageBundleVersionId: record.PackageBundleVersion?.Id ?? '',
+            VersionName: record.VersionName ?? '',
+            MajorVersion: record.MajorVersion ?? '',
+            MinorVersion: record.MinorVersion ?? '',
+            Ancestor: record.Ancestor?.Id ?? '',
+            BundleVersionComponents: record.BundleVersionComponents ?? '',
+            CreatedDate: record.CreatedDate ?? '',
+            CreatedById: record.CreatedById ?? '',
+        }));
+    }
+    static async createBundleVersion(connection, project, options) {
+        const bundleVersionComponents = PackageBundleVersionCreate.readBundleVersionComponents(options.BundleVersionComponentsPath, project);
+        const packageBundleId = PackageBundleVersionCreate.parsePackageBundleId(options.PackageBundle, project);
+        // Use provided MajorVersion and MinorVersion if they are not empty strings, otherwise get from bundle configuration
+        const version = options.MajorVersion && options.MinorVersion
+            ? { MajorVersion: options.MajorVersion, MinorVersion: options.MinorVersion }
+            : await PackageBundleVersionCreate.getPackageVersion(options, project, connection);
+        const request = {
+            PackageBundleId: packageBundleId,
+            VersionName: PackageBundleVersionCreate.getVersionName(options.PackageBundle, version.MajorVersion, version.MinorVersion),
+            MajorVersion: version.MajorVersion,
+            MinorVersion: version.MinorVersion,
+            BundleVersionComponents: JSON.stringify(bundleVersionComponents),
+            ...(options.Ancestor ? { Ancestor: options.Ancestor } : {}),
+        };
+        let createResult;
+        try {
+            createResult = await connection.tooling.sobject('PkgBundleVersionCreateReq').create(request);
+        }
+        catch (err) {
+            const error = err instanceof Error
+                ? err
+                : new Error(typeof err === 'string' ? err : messages.getMessage('failedToCreatePackageBundleVersion'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+        if (!createResult?.success) {
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToCreatePackageBundleVersion'))));
+        }
+        if (options.polling) {
+            return packageBundleVersion_1.PackageBundleVersion.pollCreateStatus(createResult.id, connection, project, options.polling);
+        }
+        return {
+            Id: createResult.id,
+            PackageBundleVersionId: createResult.id,
+            PackageBundleId: packageBundleId,
+            VersionName: PackageBundleVersionCreate.getVersionName(options.PackageBundle, version.MajorVersion, version.MinorVersion),
+            MajorVersion: version.MajorVersion,
+            MinorVersion: version.MinorVersion,
+            BundleVersionComponents: JSON.stringify(bundleVersionComponents),
+            RequestStatus: interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.success,
+            CreatedDate: new Date().toISOString(),
+            CreatedById: connection.getUsername() ?? 'unknown',
+        };
+    }
+    static readBundleVersionComponents(filePath, project) {
+        try {
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            const bundleVersionComponents = JSON.parse(fileContent);
+            if (!Array.isArray(bundleVersionComponents)) {
+                throw new core_1.SfError(messages.getMessage('bundleVersionComponentsMustBeArray'));
+            }
+            // Validate that each item has the required packageVersion property
+            for (const component of bundleVersionComponents) {
+                if (!component || typeof component !== 'object' || !component.packageVersion) {
+                    throw new core_1.SfError(messages.getMessage('bundleVersionComponentMustBeObject'));
+                }
+            }
+            // Process each component to get the package version ID
+            return bundleVersionComponents.map((component) => {
+                const packageVersion = component.packageVersion;
+                // Check if it's already an ID (04t followed by 15 characters)
+                if (/^04t[a-zA-Z0-9]{15}$/.test(packageVersion)) {
+                    return packageVersion;
+                }
+                // Otherwise, treat it as an alias and resolve it from sfdx-project.json
+                const packageVersionId = project.getPackageIdFromAlias(packageVersion);
+                if (!packageVersionId) {
+                    throw new core_1.SfError(messages.getMessage('noPackageVersionFoundWithAlias', [packageVersion]));
+                }
+                return packageVersionId;
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToReadBundleVersionComponentsFile'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static getVersionName(packageBundle, majorVersion, minorVersion) {
+        return `${packageBundle}@${majorVersion}.${minorVersion}`;
+    }
+    static parsePackageBundleId(packageBundle, project) {
+        if (/^1Fl.{15}$/.test(packageBundle)) {
+            return packageBundle;
+        }
+        const bundleId = project.getPackageBundleIdFromAlias(packageBundle);
+        if (!bundleId) {
+            throw new core_1.SfError(messages.getMessage('noPackageBundleFoundWithAlias', [packageBundle]));
+        }
+        return bundleId;
+    }
+    static async getPackageVersion(options, project, connection) {
+        const packageBundleId = PackageBundleVersionCreate.parsePackageBundleId(options.PackageBundle, project);
+        const query = `SELECT BundleName FROM PackageBundle WHERE Id = '${packageBundleId}'`;
+        const result = await connection.tooling.query(query);
+        if (!result.records || result.records.length === 0) {
+            throw new core_1.SfError(messages.getMessage('noBundleFoundWithId', [packageBundleId]));
+        }
+        const bundleName = result.records[0].BundleName;
+        const bundles = project.getSfProjectJson().getPackageBundles();
+        const bundle = bundles.find((b) => b.name === bundleName);
+        if (!bundle) {
+            throw new core_1.SfError(messages.getMessage('noBundleFoundWithName', [bundleName]));
+        }
+        const [major, minor] = bundle.versionNumber.split('.');
+        if (!major || !minor) {
+            throw new core_1.SfError(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
+        }
+        // Check if major is an integer
+        const majorInt = parseInt(major, 10);
+        if (isNaN(majorInt) || majorInt.toString() !== major) {
+            throw new core_1.SfError(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(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 core_1.SfError(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 core_1.SfError(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
+            }
+        }
+        return { MajorVersion: major, MinorVersion: minor };
+    }
+}
+exports.PackageBundleVersionCreate = PackageBundleVersionCreate;
+//# sourceMappingURL=packageBundleVersionCreate.js.map

package/lib/package/packageConvert.js

@@ -1,9 +1,18 @@
 "use strict";
 /*
- * Copyright (c) 2022, salesforce.com, inc.
- * All rights reserved.
- * Licensed under the BSD 3-Clause license.
- * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;