@salesforce/packaging 0.0.18 → 0.0.21

package/lib/package/packageVersionCreate.js

@@ -15,18 +15,16 @@ const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
 const testSetup_1 = require("@salesforce/core/lib/testSetup");
 const scratchOrgSettingsGenerator_1 = require("@salesforce/core/lib/org/scratchOrgSettingsGenerator");
 const xml2js = require("xml2js");
-const kit_1 = require("@salesforce/kit");
+const scratchOrgInfoGenerator_1 = require("@salesforce/core/lib/org/scratchOrgInfoGenerator");
 const pkgUtils = require("../utils/packageUtils");
-const constants_1 = require("../constants");
-const utils_1 = require("../utils");
 const versionNumber_1 = require("../utils/versionNumber");
+const utils_1 = 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', 'messages');
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'packageVersionCreate');
 const logger = core_1.Logger.childFromRoot('packageVersionCreate');
 const DESCRIPTOR_FILE = 'package2-descriptor.json';
-const POLL_INTERVAL_WITHOUT_VALIDATION_SECONDS = 5;
 class PackageVersionCreate {
     constructor(options) {
         this.options = options;
@@ -34,17 +32,12 @@ class PackageVersionCreate {
         this.project = this.options.project;
     }
     createPackageVersion() {
-        return this.packageVersionCreate(this.options).catch((err) => {
-            // TODO: until package2 is GA, wrap perm-based errors w/ 'contact sfdc' action (REMOVE once package2 is GA'd)
-            err = pkgUtils.massageErrorMessage(err);
-            throw pkgUtils.applyErrorAction(err);
-        });
-    }
-    async listRequest(createdlastdays, status) {
-        return (0, packageVersionCreateRequest_1.list)({ createdlastdays, status, connection: this.connection });
-    }
-    async listRequestById(id, connection) {
-        return (0, packageVersionCreateRequest_1.byId)(id, connection);
+        try {
+            return this.packageVersionCreate();
+        }
+        catch (err) {
+            throw pkgUtils.applyErrorAction(pkgUtils.massageErrorMessage(err));
+        }
     }
     // convert source to mdapi format and copy to tmp dir packaging up
     async generateMDFolderForArtifact(options) {
@@ -78,47 +71,42 @@ class PackageVersionCreate {
             return convertResult;
         }
     }
-    validateDependencyValues(dependency) {
+    async validateDependencyValues(dependency) {
         // If valid 04t package, just return it to be used straight away.
         if (dependency.subscriberPackageVersionId) {
             pkgUtils.validateId(pkgUtils.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID, dependency.subscriberPackageVersionId);
-            return Promise.resolve();
         }
         if (dependency.packageId && dependency.package) {
             throw messages.createError('errorPackageAndPackageIdCollision', []);
         }
-        const packageIdFromAlias = pkgUtils.getPackageIdFromAlias(dependency.packageId || dependency.package, this.project);
         // If valid 04t package, just return it to be used straight away.
-        if (pkgUtils.validateIdNoThrow(pkgUtils.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID, packageIdFromAlias)) {
-            dependency.subscriberPackageVersionId = packageIdFromAlias;
-            return Promise.resolve();
+        if (pkgUtils.validateIdNoThrow(pkgUtils.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID, this.packageId)) {
+            dependency.subscriberPackageVersionId = this.packageId;
         }
-        if (!packageIdFromAlias || !dependency.versionNumber) {
+        if (!this.packageId || !dependency.versionNumber) {
             throw messages.createError('errorDependencyPair', [JSON.stringify(dependency)]);
         }
         // Just override dependency.packageId value to the resolved alias.
-        dependency.packageId = packageIdFromAlias;
+        dependency.packageId = this.packageId;
         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);
         // Validate that the Package2 id exists on the server
         const query = `SELECT Id FROM Package2 WHERE Id = '${dependency.packageId}'`;
-        return this.connection.tooling.query(query).then((pkgQueryResult) => {
-            const subRecords = pkgQueryResult.records;
-            if (!subRecords || subRecords.length !== 1) {
-                throw messages.createError('errorNoIdInHub', [dependency.packageId]);
-            }
-        });
+        const result = await this.connection.tooling.query(query);
+        if (!result.records || result.records.length !== 1) {
+            throw messages.createError('errorNoIdInHub', [dependency.packageId]);
+        }
+        return result;
     }
     /**
-     *  A dependency in the workspace config file may be specified using either a subscriber package version id (04t)
-     *  or a package Id (0Ho) + a version number.  Additionally, a build number may be the actual build number, or a
-     *  keyword: LATEST or RELEASED (meaning the latest or released build number for a given major.minor.patch).
+     * A dependency in the workspace config file may be specified using either a subscriber package version id (04t)
+     * or a package Id (0Ho) + a version number.  Additionally, a build number may be the actual build number, or a
+     * keyword: LATEST or RELEASED (meaning the latest or released build number for a given major.minor.patch).
      *
-     *  This method resolves a package Id + version number to a subscriber package version id (04t)
-     *  and adds it as a SubscriberPackageVersionId parameter in the dependency object.
+     * This method resolves a package Id + version number to a subscriber package version id (04t)
+     * and adds it as a SubscriberPackageVersionId parameter in the dependency object.
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async retrieveSubscriberPackageVersionId(dependency, branchFromFlagOrDef) {
+    async retrieveSubscriberPackageVersionId(dependency) {
         await this.validateDependencyValues(dependency);
         if (dependency.subscriberPackageVersionId) {
             delete dependency.package;
@@ -128,7 +116,7 @@ class PackageVersionCreate {
         const versionNumber = versionNumber_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 : branchFromFlagOrDef;
+        const branch = dependency.branch || dependency.branch === '' ? dependency.branch : this.options.branch;
         const branchString = !branch || branch === '' ? 'null' : `'${branch}'`;
         // resolve a build number keyword to an actual number, if needed
         const resolvedBuildNumber = await this.resolveBuildNumber(versionNumber, dependency.packageId, branch);
@@ -138,7 +126,7 @@ class PackageVersionCreate {
         const branchOrReleasedCondition = buildNumber === versionNumber_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[0]} AND MinorVersion = ${versionNumber[1]} AND PatchVersion = ${versionNumber[2]} AND BuildNumber = ${resolvedBuildNumber} ${branchOrReleasedCondition}`;
+        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}`;
         const pkgVerQueryResult = await this.connection.tooling.query(query);
         const subRecords = pkgVerQueryResult.records;
         if (!subRecords || subRecords.length !== 1) {
@@ -193,8 +181,7 @@ class PackageVersionCreate {
         }
         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);
-        const records = results.records;
-        if (!records || records.length === 0 || records[0].expr0 == null) {
+        if (results.records?.length === 0 || results.records[0].expr0 == null) {
             if (versionNumber.build === versionNumber_1.BuildNumberToken.RELEASED_BUILD_NUMBER_TOKEN) {
                 throw messages.createError('noReleaseVersionFound', [packageId, versionNumber.toString()]);
             }
@@ -202,20 +189,21 @@ class PackageVersionCreate {
                 throw messages.createError('noReleaseVersionFoundForBranch', [packageId, branch, versionNumber.toString()]);
             }
         }
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
         return `${results.records[0].expr0}`;
     }
-    async createRequestObject(packageId, options, preserveFiles, packageVersTmpRoot, packageVersBlobZipFile) {
+    async createRequestObject(preserveFiles, packageVersTmpRoot, packageVersBlobZipFile) {
         const zipFileBase64 = fs.readFileSync(packageVersBlobZipFile).toString('base64');
         const requestObject = {
-            Package2Id: packageId,
+            Package2Id: this.packageId,
             VersionInfo: zipFileBase64,
-            Tag: options.tag,
-            Branch: options.branch,
-            InstallKey: options.installationkey,
-            Instance: options.buildinstance,
-            SourceOrg: options.sourceorg,
-            CalculateCodeCoverage: options.codecoverage || false,
-            SkipValidation: options.skipvalidation || false,
+            Tag: this.options.tag,
+            Branch: this.options.branch,
+            InstallKey: this.options.installationkey,
+            Instance: this.options.buildinstance,
+            SourceOrg: this.options.sourceorg,
+            CalculateCodeCoverage: this.options.codecoverage || false,
+            SkipValidation: this.options.skipvalidation || false,
         };
         if (preserveFiles) {
             logger.info(messages.getMessage('tempFileLocation', [packageVersTmpRoot]));
@@ -225,30 +213,15 @@ class PackageVersionCreate {
             return fs.promises.rm(packageVersTmpRoot, { recursive: true, force: true }).then(() => requestObject);
         }
     }
-    getPackageDescriptorJsonFromPackageId(packageId, options) {
-        const artDir = options.path;
-        const packageDescriptorJson = this.project.getPackageDirectories().find((packageDir) => {
-            const packageDirPackageId = pkgUtils.getPackageIdFromAlias(packageDir.package, this.project);
-            return !!packageDirPackageId && packageDirPackageId === packageId ? packageDir : null;
-        });
-        if (!packageDescriptorJson) {
-            throw messages.createError('packagingDirNotFoundInConfigFile', [constants_1.consts.WORKSPACE_CONFIG_FILENAME, artDir]);
-        }
-        return packageDescriptorJson;
-    }
     /**
      * Convert the list of command line options to a JSON object that can be used to create an Package2VersionCreateRequest entity.
      *
-     * @param options
-     * @param packageId
-     * @param versionNumberString
      * @returns {{Package2Id: (*|p|boolean), Package2VersionMetadata: *, Tag: *, Branch: number}}
      * @private
      */
-    async createPackageVersionCreateRequestFromOptions(options, packageId, versionNumberString) {
-        const artDir = options.path;
-        const preserveFiles = !!(options.preserve || process.env.SFDX_PACKAGE2_VERSION_CREATE_PRESERVE);
-        const uniqueHash = (0, testSetup_1.uniqid)({ template: `${packageId}-%s` });
+    async createPackageVersionCreateRequestFromOptions() {
+        const preserveFiles = !!(this.options.preserve || process.env.SFDX_PACKAGE2_VERSION_CREATE_PRESERVE);
+        const uniqueHash = (0, testSetup_1.uniqid)({ template: `${this.packageId}-%s` });
         const packageVersTmpRoot = path.join(os.tmpdir(), `${uniqueHash}`);
         const packageVersMetadataFolder = path.join(packageVersTmpRoot, 'md-files');
         const unpackagedMetadataFolder = path.join(packageVersTmpRoot, 'unpackaged-md-files');
@@ -258,7 +231,7 @@ class PackageVersionCreate {
         const unpackagedMetadataZipFile = path.join(packageVersBlobDirectory, 'unpackaged-metadata-package.zip');
         const settingsZipFile = path.join(packageVersBlobDirectory, 'settings.zip');
         const packageVersBlobZipFile = path.join(packageVersTmpRoot, 'package-version-info.zip');
-        const sourceBaseDir = path.join(this.project.getPath(), artDir);
+        const sourceBaseDir = path.join(this.project.getPath(), this.packageObject.path ?? '');
         const mdOptions = {
             deploydir: packageVersMetadataFolder,
             sourceDir: sourceBaseDir,
@@ -267,14 +240,16 @@ class PackageVersionCreate {
         const clientSideInfo = new Map();
         await fs.promises.mkdir(packageVersBlobDirectory, { recursive: true });
         const settingsGenerator = new scratchOrgSettingsGenerator_1.default({ asDirectory: true });
-        // Copy all of the metadata from the workspace to a tmp folder
+        // Copy all the metadata from the workspace to a tmp folder
         await this.generateMDFolderForArtifact(mdOptions);
-        const packageDescriptorJson = this.getPackageDescriptorJsonFromPackageId(packageId, options);
+        const packageDescriptorJson = this.packageObject;
         if (packageDescriptorJson.package) {
             delete packageDescriptorJson.package;
-            packageDescriptorJson.id = packageId;
+            packageDescriptorJson.id = this.packageId;
         }
-        const definitionFile = options.definitionfile ? options.definitionfile : packageDescriptorJson.definitionFile;
+        const definitionFile = this.options.definitionfile
+            ? this.options.definitionfile
+            : packageDescriptorJson.definitionFile;
         if (definitionFile) {
             // package2-descriptor.json sent to the server should contain only the features, snapshot & orgPreferences
             // defined in the definition file.
@@ -284,56 +259,47 @@ class PackageVersionCreate {
             delete packageDescriptorJson.snapshot;
             const definitionFilePayload = await fs.promises.readFile(definitionFile, 'utf8');
             const definitionFileJson = JSON.parse(definitionFilePayload);
-            const pkgProperties = [
-                'country',
-                'edition',
-                'language',
-                'features',
-                'orgPreferences',
-                'snapshot',
-                'release',
-                'sourceOrg',
-            ];
             // Load any settings from the definition
             await settingsGenerator.extract(definitionFileJson);
             if (settingsGenerator.hasSettings() && definitionFileJson.orgPreferences) {
                 // this is not allowed, exit with an error
-                return Promise.reject(messages.createError('signupDuplicateSettingsSpecified'));
+                throw messages.createError('signupDuplicateSettingsSpecified');
             }
-            pkgProperties.forEach((prop) => {
+            ['country', 'edition', 'language', 'features', 'orgPreferences', 'snapshot', 'release', 'sourceOrg'].forEach((prop) => {
                 const propValue = definitionFileJson[prop];
                 if (propValue) {
                     packageDescriptorJson[prop] = propValue;
                 }
             });
         }
-        const hasUnpackagedMetadata = await this.resolveUnpackagedMetadata(packageDescriptorJson, unpackagedMetadataFolder, clientSideInfo, options.codecoverage);
-        this.resolveApexTestPermissions(packageDescriptorJson, options);
+        this.resolveApexTestPermissions(packageDescriptorJson);
         // All dependencies for the packaging dir should be resolved to an 04t id to be passed to the server.
         // (see _retrieveSubscriberPackageVersionId for details)
         const dependencies = packageDescriptorJson.dependencies;
-        // branch can be set via flag or descriptor; flag takes precedence
-        options.branch = options.branch ? options.branch : packageDescriptorJson.branch;
-        const resultValues = await Promise.all(!dependencies
-            ? []
-            : dependencies.map((dependency) => this.retrieveSubscriberPackageVersionId(dependency, options.branch)));
-        const ancestorId = await pkgUtils.getAncestorId(packageDescriptorJson, this.connection, this.project, versionNumberString, options.skipancestorcheck);
+        // 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, scratchOrgInfoGenerator_1.getAncestorIds)(
+        // TODO: investigate if it's ok to convert to ScratchOggInfoPayload
+        this.packageObject, this.options.project.getSfProjectJson(), await core_1.Org.create({ aliasOrUsername: this.options.connection.getUsername() }));
         // If dependencies exist, the resultValues array will contain the dependencies populated with a resolved
         // subscriber pkg version id.
         if (resultValues.length > 0) {
             packageDescriptorJson.dependencies = resultValues;
         }
         this.cleanPackageDescriptorJson(packageDescriptorJson);
-        this.setPackageDescriptorJsonValues(packageDescriptorJson, options);
+        this.setPackageDescriptorJsonValues(packageDescriptorJson);
         await fs.promises.mkdir(packageVersTmpRoot, { recursive: true });
         await fs.promises.mkdir(packageVersBlobDirectory, { recursive: true });
         if (Reflect.has(packageDescriptorJson, 'ancestorVersion')) {
             delete packageDescriptorJson.ancestorVersion;
         }
         packageDescriptorJson.ancestorId = ancestorId;
-        await fs.promises.writeFile(path.join(packageVersBlobDirectory, DESCRIPTOR_FILE), 
-        // TODO: need to make sure packageDescriptorJson contains the right values for the descriptor
-        JSON.stringify(packageDescriptorJson), 'utf-8');
+        await fs.promises.writeFile(path.join(packageVersBlobDirectory, DESCRIPTOR_FILE), JSON.stringify(packageDescriptorJson), 'utf-8');
+        await this.cleanGeneratedPackage(packageVersMetadataFolder, packageVersProfileFolder, unpackagedMetadataFolder, metadataZipFile, settingsZipFile, packageVersBlobDirectory, packageVersBlobZipFile, unpackagedMetadataZipFile, clientSideInfo, settingsGenerator);
+        return this.createRequestObject(preserveFiles, packageVersTmpRoot, packageVersBlobZipFile);
+    }
+    async cleanGeneratedPackage(packageVersMetadataFolder, packageVersProfileFolder, unpackagedMetadataFolder, metadataZipFile, settingsZipFile, packageVersBlobDirectory, packageVersBlobZipFile, unpackagedMetadataZipFile, clientSideInfo, settingsGenerator) {
         // As part of the source convert process, the package.xml has been written into the tmp metadata directory.
         // The package.xml may need to be manipulated due to processing profiles in the workspace or additional
         // metadata exclusions. If necessary, read the existing package.xml and then re-write it.
@@ -345,18 +311,19 @@ class PackageVersionCreate {
         // Apply any necessary exclusions to typesArr.
         let typesArr = packageJson.Package.types;
         this.apiVersionFromPackageXml = packageJson.Package.version;
+        const hasUnpackagedMetadata = await this.resolveUnpackagedMetadata(this.packageObject, unpackagedMetadataFolder, clientSideInfo, this.options.codecoverage);
         // if we're using unpackaged metadata, don't package the profiles located there
         if (hasUnpackagedMetadata) {
-            typesArr = options.profileApi.filterAndGenerateProfilesForManifest(typesArr, [
+            typesArr = this.options.profileApi.filterAndGenerateProfilesForManifest(typesArr, [
                 clientSideInfo.get('UnpackagedMetadataPath'),
             ]);
         }
         else {
-            typesArr = options.profileApi.filterAndGenerateProfilesForManifest(typesArr);
+            typesArr = this.options.profileApi.filterAndGenerateProfilesForManifest(typesArr);
         }
         // Next generate profiles and retrieve any profiles that were excluded because they had no matching nodes.
-        const excludedProfiles = options.profileApi.generateProfiles(packageVersProfileFolder, {
-            Package: { types: typesArr },
+        const excludedProfiles = this.options.profileApi.generateProfiles(packageVersProfileFolder, {
+            Package: typesArr,
         }, [clientSideInfo.get('UnpackagedMetadataPath')]);
         if (excludedProfiles.length > 0) {
             const profileIdx = typesArr.findIndex((e) => e.name[0] === 'Profile');
@@ -369,7 +336,7 @@ class PackageVersionCreate {
         });
         const xml = xmlBuilder.buildObject(packageJson);
         // Log information about the profiles being packaged up
-        const profiles = options.profileApi.getProfileInformation();
+        const profiles = this.options.profileApi.getProfileInformation();
         profiles.forEach((profile) => {
             if (logger.shouldLog(core_1.LoggerLevel.DEBUG)) {
                 logger.debug(profile.logDebug());
@@ -378,8 +345,6 @@ class PackageVersionCreate {
                 logger.info(profile.logInfo());
             }
         });
-        // TODO: confirm that param xml is writeable
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         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);
@@ -395,21 +360,20 @@ class PackageVersionCreate {
         }
         // Zip the Version Info and package.zip files into another zip
         await (0, utils_1.zipDir)(packageVersBlobDirectory, packageVersBlobZipFile);
-        return this.createRequestObject(packageId, options, preserveFiles, packageVersTmpRoot, packageVersBlobZipFile);
     }
-    resolveApexTestPermissions(packageDescriptorJson, options) {
+    resolveApexTestPermissions(packageDescriptorJson) {
         // Process permissionSet and permissionSetLicenses that should be enabled when running Apex tests
         // This only applies if code coverage is enabled
-        if (options.codecoverage) {
+        if (this.options.codecoverage) {
             // Assuming no permission sets are named 0, 0n, null, undefined, false, NaN, and the empty string
-            if (packageDescriptorJson.apexTestAccess && packageDescriptorJson.apexTestAccess.permissionSets) {
+            if (packageDescriptorJson.apexTestAccess?.permissionSets) {
                 let permSets = packageDescriptorJson.apexTestAccess.permissionSets;
                 if (!Array.isArray(permSets)) {
                     permSets = permSets.split(',');
                 }
                 packageDescriptorJson.permissionSetNames = permSets.map((s) => s.trim());
             }
-            if (packageDescriptorJson.apexTestAccess && packageDescriptorJson.apexTestAccess.permissionSetLicenses) {
+            if (packageDescriptorJson.apexTestAccess?.permissionSetLicenses) {
                 let permissionSetLicenses = packageDescriptorJson.apexTestAccess.permissionSetLicenses;
                 if (!Array.isArray(permissionSetLicenses)) {
                     permissionSetLicenses = permissionSetLicenses.split(',');
@@ -420,15 +384,10 @@ class PackageVersionCreate {
         delete packageDescriptorJson.apexTestAccess;
     }
     async resolveUnpackagedMetadata(packageDescriptorJson, unpackagedMetadataFolder, clientSideInfo, codeCoverage) {
-        let hasUnpackagedMetadata = false;
         // Add the Unpackaged Metadata, if any, to the output directory, only when code coverage is specified
         if (codeCoverage && packageDescriptorJson.unpackagedMetadata && packageDescriptorJson.unpackagedMetadata.path) {
-            hasUnpackagedMetadata = true;
             const unpackagedPath = path.join(process.cwd(), packageDescriptorJson.unpackagedMetadata.path);
-            try {
-                fs.statSync(unpackagedPath);
-            }
-            catch (err) {
+            if (!fs.existsSync(unpackagedPath)) {
                 throw messages.createError('unpackagedMDDirectoryDoesNotExist', [
                     packageDescriptorJson.unpackagedMetadata.path,
                 ]);
@@ -440,251 +399,59 @@ class PackageVersionCreate {
             });
             // Set which package is the "unpackaged" package
             clientSideInfo.set('UnpackagedMetadataPath', packageDescriptorJson.unpackagedMetadata.path);
+            return true;
         }
-        return hasUnpackagedMetadata;
-    }
-    getPackagePropertyFromPackage(packageDirs, options) {
-        let foundByPackage = packageDirs.some((x) => x['package'] === options.package);
-        let foundById = packageDirs.some((x) => x['id'] === options.package);
-        if (foundByPackage && foundById) {
-            throw messages.createError('errorPackageAndIdCollision', []);
-        }
-        // didn't find anything? let's see if we can reverse look up
-        if (!foundByPackage && !foundById) {
-            // is it an alias?
-            const pkgId = pkgUtils.getPackageIdFromAlias(options.package, this.project);
-            if (pkgId === options.package) {
-                // not an alias, or not a valid one, try to reverse lookup an alias in case this is an id
-                const aliases = pkgUtils.getPackageAliasesFromId(options.package, this.project);
-                // if we found an alias, try to look that up in the config.
-                foundByPackage = aliases.some((alias) => packageDirs.find((x) => x['package'] === alias));
-            }
-            else {
-                // it is an alias; try to lookup it's id in the config
-                foundByPackage = packageDirs.some((x) => x['package'] === pkgId);
-                foundById = packageDirs.some((x) => x['id'] === pkgId);
-                if (!foundByPackage && !foundById) {
-                    // check if any configs use a different alias to that same id
-                    const aliases = pkgUtils.getPackageAliasesFromId(pkgId, this.project);
-                    foundByPackage = aliases.some((alias) => {
-                        const pd = packageDirs.find((x) => x['package'] === alias);
-                        if (pd) {
-                            // if so, set this.options.package.flags.package to be this alias instead of the alternate
-                            options.package = alias;
-                        }
-                        return pd;
-                    });
-                }
-            }
-            // if we still didn't find anything, throw the error
-            if (!foundByPackage && !foundById) {
-                throw messages.createError('errorMissingPackage', [pkgId]);
-            }
-        }
-        return foundByPackage ? 'package' : 'id';
-    }
-    getPackageValuePropertyFromDirectory(directoryFlag, options) {
-        const packageValue = this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), 'package', 'path', options.path, directoryFlag, options);
-        const packageIdValue = this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), 'id', 'path', options.path, directoryFlag, options);
-        let packagePropVal;
-        if (!packageValue && !packageIdValue) {
-            throw messages.createError('errorMissingPackage', []);
-        }
-        else if (packageValue && packageIdValue) {
-            throw messages.createError('errorPackageAndIdCollision', []);
-        }
-        else if (packageValue) {
-            packagePropVal = {
-                packageProperty: 'package',
-                packageValue,
-            };
-        }
-        else {
-            packagePropVal = {
-                packageProperty: 'id',
-                packageValue: packageIdValue,
-            };
-        }
-        return packagePropVal;
+        return false;
     }
-    /**
-     * Returns the property value that corresponds to the propertyToLookup.  This value found for a particular
-     * package directory element that matches the knownProperty and knownValue.  In other words, we locate a package
-     * directory element whose knownProperty matches the knownValue, then we grab the value for the propertyToLookup
-     * and return it.
-     *
-     * @param packageDirs The list of all the package directories from the sfdx-project.json
-     * @param propertyToLookup The property ID whose value we want to find
-     * @param knownProperty The JSON property in the packageDirectories that is already known
-     * @param knownValue The value that corresponds to the knownProperty in the packageDirectories JSON
-     * @param knownFlag The flag details e.g. short/long name, etc. Only used for the error message
-     * @param options
-     */
-    getConfigPackageDirectoriesValue(packageDirs, propertyToLookup, knownProperty, knownValue, knownFlag, options
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
-        let value;
-        let packageDir = packageDirs.find((x) => x[knownProperty] === knownValue);
-        if (!packageDir && knownFlag === 'path' && knownValue.endsWith(path.sep)) {
-            // if this is the directory flag, try removing the trailing slash added by CLI auto-complete
-            const dirWithoutTrailingSlash = knownValue.slice(0, -1);
-            packageDir = packageDirs.find((x) => x[knownProperty] === dirWithoutTrailingSlash);
-            if (packageDir) {
-                // TODO: how to deal with this side effect?
-                options.path = dirWithoutTrailingSlash;
-            }
-        }
-        // didn't find it with the package property, try a reverse lookup with alias and id
-        if (!packageDir && knownProperty === 'package') {
-            const pkgId = pkgUtils.getPackageIdFromAlias(knownValue, this.project);
-            if (pkgId !== knownValue) {
-                packageDir = packageDirs.find((x) => x[knownProperty] === pkgId);
-            }
-            else {
-                const aliases = pkgUtils.getPackageAliasesFromId(knownValue, this.project);
-                aliases.some((alias) => {
-                    packageDir = packageDirs.find((x) => x[knownProperty] === alias);
-                    return packageDir;
-                });
-            }
-        }
-        if (packageDir) {
-            value = packageDir[propertyToLookup];
-        }
-        else {
-            throw messages.createError('errorNoMatchingPackageDirectory', [`--${knownFlag}`, knownValue, knownProperty]);
-        }
-        return value;
-    }
-    async packageVersionCreate(options) {
+    async packageVersionCreate() {
         // For the first rollout of validating sfdx-project.json data against schema, make it optional and defaulted
-        // to false. Validation only occurs if the hidden -j (--validateschema) flag has been specified.
-        if (options.validateschema) {
+        // to false. Validation only occurs if the optional validateschema option has been specified.
+        if (this.options.validateschema) {
             await this.project.getSfProjectJson().schemaValidate();
         }
         // Check for empty packageDirectories
         if (this.project.getPackageDirectories()?.length === 0) {
             throw messages.createError('errorEmptyPackageDirs');
         }
-        const canonicalPackageProperty = this.resolveCanonicalPackageProperty(options);
-        const resolvedPackageId = pkgUtils.getPackageIdFromAlias(options.package, this.project);
+        // 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();
+        // set on the class so we can access them in other methods without redoing this logic
+        this.packageObject = this.project.getPackageDirectories().find((pkg) => pkg.package === this.packageAlias);
+        this.options.profileApi = await this.resolveUserLicenses(this.packageObject.includeProfileUserLicenses);
+        this.packageId = (0, utils_1.getPackageIdFromAlias)(this.packageObject.package, this.project);
         // At this point, the packageIdFromAlias should have been resolved to an Id.  Now, we
         // need to validate that the Id is correct.
-        pkgUtils.validateId(pkgUtils.BY_LABEL.PACKAGE_ID, resolvedPackageId);
-        await this.validateFlagsForPackageType(resolvedPackageId, options);
-        const versionNumberString = await this.validateVersionNumber(canonicalPackageProperty, resolvedPackageId, options);
-        try {
-            fs.statSync(path.join(process.cwd(), options.path));
-        }
-        catch (err) {
-            throw messages.createError('directoryDoesNotExist', [options.path]);
-        }
-        options.profileApi = await this.resolveUserLicenses(canonicalPackageProperty, options);
-        const request = await this.createPackageVersionCreateRequestFromOptions(options, resolvedPackageId, versionNumberString);
+        pkgUtils.validateId(pkgUtils.BY_LABEL.PACKAGE_ID, this.packageId);
+        await this.validateOptionsForPackageType();
+        const request = await this.createPackageVersionCreateRequestFromOptions();
         const createResult = await this.connection.tooling.create('Package2VersionCreateRequest', request);
         if (!createResult.success) {
-            const errStr = createResult.errors && createResult.errors.length ? createResult.errors.join(', ') : createResult.errors;
+            const errStr = createResult.errors?.join(', ') ?? createResult.errors;
             throw messages.createError('failedToCreatePVCRequest', [
                 createResult.id ? ` [${createResult.id}]` : '',
                 errStr.toString(),
             ]);
         }
-        let pollInterval = kit_1.Duration.seconds(pkgUtils.POLL_INTERVAL_SECONDS);
-        let maxRetries = 0;
-        if (options.wait?.milliseconds > 0) {
-            if (options.skipvalidation === true) {
-                pollInterval = kit_1.Duration.seconds(POLL_INTERVAL_WITHOUT_VALIDATION_SECONDS);
-            }
-            maxRetries = (60 / pollInterval.seconds) * options.wait.seconds;
-        }
-        [pollInterval, maxRetries] = await this.resolveOrgDependentPollingTime(resolvedPackageId, options, pollInterval, maxRetries);
-        return (await this.listRequestById(createResult.id, this.connection))[0];
-    }
-    resolveCanonicalPackageProperty(options) {
-        let canonicalPackageProperty;
-        if (!options.package) {
-            const packageValProp = this.getPackageValuePropertyFromDirectory(options.path, options);
-            options.package = packageValProp.packageValue;
-            canonicalPackageProperty = packageValProp.packageProperty;
-        }
-        else if (!options.path) {
-            canonicalPackageProperty = this.getPackagePropertyFromPackage(this.project.getPackageDirectories(), options);
-            options.path = this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), 'path', canonicalPackageProperty, options.package, 'package', options);
-        }
-        else {
-            canonicalPackageProperty = this.getPackagePropertyFromPackage(this.project.getPackageDirectories(), options);
-            this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), canonicalPackageProperty, 'path', options.path, 'path', options);
-            const expectedPackageId = this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), canonicalPackageProperty, 'path', options.path, 'path', options);
-            // This will throw an error if the package id flag value doesn't match
-            // any of the :id values in the package dirs.
-            this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), 'path', canonicalPackageProperty, options.package, 'package', options);
-            // This will throw an error if the package id flag value doesn't match
-            // the correct corresponding directory with that packageId.
-            if (options.package !== expectedPackageId) {
-                throw messages.createError('errorDirectoryIdMismatch', ['--path', options.path, '--package', options.package]);
-            }
-        }
-        return canonicalPackageProperty;
-    }
-    // TODO: should be in pkg utils
-    async validateVersionNumber(canonicalPackageProperty, resolvedPackageId, options) {
-        // validate the versionNumber flag value if specified, otherwise the descriptor value
-        const versionNumberString = options.versionnumber
-            ? options.versionnumber
-            : this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), 'versionNumber', canonicalPackageProperty, options.package, 'package', options);
-        pkgUtils.validateVersionNumber(versionNumberString, versionNumber_1.BuildNumberToken.NEXT_BUILD_NUMBER_TOKEN, null);
-        await pkgUtils.validatePatchVersion(this.connection, versionNumberString, resolvedPackageId);
-        return versionNumberString;
+        return (await (0, packageVersionCreateRequest_1.byId)(createResult.id, this.connection))[0];
     }
-    async resolveUserLicenses(canonicalPackageProperty, options) {
-        // Check for an includeProfileUserLiceneses flag in the packageDirectory
-        const includeProfileUserLicenses = this.getConfigPackageDirectoriesValue(this.project.getPackageDirectories(), 'includeProfileUserLicenses', canonicalPackageProperty, options.package, 'package', options);
-        if (includeProfileUserLicenses !== undefined &&
-            includeProfileUserLicenses !== true &&
-            includeProfileUserLicenses !== false) {
-            throw messages.createError('errorProfileUserLicensesInvalidValue', [includeProfileUserLicenses]);
-        }
+    async resolveUserLicenses(includeUserLicenses) {
         const shouldGenerateProfileInformation = logger.shouldLog(core_1.LoggerLevel.INFO) || logger.shouldLog(core_1.LoggerLevel.DEBUG);
-        return packageProfileApi_1.PackageProfileApi.create({
+        return await packageProfileApi_1.PackageProfileApi.create({
             project: this.project,
-            includeUserLicenses: includeProfileUserLicenses,
+            includeUserLicenses,
             generateProfileInformation: shouldGenerateProfileInformation,
         });
     }
-    async resolveOrgDependentPollingTime(resolvedPackageId, options, pollInterval, maxRetries) {
-        let pi = pollInterval;
-        let mr = maxRetries;
-        // If we are polling check to see if the package is Org-Dependent, if so, update the poll time
-        if (options.wait) {
-            const query = `SELECT IsOrgDependent FROM Package2 WHERE Id = '${resolvedPackageId}'`;
-            try {
-                const pkgQueryResult = await this.connection.singleRecordQuery(query, {
-                    tooling: true,
-                });
-                if (pkgQueryResult.IsOrgDependent) {
-                    pi = kit_1.Duration.seconds(POLL_INTERVAL_WITHOUT_VALIDATION_SECONDS);
-                    mr = (60 / pollInterval.seconds) * options.wait.seconds;
-                }
-            }
-            catch {
-                // do nothing
-            }
-        }
-        return [pi, mr];
-    }
-    async validateFlagsForPackageType(packageId, options) {
-        const packageType = await pkgUtils.getPackageType(packageId, this.connection);
-        if (packageType === 'Unlocked') {
-            if (options.postinstallscript || options.uninstallscript) {
-                // migrate coreMessages to messages
-                throw messages.createError('version_create.errorScriptsNotApplicableToUnlockedPackage');
+    async validateOptionsForPackageType() {
+        this.packageType = await pkgUtils.getPackageType(this.packageId, this.connection);
+        if (this.packageType === 'Unlocked') {
+            // Don't allow scripts in unlocked packages
+            if (this.options.postinstallscript || this.options.uninstallscript) {
+                throw messages.createError('errorScriptsNotApplicableToUnlockedPackage');
             }
             // Don't allow ancestor in unlocked packages
-            const packageDescriptorJson = this.getPackageDescriptorJsonFromPackageId(packageId, options);
-            const ancestorId = packageDescriptorJson.ancestorId;
-            const ancestorVersion = packageDescriptorJson.ancestorVersion;
-            if (ancestorId || ancestorVersion) {
-                throw messages.createError('version_create.errorAncestorNotApplicableToUnlockedPackage');
+            if (this.packageObject.ancestorId || this.packageObject.ancestorVersion) {
+                throw messages.createError('errorAncestorNotApplicableToUnlockedPackage');
             }
         }
     }
@@ -703,7 +470,8 @@ class PackageVersionCreate {
     /**
      * Sets default or override values for packageDescriptorJSON attribs
      */
-    setPackageDescriptorJsonValues(packageDescriptorJson, options) {
+    setPackageDescriptorJsonValues(packageDescriptorJson) {
+        const options = this.options;
         if (options.versionname) {
             packageDescriptorJson.versionName = options.versionname;
         }
@@ -725,13 +493,13 @@ class PackageVersionCreate {
         if (options.releasenotesurl) {
             packageDescriptorJson.releaseNotesUrl = options.releasenotesurl;
         }
-        if (packageDescriptorJson.releaseNotesUrl && !pkgUtils.validUrl(packageDescriptorJson.releaseNotesUrl)) {
+        if (packageDescriptorJson.releaseNotesUrl && !core_1.SfdcUrl.isValidUrl(packageDescriptorJson.releaseNotesUrl)) {
             throw messages.createError('malformedUrl', ['releaseNotesUrl', packageDescriptorJson.releaseNotesUrl]);
         }
         if (options.postinstallurl) {
             packageDescriptorJson.postInstallUrl = options.postinstallurl;
         }
-        if (packageDescriptorJson.postInstallUrl && !pkgUtils.validUrl(packageDescriptorJson.postInstallUrl)) {
+        if (packageDescriptorJson.postInstallUrl && !core_1.SfdcUrl.isValidUrl(packageDescriptorJson.postInstallUrl)) {
             throw messages.createError('malformedUrl', ['postInstallUrl', packageDescriptorJson.postInstallUrl]);
         }
         if (options.postinstallscript) {