@salesforce/packaging 0.0.36 → 0.0.37

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.37](https://github.com/forcedotcom/packaging/compare/v0.0.36...v0.0.37) (2022-09-16)
+
+### Bug Fixes
+
+- move util functions with single ref ([e7117d3](https://github.com/forcedotcom/packaging/commit/e7117d3530ac56717796da3535394ca184d53643))
+
 ### [0.0.36](https://github.com/forcedotcom/packaging/compare/v0.0.35...v0.0.36) (2022-09-14)
 
 ### Bug Fixes

package/lib/package/packageConvert.d.ts

@@ -1,5 +1,6 @@
 import { Connection, SfProject } from '@salesforce/core';
 import { PackagingSObjects, PackageVersionCreateRequestResult, ConvertPackageOptions } from '../interfaces';
+export declare function findOrCreatePackage2(seedPackage: string, connection: Connection): Promise<string>;
 export declare function convertPackage(pkg: string, connection: Connection, options: ConvertPackageOptions, project?: SfProject): Promise<PackageVersionCreateRequestResult>;
 /**
  * Convert the list of command line options to a JSON object that can be used to create an Package2VersionCreateRequest entity.

package/lib/package/packageConvert.js

@@ -6,7 +6,7 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPackageVersionCreateRequest = exports.convertPackage = void 0;
+exports.createPackageVersionCreateRequest = exports.convertPackage = exports.findOrCreatePackage2 = void 0;
 const path = require("path");
 const os = require("os");
 const fs = require("fs");
@@ -23,13 +23,49 @@ const pvcr = require("./packageVersionCreateRequest");
 var Package2VersionStatus = interfaces_1.PackagingSObjects.Package2VersionStatus;
 core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version_create');
+async function findOrCreatePackage2(seedPackage, connection) {
+    const query = `SELECT Id FROM Package2 WHERE ConvertedFromPackageId = '${seedPackage}'`;
+    const queryResult = (await connection.tooling.query(query)).records;
+    if (queryResult?.length > 1) {
+        const ids = queryResult.map((r) => r.Id);
+        throw messages.createError('errorMoreThanOnePackage2WithSeed', [ids.join(', ')]);
+    }
+    if (queryResult?.length === 1) {
+        // return the package2 object
+        return queryResult[0].Id;
+    }
+    // Need to create a new Package2
+    const subQuery = `SELECT Name, Description, NamespacePrefix FROM SubscriberPackage WHERE Id = '${seedPackage}'`;
+    let subscriberResult;
+    try {
+        subscriberResult = await connection.singleRecordQuery(subQuery, {
+            tooling: true,
+        });
+    }
+    catch (e) {
+        throw messages.createError('errorNoSubscriberPackageRecord', [seedPackage]);
+    }
+    const request = {
+        Name: subscriberResult.Name,
+        Description: subscriberResult.Description,
+        NamespacePrefix: subscriberResult.NamespacePrefix,
+        ContainerOptions: 'Managed',
+        ConvertedFromPackageId: seedPackage,
+    };
+    const createResult = await connection.tooling.create('Package2', request);
+    if (!createResult.success) {
+        throw pkgUtils.combineSaveErrors('Package2', 'create', createResult.errors);
+    }
+    return createResult.id;
+}
+exports.findOrCreatePackage2 = findOrCreatePackage2;
 async function convertPackage(pkg, connection, options, project) {
     let maxRetries = 0;
     const branch = 'main';
     if (options.wait) {
         maxRetries = (60 / pkgUtils.POLL_INTERVAL_SECONDS) * options.wait.minutes;
     }
-    const packageId = await pkgUtils.findOrCreatePackage2(pkg, connection);
+    const packageId = await findOrCreatePackage2(pkg, connection);
     const request = await createPackageVersionCreateRequest({ installationkey: options.installationKey, buildinstance: options.buildInstance }, packageId);
     // TODO: a lot of this is duplicated from PC, PVC, and PVCR.
     const createResult = await connection.tooling.create('Package2VersionCreateRequest', request);
@@ -105,6 +141,7 @@ async function pollForStatusWithInterval(id, retries, packageId, branch, withPro
                             const record = pkgQueryResult.records[0];
                             return `${record.MajorVersion}.${record.MinorVersion}.${record.PatchVersion}-${record.BuildNumber}`;
                         });
+                        // TODO SfProjectJson.addPackageAlias
                         const newConfig = await (0, utils_1.generatePackageAliasEntry)(connection, withProject, results[0].SubscriberPackageVersionId, packageVersionVersionString, branch, packageId);
                         withProject.getSfProjectJson().set('packageAliases', newConfig);
                         await withProject.getSfProjectJson().write();
@@ -143,7 +180,7 @@ async function pollForStatusWithInterval(id, retries, packageId, branch, withPro
                     timeRemaining: remainingTime,
                 });
                 const logger = core_1.Logger.childFromRoot('packageConvert');
-                logger.info(`Request in progress. Sleeping ${interval.seconds} seconds. Will wait a total of ${remainingTime.seconds} more seconds before timing out. Current Status='${(0, utils_1.convertCamelCaseStringToSentence)(results[0]?.Status)}'`);
+                logger.info(`Request in progress. Sleeping ${interval.seconds} seconds. Will wait a total of ${remainingTime.seconds} more seconds before timing out. Current Status='${(0, kit_1.camelCaseToTitleCase)(results[0]?.Status)}'`);
                 remainingRetries--;
                 return { completed: false, payload: results[0] };
             }

package/lib/package/packageCreate.d.ts

@@ -1,7 +1,7 @@
 import { Connection, NamedPackageDir, PackageDir, SfProject } from '@salesforce/core';
 import { PackageCreateOptions, PackagingSObjects } from '../interfaces';
 declare type Package2Request = Pick<PackagingSObjects.Package2, 'Name' | 'Description' | 'NamespacePrefix' | 'ContainerOptions' | 'IsOrgDependent' | 'PackageErrorUsername'>;
-export declare function _createPackageRequestFromContext(project: SfProject, options: PackageCreateOptions): Package2Request;
+export declare function createPackageRequestFromContext(project: SfProject, options: PackageCreateOptions): Package2Request;
 /**
  * Generate packageDirectory json entry for this package that can be written to sfdx-project.json
  *
@@ -9,7 +9,7 @@ export declare function _createPackageRequestFromContext(project: SfProject, opt
  * @param packageId the 0Ho id of the package to create the entry for
  * @private
  */
-export declare function _generatePackageDirEntry(project: SfProject, options: PackageCreateOptions): PackageDir[] | NamedPackageDir[];
+export declare function generatePackageDirEntry(project: SfProject, options: PackageCreateOptions): PackageDir[] | NamedPackageDir[];
 /**
  * Generate package alias json entry for this package that can be written to sfdx-project.json
  *
@@ -17,7 +17,7 @@ export declare function _generatePackageDirEntry(project: SfProject, options: Pa
  * @param packageId the 0Ho id of the package to create the alias entry for
  * @private
  */
-export declare function _generatePackageAliasEntry(project: SfProject, options: PackageCreateOptions, packageId: string): {
+export declare function generatePackageAliasEntry(project: SfProject, options: PackageCreateOptions, packageId: string): {
     [key: string]: string;
 };
 export declare function createPackage(connection: Connection, project: SfProject, options: PackageCreateOptions): Promise<{

package/lib/package/packageCreate.js

@@ -6,13 +6,13 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPackage = exports._generatePackageAliasEntry = exports._generatePackageDirEntry = exports._createPackageRequestFromContext = void 0;
+exports.createPackage = exports.generatePackageAliasEntry = exports.generatePackageDirEntry = exports.createPackageRequestFromContext = void 0;
 const core_1 = require("@salesforce/core");
 const ts_types_1 = require("@salesforce/ts-types");
 const pkgUtils = require("../utils/packageUtils");
 core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_create');
-function _createPackageRequestFromContext(project, options) {
+function createPackageRequestFromContext(project, options) {
     const namespace = options.noNamespace ? '' : project.getSfProjectJson().getContents().namespace || '';
     return {
         Name: options.name,
@@ -23,7 +23,7 @@ function _createPackageRequestFromContext(project, options) {
         PackageErrorUsername: options.errorNotificationUsername,
     };
 }
-exports._createPackageRequestFromContext = _createPackageRequestFromContext;
+exports.createPackageRequestFromContext = createPackageRequestFromContext;
 /**
  * Generate packageDirectory json entry for this package that can be written to sfdx-project.json
  *
@@ -31,7 +31,8 @@ exports._createPackageRequestFromContext = _createPackageRequestFromContext;
  * @param packageId the 0Ho id of the package to create the entry for
  * @private
  */
-function _generatePackageDirEntry(project, options) {
+function generatePackageDirEntry(project, options) {
+    // TODO: use SfProjectJson#addPackageDirectory for this maintenance
     let packageDirs = project.getPackageDirectories();
     if (!packageDirs) {
         packageDirs = [];
@@ -64,7 +65,7 @@ function _generatePackageDirEntry(project, options) {
     }
     return packageDirs;
 }
-exports._generatePackageDirEntry = _generatePackageDirEntry;
+exports.generatePackageDirEntry = generatePackageDirEntry;
 /**
  * Generate package alias json entry for this package that can be written to sfdx-project.json
  *
@@ -72,17 +73,17 @@ exports._generatePackageDirEntry = _generatePackageDirEntry;
  * @param packageId the 0Ho id of the package to create the alias entry for
  * @private
  */
-function _generatePackageAliasEntry(project, options, packageId) {
+function generatePackageAliasEntry(project, options, packageId) {
     const packageAliases = project.getSfProjectJson().getContents().packageAliases || {};
     const packageName = options.name;
     packageAliases[packageName] = packageId;
     return packageAliases;
 }
-exports._generatePackageAliasEntry = _generatePackageAliasEntry;
+exports.generatePackageAliasEntry = generatePackageAliasEntry;
 async function createPackage(connection, project, options) {
     // strip trailing slash from path param
     options.path = options.path.replace(/\/$/, '');
-    const request = _createPackageRequestFromContext(project, options);
+    const request = createPackageRequestFromContext(project, options);
     let packageId = null;
     const createResult = await connection.tooling
         .sobject('Package2')
@@ -101,8 +102,8 @@ async function createPackage(connection, project, options) {
     }
     const record = queryResult.records[0];
     if (!process.env.SFDX_PROJECT_AUTOUPDATE_DISABLE_FOR_PACKAGE_CREATE) {
-        const packageDirectory = _generatePackageDirEntry(project, options);
-        const packageAliases = _generatePackageAliasEntry(project, options, record.Id);
+        const packageDirectory = generatePackageDirEntry(project, options);
+        const packageAliases = generatePackageAliasEntry(project, options, record.Id);
         const projectJson = project.getSfProjectJson();
         projectJson.set('packageDirectories', packageDirectory);
         projectJson.set('packageAliases', packageAliases);

package/lib/package/packageInstall.d.ts

@@ -14,4 +14,6 @@ export declare function installPackage(connection: Connection, pkgInstallCreateR
  */
 export declare function getExternalSites(connection: Connection, subscriberPackageVersionId: string, installationKey?: string): Promise<Optional<string[]>>;
 export declare function getStatus(connection: Connection, installRequestId: string): Promise<PackageInstallRequest>;
+export declare function isErrorFromSPVQueryRestriction(err: Error): boolean;
+export declare function isErrorPackageNotAvailable(err: Error): boolean;
 export declare function waitForPublish(connection: Connection, subscriberPackageVersionId: string, timeout: number | Duration, installationKey?: string): Promise<void>;

package/lib/package/packageInstall.js

@@ -6,7 +6,7 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForPublish = exports.getStatus = exports.getExternalSites = exports.installPackage = void 0;
+exports.waitForPublish = exports.isErrorPackageNotAvailable = exports.isErrorFromSPVQueryRestriction = exports.getStatus = exports.getExternalSites = exports.installPackage = void 0;
 const core_1 = require("@salesforce/core");
 const ts_types_1 = require("@salesforce/ts-types");
 const kit_1 = require("@salesforce/kit");
@@ -22,6 +22,26 @@ const getLogger = () => {
     }
     return logger;
 };
+/**
+ * Given 04t the package type type (Managed, Unlocked, Locked(deprecated?))
+ *
+ * @param packageVersionId the 04t
+ * @param connection For tooling query
+ * @param installKey For tooling query, if an installation key is applicable to the package version it must be passed in the queries
+ * @throws Error with message when package2 cannot be found
+ */
+async function getPackageTypeBy04t(packageVersionId, connection, installKey) {
+    let query = `SELECT Package2ContainerOptions FROM SubscriberPackageVersion WHERE id ='${packageVersionId}'`;
+    if (installKey) {
+        const escapedInstallationKey = installKey.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        query += ` AND InstallationKey ='${escapedInstallationKey}'`;
+    }
+    const queryResult = await connection.tooling.query(query);
+    if (!queryResult || queryResult.records === null || queryResult.records.length === 0) {
+        throw installMsgs.createError('errorInvalidPackageId', [packageVersionId]);
+    }
+    return queryResult.records[0].Package2ContainerOptions;
+}
 async function installPackage(connection, pkgInstallCreateRequest, options) {
     const defaults = {
         ApexCompileType: 'all',
@@ -35,7 +55,7 @@ async function installPackage(connection, pkgInstallCreateRequest, options) {
     if (request.Password) {
         request.Password = (0, utils_1.escapeInstallationKey)(request.Password);
     }
-    const pkgType = await (0, utils_1.getPackageTypeBy04t)(request.SubscriberPackageVersionKey, connection, request.Password);
+    const pkgType = await getPackageTypeBy04t(request.SubscriberPackageVersionKey, connection, request.Password);
     // Only unlocked packages can change the UpgradeType and ApexCompile options from the defaults.
     if (pkgType !== 'Unlocked') {
         if (request.UpgradeType !== defaults.UpgradeType) {
@@ -87,7 +107,7 @@ async function getExternalSites(connection, subscriberPackageVersionId, installa
     catch (e) {
         // First check for Implementation Restriction error that is enforced in 214, before it was possible to query
         // against InstallationKey, otherwise surface the error.
-        if (e instanceof Error && (0, utils_1.isErrorFromSPVQueryRestriction)(e)) {
+        if (e instanceof Error && isErrorFromSPVQueryRestriction(e)) {
             queryResult = await connection.tooling.query(queryNoKey);
         }
         else {
@@ -159,6 +179,18 @@ async function pollStatus(connection, installRequestId, options) {
         throw error;
     }
 }
+// determines if error is from malformed SubscriberPackageVersion query
+// this is in place to allow cli to run against app version 214, where SPV queries
+// do not require installation key
+function isErrorFromSPVQueryRestriction(err) {
+    return (err.name === 'MALFORMED_QUERY' &&
+        err.message.includes('Implementation restriction: You can only perform queries of the form Id'));
+}
+exports.isErrorFromSPVQueryRestriction = isErrorFromSPVQueryRestriction;
+function isErrorPackageNotAvailable(err) {
+    return err.name === 'UNKNOWN_EXCEPTION' || err.name === 'PACKAGE_UNAVAILABLE';
+}
+exports.isErrorPackageNotAvailable = isErrorPackageNotAvailable;
 async function waitForPublish(connection, subscriberPackageVersionId, timeout, installationKey) {
     let queryResult;
     const pollingOptions = {
@@ -174,11 +206,11 @@ async function waitForPublish(connection, subscriberPackageVersionId, timeout, i
             catch (e) {
                 // Check first for Implementation Restriction error that is enforced in 214, before it was possible to query
                 // against InstallationKey, otherwise surface the error.
-                if (e instanceof Error && (0, utils_1.isErrorFromSPVQueryRestriction)(e)) {
+                if (e instanceof Error && isErrorFromSPVQueryRestriction(e)) {
                     queryResult = await connection.tooling.query(QUERY_NO_KEY);
                 }
                 else {
-                    if (e instanceof Error && !(0, utils_1.isErrorPackageNotAvailable)(e)) {
+                    if (e instanceof Error && !isErrorPackageNotAvailable(e)) {
                         throw e;
                     }
                 }

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

@@ -17,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;
@@ -195,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) {
@@ -213,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) {
@@ -229,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

@@ -36,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
@@ -92,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, utils_1.BuildNumberToken.LATEST_BUILD_NUMBER_TOKEN, utils_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);
@@ -286,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_2.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) {
@@ -516,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,7 +9,6 @@ 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', 'package_version_create');
 const STATUS_ERROR = 'Error';
@@ -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,
     }));