@ds-sfdc/sfparty 0.0.0 → 1.0.0-0

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

package/lib/label/combine.js

@@ -1,203 +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 { labelDefinition } from './definition.js'
-import * as xml2js from 'xml2js'
-import * as yaml from 'js-yaml'
-
-const spinner = cliSpinners['dots']
-
-export class CustomLabel {
-    #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.processList = config.processList
-    }
-
-    combine() {
-        return new Promise((resolve, reject) => {
-            const that = this
-            if (!fileUtils.directoryExists(that.sourceDir)) reject(`Path does not exist: ${that.sourceDir}`)
-
-            that.#xml = `<?xml version="1.0" encoding="UTF-8"?>${os.EOL}`
-            that.#xml += `<CustomLabels xmlns="https://soap.sforce.com/2006/04/metadata">${os.EOL}`
-
-            labelDefinition.directories.forEach(key => { that.#types.push(key) })
-            that.#types.sort()
-
-            setFileName(that)
-            processLabel(that)
-
-            saveXML(that)
-            resolve(true)
-        })
-
-        function setFileName(that) {
-            that.#fileName = path.join(that.targetDir, 'CustomLabels.labels-meta.xml')
-        }
-
-        function processLabel(that) {
-            that.#startTime = process.hrtime.bigint()
-            that.#spinnerMessage = `[%1] of ${global.processed.total} - Custom Label: [%4]${chalk.yellowBright('[%5]')}[%2][%3]`
-            that.processList.sort()
-            that.#types.forEach(key => {
-                processDirectory(that, key)
-            })
-        }
-
-        function processFile(that, key) {
-            const fileName = path.join(that.sourceDir, that.metaDir, `${key}.${global.format}`)
-            if (fileUtils.fileExists(fileName)) {
-                if (labelDefinition.singleFiles.includes(key)) {
-                    genericXML(that, key)
-                } else {
-                    that.#errorMessage += `\n${global.statusLevel.warn} Not processed: ${key}`
-                }
-            }
-        }
-
-        function processDirectory(that, key) {
-            that.sequence = 0
-            let startTime
-            that.#errorMessage = ''
-            that.processList.forEach(fileName => {
-                startTime = process.hrtime.bigint()
-                that.sequence++
-                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('[%5]', `${fileName} `)
-                )
-                try {
-                    genericXML(that, key, fileName)                   
-                } catch (error) {
-                    that.#errorMessage = error.message
-                }
-                let executionTime = getTimeDiff(BigInt(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} `)
-                    .replace('[%5', fileName)
-                )
-                logUpdate.done()
-            })
-            // TODO                that.#fileStats = fileUtils.fileInfo(fileName).stats
-
-            // genericDirectoryXML(that, key)
-            // that.#errorMessage += `\n${global.statusLevel.warn} Not processed: ${key}`
-            return true
-        }
-
-        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 += '</CustomLabels>\n'
-            writeFileSync(that.#fileName, that.#xml)
-            // utimesSync(that.#fileName, that.#fileStats.atime, that.#fileStats.mtime)
-
-        }
-
-        function nextFrame(that) {
-            return spinner.frames[that.#index = ++that.#index % spinner.frames.length]
-        }
-
-        function genericXML(that, key, fileName) {
-            fileName = path.join(that.sourceDir, fileName)
-            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.slice(0, -1)][labelDefinition.sortKeys[key]] = result[labelDefinition.sortKeys[key]]
-                result[key.slice(0, -1)] = sortJSONKeys(sortJSON(result[key.slice(0, -1)], labelDefinition.sortKeys[key]))
-                that.#xml += `\t<${key}>${os.EOL}`
-                Object.keys(result[key.slice(0, -1)]).forEach(tag => {
-                    let xml
-                    try {
-                        xml = builder.buildObject(result[key.slice(0, -1)][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}`
-            }
-        }
-        // 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
-}