@ds-sfdc/sfparty 1.0.0-0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ds-sfdc/sfparty",
-  "version": "1.0.0-0",
+  "version": "1.0.0",
   "description": "Salesforce metadata XML splitter for CI/CD",
   "type": "module",
   "repository": {

package/src/lib/permset/combine.js

@@ -1,286 +0,0 @@
-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 '../../meta/PermissionSets.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.icons.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.icons.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.icons.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.icons.success : global.icons.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/src/lib/permset/split.js

@@ -1,287 +0,0 @@
-'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 '../../meta/PermissionSets.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.icons.success : global.icons.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.icons.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.icons.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
-}