@ds-sfdc/sfparty 0.0.0

package/lib/permset/combine.js

@@ -0,0 +1,286 @@
+import path from 'path'
+import os from 'os'
+import { readFileSync, writeFileSync, utimesSync } from 'fs'
+import logUpdate from 'log-update'
+import chalk from 'chalk'
+import convertHrtime from 'convert-hrtime'
+import cliSpinners from 'cli-spinners'
+import * as fileUtils from '../fileUtils.js'
+import { permsetDefinition } from './definition.js'
+import * as xml2js from 'xml2js'
+import * as yaml from 'js-yaml'
+
+const spinner = cliSpinners['dots']
+
+export class Permset {
+    #xml = ''
+    #types = []
+    #spinnerMessage = ''
+    #index = 0
+    #startTime = 0
+    #fileName = ''
+    #errorMessage = ''
+    #fileStats
+
+    constructor(config) {
+        this.sourceDir = config.sourceDir
+        this.targetDir = config.targetDir
+        this.metaDir = config.metaDir
+        this.sequence = config.sequence
+    }
+
+    combine() {
+        return new Promise((resolve, reject) => {
+            const that = this
+            if (!fileUtils.directoryExists(path.join(that.sourceDir, that.metaDir))) reject(that.metaDir)
+
+            that.metaDir = fileUtils.getDirectories(that.sourceDir).find(element => element.toLowerCase() == that.metaDir.toLowerCase())
+
+            that.#xml = `<?xml version="1.0" encoding="UTF-8"?>${os.EOL}`
+            that.#xml += `<PermissionSet xmlns="https://soap.sforce.com/2006/04/metadata">${os.EOL}`
+
+            permsetDefinition.main.forEach(key => { that.#types.push(key) })
+            permsetDefinition.singleFiles.forEach(key => { that.#types.push(key) })
+            permsetDefinition.directories.forEach(key => { that.#types.push(key) })
+            that.#types.sort()
+
+            setFileName(that)
+            processPermSet(that)
+
+            saveXML(that)
+            resolve(that.metaDir)
+        })
+
+        function setFileName(that) {
+            const fileName = path.join(that.sourceDir, that.metaDir, `main.${global.format}`)
+            if (fileUtils.fileExists(fileName)) {
+                const data = readFileSync(fileName, { encoding: 'utf8', flag: 'r' })
+                const result = (global.format == 'yaml') ? yaml.load(data) : JSON.parse(data)
+                that.#fileStats = fileUtils.fileInfo(fileName).stats
+                that.#fileName = path.join(that.targetDir, result.name + '.permissionset-meta.xml')
+            }
+        }
+
+        function processPermSet(that) {
+            that.#startTime = process.hrtime.bigint()
+            that.#spinnerMessage = `[%1] of ${global.processed.total} - Permission Set: [%4]${chalk.yellowBright(that.metaDir)}[%2][%3]`
+            logUpdate(that.#spinnerMessage
+                .replace('[%1]', that.sequence.toString().padStart(global.processed.total.toString().length, ' '))
+                .replace('[%2]', '')
+                .replace('[%3]', '')
+                .replace('[%4]', '')
+            )
+
+            that.#types.forEach(key => {
+                let myLocation
+                if (permsetDefinition.main.includes(key)) {
+                    myLocation = 'main'
+                } else if (permsetDefinition.directories.includes(key)) {
+                    myLocation = 'directory'
+                } else if (permsetDefinition.singleFiles.includes(key)) {
+                    myLocation = 'file'
+                }
+                logUpdate(that.#spinnerMessage
+                    .replace('[%1]', that.sequence.toString().padStart(global.processed.total.toString().length, ' '))
+                    .replace('[%2]', `\n${chalk.magentaBright(nextFrame(that))} ${key}`)
+                    .replace('[%3]', `${that.#errorMessage}`)
+                    .replace('[%4]', `${global.statusLevel.working} `)
+                )
+
+                switch (myLocation) {
+                    case 'main':
+                        processMain(that, key)
+                        break
+                    case 'file':
+                        processFile(that, key)
+                        break
+                    case 'directory':
+                        processDirectory(that, key)
+                        break
+                }
+            })
+        }
+
+        function processMain(that, key) {
+            const fileName = path.join(that.sourceDir, that.metaDir, `main.${global.format}`)
+            if (fileUtils.fileExists(fileName)) {
+                const data = readFileSync(fileName, { encoding: 'utf8', flag: 'r' })
+                const result = (global.format == 'yaml') ? yaml.load(data) : JSON.parse(data)
+                if (result[key] !== undefined) that.#xml += `\t<${key}>${result[key]}</${key}>${os.EOL}`
+            }
+        }
+
+        function processFile(that, key) {
+            const fileName = path.join(that.sourceDir, that.metaDir, `${key}.${global.format}`)
+            if (fileUtils.fileExists(fileName)) {
+                if (permsetDefinition.singleFiles.includes(key)) {
+                    genericXML(that, key)
+                } else {
+                    that.#errorMessage += `\n${global.statusLevel.warn} Not processed: ${key}`
+                }
+            }
+        }
+
+        function processDirectory(that, key) {
+            switch (key) {
+                case 'objectPermissions':
+                    objectPermissions(that, key)
+                    break
+                default:
+                    if (permsetDefinition.directories.includes(key)) {
+                        genericDirectoryXML(that, key)
+                        break
+                    } else {
+                        that.#errorMessage += `\n${global.statusLevel.warn} Not processed: ${key}`
+                    }
+            }
+
+        }
+
+        function getTimeDiff(startTime, endTime = process.hrtime.bigint()) {
+            const diff = BigInt(endTime) - BigInt(startTime)
+            let executionTime = convertHrtime(diff)
+            executionTime.seconds = Math.round(executionTime.seconds)
+            executionTime.milliseconds = Math.round(executionTime.milliseconds / 1000)
+            if (executionTime.milliseconds == 0 && executionTime.nanoseconds > 0) executionTime.milliseconds = 1
+            return executionTime
+        }
+
+        function saveXML(that) {
+            fileUtils.createDirectory(that.targetDir)
+            that.#xml += '</PermissionSet>\n'
+            writeFileSync(that.#fileName, that.#xml)
+            utimesSync(that.#fileName, that.#fileStats.atime, that.#fileStats.mtime)
+
+            let executionTime = getTimeDiff(BigInt(that.#startTime))
+            let durationMessage = `${executionTime.seconds}.${executionTime.milliseconds}s`
+            let stateIcon = (that.#errorMessage == '') ? global.statusLevel.success : global.statusLevel.fail
+            logUpdate(that.#spinnerMessage
+                .replace('[%1]', that.sequence.toString().padStart(global.processed.total.toString().length, ' '))
+                .replace('[%2]', `. Processed in ${durationMessage}.`)
+                .replace('[%3]', `${that.#errorMessage}`)
+                .replace('[%4]', `${stateIcon} `)
+            )
+            logUpdate.done()
+
+        }
+
+        function nextFrame(that) {
+            return spinner.frames[that.#index = ++that.#index % spinner.frames.length]
+        }
+
+        function genericXML(that, key) {
+            const fileName = path.join(that.sourceDir, that.metaDir, `${key}.${global.format}`)
+            const builder = new xml2js.Builder({ cdata: false, headless: true, rootName: key })
+
+            if (fileUtils.fileExists(fileName)) {
+                const data = readFileSync(fileName, { encoding: 'utf8', flag: 'r' })
+                const result = (global.format == 'yaml') ? yaml.load(data) : JSON.parse(data)
+                result[key] = sortJSONKeys(sortJSON(result[key], permsetDefinition.sortKeys[key]))
+                result[key].forEach(element => {
+                    that.#xml += `\t<${key}>${os.EOL}`
+                    Object.keys(element).forEach(tag => {
+                        let xml
+                        try {
+                            xml = builder.buildObject(element[tag]).replace(`<${key}>`, '').replace(`</${key}>`, '')
+                            that.#xml += `\t\t<${tag}>${xml}</${tag}>${os.EOL}`                           
+                        } catch (error) {
+                            global.logger.error(error)
+                        }
+                    })
+                    that.#xml += `\t</${key}>${os.EOL}`
+                })
+            }
+        }
+
+        function genericDirectoryXML(that, key) {
+            let dirPath = path.join(that.sourceDir, that.metaDir, key)
+            if (!fileUtils.directoryExists(dirPath)) return
+
+            let fileList = fileUtils.getFiles(dirPath, `.${global.format}`).sort()
+            fileList.forEach(fileName => {
+                const data = readFileSync(path.join(dirPath, fileName), { encoding: 'utf8', flag: 'r' })
+                const result = (global.format == 'yaml') ? yaml.load(data) : JSON.parse(data)
+                const object = result.object
+                result[key] = sortJSONKeys(sortJSON(result[key], permsetDefinition.sortKeys[key]))
+                result[key].forEach(element => {
+                    that.#xml += `\t<${key}>${os.EOL}`
+                    Object.keys(element).forEach(tag => {
+                        if (tag == permsetDefinition.sortKeys[key] && object) {
+                            that.#xml += `\t\t<${tag}>${object}.${element[tag]}</${tag}>${os.EOL}`
+                        } else {
+                            that.#xml += `\t\t<${tag}>${element[tag]}</${tag}>${os.EOL}`
+                        }
+                    })
+                    that.#xml += `\t</${key}>${os.EOL}`
+                })
+            })
+        }
+
+        function objectPermissions(that, key) {
+            let dirPath = path.join(that.sourceDir, that.metaDir, key)
+            if (!fileUtils.directoryExists(dirPath)) return
+
+            let fileList = fileUtils.getFiles(dirPath, `.${global.format}`).sort((a, b) => a.localeCompare(b))
+            fileList.forEach(fileName => {
+                const data = readFileSync(path.join(dirPath, fileName), { encoding: 'utf8', flag: 'r' })
+                const result = (global.format == 'yaml') ? yaml.load(data) : JSON.parse(data)
+                result[key]['object'] = result.object
+                result[key] = sortJSONKeys(result[key])
+                that.#xml += `\t<${key}>${os.EOL}`
+                Object.keys(result[key]).forEach(element => {
+                    that.#xml += `\t\t<${element}>${result[key][element]}</${element}>${os.EOL}`
+                })
+                that.#xml += `\t</${key}>${os.EOL}`
+            })
+        }
+        // end of functions
+        // end of combine
+    }
+
+    // end of class
+}
+
+function sortJSON(json, key) {
+    if (Array.isArray(json)) {
+        json.sort((a, b) => {
+            if (a[key] < b[key]) return -1
+            if (a[key] > b[key]) return 1
+            return 0
+        })
+    }
+    return json
+}
+
+function sortJSONKeys(json) {
+    // sort json keys alphabetically
+    if (Array.isArray(json)) {
+        json.forEach(function (part, index) {
+            this[index] = Object.keys(this[index])
+                .sort((a, b) => {
+                    if (a < b) return -1
+                    if (a > b) return 1
+                    return 0
+                })
+                .reduce((accumulator, key) => {
+                    accumulator[key] = this[index][key]
+
+                    return accumulator
+                }, {})
+        }, json)
+
+    } else {
+        json = Object.keys(json)
+            .sort((a, b) => {
+                if (a < b) return -1
+                if (a > b) return 1
+                return 0
+            })
+            .reduce((accumulator, key) => {
+                accumulator[key] = json[key]
+
+                return accumulator
+            }, {})
+    }
+    return json
+}

package/lib/permset/definition.js

@@ -0,0 +1,74 @@
+export const permsetDefinition = {
+    metaUrl: 'https://developer.salesforce.com/docs/atlas.en-us.api_meta.meta/api_meta/meta_permissionset.htm',
+    main: [
+        'label',
+        'description',
+        'custom',
+        'hasActivationRequired',
+        'license',
+        'userLicense', // Replaced by license 
+    ],
+    singleFiles: [
+        'applicationVisibilities',
+        // 'categoryGroupVisibilities', // PROFILE ONLY
+        'classAccesses',
+        'customMetadataTypeAccesses',
+        'customPermissions',
+        'customSettingAccesses',
+        'externalDataSourceAccesses',
+        'flowAccesses',
+        // 'layoutAssignments', // PROFILE ONLY
+        // 'loginHours', // PROFILE ONLY
+        // 'loginIpRanges', // PROFILE ONLY
+        'pageAccesses',
+        // 'profileActionOverrides', // PROFILE ONLY
+        'tabSettings',
+        // 'tabVisibilities', // PROFILE ONLY
+        'userPermissions',
+    ],
+    directories: [
+        'fieldPermissions',
+        // 'loginFlows', // PROFILE ONLY
+        'objectPermissions',
+        'recordTypeVisibilities',
+    ],
+    ignore: [
+        '$',
+    ],
+    sortKeys: {
+        'applicationVisibilities': 'application',
+        // 'categoryGroupVisibilities': 'dataCategoryGroup', // PROFILE ONLY
+        'classAccesses': 'apexClass',
+        'customMetadataTypeAccesses': 'name',
+        'customPermissions': 'name',
+        'customSettingAccesses': 'name',
+        'externalDataSourceAccesses': 'externalDataSource',
+        'fieldPermissions': 'field',
+        'flowAccesses': 'flow',
+        // 'layoutAssignments': 'layout', // PROFILE ONLY
+        // 'loginFlows': 'friendlyName', // PROFILE ONLY
+        // 'loginIpRanges': 'startAddress', // PROFILE ONLY
+        'objectPermissions': 'object',
+        'pageAccesses': 'apexPage',
+        // 'profileActionOverrides': 'pageOrSobjectType', // PROFILE ONLY
+        'recordTypeVisibilities': 'recordType',
+        'tabSettings': 'tab',
+        // 'tabVisibilities': 'tab', // PROFILE ONLY
+        'userPermissions': 'name',        
+    },
+    keyOrder: {
+        applicationVisibilities: ['application', 'visible'],
+        classAccesses: ['apexClass', 'enabled'],
+        customMetadataTypeAccesses: ['name', 'enabled'],
+        customPermissions: ['name', 'enabled'],
+        customSettingAccesses: ['name', 'enabled'],
+        externalDataSourceAccesses: ['externalDataSource', 'enabled'],
+        fieldPermissions: ['field', 'editable', 'readable'],
+        flowAccesses: ['flow', 'enabled'],
+        objectPermissions: ['object', 'allowCreate', 'allowRead', 'allowEdit', 'allowDelete', 'viewAllRecords', 'modifyAllRecords'],
+        pageAccesses: ['apexPage', 'enabled'],
+        recordTypeVisibilities: ['recordType', 'visible'],
+        tabSettings: ['tab', 'visibility'],
+        userPermissions: ['name', 'enabled'],
+    },
+}

package/lib/permset/split.js

@@ -0,0 +1,287 @@
+'use strict'
+
+import path from 'path'
+import fs from 'fs'
+import os from 'os'
+import { readFile } from 'fs'
+import { Parser } from 'xml2js'
+import logUpdate from 'log-update'
+import chalk from 'chalk'
+import convertHrtime from 'convert-hrtime'
+import cliSpinners from 'cli-spinners'
+import * as yaml from 'js-yaml'
+import * as fileUtils from '../fileUtils.js'
+import { permsetDefinition } from './definition.js'
+
+const spinner = cliSpinners['dots']
+
+export class Permset {
+    #fileName = {
+        'fullName': undefined,
+        'shortName': undefined,
+    }
+    #json
+    #errorMessage = ''
+    #index = 0
+    #startTime = 0
+    #spinnerMessage = ''
+
+    constructor(config) {
+        this.sourceDir = config.sourceDir
+        this.targetDir = config.targetDir
+        this.metaFilePath = config.metaFilePath
+        this.sequence = config.sequence
+    }
+
+    get metaFilePath() {
+        return this._metaFilePath
+    }
+
+    set metaFilePath(value) {
+        value = value.trim()
+        if (value === '') {
+            throw 'The file path cannot be empty'
+        }
+        this._metaFilePath = value
+        this.#fileName.fullName = fileUtils.fileInfo(value).filename
+        this.#fileName.shortName = fileUtils.fileInfo(value).filename.replace('.permissionset-meta.xml', '')
+    }
+
+    split() {
+        const that = this
+        return new Promise((resolve, reject) => {
+
+            if (!that.#fileName || !that.sourceDir || !that.targetDir || !that.metaFilePath) {
+                global.logger.error('Invalid information passed to split')
+                process.exit(1)
+            }
+            if (!fileUtils.fileExists(that.metaFilePath)) {
+                global.logger.error(`file not found: ${that.metaFilePath}`)
+                process.exit(1)
+            }
+
+            that.targetDir = path.join(that.targetDir, that.#fileName.shortName)
+            let parser = new Parser()
+            const getJSON = new Promise((resolve, reject) => {
+                readFile(that.metaFilePath, function (err, data) {
+                    parser.parseString(data, function (err, result) {
+                        if (result) {
+                            resolve(result)
+                        } else {
+                            global.logger.error(`error converting xml to json: ${that.metaFilePath}`)
+                            process.exit(1)
+                        }
+                    })
+                })
+            })
+            getJSON.then((result) => {
+                // modify the json to remove unwanted arrays
+                delete result.PermissionSet['$']
+                let jsonString = JSON.stringify(result, (name, value) => {
+                    if (name == '' || !isNaN(name) || permsetDefinition.directories.includes(name) || permsetDefinition.singleFiles.includes(name)) {
+                        return value
+                    } else {
+                        return xml2json(value)
+                    }
+                })
+                that.#json = JSON.parse(jsonString)
+
+                Object.keys(that.#json.PermissionSet).forEach(key => {
+                    const keyOrder = permsetDefinition.keyOrder[key]
+                    const sortKey = permsetDefinition.sortKeys[key]
+
+                    if (Array.isArray(that.#json.PermissionSet[key])) {
+                        // sort json to order by sortKey
+                        that.#json.PermissionSet[key].sort((a, b) => {
+                            if (a[sortKey] < b[sortKey]) {
+                                return -1;
+                            }
+                            if (a[sortKey] > b[sortKey]) {
+                                return 1;
+                            }
+                            return 0;
+                        })
+
+                        // sort json keys in specified order
+                        that.#json.PermissionSet[key].forEach(function (part, index) {
+                            this[index] = Object.keys(this[index])
+                                .sort((a, b) => {
+                                    if (keyOrder.indexOf(a) < keyOrder.indexOf(b)) return -1
+                                    if (keyOrder.indexOf(a) > keyOrder.indexOf(b)) return 1
+                                    return 0
+                                })
+                                .reduce((accumulator, key) => {
+                                    accumulator[key] = this[index][key]
+                                    return accumulator
+                                }, {})
+                        }, that.#json.PermissionSet[key])
+                    }
+                })
+
+                processFile(that)
+                completeFile(that)
+                resolve(true)
+            })
+        })
+
+        function nextFrame(that) {
+            return spinner.frames[that.#index = ++that.#index % spinner.frames.length]
+        }
+
+        function completeFile(that) {
+            let executionTime = getTimeDiff(BigInt(that.#startTime))
+            let durationMessage = `${executionTime.seconds}.${executionTime.milliseconds}s`
+            let stateIcon = (that.#errorMessage == '') ? global.statusLevel.success : global.statusLevel.fail
+            logUpdate(that.#spinnerMessage
+                .replace('[%1]', that.sequence.toString().padStart(global.processed.total.toString().length, ' '))
+                .replace('[%2]', `. Processed in ${durationMessage}.`)
+                .replace('[%3]', `${that.#errorMessage}`)
+                .replace('[%4]', `${stateIcon} `)
+            )
+            logUpdate.done()
+        }
+
+        function processFile(that) {
+            that.#startTime = process.hrtime.bigint()
+            that.#spinnerMessage = `[%1] of ${global.processed.total} - Permission Set: [%4]${chalk.yellowBright(that.#fileName.shortName)}[%2][%3]`
+
+            fileUtils.deleteDirectory(that.targetDir, true) // recursive delete existing directory
+            fileUtils.createDirectory(that.targetDir) // create directory
+
+            Main(that)
+
+            Object.keys(that.#json.PermissionSet).forEach(key => {
+                that.sequence = global.processed.current
+                logUpdate(that.#spinnerMessage
+                    .replace('[%1]', that.sequence.toString().padStart(global.processed.total.toString().length, ' '))
+                    .replace('[%2]', `\n${chalk.magentaBright(nextFrame(that))} ${key}`)
+                    .replace('[%3]', `${that.#errorMessage}`)
+                    .replace('[%4]', `${global.statusLevel.working} `)
+                )
+                if (permsetDefinition.directories.includes(key)) {
+                    processDirectory(that, key)
+                } else if (permsetDefinition.singleFiles.includes(key)) {
+                    singleFile(that, key)
+                } else {
+                    if (!permsetDefinition.ignore.includes(key) && !permsetDefinition.main.includes(key)) {
+                        that.#errorMessage += `\n${global.statusLevel.warn} Not processed: ${key}`
+                    }
+                }
+            })
+
+            return true
+        }
+
+        function Main(that) {
+            let fileName = path.join(that.targetDir, `main.${global.format}`)
+            let mainInfo = {}
+            mainInfo.name = that.#fileName.shortName
+            permsetDefinition.main.forEach(key => {
+                if (that.#json.PermissionSet[key] !== undefined) {
+                    mainInfo[key] = that.#json.PermissionSet[key]
+                }
+            })
+
+            let jsonString = JSON.stringify(mainInfo, null, '\t')
+            switch (global.format) {
+                case 'json':
+                    fs.writeFileSync(fileName, jsonString)
+                    break
+                case 'yaml':
+                    let doc = yaml.dump(JSON.parse(jsonString))
+                    fs.writeFileSync(fileName, doc)
+            }
+        }
+
+        function processDirectory(that, key) {
+            const objects = {}
+            const myKey = permsetDefinition.sortKeys[key]
+            const hasObject = that.#json.PermissionSet[key][0][myKey].split('.').length == 2
+            fileUtils.createDirectory(path.join(that.targetDir, key)) // create directory
+
+            // populate objects with data per object
+            if (hasObject) {
+                that.#json.PermissionSet[key].forEach(element => {
+                    let [object] = element[myKey].toString().split('.')
+                    if (objects[object] === undefined) {
+                        objects[object] = {
+                            object: object
+                        }
+                    }
+                    if (objects[object][key] === undefined) {
+                        objects[object][key] = []
+                    }
+                    element[myKey] = element[myKey].replace(`${object}.`, '')
+                    objects[object][key].push(element)
+                })
+            } else {
+                that.#json.PermissionSet[key].forEach(element => {
+                    let object = element[myKey]
+                    if (objects[object] === undefined) {
+                        objects[object] = {
+                            object: object
+                        }
+                    }
+                    if (objects[object][key] === undefined) {
+                        objects[object][key] = {}
+                    }
+                    delete element[myKey]
+
+                    Object.keys(element).forEach(elemKey => {
+                        objects[object][key][elemKey] = element[elemKey]
+                    })
+                })
+            }
+
+            Object.keys(objects).forEach(object => {
+                let fileName = path.join(that.targetDir, key, `${object}.${global.format}`)
+
+                let jsonString = JSON.stringify(objects[object], null, '\t')
+                switch (global.format) {
+                    case 'json':
+                        fs.writeFileSync(fileName, jsonString)
+                        break
+                    case 'yaml':
+                        let doc = yaml.dump(JSON.parse(jsonString))
+                        fs.writeFileSync(fileName, doc)
+                }
+            })
+        }
+
+        function singleFile(that, key) {
+            let fileName = path.join(that.targetDir, `${key}.${global.format}`)
+            let currentJSON = {}
+            currentJSON[key] = that.#json.PermissionSet[key]
+
+            let jsonString = JSON.stringify(currentJSON, null, '\t')
+            switch (global.format) {
+                case 'json':
+                    fs.writeFileSync(fileName, jsonString)
+                    break
+                case 'yaml':
+                    let doc = yaml.dump(JSON.parse(jsonString))
+                    fs.writeFileSync(fileName, doc)
+            }
+        }
+    }
+}
+
+function getTimeDiff(startTime, endTime = process.hrtime.bigint()) {
+    const diff = BigInt(endTime) - BigInt(startTime)
+    let executionTime = convertHrtime(diff)
+    executionTime.seconds = Math.round(executionTime.seconds)
+    executionTime.milliseconds = Math.round(executionTime.milliseconds / 1000)
+    if (executionTime.milliseconds == 0 && executionTime.nanoseconds > 0) executionTime.milliseconds = 1
+    return executionTime
+}
+
+function xml2json(currentValue) {
+    if (Array.isArray(currentValue)) {
+        if (currentValue.length == 1) {
+            currentValue = currentValue[0].toString().trim()
+        }
+    }
+    if (currentValue == 'true') currentValue = true
+    if (currentValue == 'false') currentValue = false
+    return currentValue
+}