@ds-sfdc/sfparty 0.0.0

package/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Tim Paulaskas
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,18 @@
+# @ds-sfdc/sfparty
+
+[![NPM](https://img.shields.io/npm/v/@ds-sfdc/sfparty.svg?label=@ds-sfdc/sfparty)](https://www.npmjs.com/package/@ds-sfdc/sfparty) [![Downloads/week](https://img.shields.io/npm/dw/@ds-sfdc/sfparty.svg)](https://npmjs.org/package/@ds-sfdc/sfparty) [![License](https://img.shields.io/badge/License-BSD%203--Clause-brightgreen.svg)](https://github.com/TimPaulaskasDS/sfparty/blob/main/LICENSE.md)
+
+## Using the template
+
+This tool will split Salesforce metadata XML files into YAML parts (or JSON).
+
+## Install
+
+```bash
+npm i @ds-sfdc/sfparty
+```
+## Commands
+
+<!-- commands -->
+
+<!-- commandsstop -->

package/index.js

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+'use strict'
+import { readFileSync } from 'fs'
+import path from 'path'
+import yargs from 'yargs'
+import { hideBin } from 'yargs/helpers'
+import winston from 'winston'
+import chalk from 'chalk'
+import convertHrtime from 'convert-hrtime'
+import * as fileUtils from './lib/fileUtils.js'
+import * as profileSplit from './lib/profile/split.js'
+import * as profileCombine from './lib/profile/combine.js'
+import * as permSetSplit from './lib/permset/split.js'
+import * as permSetCombine from './lib/permset/combine.js'
+import * as labelSplit from './lib/label/split.js'
+import * as labelCombine from './lib/label/combine.js'
+import * as workflowSplit from './lib/workflow/split.js'
+import * as workflowCombine from './lib/workflow/combine.js'
+import * as workflowDefinition from './lib/workflow/definition.js'
+
+const startTime = process.hrtime.bigint()
+
+
+global.logger = winston.createLogger({
+    levels: winston.config.syslog.levels,
+    format: winston.format.cli(),
+    defaultMeta: { service: 'dstools', method: 'profile' },
+    transports: [
+        new winston.transports.Console(),
+    ],
+});
+
+global.processed = {
+    total: 0,
+    errors: 0,
+    current: 1,
+}
+
+global.statusLevel = {
+    "warn": '🔕',
+    "success": chalk.greenBright('✔'),
+    "fail": '❗',
+    "working": '⏳'
+}
+
+function getRootPath(packageDir) {
+    let rootPath = fileUtils.find('sfdx-project.json')
+    let defaultDir
+    if (rootPath) {
+        global.__basedir = fileUtils.fileInfo(rootPath).dirname
+        let packageJSON = JSON.parse(readFileSync(rootPath))
+        if (Array.isArray(packageJSON.packageDirectories)) {
+            packageJSON.packageDirectories.every(directory => {
+                if (directory.default || packageJSON.packageDirectories.length == 1) defaultDir = directory.path
+                if (directory == packageDir) {
+                    defaultDir = directory
+                    return false
+                }
+                return true
+            })
+        }
+    } else {
+        global.logger.error('Could not determine base path of Salesforce source directory. No sfdx-project.json found. Please specify a source path or execute from Salesforce project directory.')
+        process.exit(1)
+    }
+    if (packageDir && packageDir != defaultDir) {
+        global.logger.error('Could not find directory in sfdx-project.json. Please specify a package directory path from the sfdx-project.json file.')
+        process.exit(1)
+    }
+
+    return defaultDir
+}
+
+let errorMessage = chalk.red('Please specify the action of ' + chalk.whiteBright.bgRedBright('split') + ' or ' + chalk.whiteBright.bgRedBright('combine') + '.')
+
+yargs(hideBin(process.argv))
+    .alias('h', 'help')
+    .command({
+        command: '[split]',
+        alias: 'split',
+        description: 'splits metadata xml to json files',
+        builder: (yargs) => {
+            yargs
+                .example([
+                    ['$0 split --type=profile --all'],
+                    ['$0 split --type=permset --name="Permission Set Name"'],
+                    ['--source=packageDir --target=dir/dir'],
+                    ['name portion of file: [name].profile-meta.xml'],
+                    ['Example: --name="Admin" for Admin.profile-meta.xml'],
+                    ['\nCommands not supporting name or all parameters:'],
+                    ['$0 split --type=label'],
+                ])
+                .options({
+                    type: {
+                        demand: true,
+                        alias: 'type',
+                        description: 'type of metadata to split',
+                        demandOption: true,
+                        type: 'string',
+                    },
+                    format: {
+                        demand: true,
+                        alias: 'format',
+                        default: 'yaml',
+                        description: 'type of output',
+                        demandOption: true,
+                        type: 'string',
+                    },
+                    name: {
+                        alias: 'n',
+                        description: 'name of metadata file to split',
+                        demandOption: false,
+                        type: 'string',
+                    },
+                    all: {
+                        alias: 'a',
+                        description: 'all metadata files of type will be split',
+                        demandOption: false,
+                        type: 'boolean',
+                    },
+                    source: {
+                        demand: false,
+                        alias: 's',
+                        description: 'package directory path specified in sfdx-project.json',
+                        type: 'string',
+                    },
+                    target: {
+                        demand: false,
+                        alias: 't',
+                        description: 'target path to directory to create json files',
+                        type: 'string',
+                    }
+                })
+                .choices('type', ['label', 'permset', 'profile', 'workflow'])
+                .choices('format', ['json', 'yaml'])
+                .check((argv, options) => {
+                    const name = argv.name
+                    const all = argv.all
+
+                    switch (argv.type) {
+                        case 'profile':
+                        case 'permset':
+                        case 'workflow':
+                            if ((typeof name != 'undefined' || name == '') && (typeof all != 'undefined' && all)) {
+                                throw new Error(chalk.redBright('You cannot specify ' + chalk.whiteBright.bgRedBright('--name') + ' and ' + chalk.whiteBright.bgRedBright('--all') + ' at the same time.'))
+                            } else if (typeof name == 'undefined' && (typeof all == 'undefined' || !all)) {
+                                throw new Error(chalk.redBright('You must specify the ' + chalk.whiteBright.bgRedBright('--name') + ' parameter or use the ' + chalk.whiteBright.bgRedBright('--all') + ' switch.'))
+                            } else {
+                                return true // tell Yargs that the arguments passed the check
+                            }
+                        case 'label':
+                            if ((typeof name != 'undefined' && name != '') || (typeof all != 'undefined' && all)) {
+                                throw new Error(chalk.redBright('You cannot specify ' + chalk.whiteBright.bgRedBright('--name') + ' or ' + chalk.whiteBright.bgRedBright('--all') + ' when using label.'))
+                            }
+                            return true
+                    }
+                })
+        },
+        handler: (argv) => {
+            let metaExtension
+            const fileList = []
+            let type = argv.type
+            global.format = argv.format
+            switch (type) {
+                case 'profile':
+                    type = 'profiles'
+                    metaExtension = '.profile-meta.xml'
+                    break
+                case 'permset':
+                    type = 'permissionsets'
+                    metaExtension = '.permissionset-meta.xml'
+                    break
+                case 'label':
+                    type = 'labels'
+                    metaExtension = '.labels-meta.xml'
+                    break
+                case 'workflow':
+                    type = 'workflows'
+                    metaExtension = '.workflow-meta.xml'
+                    break
+                default:
+                    global.logger.error('Metadata type not supported: ' + type)
+                    process.exit(1)
+            }
+
+            let sourceDir = argv.source || ''
+            let targetDir = argv.target || ''
+            let name = argv.name
+            let all = argv.all
+            let packageDir = getRootPath(sourceDir)
+
+            if (type == 'labels') {
+                name = 'CustomLabels'
+            }
+            sourceDir = path.join(global.__basedir, packageDir, 'main', 'default', type)
+            if (targetDir == '') {
+                targetDir = path.join(global.__basedir, packageDir + '-party', 'main', 'default', type)
+            } else {
+                targetDir = path.join(targetDir, 'main', 'default', type)
+            }
+            let metaDirPath = sourceDir
+            console.log(`${chalk.bgBlackBright('Source path:')} ${sourceDir}`)
+            console.log(`${chalk.bgBlackBright('Target path:')} ${targetDir}`)
+            console.log()
+
+            if (!all) {
+                let metaFilePath = path.join(metaDirPath, name)
+                if (!fileUtils.fileExists(metaFilePath)) {
+                    name += metaExtension
+                    metaFilePath = path.join(metaDirPath, name)
+                    if (!fileUtils.fileExists(metaFilePath)) {
+                        global.logger.error('File not found: ' + metaFilePath)
+                        process.exit(1)
+                    }
+                }
+                fileList.push(name)
+            } else {
+                if (fileUtils.directoryExists(sourceDir)) {
+                    fileUtils.getFiles(sourceDir, metaExtension).forEach(file => {
+                        fileList.push(file)
+                    })
+                }
+            }
+
+            global.processed.total = fileList.length
+            console.log(`Splitting a total of ${fileList.length} file(s)`)
+            console.log()
+            const promList = []
+            fileList.forEach(metaFile => {
+                switch (type) {
+                    case 'profiles':
+                        const profile = new profileSplit.Profile({
+                            sourceDir: sourceDir,
+                            targetDir: targetDir,
+                            metaFilePath: path.join(sourceDir, metaFile),
+                            sequence: promList.length + 1,
+                        })
+                        const profProm = profile.split()
+                        promList.push(profProm)
+                        profProm.then(() => {
+                            global.processed.current++
+                        })
+                        break
+                    case 'permissionsets':
+                        const permSet = new permSetSplit.Permset({
+                            sourceDir: sourceDir,
+                            targetDir: targetDir,
+                            metaFilePath: path.join(sourceDir, metaFile),
+                            sequence: promList.length + 1,
+                        })
+                        const permProm = permSet.split()
+                        promList.push(permProm)
+                        permProm.then(() => {
+                            global.processed.current++
+                        })
+                        break
+                    case 'labels':
+                        const label = new labelSplit.CustomLabel({
+                            sourceDir: sourceDir,
+                            targetDir: targetDir,
+                            metaFilePath: path.join(sourceDir, metaFile),
+                            sequence: promList.length + 1,
+                        })
+                        const labelProm = label.split()
+                        promList.push(labelProm)
+                        labelProm.then(() => {
+                            global.processed.current++
+                        })
+                        break
+                    case 'workflows':
+                        const workflow = new workflowSplit.Split({
+                            metadataDefinition: workflowDefinition.metadataDefinition,
+                            sourceDir: sourceDir,
+                            targetDir: targetDir,
+                            metaFilePath: path.join(sourceDir, metaFile),
+                            sequence: promList.length + 1,
+                        })
+                        const workflowProm = workflow.split()
+                        promList.push(workflowProm)
+                        workflowProm.then((resolve, reject) => {
+                            if (resolve == false) {
+                                global.processed.errors++
+                                global.processed.current--
+                            } else {
+                                global.processed.current++
+                            }
+                        })
+                        break
+                }
+            })
+            Promise.allSettled(promList).then((results) => {
+                let message = `Split ${chalk.bgBlackBright(global.processed.current)} file(s) ${(global.processed.errors > 0) ? 'with ' + chalk.bgBlackBright.red(global.processed.errors) + ' error(s) ' : ''}in `
+                displayMessage(startTime, message)
+            })
+        }
+    })
+    .command({
+        command: '[combine]',
+        alias: 'combine',
+        description: 'combines json files into metadata xml',
+        builder: (yargs) => {
+            yargs
+                .example([
+                    ['$0 combine --type=profile --all'],
+                    ['$0 combine --type=permset --name="Permission Set Name"'],
+                    ['--source=packageDir --target=dir/dir'],
+                    ['name portion of file: [name].profile-meta.xml'],
+                    ['Example: --name="Admin" for Admin.profile-meta.xml'],
+                    ['\nCommands not supporting name or all parameters:'],
+                    ['$0 combine --type=label'],])
+                .options({
+                    type: {
+                        demand: true,
+                        alias: 'type',
+                        description: 'type of metadata to combine',
+                        demandOption: true,
+                        type: 'string',
+                    },
+                    format: {
+                        demand: true,
+                        alias: 'format',
+                        default: 'yaml',
+                        description: 'type of output',
+                        demandOption: true,
+                        type: 'string',
+                    },
+                    name: {
+                        alias: 'n',
+                        description: 'name of metadata file to combine',
+                        demandOption: false,
+                        type: 'string',
+                    },
+                    all: {
+                        alias: 'a',
+                        description: 'all json files of type will be combined',
+                        demandOption: false,
+                        type: 'boolean',
+                    },
+                    source: {
+                        demand: false,
+                        alias: 's',
+                        description: 'package directory path specified in sfdx-project.json',
+                        type: 'string',
+                    },
+                    target: {
+                        demand: false,
+                        alias: 't',
+                        description: 'target path to directory to create xml files',
+                        type: 'string',
+                    }
+                })
+                .choices('type', ['label', 'permset', 'profile', 'workflow'])
+                .choices('format', ['json', 'yaml'])
+                .check((argv, options) => {
+                    const name = argv.name
+                    const all = argv.all
+
+                    switch (argv.type) {
+                        case 'profile':
+                        case 'permset':
+                        case 'workflow':
+                            if ((typeof name != 'undefined' || name == '') && (typeof all != 'undefined' && all)) {
+                                throw new Error(chalk.redBright('You cannot specify ' + chalk.whiteBright.bgRedBright('--name') + ' and ' + chalk.whiteBright.bgRedBright('--all') + ' at the same time.'))
+                            } else if (typeof name == 'undefined' && (typeof all == 'undefined' || !all)) {
+                                throw new Error(chalk.redBright('You must specify the ' + chalk.whiteBright.bgRedBright('--name') + ' parameter or use the ' + chalk.whiteBright.bgRedBright('--all') + ' switch.'))
+                            } else {
+                                return true // tell Yargs that the arguments passed the check
+                            }
+                        case 'label':
+                            if ((typeof name != 'undefined' && name != '') || (typeof all != 'undefined' && all)) {
+                                throw new Error(chalk.redBright('You cannot specify ' + chalk.whiteBright.bgRedBright('--name') + ' or ' + chalk.whiteBright.bgRedBright('--all') + ' when using label.'))
+                            }
+                            return true
+                    }
+                })
+        },
+        handler: (argv) => {
+            let processList = []
+            global.format = argv.format
+            let type = argv.type
+            switch (type) {
+                case 'profile':
+                    type = 'profiles'
+                    break
+                case 'permset':
+                    type = 'permissionsets'
+                    break
+                case 'label':
+                    type = 'labels'
+                    break
+                case 'workflow':
+                    type = 'workflows'
+                    break
+                default:
+                    global.logger.error('Metadata type not supported: ' + type)
+                    process.exit(1)
+            }
+
+            let sourceDir = argv.source || ''
+            let targetDir = argv.target || ''
+            let name = argv.name
+            let all = argv.all
+            let packageDir = getRootPath(sourceDir)
+
+            sourceDir = path.join(global.__basedir, packageDir + '-party', 'main', 'default', type)
+            if (targetDir == '') {
+                targetDir = path.join(global.__basedir, packageDir, 'main', 'default', type)
+            } else {
+                targetDir = path.join(targetDir, 'main', 'default', type)
+            }
+
+            console.log(`${chalk.bgBlackBright('Source path:')} ${sourceDir}`)
+            console.log(`${chalk.bgBlackBright('Target path:')} ${targetDir}`)
+            console.log()
+
+            if (type == 'labels') {
+                processList = fileUtils.getFiles(sourceDir, `.${global.format}`)
+            } else if (!all) {
+                let metaDirPath = path.join(sourceDir, name)
+                if (!fileUtils.directoryExists(metaDirPath)) {
+                    global.logger.error('Directory not found: ' + metaDirPath)
+                    process.exit(1)
+                }
+                processList.push(name)
+            } else {
+                processList = fileUtils.getDirectories(sourceDir)
+            }
+
+            global.processed.total = processList.length
+            console.log(`Combining a total of ${global.processed.total} file(s)`)
+            console.log()
+
+            const promList = []
+            if (type != 'labels') {
+                processList.forEach(metaDir => {
+                    if (type == 'profiles') {
+                        const profile = new profileCombine.Profile({
+                            sourceDir: sourceDir,
+                            targetDir: targetDir,
+                            metaDir: metaDir,
+                            sequence: promList.length + 1,
+                        })
+                        const profProm = profile.combine()
+                        promList.push(profProm)
+                        profProm.then(() => {
+                            global.processed.current++
+                        })
+                    } else if (type == 'permissionsets') {
+                        const permSet = new permSetCombine.Permset({
+                            sourceDir: sourceDir,
+                            targetDir: targetDir,
+                            metaDir: metaDir,
+                            sequence: promList.length + 1,
+                        })
+                        const permProm = permSet.combine()
+                        promList.push(permProm)
+                        permProm.then(() => {
+                            global.processed.current++
+                        })
+                    } else if (type == 'workflows') {
+                        const workflow = new workflowCombine.Combine({
+                            metadataDefinition: workflowDefinition.metadataDefinition,
+                            sourceDir: sourceDir,
+                            targetDir: targetDir,
+                            metaDir: metaDir,
+                            sequence: promList.length + 1,
+                        })
+                        const workflowProm = workflow.combine()
+                        promList.push(workflowProm)
+                        workflowProm.then((resolve, reject) => {
+                            global.processed.current++
+                        })
+                    }
+                })
+            } else if (type == 'labels') {
+                const label = new labelCombine.CustomLabel({
+                    sourceDir: sourceDir,
+                    targetDir: targetDir,
+                    metaDir: sourceDir, // use sourceDir
+                    processList: processList,
+                })
+                const labelProm = label.combine()
+                promList.push(labelProm)
+                labelProm.then(() => {
+                    global.processed.current++
+                })
+
+            }
+
+            Promise.allSettled(promList).then(([result]) => {
+                if (result !== undefined && result.status == 'fulfilled') {
+                    let message = `Combined ${chalk.bgBlackBright(global.processed.total)} file(s) in `
+                    displayMessage(startTime, message)
+                } else {
+                    global.logger.error((result !== undefined) ? result.reason : 'metadata error')
+                }
+            })
+        }
+    })
+    .demandCommand(1, errorMessage)
+    .example([
+        ['$0 split --type=profile --all'],
+        ['$0 split --type=profile --name="Profile Name"'],
+        ['$0 combine --type=permset --all'],
+        ['$0 combine --type=permset --name="Permission Set Name"'],
+    ])
+    .help()
+    .argv
+    .parse
+
+function displayMessage(startTime, message) {
+    const diff = process.hrtime.bigint() - BigInt(startTime)
+    let durationMessage
+    let executionTime = convertHrtime(diff);
+    let minutes = Math.floor((executionTime.seconds + Math.round(executionTime.milliseconds / 100000)) / 60)
+    let seconds = Math.round((executionTime.seconds + Math.round(executionTime.milliseconds / 100000)) % 60)
+    if (minutes == 0 && seconds == 0) {
+        durationMessage = message + chalk.magentaBright(`<1s`)
+    } else if (minutes > 0) {
+        durationMessage = message + chalk.magentaBright(`${minutes}m ${seconds}s`)
+    } else {
+        durationMessage = message + chalk.magentaBright(`${seconds}s`)
+    }
+    console.log('\n' + durationMessage)
+}
+
+let callAmount = 0;
+process.on('SIGINT', function () {
+    if (callAmount < 1) {
+        console.log(`✅ Received abort command`);
+        process.exit(1)
+    }
+
+    callAmount++;
+})