@ds-sfdc/sfparty 1.2.6 → 1.3.0

package/src/index.js

@@ -13,7 +13,6 @@ import { marked } from 'marked'
 import markedTerminal from 'marked-terminal'
 
 import * as fileUtils from './lib/fileUtils.js'
-import * as pkgObj from '../package.json'  assert { type: "json" }
 import * as yargOptions from './meta/yargs.js'
 import * as metadataSplit from './party/split.js'
 import * as metadataCombine from './party/combine.js'
@@ -21,8 +20,10 @@ import * as labelDefinition from './meta/CustomLabels.js'
 import * as profileDefinition from './meta/Profiles.js'
 import * as permsetDefinition from './meta/PermissionSets.js'
 import * as workflowDefinition from './meta/Workflows.js'
+import { checkVersion } from './lib/checkVersion.js'
 import * as git from './lib/gitUtils.js'
 
+const pkgObj = fileUtils.readFile('package.json')
 const processStartTime = process.hrtime.bigint()
 
 marked.setOptions({
@@ -139,7 +140,7 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion(pkgObj.default.version, true)
+            checkVersion(axios, exec, pkgObj.version, true)
         }
     })
     .command({
@@ -154,7 +155,7 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion(pkgObj.default.version)
+            checkVersion(axios, exec, pkgObj.version)
             global.format = argv.format
             splitHandler(argv, processStartTime)
         }
@@ -171,7 +172,7 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion(pkgObj.default.version)
+            checkVersion(axios, exec, pkgObj.version)
             global.format = argv.format
             const startProm = new Promise((resolve, reject) => {
                 if (argv.git !== undefined) {
@@ -551,7 +552,7 @@ function gitFiles(data) {
             const pathArray = item.path.split(path.sep)
             if (pathArray.length > 3) {
                 if (getDirectories().includes(pathArray[3])) {
-                    switch (git.action[item.type]) {
+                    switch (item.action) {
                         case 'add':
                             global.metaTypes[getKey(pathArray[3])].add.files.push(path.join(global.__basedir, item.path))
                             if (!global.metaTypes[getKey(pathArray[3])].add.directories.includes(pathArray[4])) {
@@ -602,7 +603,7 @@ function displayHeader() {
         horizontal: '─',
         vertical: '│',
     }
-    let versionString = `sfparty v${pkgObj.default.version}${(process.stdout.columns > pkgObj.default.description.length + 15) ? ' - ' + pkgObj.default.description : ''}`
+    let versionString = `sfparty v${pkgObj.version}${(process.stdout.columns > pkgObj.description.length + 15) ? ' - ' + pkgObj.description : ''}`
     let titleMessage = `${global.icons.party} ${chalk.yellowBright(versionString)} ${global.icons.party}`
     titleMessage = titleMessage.padEnd((process.stdout.columns / 2) + versionString.length / 1.65)
     titleMessage = titleMessage.padStart(process.stdout.columns)
@@ -640,42 +641,3 @@ function getRootPath(packageDir) {
 
     return defaultDir
 }
-
-export async function checkVersion(currentVersion, update = false, test = false) {
-    try {
-        const { data } = await axios.get('https://registry.npmjs.org/@ds-sfdc/sfparty')
-        const command = 'npm i -g @ds-sfdc/sfparty@latest'
-        if (currentVersion !== data['dist-tags'].latest) {
-            if (!test) console.log(`${(update) ? global.icons.working : global.icons.fail} A newer version ${chalk.bgCyanBright(data['dist-tags'].latest)} is available.`)
-            if (!update) {
-                if (test) return 'A newer version'
-                console.log(`Please upgrade by running ${chalk.cyanBright('sfparty update')}`)
-            } else {
-                if (!test) console.log(`Updating the application using ${chalk.cyanBright(command)}`)
-                exec('npm -v', (error, stdout, stderr) => {
-                    if (error) {
-                        if (test) 'npm is not installed'
-                        global.logger.error("npm is not installed on this system. Please install npm and run the command again.")
-                        return
-                    } else {
-                        exec(command, (error, stdout, stderr) => {
-                            if (error) {
-                                global.logger.error(error)
-                                return
-                            }
-                            console.log(stdout)
-                            console.log(stderr)
-                        })
-                    }
-                })
-            }
-        } else {
-            if (update) {
-                if (test) return 'You are on the latest version'
-                console.log(`${global.icons.success} You are on the latest version.`)
-            }
-        }
-    } catch (error) {
-        global.logger.error(error)
-    }
-}

package/src/lib/checkVersion.js

@@ -0,0 +1,42 @@
+export async function checkVersion(axios, exec, 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'
+        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.`)
+            if (!update) {
+                console.log(`Please upgrade by running ${chalk.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)
+                            }
+                        })
+                    }
+                })
+            }
+        } else {
+            if (update) {
+                console.log(`${global.icons.success} You are on the latest version.`)
+                return 'You are on the latest version'
+            }
+        }
+    } catch (error) {
+        global.logger.error(error)
+        throw error
+    }
+}
+
+

package/src/lib/fileUtils.js

@@ -4,42 +4,42 @@ import * as path from 'path'
 import * as yaml from 'js-yaml'
 import { Parser } from 'xml2js'
 
-export function directoryExists(dirPath) {
-    return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()
+export function directoryExists(dirPath, fsTmp = fs) {
+    return fsTmp.existsSync(dirPath) && fsTmp.statSync(dirPath).isDirectory()
 }
 
-export function fileExists(filePath) {
-    return fs.existsSync(filePath) && fs.statSync(filePath).isFile()
+export function fileExists(filePath, fsTmp = fs) {
+    return fsTmp.existsSync(filePath) && fsTmp.statSync(filePath).isFile()
 }
 
-export function createDirectory(dirPath) {
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true })
+export function createDirectory(dirPath, fsTmp = fs) {
+    if (!fsTmp.existsSync(dirPath)) {
+        fsTmp.mkdirSync(dirPath, { recursive: true })
     }
 }
 
-export function deleteDirectory(dirPath, recursive = false) {
-    if (!directoryExists(dirPath)) {
+export function deleteDirectory(dirPath, recursive = false, fsTmp = fs) {
+    if (!directoryExists(dirPath, fsTmp)) {
         return false
     } else {
-        if (fs.existsSync(dirPath)) {
-            fs.readdirSync(dirPath).forEach(function (file) {
+        if (fsTmp.existsSync(dirPath)) {
+            fsTmp.readdirSync(dirPath).forEach(function (file) {
                 var curPath = path.join(dirPath, file)
-                if (fs.lstatSync(curPath).isDirectory() && recursive) { // recurse
-                    deleteDirectory(curPath, recursive);
+                if (fsTmp.lstatSync(curPath).isDirectory() && recursive) { // recurse
+                    deleteDirectory(curPath, recursive, fsTmp);
                 } else { // delete file
-                    fs.unlinkSync(curPath);
+                    fsTmp.unlinkSync(curPath);
                 }
             })
-            return fs.rmdirSync(dirPath);
+            return fsTmp.rmdirSync(dirPath);
         }
     }
 }
 
-export function getFiles(dirPath, filter = undefined) {
+export function getFiles(dirPath, filter = undefined, fsTmp = fs) {
     const filesList = []
-    if (directoryExists(dirPath)) {
-        fs.readdirSync(dirPath).forEach(file => {
+    if (directoryExists(dirPath, fsTmp)) {
+        fsTmp.readdirSync(dirPath).forEach(file => {
             if (!filter) {
                 filesList.push(file)
             } else {
@@ -55,9 +55,9 @@ export function getFiles(dirPath, filter = undefined) {
     }
 }
 
-export function getDirectories(dirPath) {
-    if (directoryExists(dirPath)) {
-        return fs.readdirSync(dirPath, { withFileTypes: true })
+export function getDirectories(dirPath, fsTmp = fs) {
+    if (directoryExists(dirPath, fsTmp)) {
+        return fsTmp.readdirSync(dirPath, { withFileTypes: true })
             .filter(dirent => dirent.isDirectory())
             .map(dirent => dirent.name)
     } else {
@@ -65,35 +65,35 @@ export function getDirectories(dirPath) {
     }
 }
 
-export function deleteFile(filePath) {
-    if (!fileExists(filePath)) {
+export function deleteFile(filePath, fsTmp = fs) {
+    if (!fileExists(filePath, fsTmp)) {
         return false
     } else {
-        return fs.unlinkSync(filePath, { recursive: false, force: true });
+        return fsTmp.unlinkSync(filePath, { recursive: false, force: true });
     }
 }
 
-export function fileInfo(filePath) {
+export function fileInfo(filePath, fsTmp = fs) {
     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
+        "exists": fsTmp.existsSync(filePath), //true if exists or false if not exists
+        "stats": fsTmp.existsSync(filePath) ? fsTmp.statSync(filePath) : undefined //stats object if exists or undefined if not exists
     }
 }
 
-export function saveFile(json, fileName, format = path.extname(fileName).replace('.', '')) {
+export function saveFile(json, fileName, format = path.extname(fileName).replace('.', ''), fsTmp = fs) {
     try {
         switch (format) {
             case 'json':
                 let jsonString = JSON.stringify(json, null, '\t')
-                fs.writeFileSync(fileName, jsonString)
+                fsTmp.writeFileSync(fileName, jsonString)
                 break
             case 'yaml':
                 let doc = yaml.dump(json)
-                fs.writeFileSync(fileName, doc)
+                fsTmp.writeFileSync(fileName, doc)
                 break
         }
         return true
@@ -103,11 +103,11 @@ export function saveFile(json, fileName, format = path.extname(fileName).replace
     }
 }
 
-export function readFile(fileName, convert = true) {
+export function readFile(fileName, convert = true, fsTmp = fs) {
     try {
         let result = undefined
-        if (fileExists(fileName)) {
-            const data = fs.readFileSync(fileName, { encoding: 'utf8', flag: 'r' })
+        if (fileExists(fileName, fsTmp)) {
+            const data = fsTmp.readFileSync(fileName, { encoding: 'utf8', flag: 'r' })
             if (convert && fileName.indexOf('.yaml') != -1) {
                 result = yaml.load(data)
             } else if (convert && fileName.indexOf('.json') != -1) {
@@ -141,17 +141,17 @@ async function convertXML(data) {
     })
 }
 
-export function writeFile(fileName, data, atime = new Date(), mtime = new Date()) {
+export function writeFile(fileName, data, atime = new Date(), mtime = new Date(), fsTmp = fs) {
     try {
         // write data to the file
-        fs.writeFileSync(fileName, data)
+        fsTmp.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)
+        fsTmp.utimesSync(fileName, atime, mtime)
 
     } catch (error) {
         global.logger.error(error)
@@ -159,7 +159,7 @@ export function writeFile(fileName, data, atime = new Date(), mtime = new Date()
     }
 }
 
-export function find(filename, root) {
+export function find(filename, root, fsTmp = fs) {
     // code Copyright (c) 2014, Ben Gourley
     // https://github.com/bengourley/find-nearest-file
     root = root || process.cwd();
@@ -176,7 +176,7 @@ export function find(filename, root) {
         var file = path.join(directory, filename)
 
         try {
-            if (fs.statSync(file).isFile()) return file
+            if (fsTmp.statSync(file).isFile()) return file
             // stat existed, but isFile() returned false
             return nextLevelUp()
         } catch (e) {

package/src/lib/gitUtils.js

@@ -1,5 +1,5 @@
 import path from 'path'
-import { spawn } from 'node:child_process'
+import { execSync } from 'node:child_process'
 import * as os from 'node:os'
 import { existsSync } from 'fs'
 import * as fileUtils from './fileUtils.js'
@@ -15,169 +15,116 @@ const defaultDefinition = {
 }
 
 const status = {
-    A: 'add',
-    C: 'copy',
-    D: 'delete',
-    M: 'modify',
-    R: 'rename',
-    T: 'type change',
-    U: 'unmerged',
-    X: 'unknown',
-}
-
-export const action = {
-    add: 'add',
-    copy: 'add',
-    delete: 'delete',
-    modify: 'add',
-    rename: 'ignore',
-    change: 'ignore',
-    unmerged: 'ignore',
-    unknown: 'ignore',
+    A: {
+        type: 'add',
+        action: 'add'
+    },
+    C: {
+        type: 'copy',
+        action: 'add',
+    },
+    D: {
+        type: 'delete',
+        action: 'delete'
+    },
+    M: {
+        type: 'modify',
+        action: 'add'
+    },
+    R: {
+        type: 'rename',
+        action: 'add'
+    },
+    T: {
+        type: 'type change',
+        action: 'add'
+    },
+    U: {
+        type: 'unmerged',
+        action: 'ignore'
+    },
+    X: {
+        type: 'unknown',
+        action: 'ignore'
+    },
 }
 
-export function diff(dir, gitRef) {
+export function diff(dir, gitRef = 'HEAD', existsSyncStub = existsSync, execSyncStub = execSync) {
     return new Promise((resolve, reject) => {
-        if (!existsSync(dir)) {
-            reject(new Error(`The directory "${dir}" does not exist`))
-        }
-        if (!existsSync(`${dir}/.git`)) {
+        if (!existsSyncStub(dir) || !existsSyncStub(path.join(dir, '.git'))) {
             reject(new Error(`The directory "${dir}" is not a git repository`))
         }
 
         let data = ''
-        const files = []
-        const gitDiff = spawn('git', ['diff', '--name-status', '--oneline', '--relative', `${gitRef}`], { cwd: dir })
-        gitDiff.stdout.on("data", result => {
-            const gitString = result.toString()
-            const lastIndex = gitString.lastIndexOf(os.EOL)
-            let count = (gitString.match(/\n/g) || []).length;
-            data += gitString
-            const gitData = gitString.split(os.EOL)
-            let leftOver = ''
-            gitData.forEach((gitRow, index) => {
-                if (gitRow.indexOf('\t') !== -1 && (index < count || lastIndex + 1 == gitString)) {
-                    const file = gitRow.split('\t')
-                    if (file.slice(-1) !== '') {
-                        files.push({
-                            type: status[(file[0] === file.slice(-1)) ? 'A' : Array.from(file[0])[0]],
-                            path: file.slice(-1)[0],
-                        })
-                    }
-                } else {
-                    leftOver = gitRow
-                }
-                if (leftOver !== '') {
-                    data = leftOver
-                } else {
-                    data = ''
-                }
-            })
-        })
-        gitDiff.stderr.on("data", data => {
-            const errorMessage = 'git diff: ' + data.toString().split(os.EOL)[0]
-
-            reject(new Error(errorMessage))
-        })
-        gitDiff.on('error', (error) => {
-            if (error.message.indexOf('ENOENT')) {
-                error.message = 'git not installed or no entry found in path'
-            }
+        try {
+            data = execSyncStub(`git diff --name-status --oneline --relative ${gitRef}`, { cwd: dir }).toString()
+        } catch (error) {
             reject(error)
-        })
-        gitDiff.on("close", code => {
-            if (data !== '') {
-                const gitData = data.toString().split(os.EOL)
-                gitData.forEach(gitRow => {
-                    const file = gitRow.split('\t')
-                    if (file.slice(-1) !== '') {
-                        files.push({
-                            type: status[(file[0] === file.slice(-1)) ? 'A' : Array.from(file[0])[0]],
-                            path: file.slice(-1)[0],
-                        })
-                    }
-                })
-            }
-
-            resolve(files)
-        })
-    })
-}
+        }
 
-export function log(dir, gitRef) {
-    return new Promise((resolve, reject) => {
-        const commits = []
-        const gitLog = spawn('git', ['log', '--format=format:%H', `${gitRef}`], { cwd: dir })
-        gitLog.stdout.on("data", data => {
-            commits.push(data.toString().split(os.EOL)[0])
-        })
-        gitLog.stderr.on("data", data => {
-            const errorMessage = data.toString().split(os.EOL)[0]
-            global.logger.error(`git log: ${errorMessage}`)
-            reject(errorMessage)
-        })
-        gitLog.on('error', (error) => {
-            if (error.message.indexOf('ENOENT')) {
-                error.message = 'git not installed or no entry found in path'
+        const gitData = data.toString().split(os.EOL)
+        const files = gitData.reduce((acc, gitRow) => {
+            if (gitRow.indexOf('\t') > 0) {
+                const file = gitRow.split('\t')
+                if (file.slice(-1) !== '') {
+                    const statusType = status[(file[0] === file.slice(-1)) ? 'A' : Array.from(file[0])[0]];
+                    acc.push({
+                        type: statusType.type,
+                        path: file.slice(-1)[0],
+                        action: statusType.action
+                    });
+                }
             }
-            reject(error)
-        })
-        gitLog.on("close", code => {
-            resolve(commits)
-        })
+            return acc;   
+        }, []);
+        resolve(files);
     })
 }
 
-export function latestCommit(dir) {
-    return new Promise((resolve, reject) => {
-        const commit = log(dir, '-1')
-        commit
-            .then((data, error) => {
-                resolve(data[0])
-            })
-            .catch((error) => {
-                reject(error)
-            })
-    })
+export function log(dir, gitRef, execSyncStub = execSync) {
+    try {
+        const gitLog = execSyncStub(`git log --format=format:%H ${gitRef}`, { cwd: dir, encoding: 'utf-8' });
+        const commits = gitLog.split(os.EOL).filter(commit => commit)
+        return commits
+    } catch (error) {
+        if (error.message.indexOf('ENOENT') > -1) {
+            error.message = 'git not installed or no entry found in path'
+        }
+        throw error
+    }
 }
 
-export function lastCommit(dir, fileName = 'index.yaml') {
-    return new Promise((resolve, reject) => {
-        const folder = path.join(dir, '.sfdx', 'sfparty')
-        const filePath = path.join(folder, fileName)
-        let last = undefined
-        let latest = undefined
-        fileUtils.createDirectory(folder)
-        if (fileUtils.fileExists(filePath)) {
-            const data = fileUtils.readFile(filePath)
+export function lastCommit(dir, fileName = 'index.yaml', existsSyncStub = existsSync, execSyncStub = execSync, fileUtilsStub = fileUtils) {
+    try {
+        const folder = path.resolve(dir, '.sfdx', 'sfparty')
+        const filePath = path.resolve(folder, fileName)
+        let lastCommit = undefined
+
+        fileUtilsStub.createDirectory(folder)
+        if (existsSyncStub(filePath)) {
+            const data = fileUtilsStub.readFile(filePath)
             if (data.git.lastCommit !== undefined) {
-                last = data.git.lastCommit
+                lastCommit = data.git.lastCommit
             }
         }
-        const commit = latestCommit(dir)
-        commit
-            .then((data, error) => {
-                latest = data
-                resolve({
-                    lastCommit: last,
-                    latestCommit: latest,
-                })
-            })
-            .catch((error) => {
-                reject(error)
-            })
-
-    })
+        const latestCommit = execSyncStub(`git log --format=format:%H -1`, { cwd: dir, encoding: 'utf-8' })
+        return {
+            lastCommit: lastCommit,
+            latestCommit: latestCommit,
+        }
+    } catch (error) {
+        throw new Error(error)
+    }
 }
 
-export function updateLastCommit(dir, latest) {
+export function updateLastCommit(dir, latest, fileUtilsStub = fileUtils) {
     if (typeof latest !== 'string' && typeof latest !== 'undefined') throw new Error(`updateLastCommit received a ${typeof latest} instead of string`)
     if (latest !== undefined) {
         const folder = path.join(dir, '.sfdx', 'sfparty')
         const fileName = path.join(folder, 'index.yaml')
         let data = undefined
-        if (fileUtils.fileExists(fileName)) {
-            data = fileUtils.readFile(fileName)
+        if (fileUtilsStub.fileExists(fileName)) {
+            data = fileUtilsStub.readFile(fileName)
         }
 
         if (data === undefined) {
@@ -185,6 +132,6 @@ export function updateLastCommit(dir, latest) {
         }
 
         data.git.lastCommit = latest
-        fileUtils.saveFile(data, fileName)
+        fileUtilsStub.saveFile(data, fileName)
     }
 }

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

@@ -0,0 +1,54 @@
+import { execSync } from 'child_process'
+import { existsSync } from 'fs'
+import { diff } from '../../../src/lib/gitUtils'
+
+jest.mock('fs', () => ({
+    existsSync: jest.fn()
+}))
+jest.mock('child_process', () => ({
+    execSync: jest.fn()
+}))
+const gitRef = "HEAD~1..HEAD"
+
+describe('diff', () => {
+    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('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' }
+        ])
+    })
+
+    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')
+        }
+    })
+})