@ds-sfdc/sfparty 0.0.0 → 1.0.0

package/{lib/profile/definition.js → src/meta/Profiles.js}

@@ -1,10 +1,14 @@
-export const profileDefinition = {
+export const metadataDefinition = {
     metaUrl: 'https://developer.salesforce.com/docs/atlas.en-us.api_meta.meta/api_meta/meta_profile.htm',
+    directory: 'profiles',
+    filetype: 'profile',
+    root: 'Profile',
     main: [
+        'fullName',
         'custom',
         'description',
-        'fullName',
         'userLicense',
+        '$',
     ],
     singleFiles: [
         'applicationVisibilities',
@@ -29,8 +33,10 @@ export const profileDefinition = {
         'objectPermissions',
         'recordTypeVisibilities',
     ],
-    ignore: [
-        '$',
+    splitObjects: [
+        'fieldPermissions',
+        'objectPermissions',
+        'recordTypeVisibilities',
     ],
     sortKeys: {
         'applicationVisibilities': 'application',
@@ -51,5 +57,26 @@ export const profileDefinition = {
         'recordTypeVisibilities': 'recordType',
         'tabVisibilities': 'tab',
         'userPermissions': 'name',        
-    }
+    },
+    keyOrder: {
+        applicationVisibilities: ['application', 'visible'],
+        categoryGroupVisibilities: ['dataCategoryGroup'], // TODO
+        classAccesses: ['apexClass', 'enabled'],
+        customMetadataTypeAccesses: ['name', 'enabled'],
+        customPermissions: ['name', 'enabled'],
+        customSettingAccesses: ['name', 'enabled'],
+        externalDataSourceAccesses: ['externalDataSource', 'enabled'],
+        fieldPermissions: ['field', 'editable', 'readable'],
+        flowAccesses: ['flow', 'enabled'],
+        layoutAssignments: ['layout'], // TODO
+        loginFlows: ['friendlyName'], // TODO
+        loginIpRanges: ['startAddress'], // TODO
+        objectPermissions: ['object', 'allowCreate', 'allowRead', 'allowEdit', 'allowDelete', 'viewAllRecords', 'modifyAllRecords'],
+        pageAccesses: ['apexPage', 'enabled'],
+        profileActionOverrides: ['pageOrSobjectType'], // TODO
+        recordTypeVisibilities: ['recordType', 'visible'],
+        tabVisibilities: ['tab', 'visibility'],
+        userPermissions: ['name', 'enabled'],
+    },
+    xmlFirst: 'fullName'
 }

package/{lib/workflow/definition.js → src/meta/Workflows.js}

@@ -1,5 +1,6 @@
 export const metadataDefinition = {
     metaUrl: 'https://developer.salesforce.com/docs/atlas.en-us.api_meta.meta/api_meta/meta_workflow.htm',
+    directory: 'workflows',
     filetype: 'workflow',
     root: 'Workflow',
     main: [

package/{lib/workflow → src/party}/combine.js

@@ -3,8 +3,9 @@ import logUpdate from 'log-update'
 import chalk from 'chalk'
 import convertHrtime from 'convert-hrtime'
 import cliSpinners from 'cli-spinners'
+import os from 'node:os'
 import * as xml2js from 'xml2js'
-import * as fileUtils from '../fileUtils.js'
+import * as fileUtils from '../lib/fileUtils.js'
 
 const spinner = cliSpinners['dots']
 
@@ -73,18 +74,18 @@ export class Combine {
         return new Promise((resolve, reject) => {
             const that = this
             if (!fileUtils.directoryExists(that.sourceDir)) reject(`Path does not exist: ${that.sourceDir}`)
+            let types = ['directories', 'singleFiles', 'main']
+            types.forEach(type => {
+                if (that.metadataDefinition[type] !== undefined) {
+                    that.#types = that.#types.concat(that.metadataDefinition[type])
+                }
+            })
 
-            if (that.metadataDefinition.directories !== undefined) {
-                that.#types = that.#types.concat(that.metadataDefinition.directories)
-            }
-            if (that.metadataDefinition.singleFiles !== undefined) {
-                that.#types = that.#types.concat(that.metadataDefinition.singleFiles)
-            }
-            if (that.metadataDefinition.main !== undefined) {
-                that.#types = that.#types.concat(that.metadataDefinition.main)
-            }
             that.#types.sort((a, b) => {
                 if (a == '$') return -1
+                if (that.metadataDefinition.xmlFirst !== undefined) {
+                    if (a == that.metadataDefinition.xmlFirst) return -1
+                }
                 if (a < b) return -1
                 if (a > b) return 1
                 return 0
@@ -110,7 +111,7 @@ export class Combine {
                     .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} `)
+                    .replace('[%4]', `${global.icons.working} `)
                     .replace('[%5]', `${that.#fileName.shortName} `)
                 )
 
@@ -121,9 +122,12 @@ export class Combine {
                         shortName: 'Main',
                         fullName: path.join(that.sourceDir, that.metaDir, `main.${global.format}`),
                     }
-                    processFile(that, key, fileObj)
+                    processFile(that, key, fileObj, 'main')
+                    if (that.#json.$ === undefined) {
+                        that.#json.$ = { xmlns: 'https://soap.sforce.com/2006/04/metadata' }
+                    }
                 } else if (that.metadataDefinition.singleFiles.includes(key)) {
-                    // TODO process single file
+                    processSingleFile(that, key)
                 } else if (that.metadataDefinition.directories.includes(key)) {
                     processDirectory(that, key)
                 } else {
@@ -132,6 +136,15 @@ export class Combine {
             })
         }
 
+        function processSingleFile(that, key) {
+            const fileObj = {
+                shortName: key,
+                fullName: path.join(that.sourceDir, that.metaDir, key + `.${global.format}`),
+            }
+            processFile(that, key, fileObj)
+
+        }
+
         function processDirectory(that, key) {
             // Process the directory sourceDir/metaDir/key
             const currentDir = path.join(that.sourceDir, that.metaDir, key)
@@ -147,7 +160,7 @@ export class Combine {
                         .replace('[%1]', that.sequence.toString().padStart(global.processed.total.toString().length, ' '))
                         .replace('[%2]', `\n${chalk.magentaBright(nextFrame(that))} ${key} - ${index + 1} of ${fileList.length} - ${chalk.magentaBright(file)}`)
                         .replace('[%3]', `${that.#errorMessage}`)
-                        .replace('[%4]', `${global.statusLevel.working} `)
+                        .replace('[%4]', `${global.icons.working} `)
                         .replace('[%5]', `${that.#fileName.shortName} `)
                     )
 
@@ -162,38 +175,88 @@ export class Combine {
             return true
         }
 
-        function processFile(that, key, fileObj = undefined) {
+        function processFile(that, key, fileObj = undefined, rootKey = undefined) {
             if (
                 fileObj === undefined ||
                 typeof fileObj != 'object' ||
                 fileObj.shortName === undefined ||
                 fileObj.fullName === undefined
             ) {
-                that.#errorMessage += `\n${global.statusLevel.warn} Invalid file information passed ${chalk.redBright(fileObj)}`
+                that.#errorMessage += `\n${global.icons.warn} Invalid file information passed ${chalk.redBright(fileObj)}`
                 return false
             }
 
-            if (fileUtils.fileExists(fileObj.fullName)) {
-                let result = fileUtils.readPartFile(fileObj.fullName)
-                result = sortAndArrange(that, result, key)
-                if (Array.isArray(that.#json[key])) {
-                    that.#json[key].push(result[key])
-                } else {
-                    that.#json[key] = result[key][key][key]
+            if (!fileUtils.fileExists(fileObj.fullName)) {
+                return
+            }
+
+            let result = fileUtils.readPartFile(fileObj.fullName)
+
+            // if split by object we need to add object back to values
+            if (that.metadataDefinition.splitObjects !== undefined && that.metadataDefinition.splitObjects.includes(key)) {
+                result = hydrateObject(that, result, key, fileObj)
+            }
+            result = sortAndArrange(that, result, key)
+
+            if (Array.isArray(that.#json[key])) {
+                try {
+                    if (Array.isArray(result[key])) {
+                        result[key].forEach(arrItem => {
+                            that.#json[key].push(arrItem)
+                        })                          
+                    } else {
+                        that.#json[key].push(result[key])
+                    }
+                } catch (error) {
+                    throw error
+                }
+            } else {
+                try {
+                    that.#json[key] = (rootKey !== undefined) ? result[rootKey][key] : result[key]
+                } catch (error) {
+                    let test = { key: key, rootKey: rootKey, json: result }
+                    throw error
                 }
             }
 
-            updateFileStats(that, fileUtils.fileInfo(fileObj.fullName).stats)
+            updateFileStats(that, fileObj.fullName, fileUtils.fileInfo(fileObj.fullName).stats)
             // genericXML(that, key, fileObj.fullName)
         }
 
-        function updateFileStats(that, stats) {
-            if (that.#fileStats.atime === undefined || stats.atime > that.#fileStats.atime) {
-                that.#fileStats.atime = stats.atime
+        function hydrateObject(that, json, key, fileObj) {
+            const sortKey = that.metadataDefinition.sortKeys[key]
+            let object = json.object
+
+            try {
+                json[key].forEach((arrItem) => {
+                    arrItem[sortKey] = `${object}.${arrItem[sortKey]}`.replace('.undefined', '')
+
+                    // add object key if previously existed
+                    if (that.metadataDefinition.keyOrder[key] !== undefined && that.metadataDefinition.keyOrder[key].includes('order')) {
+                        arrItem.object = object
+                    }
+                })
+
+                // delete object key that we added to the part file
+                delete json.object
+            } catch (error) {
+                throw error
             }
 
-            if (that.#fileStats.mtime === undefined || stats.mtime > that.#fileStats.mtime) {
-                that.#fileStats.mtime = stats.mtime
+            return json
+        }
+
+        function updateFileStats(that, fileName, stats) {
+            try {
+                if (that.#fileStats.atime === undefined || stats.atime > that.#fileStats.atime) {
+                    that.#fileStats.atime = stats.atime
+                }
+
+                if (that.#fileStats.mtime === undefined || stats.mtime > that.#fileStats.mtime) {
+                    that.#fileStats.mtime = stats.mtime
+                }
+            } catch (error) {
+                throw error
             }
         }
 
@@ -226,7 +289,7 @@ export class Combine {
         function finishMessage(that) {
             let executionTime = getTimeDiff(BigInt(that.#startTime))
             let durationMessage = `${executionTime.seconds}.${executionTime.milliseconds}s`
-            let stateIcon = (that.#errorMessage == '') ? global.statusLevel.success : global.statusLevel.fail
+            let stateIcon = (that.#errorMessage == '') ? global.icons.success : global.icons.fail
 
             logUpdate(that.#spinnerMessage
                 .replace('[%1]', that.sequence.toString().padStart(global.processed.total.toString().length, ' '))
@@ -250,7 +313,7 @@ export class Combine {
 }
 
 function sortJSON(json, key) {
-    if (Array.isArray(json)) {
+    if (Array.isArray(json) && key !== undefined) {
         json.sort((a, b) => {
             if (a[key] < b[key]) return -1
             if (a[key] > b[key]) return 1
@@ -263,15 +326,17 @@ function sortJSON(json, key) {
 function sortAndArrange(that, json, key = undefined, topLevel = true) {
     // sort and order keys
     const sortKey = that.metadataDefinition.sortKeys[key]
-    let jsonResult = {}
+
     json = arrangeKeys(that, json, key)
     json = sortJSON(json, sortKey)
 
     Object.keys(json).forEach((subKey, index, thisObj) => {
         if (typeof json[subKey] == 'object') {
             if (!Array.isArray(json[subKey])) {
-                // call recursively on object
-                json[subKey] = sortAndArrange(that, json[subKey], subKey)
+                if (Object.keys(json[subKey]).length > 1) {
+                    // call recursively on object
+                    json[subKey] = sortAndArrange(that, json[subKey], subKey, false)
+                }
             } else {
                 // iterate array for objects
                 json[subKey].forEach((arrItem, index) => {
@@ -284,14 +349,7 @@ function sortAndArrange(that, json, key = undefined, topLevel = true) {
         }
     })
 
-    // we need to include the key into the json for the top-level only
-    if (topLevel) {
-        jsonResult[key] = json
-    } else {
-        jsonResult = json
-    }
-
-    return jsonResult
+    return json
 }
 
 function arrangeKeys(that, json, key = undefined) {

package/{lib/workflow → src/party}/split.js

@@ -9,7 +9,7 @@ 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 * as fileUtils from '../lib/fileUtils.js'
 
 const spinner = cliSpinners['dots']
 
@@ -64,55 +64,59 @@ export class Split {
         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)) {
+                resolve(false)
+            } else 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)
-                        }
+                resolve(false)
+            } else {
+                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({ data: result, startTime: process.hrtime.bigint() })
+                            } else {
+                                global.logger.error(`error converting xml to json: ${that.metaFilePath}`)
+                                reject(`error converting xml to json: ${that.metaFilePath}`)
+                            }
+                        })
                     })
                 })
-            })
-            getJSON.then((result) => {
-                try {
-                    result[that.#root]['$'].xmlns = result[that.#root]['$'].xmlns.replace('http:', 'https:')
-                } catch (error) {
-                    global.logger.error(`${that.#fileName.fullName} has an invalid XML root`)
-                    resolve(false)
-                    return
-                }
+                getJSON.catch((error) => {
+                    throw error
+                })
+                getJSON.then((result) => {
+                    that.#startTime = result.startTime
+                    result = result.data
+                    try {
+                        result[that.#root]['$'].xmlns = result[that.#root]['$'].xmlns.replace('http:', 'https:')
+                    } catch (error) {
+                        global.logger.error(`${that.#fileName.fullName} has an invalid XML root`)
+                        resolve(false)
+                        return
+                    }
 
-                // modify the json to remove unwanted arrays
-                that.#json = transformJSON(that, result, that.#root)
-                fileUtils.deleteDirectory(that.targetDir, true) // recursive delete existing directory
-                fileUtils.createDirectory(that.targetDir) // create directory
-
-                try {
-                    processJSON(that, that.#json[that.#root], that.targetDir)
-                    completeFile(that)
-                } catch (error) {
-                    console.log(that.#fileName.shortName)
-                    global.logger.error(error)
-                }
+                    // modify the json to remove unwanted arrays
+                    that.#json = transformJSON(that, result, that.#root)
+                    fileUtils.deleteDirectory(that.targetDir, true) // recursive delete existing directory
+                    fileUtils.createDirectory(that.targetDir) // create directory
+
+                    try {
+                        processJSON(that, that.#json[that.#root], that.targetDir)
+                        completeFile(that)
+                    } catch (error) {
+                        console.log(that.#fileName.shortName)
+                        global.logger.error(error)
+                        throw error
+                    }
 
-                resolve(true)
-            })
+                    resolve(true)
+                })
+            }
         })
 
         function processJSON(that, json, baseDir) {
-            that.#startTime = process.hrtime.bigint()
             that.#spinnerMessage = `[%1] of ${global.processed.total} - Workflow: [%4]${chalk.yellowBright(that.#fileName.shortName)}[%2][%3]`
 
             let targetDir = baseDir
@@ -122,42 +126,47 @@ export class Split {
                     .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} `)
+                    .replace('[%4]', `${global.icons.working} `)
                 )
 
-                if (that.metadataDefinition.directories.includes(key)) {
+                if (that.metadataDefinition.directories !== undefined && that.metadataDefinition.directories.includes(key)) {
                     targetDir = path.join(baseDir, key)
                     fileUtils.createDirectory(targetDir) // create directory
                     if (Array.isArray(json[key])) {
                         processDirectory(that, json[key], key, targetDir)
                     }
-                } else if (that.metadataDefinition.singleFiles.includes(key)) {
-                    console.log(key, 'single file')
-                } else if (that.metadataDefinition.main.includes(key)) {
+                } else if (that.metadataDefinition.singleFiles !== undefined && that.metadataDefinition.singleFiles.includes(key)) {
+                    processFile(that, json[key], key, baseDir)
+                } else if (that.metadataDefinition.main !== undefined && that.metadataDefinition.main.includes(key)) {
                     // Main will get processed in it's own call
                 } else {
-                    console.log(key, 'unknown')
+                    logUpdate(key, 'unknown')
+                    logUpdate.done()
                 }
             })
 
-            Main(that)
+            if (that.metadataDefinition.main !== undefined) {
+                Main(that)
+            }
         }
 
         function Main(that) {
             let fileName = path.join(that.targetDir, `main.${global.format}`)
-            let mainInfo = {}
-            mainInfo.name = that.#fileName.shortName
+            let mainInfo = {
+                main: {}
+            }
+            mainInfo.main.name = that.#fileName.shortName
             that.metadataDefinition.main.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} `)
+                    .replace('[%4]', `${global.icons.working} `)
                 )
 
                 if (that.#json[that.#root][key] !== undefined) {
-                    mainInfo[key] = that.#json[that.#root][key]
+                    mainInfo.main[key] = that.#json[that.#root][key]
                 }
             })
 
@@ -171,7 +180,7 @@ export class Split {
         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
+            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}.`)
@@ -184,11 +193,52 @@ export class Split {
 }
 
 function processDirectory(that, json, key, baseDir) {
-    json.forEach(arrItem => {
+    if (that.metadataDefinition.splitObjects !== undefined && that.metadataDefinition.splitObjects.includes(key)) {
         const sortKey = that.metadataDefinition.sortKeys[key]
-        let fileName = path.join(baseDir, `${arrItem[sortKey]}.${global.format}`)
-        fileUtils.savePartFile(arrItem, fileName, global.format)
-    })
+        const objects = {}
+
+        if (sortKey === undefined) {
+            throw new Error(`No sort key specified for: ${key}`)
+        }
+        json.forEach(arrItem => {
+            const object = arrItem[sortKey].split('.')[0]
+            arrItem[sortKey] = arrItem[sortKey].split('.').pop()
+            if (objects[object] === undefined) {
+                objects[object] = {
+                    object: object
+                }
+                objects[object][key] = []
+            }
+            delete arrItem['object']
+            objects[object][key].push(arrItem)
+        })
+
+        Object.keys(objects).forEach(object => {
+            processFile(that, objects[object], key, baseDir, object)
+        })
+
+    } else {
+        json.forEach(arrItem => {
+            processFile(that, arrItem, key, baseDir)
+        })
+    }
+
+
+}
+
+function processFile(that, json, key, baseDir, fileNameOverride) {
+    let newJSON
+    let fileName
+    if (fileNameOverride !== undefined) {
+        fileName = path.join(baseDir, `${fileNameOverride}.${global.format}`)
+        newJSON = json
+    } else {
+        const sortKey = that.metadataDefinition.sortKeys[key]
+        fileName = path.join(baseDir, `${(json[sortKey] !== undefined) ? json[sortKey] : key}.${global.format}`)
+        newJSON = {}
+        newJSON[key] = json
+    }
+    fileUtils.savePartFile(newJSON, fileName, global.format)
 }
 
 function transformJSON(that, result, rootTag) {
@@ -230,17 +280,22 @@ function keySort(that, key, json) {
 
         // arrange json keys in specified order using keyOrder
         json.forEach(function (part, index) {
-            this[index] = Object.keys(this[index])
-                .sort((a, b) => {
-                    if (keyOrder.indexOf(a) == -1) return 1
-                    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
-                }, {})
+            try {
+                this[index] = Object.keys(this[index])
+                    .sort((a, b) => {
+                        if (keyOrder.indexOf(a) == -1) return 1
+                        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
+                    }, {})
+            } catch (error) {
+                let test = key
+                throw error
+            }
         }, json)
 
         // recursive objects