refactor: remove all sync calls, anything is now async

src/functions/getFirstExistingParentPath.ts

@@ -1,3 +1,4 @@
+import isDirectoryExisting from '@/src/functions/isDirectoryExisting'
 import Dependencies from '@/src/types/dependencies'
 
 /**
@@ -6,13 +7,13 @@ import Dependencies from '@/src/types/dependencies'
  * @param directoryPath - The file/folder path from where we want to know disk space
  * @param dependencies - Dependencies container
  */
-function getFirstExistingParentPath(directoryPath: string, dependencies: Dependencies): string {
+async function getFirstExistingParentPath(directoryPath: string, dependencies: Dependencies): Promise<string> {
 	let parentDirectoryPath = directoryPath
-	let parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath)
+	let parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies)
 
 	while (!parentDirectoryFound) {
 		parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..')
-		parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath)
+		parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies)
 	}
 
 	return parentDirectoryPath

src/functions/hasPowerShell3.ts

@@ -8,18 +8,19 @@ import Dependencies from '@/src/types/dependencies'
  *
  * @param dependencies - Dependencies Injection Container
  */
-function hasPowerShell3(dependencies: Dependencies): Promise<boolean> {
+async function hasPowerShell3(dependencies: Dependencies): Promise<boolean> {
 	const major = parseInt(dependencies.release.split('.')[0], 10)
 
 	if (major <= 6) {
-		return Promise.resolve(false)
+		return false
 	}
 
-	return new Promise<boolean>(function (resolve) {
-		dependencies.cpExecFile('where', ['powershell'], { windowsHide: true }, function (error) {
-			resolve(!error)
-		})
-	})
+	try {
+		await dependencies.cpExecFile('where', ['powershell'], { windowsHide: true })
+		return true
+	} catch (error) {
+		return false
+	}
 }
 
 export default hasPowerShell3

src/functions/isDirectoryExisting.ts

@@ -0,0 +1,18 @@
+import Dependencies from '@/src/types/dependencies'
+
+/**
+ * Tells if directory exists
+ *
+ * @param directoryPath - The file/folder path
+ * @param dependencies - Dependencies container
+ */
+async function isDirectoryExisting(directoryPath: string, dependencies: Dependencies): Promise<boolean> {
+	try {
+		await dependencies.fsAccess(directoryPath)
+		return Promise.resolve(true)
+	} catch (error) {
+		return Promise.resolve(false)
+	}
+}
+
+export default isDirectoryExisting

src/index.ts

@@ -1,8 +1,9 @@
-import { execFile } from 'child_process'
-import { existsSync } from 'fs'
-import { release } from 'os'
-import { normalize, sep } from 'path'
-import { platform } from 'process'
+import { execFile } from 'node:child_process'
+import { access } from 'node:fs/promises'
+import { release } from 'node:os'
+import { normalize, sep } from 'node:path'
+import { platform } from 'node:process'
+import { promisify } from 'node:util'
 
 import InvalidPathError from '@/src/errors/invalidPathError'
 import NoMatchError from '@/src/errors/noMatchError'
@@ -20,10 +21,10 @@ import DiskSpace from '@/src/types/diskSpace'
 function checkDiskSpace(directoryPath: string, dependencies: Dependencies = {
 	platform,
 	release: release(),
-	fsExistsSync: existsSync,
+	fsAccess: access,
 	pathNormalize: normalize,
 	pathSep: sep,
-	cpExecFile: execFile,
+	cpExecFile: promisify(execFile),
 }): Promise<DiskSpace> {
 	// Note: This function contains other functions in order
 	//       to wrap them in a common context and make unit tests easier
@@ -69,35 +70,28 @@ function checkDiskSpace(directoryPath: string, dependencies: Dependencies = {
 	 * @param mapping - Map between column index and normalized column name
 	 * @param coefficient - The size coefficient to get bytes instead of kB
 	 */
-	function check(
+	async function check(
 		cmd: string[],
 		filter: (driveData: string[]) => boolean,
 		mapping: Record<string, number>,
 		coefficient = 1,
 	): Promise<DiskSpace> {
-		return new Promise((resolve, reject) => {
-			const [
-				file,
-				...args
-			] = cmd
-
-			/* istanbul ignore if */
-			if (file === undefined) {
-				return Promise.reject(new Error('cmd must contain at least one item'))
-			}
-
-			dependencies.cpExecFile(file, args, { windowsHide: true }, (error, stdout) => {
-				if (error) {
-					reject(error)
-				}
-
-				try {
-					resolve(mapOutput(stdout, filter, mapping, coefficient))
-				} catch (error2) {
-					reject(error2)
-				}
-			})
-		})
+		const [
+			file,
+			...args
+		] = cmd
+
+		/* istanbul ignore if */
+		if (file === undefined) {
+			return Promise.reject(new Error('cmd must contain at least one item'))
+		}
+
+		try {
+			const { stdout } = await dependencies.cpExecFile(file, args, { windowsHide: true })
+			return mapOutput(stdout, filter, mapping, coefficient)
+		} catch (error) {
+			return Promise.reject(error)
+		}
 	}
 
 	/**
@@ -142,12 +136,12 @@ function checkDiskSpace(directoryPath: string, dependencies: Dependencies = {
 	 *
 	 * @param directoryPath - The file/folder path from where we want to know disk space
 	 */
-	function checkUnix(directoryPath: string): Promise<DiskSpace> {
+	async function checkUnix(directoryPath: string): Promise<DiskSpace> {
 		if (!dependencies.pathNormalize(directoryPath).startsWith(dependencies.pathSep)) {
 			return Promise.reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`))
 		}
 
-		const pathToCheck = getFirstExistingParentPath(directoryPath, dependencies)
+		const pathToCheck = await getFirstExistingParentPath(directoryPath, dependencies)
 
 		return check(
 			[

src/types/dependencies.ts

@@ -1,27 +1,22 @@
-import { ChildProcess, ExecException } from 'child_process'
-import { existsSync } from 'fs'
-import { normalize, sep } from 'path'
-
-type ExecFileException = ExecException & NodeJS.ErrnoException
+import { access } from 'node:fs/promises'
+import { normalize, sep } from 'node:path'
 
 type Dependencies = {
 	platform: NodeJS.Platform
 	release: string
-	fsExistsSync: typeof existsSync
+	fsAccess: typeof access
 	pathNormalize: typeof normalize
 	pathSep: typeof sep
 	cpExecFile: (
 		file: string,
 		args: ReadonlyArray<string> | undefined | null,
 		options: {
 			windowsHide: true
-		},
-		callback: (
-			error: ExecFileException | null,
-			stdout: string,
-			stderr: string
-		) => void
-	) => ChildProcess
+		}
+	) => Promise<{
+		stdout: string
+		stderr: string
+	}>
 }
 
 export default Dependencies

test/__helpers__/mockDependencies.ts

@@ -1,6 +1,5 @@
-import { ChildProcess } from 'child_process'
-import { EventEmitter } from 'events'
-import { normalize } from 'path'
+import { normalize } from 'node:path'
+import { promisify } from 'node:util'
 
 import Dependencies from '@/src/types/dependencies'
 
@@ -11,19 +10,20 @@ function mockDependencies(overrides?: Partial<Dependencies>, options?: {
 	const dependencies: Dependencies = {
 		platform: 'linux',
 		release: '11.5.0',
-		fsExistsSync: () => true,
+		fsAccess: () => Promise.resolve(),
 		pathNormalize: normalize,
 		pathSep: '/',
-		cpExecFile: (cmd, args, opts, callback) => {
-			process.nextTick(() => {
-				if (options?.cpExecFileError !== undefined) {
-					callback(options.cpExecFileError, '', '')
-				}
+		cpExecFile: async () => {
+			await promisify(process.nextTick)
 
-				callback(null, options?.cpExecFileOutput ?? '', '')
-			})
+			if (options?.cpExecFileError !== undefined) {
+				return Promise.reject(options.cpExecFileError)
+			}
 
-			return new EventEmitter() as ChildProcess
+			return {
+				stdout: options?.cpExecFileOutput ?? '',
+				stderr: '',
+			}
 		},
 		...overrides,
 	}

test/functions/getFirstExistingParentPath.spec.ts

@@ -5,20 +5,20 @@ import getFirstExistingParentPath from '@/src/functions/getFirstExistingParentPa
 import mockDependencies from '@/test/__helpers__/mockDependencies'
 
 
-test('unix: get first existing parent path', t => {
+test('unix: get first existing parent path', async t => {
 	const parentPath = '/home/Alex'
 	const dependencies = mockDependencies({
-		fsExistsSync: (directoryPath: PathLike) => directoryPath === parentPath,
+		fsAccess: async (directoryPath: PathLike) => directoryPath === parentPath ? Promise.resolve() : Promise.reject(new Error('File does not exists')),
 	})
 
-	t.is(getFirstExistingParentPath('/home/Alex/games/Some/Game', dependencies), parentPath)
+	t.is(await getFirstExistingParentPath('/home/Alex/games/Some/Game', dependencies), parentPath)
 })
 
-test('unix: get first parent can be the path itself', t => {
+test('unix: get first parent can be the path itself', async t => {
 	const parentPath = '/home/Alex'
 	const dependencies = mockDependencies({
-		fsExistsSync: (directoryPath: PathLike) => directoryPath === parentPath,
+		fsAccess: async (directoryPath: PathLike) => directoryPath === parentPath ? Promise.resolve() : Promise.reject(new Error('File does not exists')),
 	})
 
-	t.is(getFirstExistingParentPath(parentPath, dependencies), parentPath)
+	t.is(await getFirstExistingParentPath(parentPath, dependencies), parentPath)
 })