@typinghare/trick 2.0.0 → 2.1.0

package/src/config.ts

@@ -1,9 +1,11 @@
 import fsExtra from 'fs-extra'
 import {
-    ReadConfigError,
-    TargetNotFoundError,
-    WriteConfigError,
+  ReadConfigError,
+  TargetNotFoundError,
+  WriteConfigError,
+  RootDirectoryNotFoundError,
 } from './error.js'
+import { join, resolve } from 'path'
 
 /**
  * The name of the configuration file to look for in the root directory.
@@ -11,20 +13,26 @@ import {
 export const CONFIG_FILE_NAME: string = 'trick.config.json'
 
 /**
- * Config type.
+ * A list of root markers.
+ */
+export const ROOT_MARKERS: string[] = ['.git', CONFIG_FILE_NAME]
+
+/**
+ * Represents Trick configuration type.
  *
  * @property targets Mapping from target names to target objects.
- * @property default_target_name The name of the default target.
- * @property root_directory The root directory.
- * @property passphrase_file_path The path to the passphrase file.
+ * @property trickRootDirectory The name of the Trick root directory under the project root.
+ * @property passphraseDirectory The path to the passphrase directory.
+ * @property defaultTargetNames A list of default target names. If no target name is specified
+ *   when running Trick commands, these target names will be used.
  * @property encryption Encryption configuration.
  */
 export interface Config {
-    targets: { [name: string]: Target }
-    default_target_name: string | null
-    root_directory: string
-    passphrase_file_path: string
-    encryption: Encryption
+  targets: { [name: string]: Target }
+  trickRootDirectory: string
+  passphraseDirectory: string
+  defaultTargetNames: string[]
+  encryption: Encryption
 }
 
 /**
@@ -33,91 +41,129 @@ export interface Config {
  * @property files A list of files to encrypt/decrypt.
  */
 export interface Target {
-    files: string[]
+  files: string[]
 }
 
 /**
  * Encryption configuration.
  *
- * @property iteration_count The number of iteration.
+ * @property iterationCount The number of iteration.
  */
 export interface Encryption {
-    iteration_count: number
+  iterationCount: number
 }
 
 /**
  * Default configuration.
  */
 const DEFAULT_CONFIG: Config = {
-    targets: {},
-    default_target_name: null,
-    root_directory: '.trick',
-    passphrase_file_path: '~/.config/trick_passphrase.json',
-    encryption: {
-        iteration_count: 100_000,
-    },
+  targets: {},
+  trickRootDirectory: '.trick',
+  passphraseDirectory: '~/.config/trick/passphrases',
+  defaultTargetNames: [],
+  encryption: {
+    iterationCount: 100_000,
+  },
+}
+
+/**
+ * Recursively searches for the root directory of a project based on specified root markers.
+ *
+ * @param directory - The current directory to check. Defaults to the current working directory.
+ * @returns The path to the root directory.
+ * @throws {RootDirectoryNotFoundError} If the root directory cannot be found.
+ */
+export function getRootDirectory(directory: string | null = null): string {
+  if (!directory) {
+    return getRootDirectory(process.cwd())
+  }
+
+  if (directory === '/') {
+    throw new RootDirectoryNotFoundError()
+  }
+
+  for (const marker of ROOT_MARKERS) {
+    if (fsExtra.existsSync(join(directory, marker))) {
+      return directory
+    }
+  }
+
+  return getRootDirectory(resolve(join(directory, '..')))
+}
+
+/**
+ * Gets the full path to the configuration file based on the root directory.
+ *
+ * @return The full path to the configuration file.
+ * @throws {RootDirectoryNotFoundError} If the root directory cannot be found.
+ */
+export function getConfigFilePath(): string {
+  return resolve(getRootDirectory() + '/' + CONFIG_FILE_NAME)
 }
 
 /**
  * Writes a configuration object to the configuration file.
  *
  * @param config The configuration to write.
- * @throws {WriteConfigError} If error occurs when writing to the configuration
- *         file.
+ * @param createInRoot Whether to create the configuration file in the root directory if it
+ *   doesn't exist. Defaults to false.
+ * @throws {WriteConfigError} If error occurs when writing to the configuration file.
  */
-export async function writeConfig(config: Config): Promise<void> {
-    try {
-        await fsExtra.writeFile(
-            CONFIG_FILE_NAME,
-            JSON.stringify(config, null, 2)
-        )
-    } catch (err) {
-        throw new WriteConfigError(err)
+export function writeConfig(config: Config, createInRoot: boolean = true): void {
+  try {
+    if (createInRoot) {
+      const configFilePath = join(getRootDirectory(), CONFIG_FILE_NAME)
+      fsExtra.writeFileSync(configFilePath, JSON.stringify(config, null, 2))
+    } else {
+      // Always create in the current working directory
+      const configFilePath = join(process.cwd(), CONFIG_FILE_NAME)
+      fsExtra.writeFileSync(configFilePath, JSON.stringify(config, null, 2))
     }
+  } catch (err) {
+    throw new WriteConfigError(err)
+  }
 }
 
 /**
  * Retrieves the configuration object from the configuration file.
  *
- * @return The configuration object retrieved from the configuration object;
- *         null if the configuration file doesn't exist.
- * @throws {ReadConfigError} If error occurs when reading the configuration
- *         file.
+ * @return The configuration object retrieved from the configuration object; null if the
+ *   configuration file doesn't exist.
+ * @throws {ReadConfigError} If error occurs when reading the configuration file.
  */
-export async function readConfig(): Promise<Config | null> {
-    if (!fsExtra.existsSync(CONFIG_FILE_NAME)) {
-        return null
-    }
+export function readConfig(): Config | null {
+  const configFilePath = getConfigFilePath()
+  if (!fsExtra.existsSync(configFilePath)) {
+    return null
+  }
 
-    try {
-        return (await fsExtra.readJSON(CONFIG_FILE_NAME)) as Config
-    } catch (err) {
-        throw new ReadConfigError(err)
-    }
+  try {
+    return fsExtra.readJSONSync(configFilePath) as Config
+  } catch (err) {
+    throw new ReadConfigError(err)
+  }
 }
 
 /**
  * Updates the configuration object.
  *
- * This function first retrieves the configuration object fromthe configuration
- * file. If the configuration file doesn't exist, the default configuration will
- * be used instead.
+ * This function first retrieves the configuration object fromthe configuration file. If the
+ * configuration file doesn't exist, the default configuration will be used instead.
+ *
+ * Then it calls the callback function by passing on the configuration object. If the callback
+ * function returns `true`, then the object will be written to the configuration file.
  *
- * Then it calls the callback function by passing on the configuration object.
- * If the callback function returns `true`, then the object will be written to
- * the configuration file.
+ * @param callback The callback function taking the configuraition object retrieved from the
+ *   configuration file.
  *
- * @param callback The callback function taking the configuraition object
- *                 retrieved from the configuration file.
  * @see DEFAULT_CONFIG
  */
-export async function updateConfig(
-    callback: (Config: Config) => boolean | void
-): Promise<void> {
-    const config: Config = (await readConfig()) || DEFAULT_CONFIG
-    if (callback(config)) {
-        await writeConfig(config)
-    }
+export function updateConfig(
+  callback: (Config: Config) => boolean | void,
+  createInRoot: boolean = true
+): void {
+  const config: Config = readConfig() || DEFAULT_CONFIG
+  Boolean(callback(config)) && writeConfig(config, createInRoot)
 }
 
 /**
@@ -128,14 +174,11 @@ export async function updateConfig(
  * @return The target object associated with the given name.
  * @throws {TargetNotFoundError} If the target object is not found.
  */
-export function getTargetFromConfig(
-    config: Config,
-    targetName: string
-): Target {
-    const target = config.targets[targetName]
-    if (!target) {
-        throw new TargetNotFoundError(targetName)
-    }
+export function getTargetFromConfig(config: Config, targetName: string): Target {
+  const target = config.targets[targetName]
+  if (!target) {
+    throw new TargetNotFoundError(targetName)
+  }
 
-    return target
+  return target
 }

package/src/console.ts

@@ -0,0 +1,11 @@
+export function success(message: string): string {
+  return `🟩 ${message}`
+}
+
+export function warning(message: string): string {
+  return `🟨 ${message}`
+}
+
+export function error(message: string): string {
+  return `🟥 ${message}`
+}

package/src/encrypt.ts

@@ -2,190 +2,167 @@ import { execa } from 'execa'
 import * as path from 'node:path'
 import fsExtra from 'fs-extra'
 import { FailToDecryptFileError, FailToEncryptFileError } from './error.js'
+import { success } from './console.js'
 
 /**
  * Encrypts a file using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * This function checks whether the source file exists, constructs an OpenSSL
- * command, ensures the destination directory exists, and then executes the
- * encryption command.
+ * This function checks whether the source file exists, constructs an OpenSSL command, ensures the
+ * destination directory exists, and then executes the encryption command.
  *
  * @param srcFilePath The path to the source file that needs to be encrypted.
  * @param destFilePath The path where the encrypted file will be saved.
  * @param passphrase The passphrase used for encryption.
- * @param iteration_count The number of iterations to use for PBKDF2.
+ * @param iterationCount The number of iterations to use for PBKDF2.
  * @returns Resolves when the file is successfully encrypted.
- * @throws {FailToEncryptFileError} If the source file does not exist or if
- *         OpenSSL returns an error during encryption.
- * @throws {FailToDecryptFileError} If an unknown error occurs during
- *         encryption.
+ * @throws {FailToEncryptFileError} If the source file does not exist or if OpenSSL returns an error
+ *   during encryption.
+ * @throws {FailToDecryptFileError} If an unknown error occurs during encryption.
  */
 export async function encryptFile(
-    srcFilePath: string,
-    destFilePath: string,
-    passphrase: string,
-    iteration_count: number
+  srcFilePath: string,
+  destFilePath: string,
+  passphrase: string,
+  iterationCount: number
 ): Promise<void> {
-    if (!(await fsExtra.pathExists(srcFilePath))) {
-        throw new FailToEncryptFileError(srcFilePath)
-    }
+  if (!(await fsExtra.pathExists(srcFilePath))) {
+    throw new FailToEncryptFileError(srcFilePath)
+  }
 
-    const command: string = [
-        'openssl',
-        'enc',
-        '-aes-256-cbc',
-        '-salt',
-        '-pbkdf2',
-        '-iter',
-        Number(iteration_count),
-        '-in',
-        srcFilePath,
-        '-out',
-        destFilePath,
-        '-pass',
-        `'pass:${passphrase}'`,
-    ].join(' ')
+  const command: string = [
+    'openssl',
+    'enc',
+    '-aes-256-cbc',
+    '-salt',
+    '-pbkdf2',
+    '-iter',
+    Number(iterationCount),
+    '-in',
+    srcFilePath,
+    '-out',
+    destFilePath,
+    '-pass',
+    `'pass:${passphrase}'`,
+  ].join(' ')
 
-    await fsExtra.ensureDir(path.dirname(destFilePath))
+  await fsExtra.ensureDir(path.dirname(destFilePath))
 
-    try {
-        await execa(`${command}`, { shell: true })
-    } catch (err) {
-        if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
-            const error = err as { stderr: string }
-            throw new FailToEncryptFileError(srcFilePath, error.stderr)
-        } else {
-            throw new FailToDecryptFileError(
-                srcFilePath,
-                'Unknown error when encrypting the file.'
-            )
-        }
+  try {
+    await execa(`${command}`, { shell: true })
+  } catch (err) {
+    if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
+      const error = err as { stderr: string }
+      throw new FailToEncryptFileError(srcFilePath, error.stderr)
+    } else {
+      throw new FailToDecryptFileError(srcFilePath, 'Unknown error when encrypting the file.')
     }
+  }
 }
 
 /**
  * Decrypts a file using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * This function checks whether the encrypted file exists, constructs an OpenSSL
- * decryption command, ensures the destination directory exists, and then
- * executes the decryption command.
+ * This function checks whether the encrypted file exists, constructs an OpenSSL decryption command,
+ * ensures the destination directory exists, and then executes the decryption command.
  *
  * @param srcFilePath The path where the decrypted file will be saved.
  * @param destFilePath The path to the encrypted source file.
  * @param passphrase The passphrase used for decryption.
- * @param iteration_count The number of iterations used for PBKDF2.
+ * @param iterationCount The number of iterations used for PBKDF2.
  * @returns Resolves when the file is successfully decrypted.
- * @throws {FailToDecryptFileError} If the encrypted file does not exist or if
- *         OpenSSL returns an error during decryption.
- * @throws {FailToDecryptFileError} If an unknown error occurs during
- *         decryption.
+ * @throws {FailToDecryptFileError} If the encrypted file does not exist or if OpenSSL returns an
+ *   error during decryption.
+ * @throws {FailToDecryptFileError} If an unknown error occurs during decryption.
  */
 export async function decryptFile(
-    srcFilePath: string,
-    destFilePath: string,
-    passphrase: string,
-    iteration_count: number
+  srcFilePath: string,
+  destFilePath: string,
+  passphrase: string,
+  iterationCount: number
 ): Promise<void> {
-    if (!(await fsExtra.pathExists(destFilePath))) {
-        throw new FailToDecryptFileError(destFilePath)
-    }
+  if (!(await fsExtra.pathExists(destFilePath))) {
+    throw new FailToDecryptFileError(destFilePath)
+  }
 
-    const command: string = [
-        'openssl',
-        'enc',
-        '-d',
-        '-aes-256-cbc',
-        '-salt',
-        '-pbkdf2',
-        '-iter',
-        Number(iteration_count),
-        '-in',
-        destFilePath,
-        '-out',
-        srcFilePath,
-        '-pass',
-        `'pass:${passphrase}'`,
-    ].join(' ')
+  const command: string = [
+    'openssl',
+    'enc',
+    '-d',
+    '-aes-256-cbc',
+    '-salt',
+    '-pbkdf2',
+    '-iter',
+    Number(iterationCount),
+    '-in',
+    destFilePath,
+    '-out',
+    srcFilePath,
+    '-pass',
+    `'pass:${passphrase}'`,
+  ].join(' ')
 
-    await fsExtra.ensureDir(path.dirname(srcFilePath))
+  await fsExtra.ensureDir(path.dirname(srcFilePath))
 
-    try {
-        await execa(`${command}`, { shell: true })
-    } catch (err) {
-        if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
-            const error = err as { stderr: string }
-            throw new FailToDecryptFileError(srcFilePath, error.stderr)
-        } else {
-            throw new FailToDecryptFileError(
-                srcFilePath,
-                'Unknown error when decrypting the file.'
-            )
-        }
+  try {
+    await execa(`${command}`, { shell: true })
+  } catch (err) {
+    if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
+      const error = err as { stderr: string }
+      throw new FailToDecryptFileError(srcFilePath, error.stderr)
+    } else {
+      throw new FailToDecryptFileError(srcFilePath, 'Unknown error when decrypting the file.')
     }
+  }
 }
 
 /**
- * Encrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key
- * derivation.
+ * Encrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * For each source file path provided, this function constructs the destination
- * file path by appending `.enc`, then calls `encryptFile` and logs the
- * operation.
+ * For each source file path provided, this function constructs the destination file path by
+ * appending `.enc`, then calls `encryptFile` and logs the operation.
  *
  * @param srcFilePaths An array of file paths to be encrypted.
  * @param destDir The directory where the encrypted files will be saved.
  * @param passphrase The passphrase used for encryption.
- * @param iteration_count The number of iterations to use for PBKDF2.
+ * @param iterationCount The number of iterations to use for PBKDF2.
  * @returns Resolves when all files are successfully encrypted.
  * @throws {FailToEncryptFileError} If any file fails to encrypt.
  */
 export async function encryptFiles(
-    srcFilePaths: string[],
-    destDir: string,
-    passphrase: string,
-    iteration_count: number
+  srcFilePaths: string[],
+  destDir: string,
+  passphrase: string,
+  iterationCount: number
 ): Promise<void> {
-    for (const srcFilePath of srcFilePaths) {
-        const destFilePath: string = path.join(destDir, srcFilePath + '.enc')
-        await encryptFile(
-            srcFilePath,
-            destFilePath,
-            passphrase,
-            iteration_count
-        )
-        console.log(`[ENCRYPTED] ${srcFilePath} -> ${destFilePath}`)
-    }
+  for (const srcFilePath of srcFilePaths) {
+    const destFilePath: string = path.join(destDir, srcFilePath + '.enc')
+    await encryptFile(srcFilePath, destFilePath, passphrase, iterationCount)
+    console.log(success(`Encrypted: ${srcFilePath} -> ${destFilePath}`))
+  }
 }
 
 /**
- * Decrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key
- * derivation.
+ * Decrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * For each source file path provided, this function assumes the corresponding
- * encrypted file has the `.enc` extension and calls `decryptFile`, logging the
- * operation.
+ * For each source file path provided, this function assumes the corresponding encrypted file has
+ * the `.enc` extension and calls `decryptFile`, logging the operation.
  *
  * @param srcFilePaths An array of original file paths that were encrypted.
  * @param destDir The directory containing the encrypted files.
  * @param passphrase The passphrase used for decryption.
- * @param iteration_count The number of iterations used for PBKDF2.
+ * @param iterationCount The number of iterations used for PBKDF2.
  * @returns Resolves when all files are successfully decrypted.
  * @throws {FailToDecryptFileError} If any file fails to decrypt.
  */
 export async function decryptFiles(
-    srcFilePaths: string[],
-    destDir: string,
-    passphrase: string,
-    iteration_count: number
+  srcFilePaths: string[],
+  destDir: string,
+  passphrase: string,
+  iterationCount: number
 ): Promise<void> {
-    for (const srcFilePath of srcFilePaths) {
-        const destFilePath: string = path.join(destDir, srcFilePath + '.enc')
-        await decryptFile(
-            srcFilePath,
-            destFilePath,
-            passphrase,
-            iteration_count
-        )
-        console.log(`[DECRYPTED] ${destFilePath} -> ${srcFilePath}`)
-    }
+  for (const srcFilePath of srcFilePaths) {
+    const destFilePath: string = path.join(destDir, srcFilePath + '.enc')
+    await decryptFile(srcFilePath, destFilePath, passphrase, iterationCount)
+    console.log(success(`Decrypted: ${destFilePath} -> ${srcFilePath}`))
+  }
 }