@salesforce/packaging 2.2.9-profiles.0 → 2.3.0

package/lib/interfaces/packagingInterfacesAndType.d.ts

@@ -4,7 +4,6 @@ import { SaveResult } from 'jsforce';
 import { Attributes } from 'graphology-types';
 import { Optional } from '@salesforce/ts-types';
 import { ConvertResult } from '@salesforce/source-deploy-retrieve';
-import { Package } from 'jsforce/lib/api/metadata';
 import { PackageProfileApi } from '../package/packageProfileApi';
 import { PackageAncestryNode } from '../package/packageAncestry';
 import { PackagingSObjects } from './packagingSObjects';
@@ -49,6 +48,7 @@ export type PackageVersionCreateRequestResult = {
     CreatedDate: string;
     HasMetadataRemoved: boolean | null;
     CreatedBy: string;
+    ConvertedFromVersionId: string | null;
 };
 export declare const PackageVersionCreateRequestResultInProgressStatuses: PackagingSObjects.Package2VersionStatus[];
 export type PackageVersionCreateRequestError = {
@@ -155,6 +155,7 @@ export type PackageVersionListOptions = {
     verbose?: boolean;
     concise?: boolean;
     isReleased?: boolean;
+    showConversionsOnly?: boolean;
 };
 export type PackageVersionUpdateOptions = {
     InstallKey?: string;
@@ -266,10 +267,12 @@ export type PackageVersionCreateRequestQueryOptions = {
     createdlastdays?: number;
     status?: 'Queued' | 'InProgress' | 'Success' | 'Error';
     id?: string;
+    showConversionsOnly?: boolean;
 };
 export type ProfileApiOptions = {
     project: SfProject;
     includeUserLicenses: boolean;
+    generateProfileInformation: boolean;
 };
 export type PackageVersionReportResult = Partial<Omit<PackagingSObjects.Package2Version, 'AncestorId' | 'HasPassedCodeCoverageCheck' | 'HasMetadataRemoved'>> & {
     Package2: Partial<Omit<PackagingSObjects.Package2, 'IsOrgDependent'>> & {
@@ -370,6 +373,3 @@ export declare const Package1VersionEvents: {
         progress: string;
     };
 };
-export type PackageXml = {
-    Package: Pick<Package, 'types' | 'version'>;
-};

package/lib/package/packageProfileApi.d.ts

@@ -1,9 +1,21 @@
 import { SfProject } from '@salesforce/core';
 import { AsyncCreatable } from '@salesforce/kit';
-import { PackageXml, ProfileApiOptions } from '../interfaces';
+import { ProfileApiOptions } from '../interfaces';
 export declare class PackageProfileApi extends AsyncCreatable<ProfileApiOptions> {
+    readonly profiles: ProfileInformation[];
+    nodeEntities: {
+        name: string[];
+        parentElement: string[];
+        childElement: string[];
+    };
+    otherProfileSettings: {
+        name: string[];
+        parentElement: string[];
+        childElement: string[];
+    };
     project: SfProject;
     includeUserLicenses: boolean;
+    generateProfileInformation: boolean;
     constructor(options: ProfileApiOptions);
     init(): Promise<void>;
     /**
@@ -11,15 +23,41 @@ export declare class PackageProfileApi extends AsyncCreatable<ProfileApiOptions>
      * to items in the manifest.
      *
      * @param destPath location of new profiles
-     * @param manifestTypes: array of objects { name: string, members: string[] } that represent package xml types
+     * @param manifest
      * @param excludedDirectories Directories to not include profiles from
      */
-    generateProfiles(destPath: string, manifestTypes: PackageXml['Package']['types'], excludedDirectories?: string[]): string[];
+    generateProfiles(destPath: string, manifest: {
+        Package: Array<{
+            name: string[];
+            members: string[];
+        }>;
+    }, excludedDirectories?: string[]): string[];
     /**
      * Filter out all profiles in the manifest and if any profiles exists in the workspace, add them to the manifest.
      *
      * @param typesArr array of objects { name[], members[] } that represent package types JSON.
      * @param excludedDirectories Direcotires not to generate profiles for
      */
-    filterAndGenerateProfilesForManifest(typesArr: PackageXml['Package']['types'], excludedDirectories?: string[]): PackageXml['Package']['types'];
+    filterAndGenerateProfilesForManifest(typesArr: Array<{
+        name: string[];
+        members: string[];
+    }>, excludedDirectories?: string[]): Array<{
+        name: string[];
+        members: string[];
+    }>;
+    getProfileInformation(): ProfileInformation[];
+    private copyNodes;
+    private findAllProfiles;
 }
+declare class ProfileInformation {
+    ProfileName: string;
+    ProfilePath: string;
+    IsPackaged: boolean;
+    settingsRemoved: string[];
+    constructor(ProfileName: string, ProfilePath: string, IsPackaged: boolean, settingsRemoved: string[]);
+    setIsPackaged(IsPackaged: boolean): void;
+    appendRemovedSetting(setting: string): void;
+    logDebug(): string;
+    logInfo(): string;
+}
+export {};

package/lib/package/packageProfileApi.js

@@ -1,20 +1,77 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PackageProfileApi = void 0;
 /*
  * Copyright (c) 2022, salesforce.com, inc.
  * All rights reserved.
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageProfileApi = void 0;
 const path = require("path");
 const fs = require("fs");
 const glob = require("glob");
+const xmldom_1 = require("@xmldom/xmldom");
 const core_1 = require("@salesforce/core");
 const kit_1 = require("@salesforce/kit");
-const profileRewriter_1 = require("./profileRewriter");
 core_1.Messages.importMessagesDirectory(__dirname);
 const profileApiMessages = core_1.Messages.loadMessages('@salesforce/packaging', 'profile_api');
+// nodeEntities is used to determine which elements in the profile are relevant to the source being packaged.
+// name refers to the entity type name in source that the element pertains to.  As an example, a profile may
+// have an entry like the example below, which should only be added to the packaged profile if the related
+// CustomObject is in the source being packaged:
+//   <objectPermissions>
+//      <allowCreate>true</allowCreate>
+//       ...
+//      <object>MyCustomObject__c</object>
+//       ...
+//   </objectPermissions>
+//
+// For this example: nodeEntities.parentElement = objectPermissions and nodeEntities.childElement = object
+const NODE_ENTITIES = {
+    name: [
+        'CustomObject',
+        'CustomField',
+        'Layout',
+        'CustomTab',
+        'CustomApplication',
+        'ApexClass',
+        'CustomPermission',
+        'ApexPage',
+        'ExternalDataSource',
+        'RecordType',
+    ],
+    parentElement: [
+        'objectPermissions',
+        'fieldPermissions',
+        'layoutAssignments',
+        'tabVisibilities',
+        'applicationVisibilities',
+        'classAccesses',
+        'customPermissions',
+        'pageAccesses',
+        'externalDataSourceAccesses',
+        'recordTypeVisibilities',
+    ],
+    childElement: [
+        'object',
+        'field',
+        'layout',
+        'tab',
+        'application',
+        'apexClass',
+        'name',
+        'apexPage',
+        'externalDataSource',
+        'recordType',
+    ],
+};
+// There are some profile settings that are allowed to be packaged that may not necessarily map to a specific metadata
+// object. We should still handle these accordingly, but a little differently than the above mentioned types.
+const OTHER_PROFILE_SETTINGS = {
+    name: ['CustomSettings', 'CustomMetadataTypeAccess'],
+    parentElement: ['customSettingAccesses', 'customMetadataTypeAccesses'],
+    childElement: ['name', 'name'],
+};
 /*
  * This class provides functions used to re-write .profiles in the workspace when creating a package2 version.
  * All profiles found in the workspaces are extracted out and then re-written to only include metadata in the profile
@@ -23,9 +80,14 @@ const profileApiMessages = core_1.Messages.loadMessages('@salesforce/packaging',
 class PackageProfileApi extends kit_1.AsyncCreatable {
     constructor(options) {
         super(options);
+        this.profiles = [];
+        this.nodeEntities = NODE_ENTITIES;
+        this.otherProfileSettings = OTHER_PROFILE_SETTINGS;
         this.includeUserLicenses = false;
+        this.generateProfileInformation = false;
         this.project = options.project;
         this.includeUserLicenses = options.includeUserLicenses ?? false;
+        this.generateProfileInformation = options.generateProfileInformation ?? false;
     }
     // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-empty-function
     async init() { }
@@ -34,38 +96,90 @@ class PackageProfileApi extends kit_1.AsyncCreatable {
      * to items in the manifest.
      *
      * @param destPath location of new profiles
-     * @param manifestTypes: array of objects { name: string, members: string[] } that represent package xml types
+     * @param manifest
      * @param excludedDirectories Directories to not include profiles from
      */
-    generateProfiles(destPath, manifestTypes, excludedDirectories = []) {
-        const logger = core_1.Logger.childFromRoot('PackageProfileApi');
-        const profilePathsWithNames = getProfilesWithNamesAndPaths({
-            projectPath: this.project.getPath(),
-            excludedDirectories,
-        });
-        const results = profilePathsWithNames.map(({ profilePath, name: profileName }) => {
-            const originalProfile = (0, profileRewriter_1.profileStringToProfile)(fs.readFileSync(profilePath, 'utf-8'));
-            const adjustedProfile = (0, profileRewriter_1.profileRewriter)(originalProfile, (0, profileRewriter_1.manifestTypesToMap)(manifestTypes), this.includeUserLicenses);
-            const hasContent = Object.keys(adjustedProfile).length;
-            return { profileName, profilePath, hasContent, adjustedProfile, originalProfile };
-        });
-        results.map(({ profilePath, adjustedProfile, hasContent, profileName, originalProfile }) => {
-            if (!hasContent) {
-                logger.warn(`Profile ${profileName} has no content after filtering. It will still be part of the package but you can remove if it it's not needed.`);
+    generateProfiles(destPath, manifest, excludedDirectories = []) {
+        const excludedProfiles = [];
+        const profilePaths = this.findAllProfiles(excludedDirectories);
+        if (!profilePaths) {
+            return excludedProfiles;
+        }
+        profilePaths.forEach((profilePath) => {
+            // profile metadata can present in any directory in the package structure
+            const profileNameMatch = profilePath.match(/([^/]+)\.profile-meta.xml/);
+            const profileName = profileNameMatch ? profileNameMatch[1] : null;
+            if (profileName) {
+                const profileDom = new xmldom_1.DOMParser().parseFromString(fs.readFileSync(profilePath, 'utf-8'));
+                const newDom = new xmldom_1.DOMParser().parseFromString('<?xml version="1.0" encoding="UTF-8"?><Profile xmlns="http://soap.sforce.com/2006/04/metadata"></Profile>');
+                const profileNode = newDom.getElementsByTagName('Profile')[0];
+                let hasNodes = false;
+                // We need to keep track of all the members for when we package up the "OtherProfileSettings"
+                let allMembers = [];
+                manifest.Package.forEach((element) => {
+                    const name = element.name;
+                    const members = element.members;
+                    allMembers = allMembers.concat(members);
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    const idx = this.nodeEntities.name.indexOf(name[0]);
+                    if (idx > -1) {
+                        hasNodes =
+                            this.copyNodes(profileDom, this.nodeEntities.parentElement[idx], this.nodeEntities.childElement[idx], members, profileNode, profileName) || hasNodes;
+                    }
+                });
+                // Go through each of the other profile settings we might want to include. We pass in "all" the members since these
+                // will reference anything that could be packaged. The "copyNodes" function will only include the type if it
+                // exists in the profile itself
+                this.otherProfileSettings.name.forEach((element) => {
+                    const idx = this.otherProfileSettings.name.indexOf(element);
+                    if (idx > -1) {
+                        hasNodes =
+                            this.copyNodes(profileDom, this.otherProfileSettings.parentElement[idx], this.otherProfileSettings.childElement[idx], allMembers, profileNode, profileName) || hasNodes;
+                    }
+                });
+                // add userLicenses to the profile
+                if (this.includeUserLicenses) {
+                    const userLicenses = profileDom.getElementsByTagName('userLicense');
+                    if (userLicenses) {
+                        hasNodes = true;
+                        for (const userLicense of Array.from(userLicenses)) {
+                            profileNode.appendChild(userLicense.cloneNode(true));
+                        }
+                    }
+                }
+                const xmlSrcFile = path.basename(profilePath);
+                const xmlFile = xmlSrcFile.replace(/(.*)(-meta.xml)/, '$1');
+                const destFilePath = path.join(destPath, xmlFile);
+                if (hasNodes) {
+                    const serializer = new xmldom_1.XMLSerializer();
+                    serializer.serializeToString(newDom);
+                    fs.writeFileSync(destFilePath, serializer.serializeToString(newDom), 'utf-8');
+                }
+                else {
+                    // remove from manifest
+                    // eslint-disable-next-line @typescript-eslint/no-shadow
+                    const profileName = xmlFile.replace(/(.*)(\.profile)/, '$1');
+                    excludedProfiles.push(profileName);
+                    if (this.generateProfileInformation) {
+                        const profile = this.profiles.find(({ ProfileName }) => ProfileName === profileName);
+                        if (profile) {
+                            profile.setIsPackaged(false);
+                        }
+                    }
+                    try {
+                        fs.unlinkSync(destFilePath);
+                    }
+                    catch (err) {
+                        // It is normal for the file to not exist if the profile is in the workspace but not in the directory being packaged.
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                        if (err instanceof Error && 'code' in err && err.code !== 'ENOENT') {
+                            throw err;
+                        }
+                    }
+                }
             }
-            logger.info(profileApiMessages.getMessage('addProfileToPackage', [profileName, profilePath]));
-            getRemovedSettings(originalProfile, adjustedProfile).forEach((setting) => {
-                logger.info(profileApiMessages.getMessage('removeProfileSetting', [setting, profileName]));
-            });
-            fs.writeFileSync(getXmlFileLocation(destPath, profilePath), (0, profileRewriter_1.profileObjectToString)(adjustedProfile), 'utf-8');
-        });
-        return results.map((profile) => {
-            const xmlFile = getXmlFileLocation(destPath, profile.profilePath);
-            const replacedProfileName = xmlFile.replace(/(.*)(\.profile)/, '$1');
-            deleteButAllowEnoent(xmlFile);
-            logger.info(profileApiMessages.getMessage('profileNotIncluded', [replacedProfileName]));
-            return replacedProfileName;
         });
+        return excludedProfiles;
     }
     /**
      * Filter out all profiles in the manifest and if any profiles exists in the workspace, add them to the manifest.
@@ -74,40 +188,97 @@ class PackageProfileApi extends kit_1.AsyncCreatable {
      * @param excludedDirectories Direcotires not to generate profiles for
      */
     filterAndGenerateProfilesForManifest(typesArr, excludedDirectories = []) {
-        const profilePathsWithNames = getProfilesWithNamesAndPaths({
-            projectPath: this.project.getPath(),
-            excludedDirectories,
+        const profilePaths = this.findAllProfiles(excludedDirectories);
+        // Filter all profiles
+        const filteredTypesArr = (typesArr ?? []).filter((kvp) => kvp.name[0] !== 'Profile');
+        if (profilePaths) {
+            const members = [];
+            profilePaths.forEach((profilePath) => {
+                // profile metadata can present in any directory in the package structure
+                const profileNameMatch = profilePath.match(/([^/]+)\.profile-meta.xml/);
+                const profileName = profileNameMatch ? profileNameMatch[1] : null;
+                if (profileName) {
+                    members.push(profileName);
+                    if (this.generateProfileInformation) {
+                        this.profiles.push(new ProfileInformation(profileName, profilePath, true, []));
+                    }
+                }
+            });
+            if (members.length > 0) {
+                filteredTypesArr.push({ name: ['Profile'], members });
+            }
+        }
+        return filteredTypesArr;
+    }
+    getProfileInformation() {
+        return this.profiles;
+    }
+    copyNodes(originalDom, parentElement, childElement, members, appendToNode, profileName) {
+        let nodesAdded = false;
+        const nodes = originalDom.getElementsByTagName(parentElement);
+        if (!nodes) {
+            return nodesAdded;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let i = 0; i < nodes.length; i++) {
+            const name = nodes[i].getElementsByTagName(childElement)[0].childNodes[0].nodeValue;
+            if (name) {
+                if (members.includes(name)) {
+                    // appendChild will take the passed in node (newNode) and find the parent if it exists and then remove
+                    // the newNode from the parent.  This causes issues with the way this is copying the nodes, so pass in a clone instead.
+                    const currentNode = nodes[i].cloneNode(true);
+                    appendToNode.appendChild(currentNode);
+                    nodesAdded = true;
+                }
+                else if (this.generateProfileInformation) {
+                    // Tell the user which profile setting has been removed from the package
+                    const profile = this.profiles.find(({ ProfileName }) => ProfileName === profileName);
+                    if (profile) {
+                        profile.appendRemovedSetting(name);
+                    }
+                }
+            }
+        }
+        return nodesAdded;
+    }
+    findAllProfiles(excludedDirectories = []) {
+        return glob.sync(path.join(this.project.getPath(), '**', '*.profile-meta.xml'), {
+            ignore: excludedDirectories.map((dir) => `**/${dir}/**`),
         });
-        // Filter all profiles, and add back the ones we found names for
-        return typesArr
-            .filter((kvp) => kvp.name !== 'Profile')
-            .concat([{ name: 'Profile', members: profilePathsWithNames.map((i) => i.name) }]);
     }
 }
 exports.PackageProfileApi = PackageProfileApi;
-const findAllProfiles = ({ projectPath, excludedDirectories = [], }) => glob.sync(path.join(projectPath, '**', '*.profile-meta.xml'), {
-    ignore: excludedDirectories.map((dir) => `**/${dir}/**`),
-});
-const isProfilePathWithName = (profilePathWithName) => typeof profilePathWithName.name === 'string';
-const profilePathToName = (profilePath) => profilePath.match(/([^/]+)\.profile-meta.xml/)?.[1];
-const getProfilesWithNamesAndPaths = ({ projectPath, excludedDirectories, }) => findAllProfiles({ projectPath, excludedDirectories })
-    .map((profilePath) => ({ profilePath, name: profilePathToName(profilePath) }))
-    .filter(isProfilePathWithName);
-const getXmlFileLocation = (destPath, profilePath) => path.join(destPath, path.basename(profilePath).replace(/(.*)(-meta.xml)/, '$1'));
-const deleteButAllowEnoent = (destFilePath) => {
-    try {
-        fs.unlinkSync(destFilePath);
+class ProfileInformation {
+    constructor(ProfileName, ProfilePath, IsPackaged, settingsRemoved) {
+        this.ProfileName = ProfileName;
+        this.ProfilePath = ProfilePath;
+        this.IsPackaged = IsPackaged;
+        this.settingsRemoved = settingsRemoved;
+    }
+    setIsPackaged(IsPackaged) {
+        this.IsPackaged = IsPackaged;
+    }
+    appendRemovedSetting(setting) {
+        this.settingsRemoved.push(setting);
     }
-    catch (err) {
-        // It is normal for the file to not exist if the profile is in the workspace but not in the directory being packaged.
-        if (err instanceof Error && 'code' in err && err.code !== 'ENOENT') {
-            throw err;
+    logDebug() {
+        let info = profileApiMessages.getMessage('addProfileToPackage', [this.ProfileName, this.ProfilePath]);
+        this.settingsRemoved.forEach((setting) => {
+            info += '\n\t' + profileApiMessages.getMessage('removeProfileSetting', [setting, this.ProfileName]);
+        });
+        if (!this.IsPackaged) {
+            info += '\n\t' + profileApiMessages.getMessage('removeProfile', [this.ProfileName]);
         }
+        info += '\n';
+        return info;
     }
-};
-const getRemovedSettings = (originalProfile, adjustedProfile) => {
-    const originalProfileSettings = Object.keys(originalProfile);
-    const adjustedProfileSettings = Object.keys(adjustedProfile);
-    return originalProfileSettings.filter((setting) => !adjustedProfileSettings.includes(setting));
-};
+    logInfo() {
+        if (this.IsPackaged) {
+            return profileApiMessages.getMessage('addProfileToPackage', [this.ProfileName, this.ProfilePath]);
+        }
+        else {
+            return profileApiMessages.getMessage('profileNotIncluded', [this.ProfileName]);
+        }
+    }
+}
 //# sourceMappingURL=packageProfileApi.js.map

package/lib/package/packageVersionCreate.js

@@ -240,6 +240,8 @@ class PackageVersionCreate {
             sourceDir: sourceBaseDir,
             sourceApiVersion: this.project?.getSfProjectJson()?.get('sourceApiVersion') ?? undefined,
         };
+        // Stores any additional client side info that might be needed later on in the process
+        const clientSideInfo = new Map();
         await fs.promises.mkdir(packageVersBlobDirectory, { recursive: true });
         const settingsGenerator = new scratchOrgSettingsGenerator_1.default({ asDirectory: true });
         let packageDescriptorJson = (0, kit_1.cloneJson)(this.packageObject);
@@ -303,19 +305,7 @@ class PackageVersionCreate {
         }
         packageDescriptorJson.ancestorId = ancestorId;
         await fs.promises.writeFile(path.join(packageVersBlobDirectory, DESCRIPTOR_FILE), JSON.stringify(packageDescriptorJson), 'utf-8');
-        await this.cleanGeneratedPackage({
-            packageVersMetadataFolder,
-            packageVersProfileFolder,
-            unpackagedMetadataFolder,
-            seedMetadataFolder,
-            metadataZipFile,
-            settingsZipFile,
-            packageVersBlobDirectory,
-            packageVersBlobZipFile,
-            unpackagedMetadataZipFile,
-            seedMetadataZipFile,
-            settingsGenerator,
-        });
+        await this.cleanGeneratedPackage(packageVersMetadataFolder, packageVersProfileFolder, unpackagedMetadataFolder, seedMetadataFolder, metadataZipFile, settingsZipFile, packageVersBlobDirectory, packageVersBlobZipFile, unpackagedMetadataZipFile, seedMetadataZipFile, clientSideInfo, settingsGenerator);
         return this.createRequestObject(preserveFiles, packageVersTmpRoot, packageVersBlobZipFile);
     }
     verifyHasSource(componentSet) {
@@ -323,22 +313,22 @@ class PackageVersionCreate {
             throw messages.createError('noSourceInRootDirectory', [this.packageObject.path ?? '<unknown>']);
         }
     }
-    async cleanGeneratedPackage({ packageVersMetadataFolder, packageVersProfileFolder, unpackagedMetadataFolder, seedMetadataFolder, metadataZipFile, settingsZipFile, packageVersBlobDirectory, packageVersBlobZipFile, unpackagedMetadataZipFile, seedMetadataZipFile, settingsGenerator, }) {
+    async cleanGeneratedPackage(packageVersMetadataFolder, packageVersProfileFolder, unpackagedMetadataFolder, seedMetadataFolder, metadataZipFile, settingsZipFile, packageVersBlobDirectory, packageVersBlobZipFile, unpackagedMetadataZipFile, seedMetadataZipFile, 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.
         const currentPackageXml = await fs.promises.readFile(path.join(packageVersMetadataFolder, 'package.xml'), 'utf8');
         // convert to json
-        const packageXmlAsJson = (await xml2js.parseStringPromise(currentPackageXml));
-        if (!packageXmlAsJson?.Package) {
+        const packageJson = (await xml2js.parseStringPromise(currentPackageXml));
+        if (!packageJson?.Package) {
             throw messages.createError('packageXmlDoesNotContainPackage');
         }
-        if (!packageXmlAsJson?.Package?.types) {
+        if (!packageJson?.Package.types) {
             throw messages.createError('packageXmlDoesNotContainPackageTypes');
         }
         fs.mkdirSync(packageVersMetadataFolder, { recursive: true });
         fs.mkdirSync(packageVersProfileFolder, { recursive: true });
-        this.apiVersionFromPackageXml = packageXmlAsJson.Package.version;
+        this.apiVersionFromPackageXml = packageJson.Package.version;
         const sourceApiVersion = this.project?.getSfProjectJson()?.get('sourceApiVersion');
         const hasSeedMetadata = await this.metadataResolver.resolveMetadata(this.packageObject.seedMetadata?.path, seedMetadataFolder, 'seedMDDirectoryDoesNotExist', sourceApiVersion);
         let hasUnpackagedMetadata = false;
@@ -351,19 +341,32 @@ class PackageVersionCreate {
             .getPackageDirectories()
             .map((packageDir) => packageDir.unpackagedMetadata?.path)
             .filter((packageDirPath) => packageDirPath);
-        const typesArr = this.options?.profileApi?.filterAndGenerateProfilesForManifest(packageXmlAsJson.Package.types, profileExcludeDirs) ?? packageXmlAsJson.Package.types;
+        const typesArr = this.options?.profileApi?.filterAndGenerateProfilesForManifest(packageJson.Package.types, profileExcludeDirs) ??
+            packageJson.Package.types;
         // Next generate profiles and retrieve any profiles that were excluded because they had no matching nodes.
-        const excludedProfiles = this.options?.profileApi?.generateProfiles(packageVersProfileFolder, typesArr, profileExcludeDirs);
+        const excludedProfiles = this.options?.profileApi?.generateProfiles(packageVersProfileFolder, {
+            Package: typesArr,
+        }, profileExcludeDirs);
         if (excludedProfiles?.length) {
-            const profileIdx = typesArr.findIndex((e) => e.name === 'Profile');
+            const profileIdx = typesArr.findIndex((e) => e.name[0] === 'Profile');
             typesArr[profileIdx].members = typesArr[profileIdx].members.filter((e) => !excludedProfiles.includes(e));
         }
-        packageXmlAsJson.Package.types = typesArr;
+        packageJson.Package.types = typesArr;
         // Re-write the package.xml in case profiles have been added or removed
         const xmlBuilder = new xml2js.Builder({
             xmldec: { version: '1.0', encoding: 'UTF-8' },
         });
-        const xml = xmlBuilder.buildObject(packageXmlAsJson);
+        const xml = xmlBuilder.buildObject(packageJson);
+        // Log information about the profiles being packaged up
+        const profiles = this.options?.profileApi?.getProfileInformation() ?? [];
+        profiles.forEach((profile) => {
+            if (this.logger.shouldLog(core_1.LoggerLevel.DEBUG)) {
+                this.logger.debug(profile.logDebug());
+            }
+            else if (this.logger.shouldLog(core_1.LoggerLevel.INFO)) {
+                this.logger.info(profile.logInfo());
+            }
+        });
         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, packageUtils_1.zipDir)(packageVersMetadataFolder, metadataZipFile);
@@ -509,9 +512,11 @@ class PackageVersionCreate {
         return this.pkg.getType();
     }
     async resolveUserLicenses(includeUserLicenses) {
+        const shouldGenerateProfileInformation = this.logger.shouldLog(core_1.LoggerLevel.INFO) || this.logger.shouldLog(core_1.LoggerLevel.DEBUG);
         return packageProfileApi_1.PackageProfileApi.create({
             project: this.project,
             includeUserLicenses,
+            generateProfileInformation: shouldGenerateProfileInformation,
         });
     }
     async validateOptionsForPackageType() {

package/lib/package/packageVersionCreateRequest.js

@@ -14,7 +14,7 @@ core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version_create');
 const STATUS_ERROR = 'Error';
 const QUERY = 'SELECT Id, Status, Package2Id, Package2VersionId, Package2Version.SubscriberPackageVersionId, Tag, Branch, ' +
-    'CreatedDate, Package2Version.HasMetadataRemoved, CreatedById ' +
+    'CreatedDate, Package2Version.HasMetadataRemoved, CreatedById, IsConversionRequest, Package2Version.ConvertedFromVersionId ' +
     'FROM Package2VersionCreateRequest ' +
     '%s' + // WHERE, if applicable
     'ORDER BY CreatedDate desc';
@@ -58,8 +58,23 @@ async function query(query, connection) {
         CreatedDate: formatDate(new Date(record.CreatedDate)),
         HasMetadataRemoved: record.Package2Version != null ? record.Package2Version.HasMetadataRemoved : null,
         CreatedBy: record.CreatedById,
+        ConvertedFromVersionId: convertedFromVersionMessage(record.Status, record.Package2Version?.ConvertedFromVersionId),
     }));
 }
+function convertedFromVersionMessage(status, convertedFromVersionId) {
+    switch (status) {
+        case 'Success':
+            return convertedFromVersionId;
+        case 'Queued':
+            return messages.getMessage('IdUnavailableWhenQueued');
+        case 'InProgress':
+            return messages.getMessage('IdUnavailableWhenInProgress');
+        case 'Error':
+            return messages.getMessage('IdUnavailableWhenError');
+        default:
+            return messages.getMessage('IdUnavailableWhenInProgress');
+    }
+}
 async function queryForErrors(packageVersionCreateRequestId, connection) {
     const queryResult = await connection.tooling.query(`SELECT Message FROM Package2VersionCreateRequestError WHERE ParentRequest.Id = '${packageVersionCreateRequestId}'`);
     return queryResult.records ? queryResult.records.map((record) => record.Message) : [];
@@ -80,6 +95,10 @@ function constructWhere(options) {
     if (options?.status) {
         where.push(`Status = '${options.status.toLowerCase()}'`);
     }
+    // show only conversions
+    if (options?.showConversionsOnly) {
+        where.push('IsConversionRequest = true ');
+    }
     return where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
 }
 //# sourceMappingURL=packageVersionCreateRequest.js.map

package/lib/package/packageVersionList.js

@@ -34,11 +34,11 @@ const defaultFields = [
     'AncestorId',
     'ValidationSkipped',
     'CreatedById',
+    'ConvertedFromVersionId',
 ];
 const verboseFields = [
     'CodeCoverage',
     'HasPassedCodeCoverageCheck',
-    'ConvertedFromVersionId',
     'ReleaseVersion',
     'BuildDurationInSeconds',
     'HasMetadataRemoved',
@@ -107,6 +107,9 @@ function constructWhere(options) {
     if (options?.isReleased) {
         where.push('IsReleased = true');
     }
+    if (options?.showConversionsOnly) {
+        where.push('ConvertedFromVersionId != null');
+    }
     // exclude deleted
     where.push('IsDeprecated = false');
     return where;

package/lib/package/packageVersionReport.js

@@ -14,7 +14,7 @@ const core_1 = require("@salesforce/core");
 const pkgUtils = require("../utils/packageUtils");
 const QUERY = 'SELECT Package2Id, SubscriberPackageVersionId, Name, Description, Tag, Branch, AncestorId, ValidationSkipped, ' +
     'MajorVersion, MinorVersion, PatchVersion, BuildNumber, IsReleased, CodeCoverage, HasPassedCodeCoverageCheck, ' +
-    'Package2.IsOrgDependent, ReleaseVersion, BuildDurationInSeconds, HasMetadataRemoved, CreatedById ' +
+    'Package2.IsOrgDependent, ReleaseVersion, BuildDurationInSeconds, HasMetadataRemoved, CreatedById, ConvertedFromVersionId  ' +
     'FROM Package2Version ' +
     "WHERE Id = '%s' AND IsDeprecated != true " +
     'ORDER BY Package2Id, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber';

package/messages/package_version_create.md

@@ -194,3 +194,15 @@ The version number is required and was not found in the options or in package js
 # missingConnection
 
 A connection is required.
+
+# IdUnavailableWhenQueued
+
+Request is queued. ID unavailable.
+
+# IdUnavailableWhenInProgress
+
+Request is in progress. ID unavailable.
+
+# IdUnavailableWhenError
+
+ID Unavailable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/packaging",
-  "version": "2.2.9-profiles.0",
+  "version": "2.3.0",
   "description": "Packaging library for the Salesforce packaging platform",
   "main": "lib/exported",
   "types": "lib/exported.d.ts",
@@ -42,18 +42,21 @@
   ],
   "dependencies": {
     "@oclif/core": "^2.9.4",
-    "@salesforce/core": "^4.3.10",
-    "@salesforce/kit": "^3.0.5",
+    "@salesforce/core": "^4.3.2",
+    "@salesforce/kit": "^3.0.3",
     "@salesforce/schemas": "^1.6.0",
-    "@salesforce/source-deploy-retrieve": "^9.3.4",
+    "@salesforce/source-deploy-retrieve": "^8.6.0",
     "@salesforce/ts-types": "^2.0.3",
-    "fast-xml-parser": "^4.2.5",
+    "@xmldom/xmldom": "^0.8.9",
+    "debug": "^4.3.4",
     "globby": "^11",
     "graphology": "^0.25.1",
     "graphology-traversal": "^0.3.1",
     "graphology-types": "^0.24.7",
-    "jsforce": "^2.0.0-beta.27",
+    "js2xmlparser": "^4.0.2",
+    "jsforce": "^2.0.0-beta.23",
     "jszip": "^3.10.1",
+    "ts-retry-promise": "^0.7.0",
     "xml2js": "^0.6.0"
   },
   "devDependencies": {
@@ -61,20 +64,22 @@
     "@salesforce/dev-config": "^4.0.1",
     "@salesforce/dev-scripts": "^5.4.3",
     "@salesforce/prettier-config": "^0.0.3",
-    "@salesforce/ts-sinon": "^1.4.11",
+    "@salesforce/ts-sinon": "^1.4.12",
+    "@types/debug": "4.1.8",
     "@types/globby": "^9.1.0",
     "@types/jszip": "^3.4.1",
     "@types/xml2js": "^0.4.11",
     "@typescript-eslint/eslint-plugin": "^5.60.0",
     "@typescript-eslint/parser": "^5.61.0",
     "chai": "^4.3.7",
+    "commitizen": "^4.2.6",
     "eslint": "^8.44.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-config-salesforce": "^2.0.1",
     "eslint-config-salesforce-license": "^0.2.0",
     "eslint-config-salesforce-typescript": "^1.1.1",
     "eslint-plugin-header": "3.1.1",
-    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-import": "^2.28.0",
     "eslint-plugin-jsdoc": "^44.2.7",
     "eslint-plugin-sf-plugin": "^1.15.9",
     "husky": "^8.0.3",

package/lib/package/profileRewriter.d.ts

@@ -1,31 +0,0 @@
-import { Profile } from 'jsforce/api/metadata';
-import { PackageXml } from '../interfaces';
-type ProfileCustomSettingAccess = {
-    name: string;
-    enabled: boolean;
-};
-export type CorrectedProfile = Profile & {
-    customSettingAccesses: ProfileCustomSettingAccess[];
-};
-/**
- *
- * Takes a Profile that's been converted from package.xml to json.
- * Filters out all Profile props that are not
- * 1. used by packaging (ex: ipRanges)
- * 2. present in the package.xml (ex: ClassAccesses for a class not in the package)
- * 3. optionally retains the UserLicense prop only if the param is true
- *
- * @param profileJson json representation of a profile
- * @param packageXml package.xml as json
- * @param retainUserLicense boolean will preserve userLicense if true
- * @returns Profile
- */
-export declare const profileRewriter: (profileJson: CorrectedProfile, packageXml: PackageMap, retainUserLicense?: boolean) => CorrectedProfile;
-export declare const fieldCorrections: (fieldName: string) => string;
-export declare const profileStringToProfile: (profileString: string) => CorrectedProfile;
-/** pass in an object that has the Profile props at the top level.  This function will add the outer wrapper `Profile` */
-export declare const profileObjectToString: (profileObject: Partial<CorrectedProfile>) => string;
-/** it's easier to do lookups by Metadata Type on a Map */
-export declare const manifestTypesToMap: (original: PackageXml['Package']['types']) => PackageMap;
-type PackageMap = Map<string, string[]>;
-export {};

package/lib/package/profileRewriter.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.manifestTypesToMap = exports.profileObjectToString = exports.profileStringToProfile = exports.fieldCorrections = exports.profileRewriter = void 0;
-const fast_xml_parser_1 = require("fast-xml-parser");
-/**
- *
- * Takes a Profile that's been converted from package.xml to json.
- * Filters out all Profile props that are not
- * 1. used by packaging (ex: ipRanges)
- * 2. present in the package.xml (ex: ClassAccesses for a class not in the package)
- * 3. optionally retains the UserLicense prop only if the param is true
- *
- * @param profileJson json representation of a profile
- * @param packageXml package.xml as json
- * @param retainUserLicense boolean will preserve userLicense if true
- * @returns Profile
- */
-const profileRewriter = (profileJson, packageXml, retainUserLicense = false) => ({
-    ...Object.fromEntries(Object.entries(profileJson)
-        // remove settings that are not used for packaging
-        .filter(isRewriteProp)
-        // @ts-expect-error the previous filter restricts us to only things that appear in filterFunctions
-        .map(([key, value]) => [key, filterFunctions[key]?.(value, packageXml)] ?? [])
-        // some profileSettings might now be empty Arrays if the package.xml didn't have those types, so remove the entire property
-        .filter(([, value]) => (Array.isArray(value) ? value.length : true))),
-    // this one prop is controlled by a param.  Put it back the way it was if the param is true
-    ...(retainUserLicense && profileJson.userLicense ? { userLicense: profileJson.userLicense } : {}),
-});
-exports.profileRewriter = profileRewriter;
-// it's both a filter and a typeguard to make sure props are represented in filterFunctions
-const isRewriteProp = (prop) => rewriteProps.includes(prop[0]);
-const rewriteProps = [
-    'objectPermissions',
-    'fieldPermissions',
-    'layoutAssignments',
-    'applicationVisibilities',
-    'classAccesses',
-    'externalDataSourceAccesses',
-    'tabVisibilities',
-    'pageAccesses',
-    'customPermissions',
-    'customMetadataTypeAccesses',
-    'customSettingAccesses',
-    'recordTypeVisibilities',
-];
-const filterFunctions = {
-    objectPermissions: (props, packageXml) => props.filter((item) => packageXml.get('CustomObject')?.includes(item.object)),
-    fieldPermissions: (props, packageXml) => props.filter((item) => packageXml.get('CustomField')?.includes((0, exports.fieldCorrections)(item.field))),
-    layoutAssignments: (props, packageXml) => props.filter((item) => packageXml.get('Layout')?.includes(item.layout)),
-    tabVisibilities: (props, packageXml) => props.filter((item) => packageXml.get('CustomTab')?.includes(item.tab)),
-    applicationVisibilities: (props, packageXml) => props.filter((item) => packageXml.get('Application')?.includes(item.application)),
-    classAccesses: (props, packageXml) => props.filter((item) => packageXml.get('ApexClass')?.includes(item.apexClass)),
-    customPermissions: (props, packageXml) => props.filter((item) => packageXml.get('CustomPermission')?.includes(item.name)),
-    pageAccesses: (props, packageXml) => props.filter((item) => packageXml.get('ApexPage')?.includes(item.apexPage)),
-    externalDataSourceAccesses: (props, packageXml) => props.filter((item) => packageXml.get('ExternalDataSource')?.includes(item.externalDataSource)),
-    recordTypeVisibilities: (props, packageXml) => props.filter((item) => packageXml.get('RecordType')?.includes(item.recordType)),
-    customSettingAccesses: (props, packageXml) => props.filter((item) => allMembers(packageXml).includes(item.name)),
-    customMetadataTypeAccesses: (props, packageXml) => props.filter((item) => allMembers(packageXml).includes(item.name)),
-};
-const allMembers = (packageXml) => Array.from(packageXml.values()).flat();
-// github.com/forcedotcom/cli/issues/2278
-// Activity Object is polymorphic (Task and Event)
-// package.xml will display them as 'Activity'
-// profile.fieldPermissions will display them with the more specific 'Task' or 'Event'
-const fieldCorrections = (fieldName) => fieldName.replace(/^Event\./, 'Activity.').replace(/^Task\./, 'Activity.');
-exports.fieldCorrections = fieldCorrections;
-const profileStringToProfile = (profileString) => {
-    const parser = new fast_xml_parser_1.XMLParser({
-        ignoreAttributes: false,
-        parseTagValue: false,
-        parseAttributeValue: false,
-        cdataPropName: '__cdata',
-        ignoreDeclaration: true,
-        numberParseOptions: { leadingZeros: false, hex: false },
-    });
-    return parser.parse(profileString);
-};
-exports.profileStringToProfile = profileStringToProfile;
-/** pass in an object that has the Profile props at the top level.  This function will add the outer wrapper `Profile` */
-const profileObjectToString = (profileObject) => {
-    const builder = new fast_xml_parser_1.XMLBuilder({
-        format: true,
-        indentBy: '    ',
-        ignoreAttributes: false,
-        cdataPropName: '__cdata',
-        processEntities: false,
-        attributeNamePrefix: '@@@',
-    });
-    return String(builder.build({
-        '?xml': {
-            '@@@version': '1.0',
-            '@@@encoding': 'UTF-8',
-        },
-        Profile: { ...profileObject, '@@@xmlns': 'http://soap.sforce.com/2006/04/metadata' },
-    }));
-};
-exports.profileObjectToString = profileObjectToString;
-/** it's easier to do lookups by Metadata Type on a Map */
-const manifestTypesToMap = (original) => new Map(original.map((item) => [item.name, item.members]));
-exports.manifestTypesToMap = manifestTypesToMap;
-//# sourceMappingURL=profileRewriter.js.map