@salesforce/packaging 0.1.11 → 0.1.13

package/lib/package/packageVersionCreateRequest.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.byId = exports.list = void 0;
 const util = require("util");
 const core_1 = require("@salesforce/core");
+const utils_1 = require("../utils");
 core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version_create');
 const STATUS_ERROR = 'Error';
@@ -16,7 +17,7 @@ const QUERY = 'SELECT Id, Status, Package2Id, Package2VersionId, Package2Version
     'CreatedDate, Package2Version.HasMetadataRemoved, CreatedById ' +
     'FROM Package2VersionCreateRequest ' +
     '%s' + // WHERE, if applicable
-    'ORDER BY CreatedDate';
+    'ORDER BY CreatedDate desc';
 const ERROR_QUERY = "SELECT Message FROM Package2VersionCreateRequestError WHERE ParentRequest.Id = '%s'";
 function formatDate(date) {
     const pad = (num) => {
@@ -25,20 +26,25 @@ function formatDate(date) {
     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);
+    try {
+        const whereClause = _constructWhere(options);
+        return await query(util.format(QUERY, whereClause), options.connection);
+    }
+    catch (err) {
+        throw (0, utils_1.applyErrorAction)((0, utils_1.massageErrorMessage)(err));
+    }
 }
 exports.list = list;
 async function byId(packageVersionCreateRequestId, connection) {
-    const results = await _query(util.format(QUERY, `WHERE Id = '${packageVersionCreateRequestId}' `), connection);
+    const results = await query(util.format(QUERY, `WHERE Id = '${packageVersionCreateRequestId}' `), connection);
     if (results && results.length === 1 && results[0].Status === STATUS_ERROR) {
         results[0].Error = await _queryErrors(packageVersionCreateRequestId, connection);
     }
     return results;
 }
 exports.byId = byId;
-async function _query(query, connection) {
-    const queryResult = await connection.tooling.query(query);
+async function query(query, connection) {
+    const queryResult = await connection.autoFetchQuery(query, { tooling: true });
     return (queryResult.records ? queryResult.records : []).map((record) => ({
         Id: record.Id,
         Status: record.Status,
@@ -65,6 +71,9 @@ async function _queryErrors(packageVersionCreateRequestId, connection) {
 }
 function _constructWhere(options) {
     const where = [];
+    if (options?.id) {
+        where.push(`Id = '${options.id}'`);
+    }
     // filter on created date, days ago: 0 for today, etc
     if (options?.createdlastdays) {
         if (options.createdlastdays < 0) {

package/lib/package/packageVersionCreateRequestReport.js

@@ -8,11 +8,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCreatePackageVersionCreateRequestReport = void 0;
 const pkgUtils = require("../utils/packageUtils");
+const packageUtils_1 = require("../utils/packageUtils");
 const packageVersionCreateRequest_1 = require("./packageVersionCreateRequest");
 async function getCreatePackageVersionCreateRequestReport(options) {
-    pkgUtils.validateId(pkgUtils.BY_LABEL.PACKAGE_VERSION_CREATE_REQUEST_ID, options.createPackageVersionRequestId);
-    const results = await (0, packageVersionCreateRequest_1.byId)(options.createPackageVersionRequestId, options.connection);
-    return results[0];
+    try {
+        pkgUtils.validateId(pkgUtils.BY_LABEL.PACKAGE_VERSION_CREATE_REQUEST_ID, options.createPackageVersionRequestId);
+        const results = await (0, packageVersionCreateRequest_1.byId)(options.createPackageVersionRequestId, options.connection);
+        return results[0];
+    }
+    catch (err) {
+        throw (0, packageUtils_1.applyErrorAction)((0, packageUtils_1.massageErrorMessage)(err));
+    }
 }
 exports.getCreatePackageVersionCreateRequestReport = getCreatePackageVersionCreateRequestReport;
 //# sourceMappingURL=packageVersionCreateRequestReport.js.map

package/lib/package/packageVersionList.js

@@ -31,7 +31,9 @@ const getLogger = () => {
     return logger;
 };
 async function listPackageVersions(options) {
-    return options.connection.tooling.query(constructQuery(options));
+    return options.connection.autoFetchQuery(constructQuery(options), {
+        tooling: true,
+    });
 }
 exports.listPackageVersions = listPackageVersions;
 function constructQuery(options) {

package/lib/package/packageVersionReport.js

@@ -33,32 +33,6 @@ const getLogger = () => {
     }
     return logger;
 };
-/**
- * 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) {
     getLogger().debug(`entering getPackageVersionReport(${util.inspect(options, { depth: null })})`);
     const queryResult = await options.connection.tooling.query(util.format(options.verbose ? QUERY_VERBOSE : QUERY, options.packageVersionId));
@@ -71,7 +45,7 @@ async function getPackageVersionReport(options) {
         record.AncestorVersion = null;
         if (record.AncestorId) {
             // lookup AncestorVersion value
-            const ancestorVersionMap = await getPackageVersionStrings([record.AncestorId], options.connection);
+            const ancestorVersionMap = await pkgUtils.getPackageVersionStrings([record.AncestorId], options.connection);
             record.AncestorVersion = ancestorVersionMap.get(record.AncestorId);
         }
         else {

package/lib/package/subscriberPackageVersion.d.ts

@@ -0,0 +1,156 @@
+import { Connection } from '@salesforce/core';
+import { Duration } from '@salesforce/kit';
+import { Optional } from '@salesforce/ts-types';
+import { PackageInstallCreateRequest, PackageInstallOptions, PackageType, PackagingSObjects, SubscriberPackageVersionOptions } from '../interfaces';
+import { VersionNumber } from '../utils';
+export declare const SubscriberPackageVersionFields: string[];
+/**
+ * A class that represents a SubscriberPackageVersion
+ */
+export declare class SubscriberPackageVersion {
+    private options;
+    private readonly password;
+    private readonly connection;
+    private readonly id;
+    private data;
+    constructor(options: SubscriberPackageVersionOptions);
+    /**
+     * Fetches the status of a package version install request and will wait for the install to complete, if requested
+     * Package Version install emits the following events:
+     * - PackageEvents.install['subscriber-status']
+     *
+     * @param connection
+     * @param packageInstallRequestOrId
+     * @param installationKey
+     * @param options
+     */
+    static installStatus(connection: Connection, packageInstallRequestOrId: string | PackagingSObjects.PackageInstallRequest, installationKey?: string, options?: PackageInstallOptions): Promise<PackagingSObjects.PackageInstallRequest>;
+    /**
+     * Reports on the progress of a package version uninstall.
+     *
+     * @param id the 06y package version uninstall request id
+     * @param connection
+     */
+    static uninstallStatus(id: string, connection: Connection): Promise<PackagingSObjects.SubscriberPackageVersionUninstallRequest>;
+    /**
+     * Retrieves the package version create request.
+     *
+     * @param installRequestId
+     * @param connection
+     */
+    static getInstallRequest(installRequestId: string, connection: Connection): Promise<PackagingSObjects.PackageInstallRequest>;
+    /**
+     * Get the package version ID for this SubscriberPackageVersion.
+     *
+     * @returns The SubscriberPackageVersion Id (04t).
+     */
+    getId(): Promise<string>;
+    /**
+     * Get the package type for this SubscriberPackageVersion.
+     *
+     * @returns {PackageType} The package type.
+     */
+    getPackageType(): Promise<PackageType>;
+    /**
+     * Get the password passed in the constructor
+     *
+     * @returns {string} the password
+     */
+    getPassword(): Optional<string>;
+    /**
+     * Get the subscriber package Id (033) for this SubscriberPackageVersion.
+     *
+     * @returns {string} The subscriber package Id.
+     */
+    getSubscriberPackageId(): Promise<string>;
+    /**
+     * Get a VersionNumber instance for this SubscriberPackageVersion.
+     *
+     * @returns {VersionNumber} The version number.
+     */
+    getVersionNumber(): Promise<VersionNumber>;
+    /**
+     * Is the package a managed package?
+     */
+    isManaged(): Promise<boolean>;
+    /**
+     * Is the SubscriberPackageVersion deprecated?
+     *
+     * @returns {boolean} True if the SubscriberPackageVersion is deprecated.
+     */
+    isDeprecated(): Promise<boolean>;
+    /**
+     * Is the SubscriberPackageVersion password protected?
+     *
+     * @returns {boolean} True if the SubscriberPackageVersion is password protected.
+     */
+    isPasswordProtected(): Promise<boolean>;
+    /**
+     * Is the SubscriberPackageVersion org dependent?
+     *
+     * @returns {boolean} True if the SubscriberPackageVersion is org dependent.
+     */
+    isOrgDependent(): Promise<boolean>;
+    /**
+     * Return remote site settings for the SubscriberPackageVersion.
+     *
+     * @returns {RemoteSiteSettings} The remote site settings.
+     */
+    getRemoteSiteSettings(): Promise<PackagingSObjects.SubscriberPackageRemoteSiteSettings>;
+    /**
+     * Return CSP trusted sites for the SubscriberPackageVersion.
+     *
+     * @returns {CspTrustedSites} The CSP trusted sites.
+     */
+    getCspTrustedSites(): Promise<PackagingSObjects.SubscriberPackageCspTrustedSites>;
+    /**
+     * Get the installation validation status for the SubscriberPackageVersion.
+     *
+     * @returns {InstallationValidationStatus} The installation validation status.
+     */
+    getInstallValidationStatus(): Promise<PackagingSObjects.InstallValidationStatus>;
+    /**
+     * Get the SubscriberPackageVersion SObject data for this SubscriberPackageVersion.
+     *
+     * @param force - force a refresh of the subscriber package version data.
+     * @returns {PackagingSObjects.SubscriberPackageVersion} SObject data.
+     */
+    getData(options?: {
+        force?: boolean;
+        includeHighCostFields?: boolean;
+    }): Promise<PackagingSObjects.SubscriberPackageVersion>;
+    /**
+     * Installs a package version in a subscriber org.
+     *
+     * Package Version install emits the following events:
+     * - PackageEvents.install.warning
+     * - PackageEvents.install.presend
+     * - PackageEvents.install.postsend
+     * - PackageEvents.install['subscriber-status']
+     *
+     * @param pkgInstallCreateRequest
+     * @param options
+     */
+    install(pkgInstallCreateRequest: PackageInstallCreateRequest, options?: PackageInstallOptions): Promise<PackagingSObjects.PackageInstallRequest>;
+    /**
+     * Uninstalls a package version from a subscriber org.
+     *
+     * @param frequency
+     * @param wait
+     */
+    uninstall(frequency?: Duration, wait?: Duration): Promise<PackagingSObjects.SubscriberPackageVersionUninstallRequest>;
+    /**
+     * Returns an array of RSS and CSP external sites for the package.
+     *
+     * @param installationKey The installation key (if any) for the subscriber package version.
+     * @returns an array of RSS and CSP site URLs, or undefined if the package doesn't have any.
+     */
+    getExternalSites(): Promise<Optional<string[]>>;
+    /**
+     * Return a field value from the SubscriberPackageVersion SObject using the field name.
+     *
+     * @param field
+     */
+    getField<T>(field: string): Promise<T>;
+    private getFieldsForQuery;
+}

package/lib/package/subscriberPackageVersion.js

@@ -0,0 +1,346 @@
+"use strict";
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriberPackageVersion = exports.SubscriberPackageVersionFields = void 0;
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+const utils_1 = require("../utils");
+const packageInstall_1 = require("./packageInstall");
+const packageUninstall_1 = require("./packageUninstall");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'subscriber_package_version');
+// these fields have been identified as requiring additional serverside resources in order to calculate their values
+// and are therefore not returned by default
+// these will require additional queries to retrieve
+const highCostQueryFields = [
+    'AppExchangeDescription',
+    'AppExchangeLogoUrl',
+    'AppExchangePackageName',
+    'AppExchangePublisherName',
+    'CspTrustedSite',
+    'Dependencies',
+    'PostInstallUrl',
+    'ReleaseNotesUrl',
+    'RemoteSiteSettings',
+    //  'InstallValidationStatus', // This requires extra resources on the server, but is commonly used, so let it load as part of the default query
+    'Profiles',
+];
+exports.SubscriberPackageVersionFields = [
+    'AppExchangeDescription',
+    'AppExchangeLogoUrl',
+    'AppExchangePackageName',
+    'AppExchangePublisherName',
+    'BuildNumber',
+    'CspTrustedSites',
+    'Dependencies',
+    'Description',
+    'Id',
+    'InstallValidationStatus',
+    'IsBeta',
+    'IsDeprecated',
+    'IsManaged',
+    'IsOrgDependent',
+    'IsPasswordProtected',
+    'IsSecurityReviewed',
+    'MajorVersion',
+    'MinorVersion',
+    'Name',
+    'Package2ContainerOptions',
+    'PatchVersion',
+    'PostInstallUrl',
+    'Profiles',
+    'PublisherName',
+    'ReleaseNotesUrl',
+    'ReleaseState',
+    'RemoteSiteSettings',
+    'SubscriberPackageId',
+];
+let logger;
+const getLogger = () => {
+    if (!logger) {
+        logger = core_1.Logger.childFromRoot('subscriberPackageVersion');
+    }
+    return logger;
+};
+const allZeroesInstallOptions = {
+    pollingFrequency: kit_1.Duration.minutes(0),
+    pollingTimeout: kit_1.Duration.minutes(0),
+    publishFrequency: kit_1.Duration.minutes(0),
+    publishTimeout: kit_1.Duration.minutes(0),
+};
+/**
+ * A class that represents a SubscriberPackageVersion
+ */
+class SubscriberPackageVersion {
+    constructor(options) {
+        this.options = options;
+        this.connection = this.options.connection;
+        if (!this.options?.aliasOrId) {
+            throw messages.createError('errorInvalidAliasOrId', [this.options?.aliasOrId]);
+        }
+        try {
+            const project = core_1.SfProject.getInstance();
+            this.id = project.getPackageIdFromAlias(this.options.aliasOrId) || this.options.aliasOrId;
+        }
+        catch (error) {
+            const err = error.message;
+            getLogger().debug(err);
+            this.id = this.options.aliasOrId;
+        }
+        // validate ID
+        if (!this.id.startsWith('04t') || !core_1.sfdc.validateSalesforceId(this.id)) {
+            throw messages.createError('errorInvalidAliasOrId', [this.options.aliasOrId]);
+        }
+        this.password = this.options.password;
+    }
+    /**
+     * Fetches the status of a package version install request and will wait for the install to complete, if requested
+     * Package Version install emits the following events:
+     * - PackageEvents.install['subscriber-status']
+     *
+     * @param connection
+     * @param packageInstallRequestOrId
+     * @param installationKey
+     * @param options
+     */
+    static async installStatus(connection, packageInstallRequestOrId, installationKey, options) {
+        const id = typeof packageInstallRequestOrId === 'string' ? packageInstallRequestOrId : packageInstallRequestOrId.Id;
+        const packageInstallRequest = await (0, packageInstall_1.getStatus)(connection, id);
+        const pollingTimeout = (0, utils_1.numberToDuration)(options.pollingTimeout) ?? kit_1.Duration.milliseconds(0);
+        if (pollingTimeout.milliseconds <= 0) {
+            return packageInstallRequest;
+        }
+        else {
+            await (0, packageInstall_1.waitForPublish)(connection, packageInstallRequest.SubscriberPackageVersionKey, options?.publishFrequency || 0, options?.publishTimeout || 0, installationKey);
+            return (0, packageInstall_1.pollStatus)(connection, id, options);
+        }
+    }
+    /**
+     * Reports on the progress of a package version uninstall.
+     *
+     * @param id the 06y package version uninstall request id
+     * @param connection
+     */
+    static async uninstallStatus(id, connection) {
+        if (!id.startsWith('06y') || !core_1.sfdc.validateSalesforceId(id)) {
+            throw messages.createError('packageVersionUninstallRequestIdInvalid', [id]);
+        }
+        const result = (await connection.tooling.retrieve('SubscriberPackageVersionUninstallRequest', id));
+        if (result.Status === 'Error') {
+            const errorDetails = await (0, packageUninstall_1.getUninstallErrors)(connection, id);
+            const errors = errorDetails.map((record, index) => `(${index + 1}) ${record.Message}`);
+            const errHeader = errors.length > 0 ? `\n=== Errors\n${errors.join('\n')}` : '';
+            const err = messages.getMessage('defaultErrorMessage', [id, result.Id]);
+            throw new core_1.SfError(`${err}${errHeader}`, 'UNINSTALL_ERROR', [messages.getMessage('action')]);
+        }
+        return result;
+    }
+    /**
+     * Retrieves the package version create request.
+     *
+     * @param installRequestId
+     * @param connection
+     */
+    static async getInstallRequest(installRequestId, connection) {
+        if (!installRequestId.startsWith('0Hf') || !core_1.sfdc.validateSalesforceId(installRequestId)) {
+            throw messages.createError('packageVersionInstallRequestIdInvalid', [installRequestId]);
+        }
+        const installRequest = await (0, packageInstall_1.getStatus)(connection, installRequestId);
+        if (!installRequest) {
+            throw messages.createError('packageVersionInstallRequestNotFound', [installRequestId]);
+        }
+        return installRequest;
+    }
+    /**
+     * Get the package version ID for this SubscriberPackageVersion.
+     *
+     * @returns The SubscriberPackageVersion Id (04t).
+     */
+    getId() {
+        return Promise.resolve(this.id);
+    }
+    /**
+     * Get the package type for this SubscriberPackageVersion.
+     *
+     * @returns {PackageType} The package type.
+     */
+    async getPackageType() {
+        return this.getField('Package2ContainerOptions');
+    }
+    /**
+     * Get the password passed in the constructor
+     *
+     * @returns {string} the password
+     */
+    getPassword() {
+        return this.password;
+    }
+    /**
+     * Get the subscriber package Id (033) for this SubscriberPackageVersion.
+     *
+     * @returns {string} The subscriber package Id.
+     */
+    async getSubscriberPackageId() {
+        return this.getField('SubscriberPackageId');
+    }
+    /**
+     * Get a VersionNumber instance for this SubscriberPackageVersion.
+     *
+     * @returns {VersionNumber} The version number.
+     */
+    async getVersionNumber() {
+        const majorVersion = await this.getField('MajorVersion');
+        const minorVersion = await this.getField('MinorVersion');
+        const patchVersion = await this.getField('PatchVersion');
+        const buildNumber = await this.getField('BuildNumber');
+        return new utils_1.VersionNumber(majorVersion, minorVersion, patchVersion, buildNumber);
+    }
+    /**
+     * Is the package a managed package?
+     */
+    async isManaged() {
+        return this.getField('IsManaged');
+    }
+    /**
+     * Is the SubscriberPackageVersion deprecated?
+     *
+     * @returns {boolean} True if the SubscriberPackageVersion is deprecated.
+     */
+    async isDeprecated() {
+        return this.getField('IsDeprecated');
+    }
+    /**
+     * Is the SubscriberPackageVersion password protected?
+     *
+     * @returns {boolean} True if the SubscriberPackageVersion is password protected.
+     */
+    async isPasswordProtected() {
+        return this.getField('IsPasswordProtected');
+    }
+    /**
+     * Is the SubscriberPackageVersion org dependent?
+     *
+     * @returns {boolean} True if the SubscriberPackageVersion is org dependent.
+     */
+    async isOrgDependent() {
+        return this.getField('IsOrgDependent');
+    }
+    /**
+     * Return remote site settings for the SubscriberPackageVersion.
+     *
+     * @returns {RemoteSiteSettings} The remote site settings.
+     */
+    async getRemoteSiteSettings() {
+        return this.getField('RemoteSiteSettings');
+    }
+    /**
+     * Return CSP trusted sites for the SubscriberPackageVersion.
+     *
+     * @returns {CspTrustedSites} The CSP trusted sites.
+     */
+    async getCspTrustedSites() {
+        return this.getField('CspTrustedSites');
+    }
+    /**
+     * Get the installation validation status for the SubscriberPackageVersion.
+     *
+     * @returns {InstallationValidationStatus} The installation validation status.
+     */
+    async getInstallValidationStatus() {
+        return this.getField('InstallValidationStatus');
+    }
+    /**
+     * Get the SubscriberPackageVersion SObject data for this SubscriberPackageVersion.
+     *
+     * @param force - force a refresh of the subscriber package version data.
+     * @returns {PackagingSObjects.SubscriberPackageVersion} SObject data.
+     */
+    async getData(options = { force: false, includeHighCostFields: false }) {
+        if (!this.data || options.force || options.includeHighCostFields) {
+            const queryFields = this.getFieldsForQuery(options);
+            if (queryFields.length === 0) {
+                return this.data;
+            }
+            try {
+                const queryNoKey = `SELECT ${queryFields.toString()} FROM SubscriberPackageVersion WHERE Id ='${await this.getId()}'`;
+                const escapedInstallationKey = this.password ? (0, utils_1.escapeInstallationKey)(this.password) : null;
+                const queryWithKey = `${queryNoKey} AND InstallationKey ='${escapedInstallationKey}'`;
+                this.data = await this.connection.singleRecordQuery(queryWithKey, {
+                    tooling: true,
+                });
+            }
+            catch (err) {
+                throw messages.createError('errorInvalidIdNoRecordFound', [this.options.aliasOrId], undefined, err);
+            }
+        }
+        return this.data;
+    }
+    /**
+     * Installs a package version in a subscriber org.
+     *
+     * Package Version install emits the following events:
+     * - PackageEvents.install.warning
+     * - PackageEvents.install.presend
+     * - PackageEvents.install.postsend
+     * - PackageEvents.install['subscriber-status']
+     *
+     * @param pkgInstallCreateRequest
+     * @param options
+     */
+    async install(pkgInstallCreateRequest, options = allZeroesInstallOptions) {
+        try {
+            // before starting the install, check to see if the package version is available for install
+            await (0, packageInstall_1.waitForPublish)(this.connection, await this.getId(), options.publishFrequency, options.publishTimeout, pkgInstallCreateRequest.Password);
+            const pkgVersionInstallRequest = await (0, packageInstall_1.createPackageInstallRequest)(this.connection, pkgInstallCreateRequest, await this.getPackageType());
+            return SubscriberPackageVersion.installStatus(this.connection, pkgVersionInstallRequest.Id, pkgInstallCreateRequest.Password, options);
+        }
+        catch (e) {
+            throw (0, utils_1.applyErrorAction)((0, utils_1.massageErrorMessage)(e));
+        }
+    }
+    /**
+     * Uninstalls a package version from a subscriber org.
+     *
+     * @param frequency
+     * @param wait
+     */
+    async uninstall(frequency = kit_1.Duration.milliseconds(0), wait = kit_1.Duration.milliseconds(0)) {
+        return await (0, packageUninstall_1.uninstallPackage)(await this.getId(), this.connection, frequency, wait);
+    }
+    /**
+     * Returns an array of RSS and CSP external sites for the package.
+     *
+     * @param installationKey The installation key (if any) for the subscriber package version.
+     * @returns an array of RSS and CSP site URLs, or undefined if the package doesn't have any.
+     */
+    async getExternalSites() {
+        getLogger().debug(`Checking package: [${await this.getId()}] for external sites`);
+        const remoteSiteSettings = await this.getRemoteSiteSettings();
+        const cspTrustedSites = await this.getCspTrustedSites();
+        const rssUrls = remoteSiteSettings?.settings ? remoteSiteSettings.settings?.map((rss) => rss.url) : [];
+        const cspUrls = cspTrustedSites?.settings ? cspTrustedSites?.settings.map((csp) => csp.endpointUrl) : [];
+        const sites = [...rssUrls, ...cspUrls];
+        return sites.length > 0 ? sites : undefined;
+    }
+    /**
+     * Return a field value from the SubscriberPackageVersion SObject using the field name.
+     *
+     * @param field
+     */
+    async getField(field) {
+        if (!this.data || !Reflect.has(this.data, field)) {
+            await this.getData({ includeHighCostFields: highCostQueryFields.includes(field) });
+        }
+        return Reflect.get(this.data || {}, field);
+    }
+    getFieldsForQuery(options) {
+        return exports.SubscriberPackageVersionFields.filter((field) => !highCostQueryFields.includes(field) || options.includeHighCostFields);
+    }
+}
+exports.SubscriberPackageVersion = SubscriberPackageVersion;
+//# sourceMappingURL=subscriberPackageVersion.js.map

package/lib/utils/packageUtils.d.ts

@@ -1,6 +1,7 @@
 import { Connection, NamedPackageDir, PackageDir, SfdcUrl, SfError, SfProject } from '@salesforce/core';
 import { Many, Nullable } from '@salesforce/ts-types';
 import { SaveError } from 'jsforce';
+import { Duration } from '@salesforce/kit';
 import { PackageType, PackagingSObjects } from '../interfaces';
 export declare const VERSION_NUMBER_SEP = ".";
 export declare type IdRegistryValue = {
@@ -26,6 +27,7 @@ export declare function validateId(idObj: Many<IdRegistryValue>, value: string):
 export declare function getSourceApiVersion(project: SfProject): string;
 export declare function validateIdNoThrow(idObj: Many<IdRegistryValue>, value: any): IdRegistryValue | false;
 export declare function applyErrorAction(err: Error): Error;
+export declare function massageErrorMessage(err: Error): Error;
 /**
  * Given a subscriber package version ID (04t) or package version ID (05i), return the package version ID (05i)
  *
@@ -34,14 +36,6 @@ export declare function applyErrorAction(err: Error): Error;
  */
 export declare function getPackageVersionId(versionId: string, connection: Connection): Promise<string>;
 export declare function escapeInstallationKey(key?: string): Nullable<string>;
-/**
- * Given 0Ho the package type type (Managed, Unlocked, Locked(deprecated?))
- *
- * @param packageId the 0Ho
- * @param connection For tooling query
- * @throws Error with message when package2 cannot be found
- */
-export declare function getPackageType(packageId: string, connection: Connection): Promise<PackageType>;
 /**
  * Get the ContainerOptions for the specified Package2 (0Ho) IDs.
  *
@@ -113,8 +107,13 @@ export declare function getPackageAliasesFromId(packageId: string, project: SfPr
  * @param packageId the 0Ho id
  * @private
  */
-export declare function generatePackageAliasEntry(connection: Connection, project: SfProject, packageVersionId: string, packageVersionNumber: string, branch: string, packageId: string): Promise<{
-    [p: string]: string;
-}>;
+export declare function generatePackageAliasEntry(connection: Connection, project: SfProject, packageVersionId: string, packageVersionNumber: string, branch: string, packageId: string): Promise<[string, string]>;
 export declare function formatDate(date: Date): string;
 export declare function combineSaveErrors(sObject: string, crudOperation: string, errors: SaveError[]): SfError;
+/**
+ * Returns a Duration object from param duration when it is a number, otherwise return itself
+ *
+ * @param duration = number to be converted to a Duration or Duration object
+ * @param unit = (Default Duration.Unit.MILLISECONDS) Duration unit of number - See @link {Duration.Unit} for valid values
+ */
+export declare function numberToDuration(duration: number | Duration, unit?: Duration.Unit): Duration;