@salesforce/packaging 0.0.4 → 0.0.7

package/lib/package/packageProfileApi.js

@@ -0,0 +1,278 @@
+"use strict";
+/*
+ * 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_sfdx_encoding_1 = require("xmldom-sfdx-encoding");
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+core_1.Messages.importMessagesDirectory(__dirname);
+// TODO: need to transfer these messages
+const profileApiMessages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+/*
+ * 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
+ * that is relevant to the source in the package directory being packaged.
+ */
+class PackageProfileApi extends kit_1.AsyncCreatable {
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.profiles = [];
+        this.generateProfileInformation = false;
+    }
+    async init() {
+        this.project = this.options.project;
+        this.includeUserLicenses = this.options.includeUserLicenses;
+        this.generateProfileInformation = this.options.generateProfileInformation;
+        this.config = await core_1.ConfigAggregator.create();
+        this.apiVersion = this.config.getPropertyValue('apiVersion');
+        // 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
+        this.nodeEntities = {
+            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.
+        this.otherProfileSettings = {
+            name: ['CustomSettings', 'CustomMetadataTypeAccess'],
+            parentElement: ['customSettingAccesses', 'customMetadataTypeAccesses'],
+            childElement: ['name', 'name'],
+        };
+    }
+    /**
+     * For any profile present in the workspace, this function generates a subset of data that only contains references
+     * to items in the manifest.
+     *
+     * @param destPath location of new profiles
+     * @param manifest
+     * @param excludedDirectories Directories to not include profiles from
+     */
+    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 profileName = profilePath.match(/([^/]+)\.profile-meta.xml/)[1];
+            const profileDom = new xmldom_sfdx_encoding_1.DOMParser().parseFromString(fs.readFileSync(profilePath, 'utf-8'));
+            const newDom = new xmldom_sfdx_encoding_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.types.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 === true) {
+                const userLicenses = profileDom.getElementsByTagName('userLicense');
+                if (userLicenses) {
+                    hasNodes = true;
+                    for (const userLicense of 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_sfdx_encoding_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 worskpace but not in the directory being packaged.
+                    if (err.code !== 'ENOENT') {
+                        throw err;
+                    }
+                }
+            }
+        });
+        return excludedProfiles;
+    }
+    /**
+     * 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, excludedDirectories = []) {
+        const profilePaths = this.findAllProfiles(excludedDirectories);
+        // Filter all profiles
+        typesArr = 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 profileName = profilePath.match(/([^/]+)\.profile-meta.xml/)[1];
+                members.push(profileName);
+                if (this.generateProfileInformation) {
+                    this.profiles.push(new ProfileInformation(profileName, profilePath, true, []));
+                }
+            });
+            if (members.length > 0) {
+                typesArr.push({ name: ['Profile'], members });
+            }
+        }
+        return typesArr;
+    }
+    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 (members.indexOf(name) >= 0) {
+                // 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 {
+                // Tell the user which profile setting has been removed from the package
+                if (this.generateProfileInformation) {
+                    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}/**`),
+        });
+    }
+}
+exports.PackageProfileApi = PackageProfileApi;
+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);
+    }
+    logDebug() {
+        let info = profileApiMessages.getMessage('profile_api.addProfileToPackage', [this.ProfileName, this.ProfilePath]);
+        this.settingsRemoved.forEach((setting) => {
+            info += '\n\t' + profileApiMessages.getMessage('profile_api.removeProfileSetting', [setting, this.ProfileName]);
+        });
+        if (!this.IsPackaged) {
+            info += '\n\t' + profileApiMessages.getMessage('profile_api.removeProfile', [this.ProfileName]);
+        }
+        info += '\n';
+        return info;
+    }
+    logInfo() {
+        if (this.IsPackaged) {
+            return profileApiMessages.getMessage('profile_api.addProfileToPackage', [this.ProfileName, this.ProfilePath]);
+        }
+        else {
+            return profileApiMessages.getMessage('profile_api.profileNotIncluded', [this.ProfileName]);
+        }
+    }
+}
+//# sourceMappingURL=packageProfileApi.js.map

package/lib/package/packageVersion.d.ts

@@ -0,0 +1,25 @@
+import { PackageVersionCreateRequestResult, PackageSaveResult, PackageVersionCreateOptions, PackageVersionOptions } from '../interfaces';
+export declare class PackageVersion {
+    private options;
+    private readonly project;
+    private readonly connection;
+    constructor(options: PackageVersionOptions);
+    /**
+     * Creates a new package version.
+     *
+     * @param options
+     */
+    create(options: PackageVersionCreateOptions): Promise<Partial<PackageVersionCreateRequestResult>>;
+    /**
+     * Deletes a package version.
+     *
+     * @param idOrAlias
+     * @param undelete
+     */
+    delete(idOrAlias: string, undelete?: boolean): Promise<PackageSaveResult>;
+    convert(): Promise<void>;
+    install(): Promise<void>;
+    list(): Promise<void>;
+    uninstall(): Promise<void>;
+    update(): Promise<void>;
+}

package/lib/package/packageVersion.js

@@ -0,0 +1,73 @@
+"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.PackageVersion = void 0;
+const core_1 = require("@salesforce/core");
+const pkgUtils = require("../utils/packageUtils");
+const utils_1 = require("../utils");
+const packageVersionCreate_1 = require("./packageVersionCreate");
+core_1.Messages.importMessagesDirectory(__dirname);
+// const messages = Messages.loadMessages('@salesforce/packaging', 'messages');
+// const logger = Logger.childFromRoot('packageVersionCreate');
+class PackageVersion {
+    constructor(options) {
+        this.options = options;
+        this.connection = this.options.connection;
+        this.project = this.options.project;
+    }
+    /**
+     * Creates a new package version.
+     *
+     * @param options
+     */
+    async create(options) {
+        const pvc = new packageVersionCreate_1.PackageVersionCreate({ ...options, ...this.options });
+        return pvc.createPackageVersion();
+    }
+    /**
+     * Deletes a package version.
+     *
+     * @param idOrAlias
+     * @param undelete
+     */
+    async delete(idOrAlias, undelete = false) {
+        const packageVersionId = pkgUtils.getPackageIdFromAlias(idOrAlias, this.project);
+        // ID can be an 04t or 05i
+        pkgUtils.validateId([pkgUtils.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID, pkgUtils.BY_LABEL.PACKAGE_VERSION_ID], packageVersionId);
+        // lookup the 05i ID, if needed
+        const packageId = await pkgUtils.getPackageVersionId(packageVersionId, this.connection);
+        // setup the request
+        const request = {
+            Id: packageId,
+            IsDeprecated: !undelete,
+        };
+        const updateResult = await this.connection.tooling.update('Package2Version', request);
+        if (!updateResult.success) {
+            throw (0, utils_1.combineSaveErrors)('Package2', 'update', updateResult.errors);
+        }
+        updateResult.id = await pkgUtils.getSubscriberPackageVersionId(packageVersionId, this.connection);
+        return updateResult;
+    }
+    convert() {
+        return Promise.resolve(undefined);
+    }
+    install() {
+        return Promise.resolve(undefined);
+    }
+    list() {
+        return Promise.resolve(undefined);
+    }
+    uninstall() {
+        return Promise.resolve(undefined);
+    }
+    update() {
+        return Promise.resolve(undefined);
+    }
+}
+exports.PackageVersion = PackageVersion;
+//# sourceMappingURL=packageVersion.js.map

package/lib/package/packageVersionCreate.d.ts

@@ -0,0 +1,68 @@
+import { Connection } from '@salesforce/core';
+import { PackageVersionCreateRequestResult, PackageVersionCreateOptions } from '../interfaces';
+export declare class PackageVersionCreate {
+    private options;
+    private apiVersionFromPackageXml;
+    private readonly project;
+    private readonly connection;
+    constructor(options: PackageVersionCreateOptions);
+    createPackageVersion(): Promise<Partial<PackageVersionCreateRequestResult>>;
+    listRequest(createdlastdays?: number, status?: string): Promise<PackageVersionCreateRequestResult[]>;
+    listRequestById(id: string, connection: Connection): Promise<PackageVersionCreateRequestResult[]>;
+    private generateMDFolderForArtifact;
+    private validateDependencyValues;
+    /**
+     *  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.
+     */
+    private retrieveSubscriberPackageVersionId;
+    private resolveBuildNumber;
+    private createRequestObject;
+    private getPackageDescriptorJsonFromPackageId;
+    /**
+     * 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
+     */
+    private createPackageVersionCreateRequestFromOptions;
+    private resolveApexTestPermissions;
+    private resolveUnpackagedMetadata;
+    private getPackagePropertyFromPackage;
+    private getPackageValuePropertyFromDirectory;
+    /**
+     * 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
+     */
+    private getConfigPackageDirectoriesValue;
+    private packageVersionCreate;
+    private resolveCanonicalPackageProperty;
+    private validateVersionNumber;
+    private resolveUserLicenses;
+    private resolveOrgDependentPollingTime;
+    private validateFlagsForPackageType;
+    /**
+     * Cleans invalid attribute(s) from the packageDescriptorJSON
+     */
+    private cleanPackageDescriptorJson;
+    /**
+     * Sets default or override values for packageDescriptorJSON attribs
+     */
+    private setPackageDescriptorJsonValues;
+}