@ds-sfdc/sfparty 1.3.6 → 1.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ds-sfdc/sfparty",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "Salesforce metadata XML splitter for CI/CD",
   "type": "module",
   "repository": {

package/src/index.js

@@ -11,7 +11,7 @@ import convertHrtime from 'convert-hrtime'
 import axios from 'axios'
 import { marked } from 'marked'
 import markedTerminal from 'marked-terminal'
-import * as pkgObj from '../package.json'  assert { type: "json" }
+import pkgObj from './lib/pkgObj.cjs'
 import * as fileUtils from './lib/fileUtils.js'
 import * as yargOptions from './meta/yargs.js'
 import * as metadataSplit from './party/split.js'
@@ -139,7 +139,7 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion({axios, spawnSync, currentVersion: pkgObj.default.version, update: true})
+            checkVersion({axios, spawnSync, currentVersion: pkgObj.version, update: true})
         }
     })
     .command({
@@ -162,7 +162,6 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion({axios, spawnSync, currentVersion: pkgObj.default.version})
             global.format = argv.format
             splitHandler(argv, processStartTime)
         }
@@ -179,7 +178,6 @@ yargs(hideBin(process.argv))
                 .check(yargCheck)
         },
         handler: (argv) => {
-            checkVersion({axios, spawnSync, currentVersion: pkgObj.default.version})
             global.format = argv.format
             const startProm = new Promise((resolve, reject) => {
                 if (argv.git !== undefined) {
@@ -193,11 +191,10 @@ yargs(hideBin(process.argv))
                                 global.git.latest = data.latestCommit
                                 global.git.last = data.lastCommit
                                 if (data.last === undefined) {
-                                    console.log(`${clc.yellowBright('git mode')} ${clc.bgMagentaBright('not active:')} no prior commit - processing all`)
+                                    gitMode({status: 'not active'})
                                     resolve(false)
                                 } else {
-                                    console.log(`${clc.yellowBright('git mode')} ${clc.magentaBright('active:')} ${clc.bgBlackBright(data.lastCommit) + '..' + clc.bgBlackBright(data.latestCommit)}`)
-                                    console.log()
+                                    gitMode({status: 'active', lastCommit: data.lastCommit, latestCommit: data.latestCommit})
                                     const diff = git.diff(global.__basedir, `${data.lastCommit}..${data.latestCommit}`)
                                     diff
                                         .then((data, error) => {
@@ -215,8 +212,7 @@ yargs(hideBin(process.argv))
                                 throw error
                             })
                     } else {
-                        console.log(`${clc.yellowBright('git mode')} ${clc.magentaBright('active:')} ${clc.bgBlackBright(gitRef)}`)
-                        console.log()
+                        gitMode({status: 'active', gitRef})
                         const diff = git.diff(global.__basedir, gitRef)
                         diff
                             .then((data, error) => {
@@ -252,6 +248,26 @@ yargs(hideBin(process.argv))
     .argv
     .parse
 
+function gitMode({ status, gitRef, lastCommit, latestCommit }) {
+    let statusMessage
+    let displayMessage
+    if (status == 'not active') {
+        statusMessage = clc.bgMagentaBright('not active:')
+        displayMessage = `no prior commit - processing all`
+    } else {
+        statusMessage = clc.magentaBright('active:')
+        if (gitRef === undefined) {
+            displayMessage = `${clc.bgBlackBright(data.lastCommit) + '..' + clc.bgBlackBright(data.latestCommit)}`
+            console.log(`${clc.yellowBright('git mode')} ${clc.magentaBright('active:')} ${clc.bgBlackBright(data.lastCommit) + '..' + clc.bgBlackBright(data.latestCommit)}`)
+        } else {
+            displayMessage = `${clc.magentaBright('active:')} ${clc.bgBlackBright(gitRef)}`
+            console.log(`${clc.yellowBright('git mode')} ${clc.magentaBright('active:')} ${clc.bgBlackBright(gitRef)}`)
+        }
+    }
+    console.log(`${clc.yellowBright('git mode')} ${status}:)} ${displayMessage}`)
+    console.log()
+}
+
 function yargCheck(argv, options) {
     const argvKeys = Object.keys(argv)
     const invalidKeys = argvKeys.filter(key =>
@@ -262,7 +278,7 @@ function yargCheck(argv, options) {
         )
 
     if (!argv._.includes('update')) {
-        checkVersion({axios, spawnSync, currentVersion: pkgObj.default.version, update: false})        
+        checkVersion({axios, spawnSync, currentVersion: pkgObj.version, update: false})        
     }
     
     if (invalidKeys.length > 0) {
@@ -614,7 +630,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} ${clc.yellowBright(versionString)} ${global.icons.party}`
     titleMessage = titleMessage.padEnd((process.stdout.columns / 2) + versionString.length / 1.65)
     titleMessage = titleMessage.padStart(process.stdout.columns)

package/src/lib/checkVersion.js

@@ -22,7 +22,7 @@ class UpdateError extends Error {
     }
 }
 
-export async function checkVersion({axios, spawnSync, currentVersion, update = false}) {
+export async function checkVersion({ axios, spawnSync, currentVersion, update = false }) {
     try {
         const { data } = await axios.get('https://registry.npmjs.org/@ds-sfdc/sfparty', {
             params: {
@@ -31,13 +31,9 @@ export async function checkVersion({axios, spawnSync, currentVersion, update = f
         })
         const latestVersion = data['dist-tags'].latest
         if (semver.gt(latestVersion, currentVersion)) {
-            let icon
             const version = clc.bgCyanBright(data['dist-tags'].latest)
-            if (update) {
-                icon = global.icons.working
-            } else {
-                icon = global.icons.fail
-            }
+            const icon = (update) ? global.icons.working : global.icons.fail
+            console.log()
             console.log(`${icon} A newer version ${version} is available.`)
             if (!update) {
                 console.log(`Please upgrade by running ${clc.cyanBright('sfparty update')}`)

package/src/lib/packageUtil.js

@@ -25,7 +25,6 @@ export class Package {
                                 processJSON(that, json, fileUtils)
                                 resolve('existing')                                    
                             } catch (error) {
-                                console.error(error)
                                 reject(error)
                             }
                         })
@@ -49,12 +48,27 @@ export class Package {
 
         function processJSON(that, json, fileUtils) {
             try {
-                json.Package.version = fileUtils.readFile(path.join(global.__basedir, 'sfdx-project.json')).sourceApiVersion
+                let data = fileUtils.readFile(path.join(global.__basedir, 'sfdx-project.json'))
+                json.Package.version = data.sourceApiVersion
             } catch (error) {
                 json.Package.version = packageDefinition.metadataDefinition.fallbackVersion
             }
             that.packageJSON = json
             if (json.Package.types !== undefined) transformJSON(json.Package.types)
+            cleanPackage(that)
+        }
+
+        function cleanPackage(that) {
+            if (that.packageJSON === undefined) throw new Error('getPackageXML must be called before adding members')
+            if (that.packageJSON.Package == undefined) throw new Error('Package initialization failed')
+            if (that.packageJSON.Package.types === undefined) return 'No types found'
+        
+            const typeArray = Object.values(global.metaTypes).map(metaType => metaType.definition.root);
+            that.packageJSON.Package.types.forEach(typeItem => {
+                if (typeArray.includes(typeItem.name)) {
+                    typeItem.members = typeItem.members.filter(member => !member.endsWith(`.${global.format}`))
+                }
+            })
         }
     }
 

package/src/lib/pkgObj.cjs

@@ -0,0 +1 @@
+module.exports = pkgObj = require('../../package.json')

package/src/meta/Workflows.js

@@ -53,5 +53,14 @@ export const metadataDefinition = {
         'rules': ['fullName'],
         'outboundMessages': ['fullName'],
         'tasks': ['fullName'],
+    },
+    package: {
+        'alerts': 'WorkflowAlert',
+        'fieldUpdates': 'WorkflowFieldUpdate',
+        'flowActions': 'WorkflowFlowAction',
+        'knowledgePublishes': 'WorkflowKnowledgePublish',
+        'outboundMessages': 'WorkflowOutboundMessage',
+        'rules': 'WorkflowRule',
+        'tasks': '	WorkflowTask',
     }
 }

package/test/{checkVersion.spec.js → lib/checkVersion.spec.js}

@@ -1,7 +1,7 @@
 import axios from 'axios'
 import { spawnSync } from 'child_process'
 import clc from 'cli-color'
-import { checkVersion } from '../src/lib/checkVersion.js'
+import { checkVersion } from '../../src/lib/checkVersion.js'
 
 global.icons = {
     "success": clc.greenBright('✔'),

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

@@ -1,57 +1,171 @@
+
 import * as packageDefinition from '../../../src/meta/Package.js'
 import { Package } from '../../../src/lib/packageUtil.js'
+import * as labelDefinition from '../../../src/meta/CustomLabels.js'
+import * as profileDefinition from '../../../src/meta/Profiles.js'
+import * as permsetDefinition from '../../../src/meta/PermissionSets.js'
+import * as workflowDefinition from '../../../src/meta/Workflows.js'
+
+global.__basedir = '.'
+global.format = 'yaml'
+global.metaTypes = {
+    label: {
+        type: labelDefinition.metadataDefinition.filetype,
+        definition: labelDefinition.metadataDefinition,
+        add: { files: [], directories: [] },
+        remove: { files: [], directories: [] },
+    },
+    profile: {
+        type: profileDefinition.metadataDefinition.filetype,
+        definition: profileDefinition.metadataDefinition,
+        add: { files: [], directories: [] },
+        remove: { files: [], directories: [] },
+    },
+    permset: {
+        type: permsetDefinition.metadataDefinition.filetype,
+        definition: permsetDefinition.metadataDefinition,
+        add: { files: [], directories: [] },
+        remove: { files: [], directories: [] },
+    },
+    workflow: {
+        type: workflowDefinition.metadataDefinition.filetype,
+        definition: workflowDefinition.metadataDefinition,
+        add: { files: [], directories: [] },
+        remove: { files: [], directories: [] },
+    },
+}
 
-let pkg;
+let pkg
 const fileUtils = {
     fileExists: jest.fn(),
     readFile: jest.fn(),
 }
 beforeEach(() => {
-    pkg = new Package('xmlPath');
-});
-global.__basedir = '.'
+    pkg = new Package('xmlPath')
+})
+
+
 afterEach(() => {
-    jest.clearAllMocks();
-});
+    jest.clearAllMocks()
+})
 
 it('should default the package if the json is empty', async () => {
-    fileUtils.fileExists.mockReturnValue(true);
-    fileUtils.readFile.mockResolvedValue({});
+    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);
-});
+    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);
+    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();
-});
+    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);
+    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);
-});
+    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');
-});
+    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');
-});
+    fileUtils.fileExists.mockReturnValue(true)
+    fileUtils.readFile.mockRejectedValue(new Error('Error'))
+    await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Error')
+})
+
+it('should catch errors and reject the promise', async () => {
+    fileUtils.fileExists.mockReturnValue(true)
+    fileUtils.readFile.mockRejectedValue(new Error('Test Error'))
+    global.git = { append: true }
+    try {
+        await pkg.getPackageXML(fileUtils)
+    } catch (error) {
+        expect(error.message).toEqual('Test Error')
+    }
+})
+
+it('should default to an empty package if the read file 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(pkg.packageJSON).toEqual(packageDefinition.metadataDefinition.emptyPackage)
+    expect(fileUtils.fileExists).toHaveBeenCalled()
+    expect(fileUtils.readFile).toHaveBeenCalled()
+})
+
+it('should throw an error if fileUtils.readFile() returns a rejected promise', async () => {
+    fileUtils.fileExists.mockReturnValue(true)
+    fileUtils.readFile.mockRejectedValue(new Error('Test Error'))
+    global.git = { append: true }
+    await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Test Error')
+    expect(fileUtils.fileExists).toHaveBeenCalled()
+    expect(fileUtils.readFile).toHaveBeenCalled()
+})
+
+it('should correctly process the json object returned from the XML file', async () => {
+    fileUtils.fileExists.mockReturnValue(true)
+    fileUtils.readFile.mockResolvedValueOnce({
+        "Package": {
+            "types": [{
+                "members": ["Test", "Test.yaml"],
+                "name": "CustomLabels"
+            }, {
+                "members": ["Test", "Test.yaml"],
+                "name": "Profile"
+            }, {
+                "members": ["Test", "Test.yaml"],
+                "name": "PermissionSet"
+            }, {
+                "members": ["Test", "Test.yaml"],
+                "name": "Workflow"
+            }],
+            "version": "56.0"
+        }
+    })
+    fileUtils.readFile.mockImplementationOnce(() => {
+        return { sourceApiVersion: '56.0' }
+    })
+    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({
+        "Package": {
+            "types": [{
+                "members": ["Test"],
+                "name": "CustomLabels"
+            }, {
+                "members": ["Test"],
+                "name": "Profile"
+            }, {
+                "members": ["Test"],
+                "name": "PermissionSet"
+            }, {
+                "members": ["Test"],
+                "name": "Workflow"
+            }],
+            "version": "56.0"
+        }
+    })
+})