@ds-sfdc/sfparty 1.3.3 → 1.3.5

package/README.md

@@ -159,3 +159,10 @@ Optional:
 ```
 sfparty combine --git=HEAD~1..HEAD --append --delta --package=deploy/package.xml --destructive=deploy/destructiveChanges/destructiveChanges.xml
 ```
+#### Previous Commit to Current and output to different target directory
+
+The default target is the package file specified in the `sfdx-project.json` file. You can use the `--target` parameter if you want the files to be created in a different location. sfparty will create the /main/default/* directories accordingly.
+
+```
+sfparty combine --git=HEAD~1..HEAD --append --delta --package=deploy/package.xml --destructive=deploy/destructiveChanges/destructiveChanges.xml --target=deployDir/force-app
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ds-sfdc/sfparty",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Salesforce metadata XML splitter for CI/CD",
   "type": "module",
   "repository": {
@@ -25,7 +25,7 @@
   "dependencies": {
     "axios": "^1.2.2",
     "chai-as-promised": "^7.1.1",
-    "chalk": "^5.2.0",
+    "cli-color": "^2.0.3",
     "cli-spinners": "^2.7.0",
     "convert-hrtime": "^5.0.0",
     "js-yaml": "^4.1.0",

package/src/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 'use strict'
-import { exec } from 'child_process'
+import { exec, spawnSync } from 'child_process'
 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 clc from 'cli-color'
 import convertHrtime from 'convert-hrtime'
 import axios from 'axios'
 import { marked } from 'marked'
@@ -51,7 +51,7 @@ global.logger = winston.createLogger({
 
 global.icons = {
     "warn": '🔕',
-    "success": chalk.greenBright('✔'),
+    "success": clc.greenBright('✔'),
     "fail": '❗',
     "working": '⏳',
     "party": '🎉',
@@ -110,7 +110,7 @@ global.metaTypes = {
 let types = []
 const packageDir = getRootPath()
 
-let errorMessage = chalk.red('Please specify the action of ' + chalk.whiteBright.bgRedBright('split') + ' or ' + chalk.whiteBright.bgRedBright('combine') + '.')
+let errorMessage = clc.red('Please specify the action of ' + clc.whiteBright.bgRedBright('split') + ' or ' + clc.whiteBright.bgRedBright('combine') + '.')
 
 displayHeader() // display header mast
 
@@ -128,7 +128,7 @@ yargs(hideBin(process.argv))
         alias: 'test',
         handler: (argv) => {
             // THIS IS A PLACE TO TEST NEW CODE
-            global.logger.info(chalk.magentaBright(`${global.icons.party} TEST ${global.icons.party}`))
+            global.logger.info(clc.magentaBright(`${global.icons.party} TEST ${global.icons.party}`))
         }
     })
     .command({
@@ -139,7 +139,7 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion(axios, exec, pkgObj.default.version, true)
+            checkVersion(axios, spawnSync, pkgObj.default.version, true)
         }
     })
     .command({
@@ -154,7 +154,7 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion(axios, exec, pkgObj.default.version)
+            checkVersion(axios, spawnSync, pkgObj.default.version)
             global.format = argv.format
             splitHandler(argv, processStartTime)
         }
@@ -171,7 +171,7 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion(axios, exec, pkgObj.default.version)
+            checkVersion(axios, spawnSync, pkgObj.default.version)
             global.format = argv.format
             const startProm = new Promise((resolve, reject) => {
                 if (argv.git !== undefined) {
@@ -185,10 +185,10 @@ yargs(hideBin(process.argv))
                                 global.git.latest = data.latestCommit
                                 global.git.last = data.lastCommit
                                 if (data.last === undefined) {
-                                    console.log(`${chalk.yellowBright('git mode')} ${chalk.bgMagentaBright('not active:')} no prior commit - processing all`)
+                                    console.log(`${clc.yellowBright('git mode')} ${clc.bgMagentaBright('not active:')} no prior commit - processing all`)
                                     resolve(false)
                                 } else {
-                                    console.log(`${chalk.yellowBright('git mode')} ${chalk.magentaBright('active:')} ${chalk.bgBlackBright(data.lastCommit) + '..' + chalk.bgBlackBright(data.latestCommit)}`)
+                                    console.log(`${clc.yellowBright('git mode')} ${clc.magentaBright('active:')} ${clc.bgBlackBright(data.lastCommit) + '..' + clc.bgBlackBright(data.latestCommit)}`)
                                     console.log()
                                     const diff = git.diff(global.__basedir, `${data.lastCommit}..${data.latestCommit}`)
                                     diff
@@ -207,7 +207,7 @@ yargs(hideBin(process.argv))
                                 throw error
                             })
                     } else {
-                        console.log(`${chalk.yellowBright('git mode')} ${chalk.magentaBright('active:')} ${chalk.bgBlackBright(gitRef)}`)
+                        console.log(`${clc.yellowBright('git mode')} ${clc.magentaBright('active:')} ${clc.bgBlackBright(gitRef)}`)
                         console.log()
                         const diff = git.diff(global.__basedir, gitRef)
                         diff
@@ -254,7 +254,7 @@ function yargCheck(argv, options) {
         )
 
     if (invalidKeys.length > 0) {
-        const invalidKeysWithColor = invalidKeys.map(key => chalk.redBright(key))
+        const invalidKeysWithColor = invalidKeys.map(key => clc.redBright(key))
         throw new Error(`Invalid options specified: ${invalidKeysWithColor.join(', ')}`)
     }
 
@@ -270,13 +270,13 @@ function yargCheck(argv, options) {
     if (types.length > 1) {
         // if using multiple types you cannot specify name
         if ((typeof name != 'undefined' && name != '')) {
-            throw new Error(chalk.redBright('You cannot specify ' + chalk.whiteBright.bgRedBright('--name') + ' when using multiple types.'))
+            throw new Error(clc.redBright('You cannot specify ' + clc.whiteBright.bgRedBright('--name') + ' when using multiple types.'))
         }
     } else {
         switch (argv.type) {
             case 'label':
                 if ((typeof name != 'undefined' && name != '')) {
-                    throw new Error(chalk.redBright('You cannot specify ' + chalk.whiteBright.bgRedBright('--name') + '  when using label.'))
+                    throw new Error(clc.redBright('You cannot specify ' + clc.whiteBright.bgRedBright('--name') + '  when using label.'))
                 }
                 break
         }
@@ -291,11 +291,11 @@ function displayMessageAndDuration(startTime, message) {
     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`)
+        durationMessage = message + clc.magentaBright(`<1s`)
     } else if (minutes > 0) {
-        durationMessage = message + chalk.magentaBright(`${minutes}m ${seconds}s`)
+        durationMessage = message + clc.magentaBright(`${minutes}m ${seconds}s`)
     } else {
-        durationMessage = message + chalk.magentaBright(`${seconds}s`)
+        durationMessage = message + clc.magentaBright(`${seconds}s`)
     }
     console.log('\n' + durationMessage)
 }
@@ -384,8 +384,8 @@ function processSplit(typeItem, argv) {
 
         if (processed.total == 0) resolve(true)
 
-        console.log(`${chalk.bgBlackBright('Source path:')} ${sourceDir}`)
-        console.log(`${chalk.bgBlackBright('Target path:')} ${targetDir}`)
+        console.log(`${clc.bgBlackBright('Source path:')} ${sourceDir}`)
+        console.log(`${clc.bgBlackBright('Target path:')} ${targetDir}`)
         console.log()
         console.log(`Splitting a total of ${processed.total} file(s)`)
         console.log()
@@ -412,7 +412,7 @@ function processSplit(typeItem, argv) {
             })
         })
         Promise.allSettled(promList).then((results) => {
-            let message = `Split ${chalk.bgBlackBright((processed.current > promList.length) ? promList.length : processed.current)} file(s) ${(processed.errors > 0) ? 'with ' + chalk.bgBlackBright.red(processed.errors) + ' error(s) ' : ''}in `
+            let message = `Split ${clc.bgBlackBright((processed.current > promList.length) ? promList.length : processed.current)} file(s) ${(processed.errors > 0) ? 'with ' + clc.bgBlackBright.red(processed.errors) + ' error(s) ' : ''}in `
             displayMessageAndDuration(startTime, message)
             resolve(true)
         })
@@ -496,7 +496,7 @@ function processCombine(typeItem, argv) {
         }
 
         processed.total = processList.length
-        console.log(`${chalk.bgBlackBright(processed.total)} ${typeItem} file(s) to process`)
+        console.log(`${clc.bgBlackBright(processed.total)} ${typeItem} file(s) to process`)
 
         // Abort if there are no files to process
         if (processed.total == 0) {
@@ -505,8 +505,8 @@ function processCombine(typeItem, argv) {
         }
 
         console.log()
-        console.log(`${chalk.bgBlackBright('Source path:')} ${sourceDir}`)
-        console.log(`${chalk.bgBlackBright('Target path:')} ${targetDir}`)
+        console.log(`${clc.bgBlackBright('Source path:')} ${sourceDir}`)
+        console.log(`${clc.bgBlackBright('Target path:')} ${targetDir}`)
         console.log()
 
         const promList = []
@@ -538,7 +538,7 @@ function processCombine(typeItem, argv) {
                     errors++
                 }
             })
-            let message = `Combined ${chalk.bgBlackBright(successes)} file(s) ${(errors > 0) ? 'with ' + chalk.bgBlackBright(errors) + 'error(s) ' : ''}in `
+            let message = `Combined ${clc.bgBlackBright(successes)} file(s) ${(errors > 0) ? 'with ' + clc.bgBlackBright(errors) + 'error(s) ' : ''}in `
             displayMessageAndDuration(startTime, message)
             resolve(true)
         })
@@ -603,13 +603,13 @@ function displayHeader() {
         vertical: '│',
     }
     let versionString = `sfparty v${pkgObj.default.version}${(process.stdout.columns > pkgObj.default.description.length + 15) ? ' - ' + pkgObj.default.description : ''}`
-    let titleMessage = `${global.icons.party} ${chalk.yellowBright(versionString)} ${global.icons.party}`
+    let titleMessage = `${global.icons.party} ${clc.yellowBright(versionString)} ${global.icons.party}`
     titleMessage = titleMessage.padEnd((process.stdout.columns / 2) + versionString.length / 1.65)
     titleMessage = titleMessage.padStart(process.stdout.columns)
-    titleMessage = chalk.blackBright(box.vertical) + '  ' + titleMessage + '      ' + chalk.blackBright(box.vertical)
-    console.log(`${chalk.blackBright(box.topLeft + box.horizontal.repeat(process.stdout.columns - 2) + box.topRight)}`)
+    titleMessage = clc.blackBright(box.vertical) + '  ' + titleMessage + '      ' + clc.blackBright(box.vertical)
+    console.log(`${clc.blackBright(box.topLeft + box.horizontal.repeat(process.stdout.columns - 2) + box.topRight)}`)
     console.log(titleMessage)
-    console.log(`${chalk.blackBright(box.bottomLeft + box.horizontal.repeat(process.stdout.columns - 2) + box.bottomRight)}`)
+    console.log(`${clc.blackBright(box.bottomLeft + box.horizontal.repeat(process.stdout.columns - 2) + box.bottomRight)}`)
     console.log()
 }
 

package/src/lib/checkVersion.js

@@ -1,42 +1,78 @@
-export async function checkVersion(axios, exec, currentVersion, update = false) {
+import clc from 'cli-color'
+
+class NpmNotInstalledError extends Error {
+    constructor(message) {
+        super(message)
+        this.name = "NpmNotInstalledError"
+    }
+}
+
+class PackageNotFoundError extends Error {
+    constructor(message) {
+        super(message)
+        this.name = "PackageNotFoundError"
+    }
+}
+
+class UpdateError extends Error {
+    constructor(message) {
+        super(message)
+        this.name = "UpdateError"
+    }
+}
+
+export async function checkVersion(axios, spawnSync, currentVersion, update = false) {
     try {
-        const { data } = await axios.get('https://registry.npmjs.org/@ds-sfdc/sfparty')
-        const command = 'npm i -g @ds-sfdc/sfparty@latest'
+        const { data } = await axios.get('https://registry.npmjs.org/@ds-sfdc/sfparty', {
+            params: {
+                field: 'dist-tags.latest'
+            }
+        })
         if (currentVersion !== data['dist-tags'].latest) {
-            console.log(`${(update) ? global.icons.working : global.icons.fail} A newer version ${chalk.bgCyanBright(data['dist-tags'].latest)} is available.`)
+            let icon
+            const version = clc.bgCyanBright(data['dist-tags'].latest)
+            if (update) {
+                icon = global.icons.working
+            } else {
+                icon = global.icons.fail
+            }
+            console.log(`${icon} A newer version ${version} is available.`)
             if (!update) {
-                console.log(`Please upgrade by running ${chalk.cyanBright('sfparty update')}`)
+                console.log(`Please upgrade by running ${clc.cyanBright('sfparty update')}`)
                 return 'A newer version'
             } else {
-                console.log(`Updating the application using ${chalk.cyanBright(command)}`)
-                exec('npm -v', (error, stdout, stderr) => {
-                    if (error) {
-                         global.logger.error("npm is not installed on this system. Please install npm and run the command again.")
-                        return 'npm is not installed'
-                    } else {
-                        exec(command, (error, stdout, stderr) => {
-                            if (error) {
-                                global.logger.error(error)
-                                reject(error)
-                            } else {
-                                console.log(stdout)
-                                console.log(stderr)
-                                resolve(true)
-                            }
-                        })
+                let command = 'npm i -g @ds-sfdc/sfparty'.split(' ')
+                console.log(`Updating the application using ${clc.cyanBright(command.join(' '))}`)
+                try {
+                    const npmVersion = spawnSync('npm', ['-v'])
+                    if (npmVersion.stderr.toString().trim() === 'command not found') {
+                        throw new NpmNotInstalledError("npm is not installed on this system. Please install npm and run the command again.")
+                    }
+                    const update = spawnSync(command[0], command.slice(1))
+                    if (update.status !== 0) {
+                        throw new UpdateError("Error updating the application.")
                     }
-                })
+                    console.log("Application updated successfully.")
+                } catch (err) {
+                    if (err instanceof NpmNotInstalledError) {
+                        console.error(err)
+                    } else if (err instanceof UpdateError) {
+                        console.error(err)
+                    }
+                    throw err
+                }
             }
         } else {
             if (update) {
                 console.log(`${global.icons.success} You are on the latest version.`)
-                return 'You are on the latest version'
             }
+            return 'You are on the latest version'
         }
     } catch (error) {
-        global.logger.error(error)
+        if (error.response && error.response.status === 404) {
+            error = new PackageNotFoundError("Package not found on the npm registry")
+        }
+        console.error(error)
         throw error
     }
-}
-
-
+}

package/src/lib/fileUtils.js

@@ -133,6 +133,7 @@ async function convertXML(data) {
         try {
             let parser = new Parser()
             parser.parseString(data, function (err, result) {
+                if (err) throw err
                 resolve(result)
             })
         } catch (error) {

package/src/lib/packageUtil.js

@@ -1,7 +1,4 @@
 import path from 'path'
-import chalk from 'chalk'
-import * as xml2js from 'xml2js'
-import * as fileUtils from './fileUtils.js'
 import * as packageDefinition from '../meta/Package.js'
 
 export class Package {
@@ -12,30 +9,45 @@ export class Package {
         this.packageJSON = undefined
     }
 
-    getPackageXML() {
+    getPackageXML(fileUtils) {
         const that = this
         return new Promise((resolve, reject) => {
-            if (that.xmlPath === undefined) throw new Error('Package not initialized')
-
-            let fileName = path.resolve(that.xmlPath)
-            if (fileUtils.fileExists(fileName) && global.git.append) {
-                let data = fileUtils.readFile(fileName)
-                data
-                    .then((json) => {
+            try {
+                if (that.xmlPath === undefined) throw new Error('Package not initialized')
+
+                let fileName = path.resolve(that.xmlPath)
+                if (fileUtils.fileExists(fileName) && global.git.append) {
+                    let data = fileUtils.readFile(fileName)
+                    data
+                        .then((json) => {
+                            try {
+                                if (json === undefined || Object.keys(json).length === 0 ) json = packageDefinition.metadataDefinition.emptyPackage
+                                processJSON(that, json, fileUtils)
+                                resolve('existing')                                    
+                            } catch (error) {
+                                console.error(error)
+                                reject(error)
+                            }
+                        })
+                        .catch((error) => {
+                            reject(error)
+                        })
+                } else {
+                    try {
+                        let json = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyPackage))
                         processJSON(that, json)
-                        resolve('existing')
-                    })
-                    .catch((error) => {
+                        resolve('not found')                            
+                    } catch (error) {
                         reject(error)
-                    })
-            } else {
-                let json = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyPackage))
-                processJSON(that, json)
-                resolve('not found')
+                    }
+                }                
+            } catch (error) {
+                reject(error)
             }
+
         })
 
-        function processJSON(that, json) {
+        function processJSON(that, json, fileUtils) {
             try {
                 json.Package.version = fileUtils.readFile(path.join(global.__basedir, 'sfdx-project.json')).sourceApiVersion
             } catch (error) {
@@ -49,8 +61,9 @@ export class Package {
     addMember(type, member) {
         const that = this
         if (that.packageJSON === undefined) throw new Error('getPackageXML must be called before adding members')
-        if (type === undefined) throw new Error('An undefined type was received when attempting to add a member')
-        if (member === undefined) throw new Error('An undefined member was received when attempting to add a member')
+        if (type === undefined || type.trim() == '') throw new Error('An undefined type was received when attempting to add a member')
+        if (member === undefined || member.trim() == '') throw new Error('An undefined member was received when attempting to add a member')
+        if (member.indexOf(`.${global.format}`) !== -1)  throw new Error('Part file received as member is not allowed')
 
         const packageJSON = that.packageJSON
         let foundMember = false
@@ -77,82 +90,99 @@ export class Package {
                     })
                 }
             } catch (error) {
-                global.displayError(error, true)
+                throw error
             }
         })
 
         // exit if member already exists
         if (foundMember) return
         if (foundAsterisk) {
-            // global.logger.warn(`Found ${chalk.bgBlackBright('*')} in type: ${type}.`)
             return
         }
 
-        if (typeJSON !== undefined) {
-            typeJSON.members.push(member)
-            typeJSON.members.sort()
-        } else {
-            typeJSON = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyNode))
-            typeJSON.name = type
-            typeJSON.members.push(member)
-
-            packageJSON.Package.types.push(typeJSON)
+        try {
+            if (typeJSON !== undefined) {
+                typeJSON.members.push(member)
+                typeJSON.members.sort()
+            } else {
+                typeJSON = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyNode))
+                typeJSON.name = type
+                typeJSON.members.push(member)
+    
+                packageJSON.Package.types.push(typeJSON)
+            }
+    
+            packageJSON.Package.types.sort((a, b) => {
+                if (a.name < b.name) return -1
+                if (a.name > b.name) return 1
+                return 0
+            })                
+        } catch (error) {
+            throw error
         }
-
-        packageJSON.Package.types.sort((a, b) => {
-            if (a.name < b.name) return -1
-            if (a.name > b.name) return 1
-            return 0
-        })
     }
 
-    savePackage() {
+    savePackage(xml2js, fileUtils) {
         let that = this
         let json = that.packageJSON.Package
-        json.$.xmlns = json.$.xmlns.replace('http:', 'https:')
-
-        const builder = new xml2js.Builder(
-            {
-                cdata: false,
-                rootName: 'Package',
-                xmldec: { 'version': '1.0', 'encoding': 'UTF-8' }
-            }
-        )
-        let fileName = that.xmlPath
-        fileUtils.createDirectory(path.dirname(fileName))
-
-        const xml = builder.buildObject(json)
-
-        fileUtils.writeFile(fileName, xml)
+        try {
+            json.$.xmlns = json.$.xmlns.replace('http:', 'https:')
+            const version = json.version
+            delete json.version
+            json.version = version
+
+            const builder = new xml2js.Builder(
+                {
+                    cdata: false,
+                    rootName: 'Package',
+                    xmldec: { 'version': '1.0', 'encoding': 'UTF-8' }
+                }
+            )
+            let fileName = that.xmlPath
+            fileUtils.createDirectory(path.dirname(fileName))
+    
+            const xml = builder.buildObject(json)
+    
+            fileUtils.writeFile(fileName, xml)
+                
+        } catch (error) {
+            throw error            
+        }
     }
 }
 
 function transformJSON(json) {
-    json.forEach(typesItem => {
-        Object.keys(typesItem).forEach(key => {
-            let jsonString = JSON.stringify(typesItem[key], (name, value) => {
-                if (key == 'members') {
-                    return value
-                } else {
-                    return xml2json(value)
-                }
+    try {
+        json.forEach(typesItem => {
+            Object.keys(typesItem).forEach(key => {
+                let jsonString = JSON.stringify(typesItem[key], (name, value) => {
+                    if (key == 'members') {
+                        return value
+                    } else {
+                        return xml2json(value)
+                    }
+                })
+                typesItem[key] = JSON.parse(jsonString)
             })
-            typesItem[key] = JSON.parse(jsonString)
         })
-    })
-
-    return
-}
+    
+        return            
+    } catch (error) {
+        throw error
+    }
 
-function xml2json(currentValue) {
-    if (Array.isArray(currentValue)) {
-        if (currentValue.length == 1) {
-            currentValue = currentValue[0].toString().trim()
+    function xml2json(currentValue) {
+        try {
+            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            
+        } catch (error) {
+            throw error
         }
     }
-    if (currentValue == 'true') currentValue = true
-    if (currentValue == 'false') currentValue = false
-    return currentValue
 }
-
-// Create JEST tests that cover 100% of the code

package/src/party/combine.js

@@ -1,6 +1,6 @@
 import path from 'path'
 import logUpdate from 'log-update'
-import chalk from 'chalk'
+import clc from 'cli-color'
 import convertHrtime from 'convert-hrtime'
 import cliSpinners from 'cli-spinners'
 import os from 'node:os'
@@ -110,8 +110,8 @@ export class Combine {
             if (global.git.enabled) {
                 that.#addPkg = new packageUtil.Package(that.addManifest)
                 that.#desPkg = new packageUtil.Package(that.desManifest)
-                const prom1 = that.#addPkg.getPackageXML()
-                const prom2 = that.#desPkg.getPackageXML()
+                const prom1 = that.#addPkg.getPackageXML(fileUtils)
+                const prom2 = that.#desPkg.getPackageXML(fileUtils)
 
                 Promise.allSettled([prom1, prom2])
                     .then((results) => {
@@ -130,20 +130,24 @@ export class Combine {
         function processStart(that) {
             let success = getXML(that)
             if (success) {
-                if (!that.metadataDefinition.packageTypeIsDirectory) that.#addPkg.addMember(that.#root, that.#fileName.shortName)
+                if (!that.metadataDefinition.packageTypeIsDirectory && global.git.enabled) {
+                    that.#addPkg.addMember(that.#root, that.#fileName.shortName)
+                }
                 saveXML(that)
                 if (global.git.enabled) savePackageXML(that)
                 return true
             } else {
                 logUpdate(that.#spinnerMessage
                     .replace('[%1]', that.sequence.toString().padStart(that.total.toString().length, ' '))
-                    .replace('[%2]', `. ${chalk.redBright('source not found - removing XML file')}`)
+                    .replace('[%2]', `. ${clc.redBright('source not found - removing XML file')}`)
                     .replace('[%3]', ``)
                     .replace('[%4]', `${global.icons.delete} `)
                     .replace('[%5]', that.#fileName.shortName)
                 )
                 logUpdate.done()
-                if (!that.metadataDefinition.packageTypeIsDirectory) that.#desPkg.addMember(that.#root, that.#fileName.shortName)
+                if (!that.metadataDefinition.packageTypeIsDirectory && global.git.enabled) {
+                    that.#desPkg.addMember(that.#root, that.#fileName.shortName)
+                } 
                 deleteFile(that.#fileName.fullName)
                 if (global.git.enabled) savePackageXML(that)
                 return 'deleted'
@@ -151,8 +155,8 @@ export class Combine {
         }
 
         function savePackageXML(that) {
-            that.#addPkg.savePackage()
-            that.#desPkg.savePackage()
+            that.#addPkg.savePackage(xml2js, fileUtils)
+            that.#desPkg.savePackage(xml2js, fileUtils)
         }
 
         function getXML(that) {
@@ -163,14 +167,14 @@ export class Combine {
             processed.current++
 
             that.#startTime = process.hrtime.bigint()
-            that.#spinnerMessage = `[%1] of ${that.total} - ${that.#root}: [%4]${chalk.yellowBright('[%5]')}[%2][%3]`
+            that.#spinnerMessage = `[%1] of ${that.total} - ${that.#root}: [%4]${clc.yellowBright('[%5]')}[%2][%3]`
 
             try {
                 that.#types.forEach(key => {
                     // display message
                     logUpdate(that.#spinnerMessage
                         .replace('[%1]', that.sequence.toString().padStart(that.total.toString().length, ' '))
-                        .replace('[%2]', `\n${chalk.magentaBright(nextFrame(that))} ${key}`)
+                        .replace('[%2]', `\n${clc.magentaBright(nextFrame(that))} ${key}`)
                         .replace('[%3]', `${that.#errorMessage}`)
                         .replace('[%4]', `${global.icons.working} `)
                         .replace('[%5]', `${that.#fileName.shortName} `)
@@ -195,7 +199,7 @@ export class Combine {
                     } else if (that.metadataDefinition.directories.includes(key)) {
                         processDirectory(that, key)
                     } else {
-                        global.logger.warn(`Unexpected metadata type: ${chalk.redBright(key)}`)
+                        global.logger.warn(`Unexpected metadata type: ${clc.redBright(key)}`)
                     }
                 })
                 return true
@@ -230,7 +234,7 @@ export class Combine {
                 fileList.forEach((file, index) => {
                     logUpdate(that.#spinnerMessage
                         .replace('[%1]', that.sequence.toString().padStart(that.total.toString().length, ' '))
-                        .replace('[%2]', `\n${chalk.magentaBright(nextFrame(that))} ${key} - ${index + 1} of ${fileList.length} - ${chalk.magentaBright(file)}`)
+                        .replace('[%2]', `\n${clc.magentaBright(nextFrame(that))} ${key} - ${index + 1} of ${fileList.length} - ${clc.magentaBright(file)}`)
                         .replace('[%3]', `${that.#errorMessage}`)
                         .replace('[%4]', `${global.icons.working} `)
                         .replace('[%5]', `${that.#fileName.shortName} `)
@@ -259,7 +263,7 @@ export class Combine {
                 fileObj.shortName === undefined ||
                 fileObj.fullName === undefined
             ) {
-                global.displayError(`${global.icons.warn} Invalid file information passed ${chalk.redBright(fileObj)}`, true)
+                global.displayError(`${global.icons.warn} Invalid file information passed ${clc.redBright(fileObj)}`, true)
             }
 
             if (!fileUtils.fileExists(fileObj.fullName)) {
@@ -270,7 +274,9 @@ export class Combine {
                 }
 
                 if (that.metadataDefinition.packageTypeIsDirectory) {
-                    that.#desPkg.addMember(that.#root, fileObj.shortName.replace(`.${global.format}`, ''))
+                    if (global.git.enabled) {
+                        that.#desPkg.addMember(that.#root, fileObj.shortName.replace(`.${global.format}`, ''))
+                    }
                 }
                 return true
             }
@@ -313,7 +319,9 @@ export class Combine {
 
             if (that.metadataDefinition.packageTypeIsDirectory) {
                 if (fileObj.fullName !== path.join(that.sourceDir, that.metaDir, `main.${global.format}`)) {
-                    that.#addPkg.addMember(that.#root, fileObj.shortName.replace(`.${global.format}`, ''))
+                    if (global.git.enabled) {
+                        that.#addPkg.addMember(that.#root, fileObj.shortName.replace(`.${global.format}`, ''))
+                    }
                 }
             }
 

package/src/party/split.js

@@ -4,7 +4,7 @@ import path from 'path'
 import { readFile } from 'fs'
 import { Parser } from 'xml2js'
 import logUpdate from 'log-update'
-import chalk from 'chalk'
+import clc from 'cli-color'
 import convertHrtime from 'convert-hrtime'
 import cliSpinners from 'cli-spinners'
 import * as fileUtils from '../lib/fileUtils.js'
@@ -128,7 +128,7 @@ export class Split {
         })
 
         function processJSON(that, json, baseDir) {
-            that.#spinnerMessage = `[%1] of ${that.total} - ${that.#root}: [%4]${chalk.yellowBright(that.#fileName.shortName)}[%2][%3]`
+            that.#spinnerMessage = `[%1] of ${that.total} - ${that.#root}: [%4]${clc.yellowBright(that.#fileName.shortName)}[%2][%3]`
 
             let targetDir = baseDir
             if (processed.type != that.#root) {
@@ -140,7 +140,7 @@ export class Split {
                 that.sequence = processed.current
                 logUpdate(that.#spinnerMessage
                     .replace('[%1]', that.sequence.toString().padStart(that.total.toString().length, ' '))
-                    .replace('[%2]', `\n${chalk.magentaBright(nextFrame(that))} ${key}`)
+                    .replace('[%2]', `\n${clc.magentaBright(nextFrame(that))} ${key}`)
                     .replace('[%3]', `${that.#errorMessage}`)
                     .replace('[%4]', `${global.icons.working} `)
                 )
@@ -176,7 +176,7 @@ export class Split {
                 that.sequence = processed.current
                 logUpdate(that.#spinnerMessage
                     .replace('[%1]', that.sequence.toString().padStart(that.total.toString().length, ' '))
-                    .replace('[%2]', `\n${chalk.magentaBright(nextFrame(that))} ${key}`)
+                    .replace('[%2]', `\n${clc.magentaBright(nextFrame(that))} ${key}`)
                     .replace('[%3]', `${that.#errorMessage}`)
                     .replace('[%4]', `${global.icons.working} `)
                 )

package/test/checkVersion.spec.js

@@ -0,0 +1,69 @@
+import axios from 'axios'
+import { spawnSync } from 'child_process'
+import clc from 'cli-color'
+import { checkVersion } from '../src/lib/checkVersion.js'
+
+global.icons = {
+    "success": clc.greenBright('✔'),
+    "fail": '❗',
+    "working": '⏳',
+}
+
+jest.mock('axios')
+jest.mock('child_process', () => ({ spawnSync: jest.fn() }))
+
+describe('checkVersion', () => {
+    let spy
+    beforeEach(() => {
+        jest.clearAllMocks()
+        spy = jest.spyOn(console, 'log')
+    })
+    afterEach(() => {
+        spy.mockRestore()
+    })
+
+    it('should return "A newer version" if a newer version is available', async () => {
+        axios.get.mockResolvedValue({ data: { 'dist-tags': { latest: '2.0.0' } } })
+        const result = await checkVersion(axios, spawnSync, '1.0.0')
+        expect(result).toBe('A newer version')
+    })
+
+    it('should return "You are on the latest version" if the current version is the latest version', async () => {
+        axios.get.mockResolvedValue({ data: { 'dist-tags': { latest: '1.0.0' } } })
+        const result = await checkVersion(axios, spawnSync, '1.0.0')
+        expect(result).toBe('You are on the latest version')
+    })
+
+    it('should throw a NpmNotInstalledError if npm is not installed', async () => {
+        axios.get.mockResolvedValue({ data: { 'dist-tags': { latest: '2.0.0' } } })
+        spawnSync.mockReturnValue({ status: 1, stderr: { toString: () => 'command not found' } })
+        try {
+            await checkVersion(axios, spawnSync, '1.0.0', true)
+        } catch (err) {
+            expect(err.name).toBe('NpmNotInstalledError')
+            expect(err.message).toBe('npm is not installed on this system. Please install npm and run the command again.')
+        }
+    })
+
+    it('should throw a PackageNotFoundError if the package is not found on the npm registry', async () => {
+        axios.get.mockRejectedValue({ response: { status: 404 } });
+        try {
+            await checkVersion(axios, spawnSync, '1.0.0');
+        } catch (err) {
+            expect(err.name).toBe('PackageNotFoundError');
+            expect(err.message).toBe('Package not found on the npm registry');
+        }
+    });
+    
+    it('should throw a UpdateError if an error occurs while updating the package', async () => {
+        axios.get.mockResolvedValue({ data: { 'dist-tags': { latest: '2.0.0' } } });
+        spawnSync.mockReturnValue({ status: 1, stderr: { toString: () => 'Update error' } });
+        try {
+            await checkVersion(axios, spawnSync, '1.0.0', true);
+        } catch (err) {
+            expect(err.name).toBe('UpdateError');
+            expect(err.message).toBe('Error updating the application.');
+        }
+    });
+    
+})

package/test/lib/git/diff.spec.js

@@ -10,45 +10,43 @@ jest.mock('child_process', () => ({
 }))
 const gitRef = "HEAD~1..HEAD"
 
-describe('diff', () => {
-    beforeEach(() => {
-        jest.clearAllMocks()
-    })
+beforeEach(() => {
+    jest.clearAllMocks()
+})
 
-    test('rejects if directory is not a git repository', async () => {
-        existsSync.mockReturnValueOnce(false)
-        try {
-            await diff('/path/to/dir')
-            fail('Expected function to throw an error', gitRef, existsSync)
-        } catch (error) {
-            expect(error.message).toEqual('The directory "/path/to/dir" is not a git repository')
-        }
-    })
+test('rejects if directory is not a git repository', async () => {
+    existsSync.mockReturnValueOnce(false)
+    try {
+        await diff('/path/to/dir')
+        fail('Expected function to throw an error', gitRef, existsSync)
+    } catch (error) {
+        expect(error.message).toEqual('The directory "/path/to/dir" is not a git repository')
+    }
+})
 
-    test('resolves with files when git diff command is successful', async () => {
-        existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
-        execSync.mockReturnValueOnce(
-`A\tfile1.txt
+test('resolves with files when git diff command is successful', async () => {
+    existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+    execSync.mockReturnValueOnce(
+        `A\tfile1.txt
 M\tfile2.txt
 D\tfile3.txt`)
 
-        const files = await diff('/path/to/dir', gitRef, existsSync, execSync)
-        expect(files).toEqual([
-            { type: 'add', path: 'file1.txt', action: 'add' },
-            { type: 'modify', path: 'file2.txt', action: 'add' },
-            { type: 'delete', path: 'file3.txt', action: 'delete' }
-        ])
-    })
+    const files = await diff('/path/to/dir', gitRef, existsSync, execSync)
+    expect(files).toEqual([
+        { type: 'add', path: 'file1.txt', action: 'add' },
+        { type: 'modify', path: 'file2.txt', action: 'add' },
+        { type: 'delete', path: 'file3.txt', action: 'delete' }
+    ])
+})
 
-    test('rejects when git diff command fails', async () => {
-        existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
-        execSync.mockImplementation(() => { throw new Error('Command failed') })
+test('rejects when git diff command fails', async () => {
+    existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+    execSync.mockImplementation(() => { throw new Error('Command failed') })
 
-        try {
-            await diff('/path/to/dir', gitRef, existsSync, execSync)
-            fail('Expected function to throw an error')
-        } catch (error) {
-            expect(error.message).toEqual('Command failed')
-        }
-    })
+    try {
+        await diff('/path/to/dir', gitRef, existsSync, execSync)
+        fail('Expected function to throw an error')
+    } catch (error) {
+        expect(error.message).toEqual('Command failed')
+    }
 })

package/test/lib/git/log.spec.js

@@ -8,26 +8,24 @@ jest.mock('child_process', () => {
     }
 })
 
-describe('log', () => {
-    beforeEach(() => {
-        jest.resetAllMocks()
-    })
+beforeEach(() => {
+    jest.resetAllMocks()
+})
 
-    it('should return an array of git commit hashes', () => {
-        const commits = ['1234567890abcdef', '234567890abcdef1', '34567890abcdef12']
-        execSync.mockReturnValue(commits.join(os.EOL))
-        const dir = process.cwd()
-        const gitRef = 'HEAD~1..HEAD'
-        const result = log(dir, gitRef, execSync)
-        expect(execSync).toHaveBeenCalledWith(`git log --format=format:%H ${gitRef}`, { cwd: dir, encoding: 'utf-8' })
-        expect(result).toEqual(commits)
-    })
+it('should return an array of git commit hashes', () => {
+    const commits = ['1234567890abcdef', '234567890abcdef1', '34567890abcdef12']
+    execSync.mockReturnValue(commits.join(os.EOL))
+    const dir = process.cwd()
+    const gitRef = 'HEAD~1..HEAD'
+    const result = log(dir, gitRef, execSync)
+    expect(execSync).toHaveBeenCalledWith(`git log --format=format:%H ${gitRef}`, { cwd: dir, encoding: 'utf-8' })
+    expect(result).toEqual(commits)
+})
 
-    it('should throw an error if git is not installed or no entry found in path', () => {
-        const error = { message: 'ENOENT' }
-        execSync.mockImplementation(() => { throw error })
-        const dir = process.cwd()
-        const gitRef = 'HEAD~1..HEAD'
-        expect(() => log(dir, gitRef, execSync)).toThrowError('git not installed or no entry found in path')
-    })
+it('should throw an error if git is not installed or no entry found in path', () => {
+    const error = { message: 'ENOENT' }
+    execSync.mockImplementation(() => { throw error })
+    const dir = process.cwd()
+    const gitRef = 'HEAD~1..HEAD'
+    expect(() => log(dir, gitRef, execSync)).toThrowError('git not installed or no entry found in path')
 })

package/test/lib/package/addMember.spec.js

@@ -0,0 +1,49 @@
+import * as packageDefinition from '../../../src/meta/Package.js'
+import { Package } from '../../../src/lib/packageUtil.js'
+
+let pkg;
+beforeEach(() => {
+    pkg = new Package('xmlPath');
+    pkg.packageJSON = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyPackage));
+});
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+it('should add a member to the pkg JSON', () => {
+    pkg.addMember('type', 'member');
+    expect(pkg.packageJSON.Package.types[0].name).toBe('type');
+    expect(pkg.packageJSON.Package.types[0].members).toEqual(['member']);
+});
+
+it('should throw an error if packageJSON is undefined', () => {
+    pkg.packageJSON = undefined;
+    expect(() => pkg.addMember('type', 'member')).toThrowError('getPackageXML must be called before adding members');
+});
+
+it('should throw an error if type is undefined', () => {
+    expect(() => pkg.addMember(undefined, 'member')).toThrowError('An undefined type was received when attempting to add a member');
+});
+
+it('should throw an error if member is undefined', () => {
+    expect(() => pkg.addMember('type', undefined)).toThrowError('An undefined member was received when attempting to add a member');
+});
+
+it('should throw an error if member is a part file', () => {
+    global.format = "part"
+    expect(() => pkg.addMember('type', 'member.part')).toThrowError('Part file received as member is not allowed');
+});
+
+it('should not add the member if it already exists', () => {
+    pkg.packageJSON.Package.types = [{ name: "type", members: ["member"] }];
+    pkg.addMember('type', 'member');
+    expect(pkg.packageJSON.Package.types[0].members).toEqual(["member"]);
+});
+
+it('should not add the member if type already has an asterisk', () => {
+    pkg.packageJSON.Package.types = [{ name: "type", members: ["*"] }];
+    pkg.addMember('type', 'member');
+    expect(pkg.packageJSON.Package.types[0].members).toEqual(["*"]);
+});

package/test/lib/package/getPackageXML.spec.js

@@ -0,0 +1,57 @@
+import * as packageDefinition from '../../../src/meta/Package.js'
+import { Package } from '../../../src/lib/packageUtil.js'
+
+let pkg;
+const fileUtils = {
+    fileExists: jest.fn(),
+    readFile: jest.fn(),
+}
+beforeEach(() => {
+    pkg = new Package('xmlPath');
+});
+global.__basedir = '.'
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+it('should default the package if the json is empty', async () => {
+    fileUtils.fileExists.mockReturnValue(true);
+    fileUtils.readFile.mockResolvedValue({});
+    global.git = { append: true }
+    const result = await pkg.getPackageXML(fileUtils);
+    expect(result).toBe('existing');
+    expect(fileUtils.fileExists).toHaveBeenCalled();
+    expect(fileUtils.readFile).toHaveBeenCalled();
+    expect(pkg.packageJSON).toEqual(packageDefinition.metadataDefinition.emptyPackage);
+});
+
+it('should read an existing file and call processJSON', async () => {
+    fileUtils.fileExists.mockReturnValue(true);
+    fileUtils.readFile.mockResolvedValue(packageDefinition.metadataDefinition.emptyPackage);
+    global.git = { append: true }
+    const result = await pkg.getPackageXML(fileUtils);
+    expect(result).toBe('existing');
+    expect(fileUtils.fileExists).toHaveBeenCalled();
+    expect(fileUtils.readFile).toHaveBeenCalled();
+});
+
+it('should create an empty pkg JSON and call processJSON', async () => {
+    fileUtils.fileExists.mockReturnValue(false);
+    const finalJSON = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyPackage))
+    finalJSON.Package.version = packageDefinition.metadataDefinition.fallbackVersion
+    const result = await pkg.getPackageXML(fileUtils);
+    expect(result).toBe('not found');
+    expect(fileUtils.fileExists).toHaveBeenCalled();
+    expect(pkg.packageJSON).toEqual(finalJSON);
+});
+
+it('should throw an error if xmlPath is undefined', async () => {
+    pkg.xmlPath = undefined;
+    await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Package not initialized');
+});
+
+it('should throw an error if error occurs during processing', async () => {
+    fileUtils.fileExists.mockReturnValue(true);
+    fileUtils.readFile.mockRejectedValue(new Error('Error'));
+    await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Error');
+});

package/test/lib/package/savePackage.spec.js

@@ -0,0 +1,57 @@
+import * as xml2js from 'xml2js'
+import path from 'path'
+import fs from 'fs'
+import { Package } from '../../../src/lib/packageUtil.js'
+
+const fileUtils = {
+  createDirectory: jest.fn(),
+  writeFile: jest.fn()
+}
+
+describe('savePackage', () => {
+  let pkg
+  beforeEach(() => {
+    pkg = new Package('path/to/file.xml')
+    pkg.packageJSON = {
+      Package: {
+        $: { xmlns: 'http://www.example.com' },
+        version: '1.0'
+      }
+    }
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('should replace http with https in xmlns property', () => {
+    pkg.savePackage(xml2js, fileUtils)
+    expect(pkg.packageJSON.Package.$.xmlns).toBe('https://www.example.com')
+  })
+
+  it('should save version property to variable, delete it from json and set it again', () => {
+    const version = pkg.packageJSON.Package.version
+    pkg.savePackage(xml2js, fileUtils)
+    expect(version).toBe('1.0')
+    expect(pkg.packageJSON.Package.version).toBe(version)
+  })
+
+  it('should build xml object from json and write it to a file', () => {
+    pkg.addMember('type', 'member');
+    expect(pkg.packageJSON.Package.types[0].name).toBe('type');
+    expect(pkg.packageJSON.Package.types[0].members).toEqual(['member']);
+      pkg.savePackage(xml2js, fileUtils)
+    const xml = '<?xml version="1.0" encoding="UTF-8"?>\n<Package xmlns="https://www.example.com">\n  <types>\n    <members>member</members>\n    <name>type</name>\n  </types>\n  <version>1.0</version>\n</Package>'
+    expect(fileUtils.createDirectory).toHaveBeenCalledWith(path.dirname('path/to/file.xml'))
+    expect(fileUtils.writeFile).toHaveBeenCalledWith('path/to/file.xml', xml)
+  })
+
+  it('should throw an error if it occurs', () => {
+    fileUtils.createDirectory.mockImplementation(() => {
+      throw new Error('createDirectory error')
+    })
+    expect(() => {
+      pkg.savePackage(xml2js, fileUtils)
+    }).toThrowError('createDirectory error')
+  })
+})