@ds-sfdc/sfparty 1.7.8 → 3.0.0

package/src/lib/checkVersion.js

@@ -1,109 +0,0 @@
-import clc from 'cli-color'
-import semver from 'semver'
-
-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,
-}) {
-	let result
-	try {
-		const { data } = await axios.get(
-			'https://registry.npmjs.org/@ds-sfdc/sfparty',
-			{
-				params: {
-					field: 'dist-tags.latest',
-				},
-			},
-		)
-		result = data
-	} catch (error) {
-		// do not display errors
-	}
-
-	let updateCommand
-	switch (global.runType) {
-		case 'global':
-			updateCommand = 'sfparty update'
-			break
-		case 'npx':
-			updateCommand = 'npm i @ds-sfdc/sfparty@latest'
-			break
-		case 'node':
-			updateCommand = 'git pull'
-			break
-	}
-
-	if (result !== undefined) {
-		const latestVersion = result['dist-tags'].latest
-		if (semver.gt(latestVersion, currentVersion)) {
-			const version = clc.bgMagenta(result['dist-tags'].latest)
-			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(
-						updateCommand,
-					)}`,
-				)
-				return 'A newer version'
-			} else {
-				const command = 'npm i -g @ds-sfdc/sfparty@latest'.split(' ')
-				console.log(
-					`Updating the application using ${clc.cyanBright(
-						command.join(' '),
-					)}`,
-				)
-				try {
-					const npmVersion = spawnSync('npm', ['-v'])
-					if (
-						npmVersion.stderr &&
-						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) {
-					throw err
-				}
-			}
-		} else {
-			if (update) {
-				console.log(
-					`${global.icons.success} You are on the latest version.`,
-				)
-			}
-			return 'You are on the latest version'
-		}
-	}
-}

package/src/lib/fileUtils.js

@@ -1,247 +0,0 @@
-'use strict'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as yaml from 'js-yaml'
-import { Parser } from 'xml2js'
-
-String.prototype.replaceSpecialChars = function () {
-	return this.replace(/\*/g, '\u002a')
-		.replace(/\?/g, '\u003f')
-		.replace(/</g, '\u003c')
-		.replace(/>/g, '\u003e')
-		.replace(/"/g, '\u0022')
-		.replace(/\|/g, '\u007c')
-		.replace(/\\/g, '\u005c')
-		.replace(/:/g, '\u003a')
-}
-
-export function directoryExists({ dirPath, fs }) {
-	dirPath = dirPath.replaceSpecialChars()
-	return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()
-}
-
-export function fileExists({ filePath, fs }) {
-	filePath = filePath.replaceSpecialChars()
-	return fs.existsSync(filePath) && fs.statSync(filePath).isFile()
-}
-
-export function createDirectory(dirPath, fsTmp = fs) {
-	dirPath = dirPath.replaceSpecialChars()
-	if (!fsTmp.existsSync(dirPath)) {
-		fsTmp.mkdirSync(dirPath, { recursive: true })
-	}
-}
-
-export function deleteDirectory(dirPath, recursive = false, fsTmp = fs) {
-	dirPath = dirPath.replaceSpecialChars()
-	if (!directoryExists({ dirPath, fs: fsTmp })) {
-		return false
-	} else {
-		if (fsTmp.existsSync(dirPath)) {
-			fsTmp.readdirSync(dirPath).forEach(function (file) {
-				var curPath = path.join(dirPath, file)
-				if (fsTmp.lstatSync(curPath).isDirectory() && recursive) {
-					// recurse
-					deleteDirectory(curPath, recursive, fsTmp)
-				} else {
-					try {
-						// delete file
-						fsTmp.unlinkSync(curPath)
-					} catch (error) {
-						fsTmp.rmdirSync(curPath)
-					}
-				}
-			})
-			return fsTmp.rmdirSync(dirPath)
-		}
-	}
-}
-
-export function getFiles(dirPath, filter = undefined, fsTmp = fs) {
-	dirPath = dirPath.replaceSpecialChars()
-	const filesList = []
-	if (directoryExists({ dirPath, fs: fsTmp })) {
-		fsTmp.readdirSync(dirPath).forEach((file) => {
-			if (!filter) {
-				filesList.push(file)
-			} else {
-				if (
-					file
-						.toLocaleLowerCase()
-						.endsWith(filter.toLocaleLowerCase())
-				) {
-					filesList.push(file)
-				}
-			}
-		})
-		filesList.sort()
-		return filesList
-	} else {
-		return []
-	}
-}
-
-export function getDirectories(dirPath, fsTmp = fs) {
-	dirPath = dirPath.replaceSpecialChars()
-	if (directoryExists({ dirPath, fs: fsTmp })) {
-		return fsTmp
-			.readdirSync(dirPath, { withFileTypes: true })
-			.filter((dirent) => dirent.isDirectory())
-			.map((dirent) => dirent.name)
-	} else {
-		return []
-	}
-}
-
-export function deleteFile(filePath, fsTmp = fs) {
-	filePath = filePath.replaceSpecialChars()
-	if (!fileExists({ filePath, fs: fsTmp })) {
-		return false
-	} else {
-		return fsTmp.unlinkSync(filePath, { recursive: false, force: true })
-	}
-}
-
-export function fileInfo(filePath, fsTmp = fs) {
-	filePath = filePath.replaceSpecialChars()
-	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: 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('.', ''),
-	fsTmp = fs,
-) {
-	try {
-		fileName = fileName.replaceSpecialChars()
-		switch (format) {
-			case 'json':
-				const jsonString = JSON.stringify(json, null, '\t')
-				fsTmp.writeFileSync(fileName, jsonString)
-				break
-			case 'yaml':
-				const doc = yaml.dump(json)
-				fsTmp.writeFileSync(fileName, doc)
-				break
-		}
-		return true
-	} catch (error) {
-		global.logger.error(error)
-		throw error
-	}
-}
-
-export function readFile(filePath, convert = true, fsTmp = fs) {
-	try {
-		filePath = filePath.replaceSpecialChars()
-		let result = undefined
-		if (fileExists({ filePath, fs: fsTmp })) {
-			const data = fsTmp.readFileSync(filePath, {
-				encoding: 'utf8',
-				flag: 'r',
-			})
-			if (convert && filePath.indexOf('.yaml') != -1) {
-				result = yaml.load(data, {
-					onWarning: (warning, filePath) => {
-						throw new Error(`YAML parsing ${filePath}: ${warning}`)
-					},
-				})
-			} else if (convert && filePath.indexOf('.json') != -1) {
-				result = JSON.parse(data)
-			} else if (convert && filePath.indexOf('.xml') != -1) {
-				// returns a promise
-				result = convertXML(data)
-			} else {
-				result = data
-			}
-			return result
-		} else {
-			return undefined
-		}
-	} catch (error) {
-		global.logger.error(error)
-		throw error
-	}
-}
-
-async function convertXML(data) {
-	return new Promise((resolve, reject) => {
-		try {
-			const parser = new Parser()
-			parser.parseString(data, function (err, result) {
-				if (err) throw err
-				resolve(result)
-			})
-		} catch (error) {
-			reject(error)
-		}
-	})
-}
-
-export function writeFile(
-	fileName,
-	data,
-	atime = new Date(),
-	mtime = new Date(),
-	fsTmp = fs,
-) {
-	try {
-		fileName = fileName.replaceSpecialChars()
-		// write data to the file
-		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
-		fsTmp.utimesSync(fileName, atime, mtime)
-	} catch (error) {
-		global.logger.error(error)
-		throw error
-	}
-}
-
-export function find(filename, root, fsTmp = fs) {
-	// code Copyright (c) 2014, Ben Gourley
-	// https://github.com/bengourley/find-nearest-file
-	root = root || process.cwd()
-
-	if (!filename) throw new Error('filename is required')
-	filename = filename.replaceSpecialChars()
-
-	if (filename.indexOf('/') !== -1 || filename === '..') {
-		throw new Error('filename must be just a filename and not a path')
-	}
-
-	function findFile(directory, filename) {
-		var file = path.join(directory, filename)
-
-		try {
-			if (fsTmp.statSync(file).isFile()) return file
-			// stat existed, but isFile() returned false
-			return nextLevelUp()
-		} catch (e) {
-			// stat did not exist
-			return nextLevelUp()
-		}
-
-		function nextLevelUp() {
-			// Don't proceed to the next directory when already at the fs root
-			if (directory === path.resolve('/')) return null
-			return findFile(path.dirname(directory), filename)
-		}
-	}
-
-	return findFile(root, filename)
-}

package/src/lib/gitUtils.js

@@ -1,242 +0,0 @@
-import path from 'path'
-import * as os from 'node:os'
-import { execSync } from 'child_process'
-
-const defaultDefinition = {
-	git: {
-		lastCommit: undefined,
-	},
-	local: {
-		lastDate: undefined,
-	},
-}
-
-const status = {
-	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 = 'HEAD', existsSync, spawn }) {
-	return new Promise((resolve, reject) => {
-		try {
-			if (!existsSync(dir)) {
-				throw new Error(`The directory "${dir}" does not exist`)
-			}
-			if (!existsSync(path.join(dir, '.git'))) {
-				throw new Error(
-					`The directory "${dir}" is not a git repository`,
-				)
-			}
-
-			const git = spawn('git', ['--version'])
-			git.on('error', (err) => {
-				throw new Error('Git is not installed on this machine')
-			})
-			git.on('close', (code) => {
-				if (code !== 0) {
-					reject(
-						new Error(
-							`git --version command failed with code ${code}`,
-						),
-					)
-				}
-
-				const gitDiff = spawn(
-					'git',
-					[
-						'diff',
-						'--name-status',
-						'--oneline',
-						'--no-renames',
-						'--relative',
-						gitRef,
-						'--',
-						'*-party/*',
-					],
-					{ cwd: dir },
-				)
-				let data = ''
-				gitDiff.stdout.setEncoding('utf8')
-				gitDiff.stderr.on('data', (data) => {
-					if (data !== '')
-						reject(
-							new Error(
-								`git diff command failed with error: ${data}`,
-							),
-						)
-				})
-				gitDiff.stdout.on('data', (chunk) => {
-					data += chunk
-				})
-				gitDiff.stdout.on('close', (code) => {
-					if (code !== 0 && code !== false) {
-						reject(
-							new Error(
-								`git diff command failed with code ${code}`,
-							),
-						)
-					}
-					const gitData = data.toString().split(os.EOL)
-					const files = gitData.reduce((acc, gitRow) => {
-						if (gitRow.lastIndexOf('\t') > 0) {
-							const file = gitRow.split('\t')
-							if (file.slice(-1)[0] !== '') {
-								const statusType = status[file[0]]
-								acc.push({
-									type:
-										statusType !== undefined
-											? statusType.type
-											: 'A',
-									path: file.slice(-1)[0],
-									action: statusType.action,
-								})
-							}
-						}
-						return acc
-					}, [])
-					resolve(files)
-				})
-			})
-		} 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',
-	existsSync,
-	execSync,
-	fileUtils,
-}) {
-	return new Promise((resolve, reject) => {
-		try {
-			const folder = path.resolve(dir, '.sfdx', 'sfparty')
-			const filePath = path.resolve(folder, fileName)
-			let branchSpecificLastCommit
-
-			// Ensure the folder exists
-			fileUtils.createDirectory(folder)
-
-			if (existsSync(filePath)) {
-				const data = fileUtils.readFile(filePath)
-
-				// Determine the current branch name
-				const currentBranch = execSync(
-					`git rev-parse --abbrev-ref HEAD`,
-					{
-						cwd: dir,
-						encoding: 'utf-8',
-					},
-				).trim()
-
-				// Check if branch-specific last commit exists
-				if (
-					data.git.branches &&
-					data.git.branches[currentBranch] !== undefined
-				) {
-					branchSpecificLastCommit = data.git.branches[currentBranch]
-				} else {
-					// Fallback to top-level lastCommit if branch-specific commit doesn't exist
-					branchSpecificLastCommit = data.git.lastCommit
-				}
-			}
-
-			const latestCommit = execSync(`git log --format=format:%H -1`, {
-				cwd: dir,
-				encoding: 'utf-8',
-			})
-
-			resolve({
-				lastCommit: branchSpecificLastCommit,
-				latestCommit: latestCommit,
-			})
-		} catch (error) {
-			reject(error)
-		}
-	})
-}
-
-export function updateLastCommit({ dir, latest, fileUtils, fs }) {
-	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({ filePath: fileName, fs })) {
-			data = fileUtils.readFile(fileName)
-		}
-
-		if (data === undefined) {
-			data = defaultDefinition
-		}
-
-		// Determine the current branch name
-		const currentBranch = execSync(`git rev-parse --abbrev-ref HEAD`, {
-			cwd: dir,
-			encoding: 'utf-8',
-		}).trim()
-
-		// Initialize branches object if not exist
-		if (!data.git.branches) {
-			data.git.branches = {}
-		}
-
-		// Update the last commit for the current branch
-		data.git.branches[currentBranch] = latest
-
-		fileUtils.saveFile(data, fileName)
-	}
-}