@salesforce/packaging 0.0.35 → 0.0.37

package/lib/package/packageUninstall.js

@@ -10,8 +10,10 @@ exports.uninstallPackage = void 0;
 const os = require("os");
 const core_1 = require("@salesforce/core");
 const kit_1 = require("@salesforce/kit");
+const interfaces_1 = require("../interfaces");
 core_1.Messages.importMessagesDirectory(__dirname);
-const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_uninstall');
+const pkgMessages = core_1.Messages.loadMessages('@salesforce/packaging', 'package');
 async function poll(id, conn) {
     const uninstallRequest = await conn.tooling.sobject('SubscriberPackageVersionUninstallRequest').retrieve(id);
     switch (uninstallRequest.Status) {
@@ -20,13 +22,13 @@ async function poll(id, conn) {
         }
         case 'InProgress':
         case 'Queued': {
-            core_1.Lifecycle.getInstance().emit('packageUninstall', {
+            await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageEvents.uninstall, {
                 ...uninstallRequest,
             });
             return { completed: false, payload: uninstallRequest };
         }
         default: {
-            const err = messages.getMessage('defaultErrorMessage', [id, uninstallRequest.Id]);
+            const err = pkgMessages.getMessage('defaultErrorMessage', [id, uninstallRequest.Id]);
             const errorQueryResult = await conn.tooling.query(`"SELECT Message FROM PackageVersionUninstallRequestError WHERE ParentRequest.Id = '${id}' ORDER BY Message"`);
             const errors = [];
             if (errorQueryResult.records.length) {

package/lib/package/packageVersion.d.ts

@@ -63,4 +63,11 @@ export declare class PackageVersion {
     update(id: string, options: PackageVersionUpdateOptions): Promise<PackageSaveResult>;
     private updateDeprecation;
     private updateProjectWithPackageVersion;
+    /**
+     * Given a package version ID (05i) or subscriber package version ID (04t), return the subscriber package version ID (04t)
+     *
+     * @param versionId The suscriber package version ID
+     * @param connection For tooling query
+     */
+    private getSubscriberPackageVersionId;
 }

package/lib/package/packageVersion.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageVersion = void 0;
 const core_1 = require("@salesforce/core");
 const kit_1 = require("@salesforce/kit");
+const interfaces_1 = require("../interfaces");
 const utils_1 = require("../utils");
 const packageVersionCreate_1 = require("./packageVersionCreate");
 const packageVersionReport_1 = require("./packageVersionReport");
@@ -16,6 +17,7 @@ const packageVersionCreateRequestReport_1 = require("./packageVersionCreateReque
 const packageVersionList_1 = require("./packageVersionList");
 const packageVersionCreateRequest_1 = require("./packageVersionCreateRequest");
 core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version');
 class PackageVersion {
     constructor(options) {
         this.options = options;
@@ -114,7 +116,7 @@ class PackageVersion {
                 report = await this.getCreateVersionReport(createPackageVersionRequestId);
                 switch (report.Status) {
                     case 'Queued':
-                        await core_1.Lifecycle.getInstance().emit('enqueued', { ...report, remainingWaitTime });
+                        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,
@@ -126,18 +128,21 @@ class PackageVersion {
                     case 'VerifyingDependencies':
                     case 'VerifyingMetadata':
                     case 'FinalizingPackageVersion':
-                        await core_1.Lifecycle.getInstance().emit('in-progress', { ...report, remainingWaitTime });
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.progress, {
+                            ...report,
+                            remainingWaitTime,
+                        });
                         remainingWaitTime = kit_1.Duration.seconds(remainingWaitTime.seconds - polling.frequency.seconds);
                         return {
                             completed: false,
                             payload: report,
                         };
                     case 'Success':
-                        await core_1.Lifecycle.getInstance().emit('success', report);
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.success, report);
                         await this.updateProjectWithPackageVersion(this.project, report);
                         return { completed: true, payload: report };
                     case 'Error':
-                        await core_1.Lifecycle.getInstance().emit('error', report);
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.error, report);
                         return { completed: true, payload: report };
                 }
             },
@@ -148,7 +153,7 @@ class PackageVersion {
             return pollingClient.subscribe();
         }
         catch (err) {
-            await core_1.Lifecycle.getInstance().emit('timed-out', report);
+            await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create['timed-out'], report);
             throw (0, utils_1.applyErrorAction)(err);
         }
     }
@@ -191,7 +196,7 @@ class PackageVersion {
             throw new Error(result.errors.join(', '));
         }
         // Use the 04t ID for the success message
-        result.id = await (0, utils_1.getSubscriberPackageVersionId)(id, this.connection);
+        result.id = await this.getSubscriberPackageVersionId(id);
         return result;
     }
     async updateDeprecation(idOrAlias, IsDeprecated) {
@@ -209,7 +214,7 @@ class PackageVersion {
         if (!updateResult.success) {
             throw (0, utils_1.combineSaveErrors)('Package2', 'update', updateResult.errors);
         }
-        updateResult.id = await (0, utils_1.getSubscriberPackageVersionId)(packageVersionId, this.connection);
+        updateResult.id = await this.getSubscriberPackageVersionId(packageVersionId);
         return updateResult;
     }
     async updateProjectWithPackageVersion(withProject, results) {
@@ -225,6 +230,28 @@ class PackageVersion {
             await this.project.getSfProjectJson().write();
         }
     }
+    /**
+     * Given a package version ID (05i) or subscriber package version ID (04t), return the subscriber package version ID (04t)
+     *
+     * @param versionId The suscriber package version ID
+     * @param connection For tooling query
+     */
+    async getSubscriberPackageVersionId(versionId) {
+        // if it's already a 04t return it, otherwise query for it
+        if (!versionId || versionId.startsWith(utils_1.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID.prefix)) {
+            return versionId;
+        }
+        const query = `SELECT SubscriberPackageVersionId FROM Package2Version WHERE Id = '${versionId}'`;
+        const queryResult = await this.connection.tooling.query(query);
+        if (!queryResult || !queryResult.totalSize) {
+            throw messages.createError('errorInvalidIdNoMatchingVersionId', [
+                utils_1.BY_LABEL.PACKAGE_VERSION_ID.label,
+                versionId,
+                utils_1.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID.label,
+            ]);
+        }
+        return queryResult.records[0].SubscriberPackageVersionId;
+    }
 }
 exports.PackageVersion = PackageVersion;
 //# sourceMappingURL=packageVersion.js.map

package/lib/package/packageVersionCreate.d.ts

@@ -44,4 +44,10 @@ export declare class PackageVersionCreate {
      * Sets default or override values for packageDescriptorJSON attribs
      */
     private setPackageDescriptorJsonValues;
+    private validateVersionNumber;
+    private validatePatchVersion;
+    private massageErrorMessage;
+    private getAncestorId;
+    private validateAncestorId;
+    private getAncestorIdHighestRelease;
 }

package/lib/package/packageVersionCreate.js

@@ -16,12 +16,13 @@ const scratchOrgSettingsGenerator_1 = require("@salesforce/core/lib/org/scratchO
 const xml2js = require("xml2js");
 const uniqid_1 = require("../utils/uniqid");
 const pkgUtils = require("../utils/packageUtils");
-const versionNumber_1 = require("../utils/versionNumber");
 const utils_1 = require("../utils");
+const interfaces_1 = require("../interfaces");
+const utils_2 = require("../utils");
 const packageProfileApi_1 = require("./packageProfileApi");
 const packageVersionCreateRequest_1 = require("./packageVersionCreateRequest");
 core_1.Messages.importMessagesDirectory(__dirname);
-const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'packageVersionCreate');
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version_create');
 const logger = core_1.Logger.childFromRoot('packageVersionCreate');
 const DESCRIPTOR_FILE = 'package2-descriptor.json';
 class PackageVersionCreate {
@@ -35,7 +36,7 @@ class PackageVersionCreate {
             return this.packageVersionCreate();
         }
         catch (err) {
-            throw pkgUtils.applyErrorAction(pkgUtils.massageErrorMessage(err));
+            throw pkgUtils.applyErrorAction(this.massageErrorMessage(err));
         }
     }
     // convert source to mdapi format and copy to tmp dir packaging up
@@ -57,7 +58,7 @@ class PackageVersionCreate {
         if (packageName) {
             // SDR will build an output path like /output/directory/packageName/package.xml
             // this was breaking from toolbelt, so to revert it we copy the directory up a level and delete the original
-            (0, utils_1.copyDir)(convertResult.packagePath, outputDirectory);
+            (0, utils_2.copyDir)(convertResult.packagePath, outputDirectory);
             try {
                 fs.rmSync(convertResult.packagePath, { recursive: true });
             }
@@ -91,7 +92,8 @@ class PackageVersionCreate {
         // Just override dependency.packageId value to the resolved alias.
         dependency.packageId = packageIdFromAlias;
         pkgUtils.validateId(pkgUtils.BY_LABEL.PACKAGE_ID, dependency.packageId);
-        pkgUtils.validateVersionNumber(dependency.versionNumber, versionNumber_1.BuildNumberToken.LATEST_BUILD_NUMBER_TOKEN, versionNumber_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN);
+        this.validateVersionNumber(dependency.versionNumber, utils_1.BuildNumberToken.LATEST_BUILD_NUMBER_TOKEN, utils_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN);
+        await this.validatePatchVersion(dependency.versionNumber, dependency.packageId);
         // Validate that the Package2 id exists on the server
         const query = `SELECT Id FROM Package2 WHERE Id = '${dependency.packageId}'`;
         const result = await this.connection.tooling.query(query);
@@ -114,7 +116,7 @@ class PackageVersionCreate {
             // if a 04t id is specified just use it.
             return dependency;
         }
-        const versionNumber = versionNumber_1.VersionNumber.from(dependency.versionNumber);
+        const versionNumber = utils_1.VersionNumber.from(dependency.versionNumber);
         const buildNumber = versionNumber.build;
         // use the dependency.branch if present otherwise use the branch of the version being created
         const branch = dependency.branch || dependency.branch === '' ? dependency.branch : this.options.branch;
@@ -124,7 +126,7 @@ class PackageVersionCreate {
         // now that we have a full build number, query for the associated 04t.
         // because the build number may not be unique across versions, add in conditionals for
         // the branch or the RELEASED token (if used)
-        const branchOrReleasedCondition = buildNumber === versionNumber_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN
+        const branchOrReleasedCondition = buildNumber === utils_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN
             ? 'AND IsReleased = true'
             : `AND Branch = ${branchString}`;
         const query = `SELECT SubscriberPackageVersionId FROM Package2Version WHERE Package2Id = '${dependency.packageId}' AND MajorVersion = ${versionNumber.major} AND MinorVersion = ${versionNumber.minor} AND PatchVersion = ${versionNumber.patch} AND BuildNumber = ${resolvedBuildNumber} ${branchOrReleasedCondition}`;
@@ -142,7 +144,7 @@ class PackageVersionCreate {
         // warn user of the resolved build number when LATEST and RELEASED keywords are used
         if (versionNumber.isbuildKeyword()) {
             versionNumber.build = resolvedBuildNumber;
-            if (buildNumber === versionNumber_1.BuildNumberToken.LATEST_BUILD_NUMBER_TOKEN) {
+            if (buildNumber === utils_1.BuildNumberToken.LATEST_BUILD_NUMBER_TOKEN) {
                 logger.info(messages.getMessage('buildNumberResolvedForLatest', [
                     dependency.package,
                     versionNumber.toString(),
@@ -150,7 +152,7 @@ class PackageVersionCreate {
                     dependency.subscriberPackageVersionId,
                 ]));
             }
-            else if (buildNumber === versionNumber_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN) {
+            else if (buildNumber === utils_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN) {
                 logger.info(messages.getMessage('buildNumberResolvedForReleased', [
                     dependency.package,
                     versionNumber.toString(),
@@ -172,18 +174,18 @@ class PackageVersionCreate {
         // query for the LATEST or RELEASED build number (excluding deleted versions)
         let branchCondition = '';
         let releasedCondition = '';
-        if (versionNumber[3] === versionNumber_1.BuildNumberToken.LATEST_BUILD_NUMBER_TOKEN) {
+        if (versionNumber[3] === utils_1.BuildNumberToken.LATEST_BUILD_NUMBER_TOKEN) {
             // respect the branch when querying for LATEST
             const branchString = !branch || branch === '' ? 'null' : `'${branch}'`;
             branchCondition = `AND Branch = ${branchString}`;
         }
-        else if (versionNumber[3] === versionNumber_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN) {
+        else if (versionNumber[3] === utils_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN) {
             releasedCondition = 'AND IsReleased = true';
         }
         const query = `SELECT MAX(BuildNumber) FROM Package2Version WHERE Package2Id = '${packageId}' AND IsDeprecated != true AND MajorVersion = ${versionNumber.major} AND MinorVersion = ${versionNumber.minor} AND PatchVersion = ${versionNumber.patch} ${branchCondition} ${releasedCondition}`;
         const results = await this.connection.tooling.query(query);
         if (results.records?.length === 0 || results.records[0].expr0 == null) {
-            if (versionNumber.build === versionNumber_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN) {
+            if (versionNumber.build === utils_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN) {
                 throw messages.createError('noReleaseVersionFound', [packageId, versionNumber.toString()]);
             }
             else {
@@ -208,7 +210,7 @@ class PackageVersionCreate {
         };
         if (preserveFiles) {
             const message = messages.getMessage('tempFileLocation', [packageVersTmpRoot]);
-            await core_1.Lifecycle.getInstance().emit('packageVersionCreate:preserveFiles', {
+            await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create['preserve-files'], {
                 location: packageVersTmpRoot,
                 message,
             });
@@ -285,7 +287,7 @@ class PackageVersionCreate {
         // branch can be set via options or descriptor; option takes precedence
         this.options.branch = this.options.branch ?? packageDescriptorJson.branch;
         const resultValues = await Promise.all(!dependencies ? [] : dependencies.map((dependency) => this.retrieveSubscriberPackageVersionId(dependency)));
-        const ancestorId = await (0, utils_1.getAncestorId)(packageDescriptorJson, this.options.project, this.options.connection, this.options.versionnumber ?? packageDescriptorJson.versionNumber, this.options.skipancestorcheck);
+        const ancestorId = await this.getAncestorId(packageDescriptorJson, this.options.project, this.options.versionnumber ?? packageDescriptorJson.versionNumber, this.options.skipancestorcheck);
         // If dependencies exist, the resultValues array will contain the dependencies populated with a resolved
         // subscriber pkg version id.
         if (resultValues.length > 0) {
@@ -351,19 +353,19 @@ class PackageVersionCreate {
         });
         await fs.promises.writeFile(path.join(packageVersMetadataFolder, 'package.xml'), xml, 'utf-8');
         // Zip the packageVersMetadataFolder folder and put the zip in {packageVersBlobDirectory}/package.zip
-        await (0, utils_1.zipDir)(packageVersMetadataFolder, metadataZipFile);
+        await (0, utils_2.zipDir)(packageVersMetadataFolder, metadataZipFile);
         if (hasUnpackagedMetadata) {
             // Zip the unpackagedMetadataFolder folder and put the zip in {packageVersBlobDirectory}/{unpackagedMetadataZipFile}
-            await (0, utils_1.zipDir)(unpackagedMetadataFolder, unpackagedMetadataZipFile);
+            await (0, utils_2.zipDir)(unpackagedMetadataFolder, unpackagedMetadataZipFile);
         }
         // Zip up the expanded settings (if present)
         if (settingsGenerator.hasSettings()) {
             await settingsGenerator.createDeploy();
             await settingsGenerator.createDeployPackageContents(this.apiVersionFromPackageXml);
-            await (0, utils_1.zipDir)(`${settingsGenerator.getDestinationPath()}${path.sep}${settingsGenerator.getShapeDirName()}`, settingsZipFile);
+            await (0, utils_2.zipDir)(`${settingsGenerator.getDestinationPath()}${path.sep}${settingsGenerator.getShapeDirName()}`, settingsZipFile);
         }
         // Zip the Version Info and package.zip files into another zip
-        await (0, utils_1.zipDir)(packageVersBlobDirectory, packageVersBlobZipFile);
+        await (0, utils_2.zipDir)(packageVersBlobDirectory, packageVersBlobZipFile);
     }
     resolveApexTestPermissions(packageDescriptorJson) {
         // Process permissionSet and permissionSetLicenses that should be enabled when running Apex tests
@@ -418,7 +420,7 @@ class PackageVersionCreate {
             throw messages.createError('errorEmptyPackageDirs');
         }
         // from the packageDirectories in sfdx-project.json, find the correct package entry either by finding a matching package (name) or path
-        this.packageAlias = (0, utils_1.getPackageAliasesFromId)(this.options.packageId, this.options.project).join();
+        this.packageAlias = (0, utils_2.getPackageAliasesFromId)(this.options.packageId, this.options.project).join();
         this.packageId = this.options.packageId;
         // set on the class, so we can access them in other methods without redoing this logic
         this.packageObject = this.project
@@ -491,8 +493,8 @@ class PackageVersionCreate {
         if (!packageDescriptorJson.versionName) {
             const versionNumber = packageDescriptorJson.versionNumber;
             packageDescriptorJson.versionName =
-                versionNumber.split(pkgUtils.VERSION_NUMBER_SEP)[3] === versionNumber_1.BuildNumberToken.NEXT_BUILD_NUMBER_TOKEN
-                    ? versionNumber.substring(0, versionNumber.indexOf(pkgUtils.VERSION_NUMBER_SEP + versionNumber_1.BuildNumberToken.NEXT_BUILD_NUMBER_TOKEN))
+                versionNumber.split(pkgUtils.VERSION_NUMBER_SEP)[3] === utils_1.BuildNumberToken.NEXT_BUILD_NUMBER_TOKEN
+                    ? versionNumber.substring(0, versionNumber.indexOf(pkgUtils.VERSION_NUMBER_SEP + utils_1.BuildNumberToken.NEXT_BUILD_NUMBER_TOKEN))
                     : versionNumber;
             logger.warn(options, messages.getMessage('defaultVersionName', [packageDescriptorJson.versionName]));
         }
@@ -515,6 +517,210 @@ class PackageVersionCreate {
             packageDescriptorJson.uninstallScript = options.uninstallscript;
         }
     }
+    validateVersionNumber(versionNumberString, supportedBuildNumberToken, supportedBuildNumberToken2) {
+        const versionNumber = utils_1.VersionNumber.from(versionNumberString);
+        // build number can be a number or valid token
+        if (Number.isNaN(parseInt(`${versionNumber.build}`, 10)) &&
+            versionNumber.build !== supportedBuildNumberToken &&
+            versionNumber.build !== supportedBuildNumberToken2) {
+            if (supportedBuildNumberToken2) {
+                throw messages.createError('errorInvalidBuildNumberForKeywords', [
+                    versionNumberString,
+                    supportedBuildNumberToken,
+                    supportedBuildNumberToken2,
+                ]);
+            }
+            else {
+                throw messages.createError('errorInvalidBuildNumber', [versionNumberString, supportedBuildNumberToken]);
+            }
+        }
+        return versionNumberString;
+    }
+    async validatePatchVersion(versionNumberString, packageId) {
+        const query = `SELECT ContainerOptions FROM Package2 WHERE id ='${packageId}'`;
+        const queryResult = await this.connection.tooling.query(query);
+        if (queryResult.records === null || queryResult.records.length === 0) {
+            throw messages.createError('errorInvalidPackageId', [packageId]);
+        }
+        // Enforce a patch version of zero (0) for Locked packages only
+        if (queryResult.records[0].ContainerOptions === 'Locked') {
+            const versionNumber = utils_1.VersionNumber.from(versionNumberString);
+            if (versionNumber.patch !== '0') {
+                throw messages.createError('errorInvalidPatchNumber', [versionNumberString]);
+            }
+        }
+    }
+    massageErrorMessage(err) {
+        if (err.name === 'INVALID_OR_NULL_FOR_RESTRICTED_PICKLIST') {
+            err['message'] = messages.getMessage('invalidPackageTypeMessage');
+        }
+        if (err.name === 'MALFORMED_ID' &&
+            (err.message.includes('Version ID') || err.message.includes('Version Definition ID'))) {
+            err['message'] = messages.getMessage('malformedPackageVersionIdMessage');
+        }
+        if (err.name === 'MALFORMED_ID' && err.message.includes('Package2 ID')) {
+            err['message'] = messages.getMessage('malformedPackageIdMessage');
+        }
+        // remove references to Second Generation
+        if (err.message.includes('Second Generation ')) {
+            err['message'] = err.message.replace('Second Generation ', '');
+        }
+        return err;
+    }
+    // eslint-disable-next-line complexity
+    async getAncestorId(packageDescriptorJson, project, versionNumberString, skipAncestorCheck) {
+        // If an id property is present, use it.  Otherwise, look up the package id from the package property.
+        const packageId = packageDescriptorJson.id ?? (0, utils_2.getPackageIdFromAlias)(packageDescriptorJson.package, project);
+        // No need to proceed if Unlocked
+        const packageType = await (0, utils_2.getPackageType)(packageId, this.connection);
+        if (packageType === 'Unlocked') {
+            return '';
+        }
+        let ancestorId = '';
+        // ancestorID can be alias, 05i, or 04t;
+        // validate and convert to 05i, as needed
+        const versionNumber = utils_1.VersionNumber.from(versionNumberString);
+        let origSpecifiedAncestor = packageDescriptorJson.ancestorId;
+        let highestReleasedVersion = null;
+        const explicitUseHighestRelease = packageDescriptorJson.ancestorId === utils_1.BuildNumberToken.HIGHEST_VERSION_NUMBER_TOKEN ||
+            packageDescriptorJson.ancestorVersion === utils_1.BuildNumberToken.HIGHEST_VERSION_NUMBER_TOKEN;
+        const explicitUseNoAncestor = packageDescriptorJson.ancestorId === utils_1.BuildNumberToken.NONE_VERSION_NUMBER_TOKEN ||
+            packageDescriptorJson.ancestorVersion === utils_1.BuildNumberToken.NONE_VERSION_NUMBER_TOKEN;
+        if ((explicitUseHighestRelease || explicitUseNoAncestor) &&
+            packageDescriptorJson.ancestorId &&
+            packageDescriptorJson.ancestorVersion) {
+            if (packageDescriptorJson.ancestorId !== packageDescriptorJson.ancestorVersion) {
+                // both ancestorId and ancestorVersion specified, HIGHEST and/or NONE are used, the values disagree
+                throw messages.createError('errorAncestorIdVersionHighestOrNoneMismatch', [
+                    packageDescriptorJson.ancestorId,
+                    packageDescriptorJson.ancestorVersion,
+                ]);
+            }
+        }
+        if (explicitUseNoAncestor && skipAncestorCheck) {
+            return '';
+        }
+        else {
+            const result = await this.getAncestorIdHighestRelease(packageId, versionNumberString, explicitUseHighestRelease, skipAncestorCheck);
+            if (result.finalAncestorId) {
+                return result.finalAncestorId;
+            }
+            highestReleasedVersion = result.highestReleasedVersion;
+        }
+        // at this point if explicitUseHighestRelease=true, we have returned the ancestorId or thrown an error
+        // highestReleasedVersion should be null only if skipAncestorCheck or if there is no existing released package version
+        if (!explicitUseNoAncestor && packageDescriptorJson.ancestorId) {
+            ancestorId = (0, utils_2.getPackageIdFromAlias)(packageDescriptorJson.ancestorId, project);
+            (0, utils_2.validateId)([utils_2.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID, utils_2.BY_LABEL.PACKAGE_VERSION_ID], ancestorId);
+            ancestorId = await (0, utils_2.getPackageVersionId)(ancestorId, this.connection);
+        }
+        if (!explicitUseNoAncestor && packageDescriptorJson.ancestorVersion) {
+            const regNumbers = new RegExp('^[0-9]+$');
+            const versionNumber = packageDescriptorJson.ancestorVersion.split(utils_2.VERSION_NUMBER_SEP);
+            if (versionNumber.length < 3 ||
+                versionNumber.length > 4 ||
+                !versionNumber[0].match(regNumbers) ||
+                !versionNumber[1].match(regNumbers) ||
+                !versionNumber[2].match(regNumbers)) {
+                throw new Error(messages.getMessage('errorInvalidAncestorVersionFormat', [packageDescriptorJson.ancestorVersion]));
+            }
+            const query = 'SELECT Id, IsReleased FROM Package2Version ' +
+                `WHERE Package2Id = '${packageId}' AND MajorVersion = ${versionNumber[0]} AND MinorVersion = ${versionNumber[1]} AND PatchVersion = ${versionNumber[2]}`;
+            let queriedAncestorId;
+            const ancestorVersionResult = await this.connection.tooling.query(query);
+            if (!ancestorVersionResult || !ancestorVersionResult.totalSize) {
+                throw messages.createError('errorNoMatchingAncestor', [packageDescriptorJson.ancestorVersion, packageId]);
+            }
+            else {
+                const releasedAncestor = ancestorVersionResult.records.find((rec) => rec.IsReleased === true);
+                if (!releasedAncestor) {
+                    throw messages.createError('errorAncestorNotReleased', [packageDescriptorJson.ancestorVersion]);
+                }
+                else {
+                    queriedAncestorId = releasedAncestor.Id;
+                }
+            }
+            // check for discrepancy between queried ancestorId and descriptor's ancestorId
+            if (packageDescriptorJson?.ancestorId && ancestorId !== queriedAncestorId) {
+                throw messages.createError('errorAncestorIdVersionMismatch', [
+                    packageDescriptorJson.ancestorVersion,
+                    packageDescriptorJson.ancestorId,
+                ]);
+            }
+            ancestorId = queriedAncestorId;
+            origSpecifiedAncestor = packageDescriptorJson.ancestorVersion;
+        }
+        return this.validateAncestorId(ancestorId, highestReleasedVersion, explicitUseNoAncestor, versionNumber.patch !== '0', skipAncestorCheck, origSpecifiedAncestor);
+    }
+    validateAncestorId(ancestorId, highestReleasedVersion, explicitUseNoAncestor, isPatch, skipAncestorCheck, origSpecifiedAncestor) {
+        if (explicitUseNoAncestor) {
+            if (!highestReleasedVersion) {
+                return '';
+            }
+            else {
+                // the explicitUseNoAncestor && skipAncestorCheck case is handled above
+                throw messages.createError('errorAncestorNoneNotAllowed', [(0, utils_2.getPackageVersionNumber)(highestReleasedVersion)]);
+            }
+        }
+        if (!isPatch && !skipAncestorCheck) {
+            if (highestReleasedVersion) {
+                if (highestReleasedVersion.Id !== ancestorId) {
+                    throw messages.createError('errorAncestorNotHighest', [
+                        origSpecifiedAncestor,
+                        (0, utils_2.getPackageVersionNumber)(highestReleasedVersion),
+                    ]);
+                }
+            }
+            else {
+                // looks like the initial version:create - allow
+                ancestorId = '';
+            }
+        }
+        return ancestorId;
+    }
+    async getAncestorIdHighestRelease(packageId, versionNumberString, explicitUseHighestRelease, skipAncestorCheck) {
+        const versionNumber = versionNumberString.split(utils_2.VERSION_NUMBER_SEP);
+        const isPatch = versionNumber[2] !== '0';
+        const result = { finalAncestorId: null, highestReleasedVersion: null };
+        if (isPatch && explicitUseHighestRelease) {
+            // based on server-side validation, whatever ancestor is specified for a patch is
+            // tightly controlled; therefore we only need concern ourselves if explicitUseHighestRelease == true;
+            // equally applies when skipAncestorCheck == true
+            // gather appropriate matching major.minor.0
+            const query = `SELECT Id FROM Package2Version WHERE Package2Id = '${packageId}' ` +
+                'AND IsReleased = True AND IsDeprecated = False AND PatchVersion = 0 ' +
+                `AND MajorVersion = ${versionNumber[0]} AND MinorVersion = ${versionNumber[1]} ` +
+                'ORDER BY MajorVersion Desc, MinorVersion Desc, PatchVersion Desc, BuildNumber Desc LIMIT 1';
+            const majorMinorVersionResult = await this.connection.tooling.query(query);
+            const majorMinorVersionRecords = majorMinorVersionResult.records;
+            if (majorMinorVersionRecords && majorMinorVersionRecords?.length === 1 && majorMinorVersionRecords[0]) {
+                result.finalAncestorId = majorMinorVersionRecords[0].Id;
+            }
+            else {
+                const majorMinorNotFound = `${versionNumber[0]}.${versionNumber[1]}.0`;
+                throw messages.createError('errorNoMatchingMajorMinorForPatch', [majorMinorNotFound]);
+            }
+        }
+        else if (!isPatch && (explicitUseHighestRelease || !skipAncestorCheck)) {
+            // ancestor must be set to latest released major.minor version
+            const query = 'SELECT Id, SubscriberPackageVersionId, MajorVersion, MinorVersion, PatchVersion FROM Package2Version ' +
+                `WHERE Package2Id = '${packageId}' AND IsReleased = True AND IsDeprecated = False AND PatchVersion = 0 ` +
+                'ORDER BY MajorVersion Desc, MinorVersion Desc, PatchVersion Desc, BuildNumber Desc LIMIT 1';
+            const highestVersionResult = await this.connection.tooling.query(query);
+            const highestVersionRecords = highestVersionResult.records;
+            if (highestVersionRecords && highestVersionRecords[0]) {
+                result.highestReleasedVersion = highestVersionRecords[0];
+                if (explicitUseHighestRelease) {
+                    result.finalAncestorId = result.highestReleasedVersion.Id;
+                }
+            }
+            else if (explicitUseHighestRelease) {
+                // there is no eligible ancestor version
+                throw messages.createError('errorNoMatchingAncestor', [versionNumberString, packageId]);
+            }
+        }
+        return result;
+    }
 }
 exports.PackageVersionCreate = PackageVersionCreate;
 //# sourceMappingURL=packageVersionCreate.js.map

package/lib/package/packageVersionCreateRequest.js

@@ -9,9 +9,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.byId = exports.list = void 0;
 const util = require("util");
 const core_1 = require("@salesforce/core");
-const packageUtils = require("../utils/packageUtils");
 core_1.Messages.importMessagesDirectory(__dirname);
-const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version_create');
 const STATUS_ERROR = 'Error';
 const QUERY = 'SELECT Id, Status, Package2Id, Package2VersionId, Package2Version.SubscriberPackageVersionId, Tag, Branch, ' +
     'CreatedDate, Package2Version.HasMetadataRemoved, CreatedById ' +
@@ -19,6 +18,12 @@ const QUERY = 'SELECT Id, Status, Package2Id, Package2VersionId, Package2Version
     '%s' + // WHERE, if applicable
     'ORDER BY CreatedDate';
 const ERROR_QUERY = "SELECT Message FROM Package2VersionCreateRequestError WHERE ParentRequest.Id = '%s'";
+function formatDate(date) {
+    const pad = (num) => {
+        return num < 10 ? `0${num}` : `${num}`;
+    };
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
 async function list(options) {
     const whereClause = _constructWhere(options);
     return _query(util.format(QUERY, whereClause), options.connection);
@@ -43,7 +48,7 @@ async function _query(query, connection) {
         Tag: record.Tag,
         Branch: record.Branch,
         Error: [],
-        CreatedDate: packageUtils.formatDate(new Date(record.CreatedDate)),
+        CreatedDate: formatDate(new Date(record.CreatedDate)),
         HasMetadataRemoved: record.Package2Version != null ? record.Package2Version.HasMetadataRemoved : null,
         CreatedBy: record.CreatedById,
     }));

package/lib/package/packageVersionList.js

@@ -11,7 +11,7 @@ const core_1 = require("@salesforce/core");
 const ts_types_1 = require("@salesforce/ts-types");
 const utils_1 = require("../utils");
 core_1.Messages.importMessagesDirectory(__dirname);
-const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version_create');
 // Stripping CodeCoverage, HasPassedCodeCoverageCheck as they are causing a perf issue in 47.0+ W-6997762
 const DEFAULT_SELECT = 'SELECT Id, Package2Id, SubscriberPackageVersionId, Name, Package2.Name, Package2.NamespacePrefix, Package2.IsOrgDependent, ' +
     'Description, Tag, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber, IsReleased, ' +

package/lib/package/packageVersionReport.js

@@ -27,6 +27,32 @@ const QUERY_VERBOSE = 'SELECT Id, Package2Id, SubscriberPackageVersionId, Name,
     "WHERE Id = '%s' AND IsDeprecated != true " +
     'ORDER BY Package2Id, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber';
 const logger = core_1.Logger.childFromRoot('getPackageVersionReport');
+/**
+ * Given a list of subscriber package version IDs (04t), return the associated version strings (e.g., Major.Minor.Patch.Build)
+ *
+ * @return Map of subscriberPackageVersionId to versionString
+ * @param subscriberPackageVersionIds
+ * @param connection For tooling query
+ */
+async function getPackageVersionStrings(subscriberPackageVersionIds, connection) {
+    let results = new Map();
+    if (!subscriberPackageVersionIds || subscriberPackageVersionIds.length === 0) {
+        return results;
+    }
+    // remove any duplicate Ids
+    const ids = [...new Set(subscriberPackageVersionIds)];
+    const query = `SELECT SubscriberPackageVersionId, MajorVersion, MinorVersion, PatchVersion, BuildNumber FROM Package2Version WHERE SubscriberPackageVersionId IN (${ids
+        .map((id) => `'${id}'`)
+        .join(',')})`;
+    const records = await pkgUtils.queryWithInConditionChunking(query, ids, '%IDS%', connection);
+    if (records && records.length > 0) {
+        results = new Map(records.map((record) => {
+            const version = pkgUtils.concatVersion(record.MajorVersion, record.MinorVersion, record.PatchVersion, record.BuildNumber);
+            return [record.SubscriberPackageVersionId, version];
+        }));
+    }
+    return results;
+}
 async function getPackageVersionReport(options) {
     logger.debug(`entering getPackageVersionReport(${util.inspect(options, { depth: null })})`);
     let packageVersionId = pkgUtils.getPackageIdFromAlias(options.idOrAlias, options.project);
@@ -36,7 +62,7 @@ async function getPackageVersionReport(options) {
     packageVersionId = await pkgUtils.getPackageVersionId(packageVersionId, options.connection);
     const queryResult = await options.connection.tooling.query(util.format(options.verbose ? QUERY_VERBOSE : QUERY, packageVersionId));
     const records = queryResult.records;
-    if (records && records.length > 0) {
+    if (records?.length > 0) {
         const record = records[0];
         record.Version = [record.MajorVersion, record.MinorVersion, record.PatchVersion, record.BuildNumber].join('.');
         const containerOptions = await pkgUtils.getContainerOptions([record.Package2Id], options.connection);
@@ -44,7 +70,7 @@ async function getPackageVersionReport(options) {
         record.AncestorVersion = null;
         if (record.AncestorId) {
             // lookup AncestorVersion value
-            const ancestorVersionMap = await pkgUtils.getPackageVersionStrings([record.AncestorId], options.connection);
+            const ancestorVersionMap = await getPackageVersionStrings([record.AncestorId], options.connection);
             record.AncestorVersion = ancestorVersionMap.get(record.AncestorId);
         }
         else {

package/lib/package1/package1VersionCreate.js

@@ -10,8 +10,9 @@ exports.package1VersionCreate = void 0;
 const os = require("os");
 const core_1 = require("@salesforce/core");
 const kit_1 = require("@salesforce/kit");
+const interfaces_1 = require("../interfaces");
 core_1.Messages.importMessagesDirectory(__dirname);
-const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package1_version_create');
 const packageUploadRequestStatus = async (id, connection, timeout, frequency) => {
     const pollingResult = await connection.tooling.sobject('PackageUploadRequest').retrieve(id);
     switch (pollingResult.Status) {
@@ -20,7 +21,7 @@ const packageUploadRequestStatus = async (id, connection, timeout, frequency) =>
         case 'IN_PROGRESS':
         case 'QUEUED':
             timeout -= frequency;
-            await core_1.Lifecycle.getInstance().emit('package1VersionCreate:progress', { timeout, pollingResult });
+            await core_1.Lifecycle.getInstance().emit(interfaces_1.Package1VersionEvents.create.progress, { timeout, pollingResult });
             return { completed: false, payload: pollingResult };
         default: {
             if (pollingResult?.Errors?.errors?.length > 0) {