@ds-sfdc/sfparty 0.0.0

package/lib/fileUtils.js

@@ -0,0 +1,165 @@
+'use strict'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as yaml from 'js-yaml'
+
+export function directoryExists(dirPath) {
+    return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()
+}
+
+export function fileExists(filePath) {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile()
+}
+
+export function createDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true })
+    }
+}
+
+export function deleteDirectory(dirPath, recursive = false) {
+    if (!directoryExists(dirPath)) {
+        return false
+    } else {
+        if (fs.existsSync(dirPath)) {
+            fs.readdirSync(dirPath).forEach(function (file) {
+                var curPath = path.join(dirPath, file)
+                if (fs.lstatSync(curPath).isDirectory() && recursive) { // recurse
+                    deleteDirectory(curPath, recursive);
+                } else { // delete file
+                    fs.unlinkSync(curPath);
+                }
+            })
+            return fs.rmdirSync(dirPath);
+        }
+    }
+}
+
+export function getFiles(dirPath, filter = undefined) {
+    const filesList = []
+    fs.readdirSync(dirPath).forEach(file => {
+        if (!filter) {
+            filesList.push(file)
+        } else {
+            if (file.endsWith(filter)) {
+                filesList.push(file)
+            }
+        }
+    })
+    filesList.sort()
+    return filesList
+}
+
+export function getDirectories(dirPath) {
+    return fs.readdirSync(dirPath, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+}
+
+export function deleteFile(filePath) {
+    if (!fileExists(filePath)) {
+        return false
+    } else {
+        return unlinkSync(filePath, { recursive: false, force: true });
+    }
+}
+
+export function fileInfo(filePath) {
+    return {
+        "dirname": path.join(path.dirname(filePath)), //something/folder/example
+        "basename": path.basename(filePath, path.extname(filePath)), //example
+        "filename": path.basename(filePath), //example.txt
+        "extname": path.extname(filePath), //txt
+        "exists": fs.existsSync(filePath), //true if exists or false if not exists
+        "stats": fs.existsSync(filePath) ? fs.statSync(filePath) : undefined //stats object if exists or undefined if not exists
+    }
+}
+
+export function savePartFile(json, fileName, format) {
+    try {
+        switch (format) {
+            case 'json':
+                let jsonString = JSON.stringify(json, null, '\t')
+                fs.writeFileSync(fileName, jsonString)
+                break
+            case 'yaml':
+                let doc = yaml.dump(json)
+                fs.writeFileSync(fileName, doc)
+                break
+        }
+        return true
+    } catch (error) {
+        global.logger.error(error)
+        throw error
+    }
+}
+
+export function readPartFile(fileName) {
+    try {
+        let result = undefined
+        const data = fs.readFileSync(fileName, { encoding: 'utf8', flag: 'r' })
+        if (fileName.indexOf('.yaml') != -1) {
+            result = yaml.load(data)
+        } else {
+            result = JSON.parse(data)
+        }
+        return result
+    } catch (error) {
+        global.logger.error(error)
+        throw error
+    }
+}
+
+export function writeFile(fileName, data, atime = new Date(), mtime = new Date()) {
+    try {
+        // write data to the file
+        fs.writeFileSync(fileName, data)
+
+        // if atime or mtime are undefined, use current date/time
+        if (atime === undefined) atime = new Date()
+        if (mtime === undefined) mtime = new Date()
+
+        // update XML file to match the latest atime and mtime of the files processed
+        fs.utimesSync(fileName, atime, mtime)
+
+    } catch (error) {
+        global.logger.error(error)
+        throw error
+    }
+}
+
+export function find(filename, root) {
+    // code Copyright (c) 2014, Ben Gourley
+    // https://github.com/bengourley/find-nearest-file
+    root = root || process.cwd();
+
+    if (!filename) throw new Error('filename is required')
+
+    if (filename.indexOf('/') !== -1 || filename === '..') {
+        throw new Error('filename must be just a filename and not a path')
+    }
+
+
+    function findFile(directory, filename) {
+
+        var file = path.join(directory, filename)
+
+        try {
+            if (fs.statSync(file).isFile()) return file
+            // stat existed, but isFile() returned false
+            return nextLevelUp()
+        } catch (e) {
+            // stat did not exist
+            return nextLevelUp()
+        }
+
+        function nextLevelUp() {
+            // Don't proceed to the next directory when already at the fs root
+            if (directory === path.resolve('/')) return null
+            return findFile(path.dirname(directory), filename)
+        }
+
+    }
+
+    return findFile(root, filename)
+}

package/lib/label/combine.js

@@ -0,0 +1,203 @@
+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
+}

package/lib/label/definition.js

@@ -0,0 +1,12 @@
+export const labelDefinition = {
+    metaUrl: 'https://developer.salesforce.com/docs/atlas.en-us.api_meta.meta/api_meta/meta_customlabels.htm',
+    directories: [
+        'labels',
+    ],
+    sortKeys: {
+        'labels': 'fullName',
+    },
+    keyOrder: {
+        labels: ['fullName', 'shortDescription', 'categories', 'protected', 'language', 'value'],
+    },
+}

package/lib/label/split.js

@@ -0,0 +1,213 @@
+'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 { labelDefinition } from './definition.js'
+
+const spinner = cliSpinners['dots']
+
+export class CustomLabel {
+    #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('.labels-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.CustomLabels['$']
+                let jsonString = JSON.stringify(result, (name, value) => {
+                    if (name == '' || !isNaN(name) || labelDefinition.directories.includes(name)) {
+                        return value
+                    } else {
+                        return xml2json(value)
+                    }
+                })
+                that.#json = JSON.parse(jsonString)
+
+                Object.keys(that.#json.CustomLabels).forEach(key => {
+                    const keyOrder = labelDefinition.keyOrder[key]
+                    const sortKey = labelDefinition.sortKeys[key]
+
+                    if (Array.isArray(that.#json.CustomLabels[key])) {
+                        // sort json to order by sortKey
+                        that.#json.CustomLabels[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.CustomLabels[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.CustomLabels[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} - Custom Labels: [%4]${chalk.yellowBright(that.#fileName.shortName)}[%2][%3]`
+
+            fileUtils.deleteDirectory(that.targetDir, true) // recursive delete existing directory
+            fileUtils.createDirectory(that.targetDir) // create directory
+
+            Object.keys(that.#json.CustomLabels).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 (labelDefinition.directories.includes(key)) {
+                    processDirectory(that, key)
+                } else {
+                    that.#errorMessage += `\n${global.statusLevel.warn} Not processed: ${key}`
+                }
+            })
+
+            return true
+        }
+
+        function processDirectory(that, key) {
+            const myKey = labelDefinition.sortKeys[key]
+
+            // populate objects with data per object
+            that.#json.CustomLabels[key].forEach(element => {
+                let fileName = path.join(that.targetDir, `${element[myKey]}.${global.format}`)
+                const labelJSON = {}
+                labelJSON[myKey] = element[myKey]
+                delete element[myKey]
+                labelJSON[key.slice(0, -1)] = element  //use slice to remove the s
+
+                let jsonString = JSON.stringify(labelJSON, 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)
+                        break
+                }
+            })
+        }
+    }
+}
+
+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
+}