@decaf-ts/utils
Version:
module management utils for decaf-ts
490 lines • 59 kB
JavaScript
import fs from "fs";
import path from "path";
import { patchString } from "./text.js";
import { runCommand } from "./utils.js";
import { Logging } from "@decaf-ts/logging";
const logger = Logging.for("fs");
/**
* @description Patches a file with given values.
* @summary Reads a file, applies patches using TextUtils, and writes the result back to the file.
*
* @param {string} path - The path to the file to be patched.
* @param {Record<string, number | string>} values - The values to patch into the file.
* @return {void}
*
* @function patchFile
*
* @mermaid
* sequenceDiagram
* participant Caller
* participant patchFile
* participant fs
* participant readFile
* participant TextUtils
* participant writeFile
* Caller->>patchFile: Call with path and values
* patchFile->>fs: Check if file exists
* patchFile->>readFile: Read file content
* readFile->>fs: Read file
* fs-->>readFile: Return file content
* readFile-->>patchFile: Return file content
* patchFile->>TextUtils: Patch string
* TextUtils-->>patchFile: Return patched content
* patchFile->>writeFile: Write patched content
* writeFile->>fs: Write to file
* fs-->>writeFile: File written
* writeFile-->>patchFile: File written
* patchFile-->>Caller: Patching complete
*
* @memberOf module:utils
*/
export function patchFile(path, values) {
const log = logger.for(patchFile);
if (!fs.existsSync(path))
throw new Error(`File not found at path "${path}".`);
let content = readFile(path);
try {
log.verbose(`Patching file "${path}"...`);
log.debug(`with value: ${JSON.stringify(values)}`);
content = patchString(content, values);
}
catch (error) {
throw new Error(`Error patching file: ${error}`);
}
writeFile(path, content);
}
/**
* @description Reads a file and returns its content.
* @summary Reads the content of a file at the specified path and returns it as a string.
*
* @param {string} path - The path to the file to be read.
* @return {string} The content of the file.
*
* @function readFile
*
* @memberOf module:utils
*/
export function readFile(path) {
const log = logger.for(readFile);
try {
log.verbose(`Reading file "${path}"...`);
return fs.readFileSync(path, "utf8");
}
catch (error) {
log.verbose(`Error reading file "${path}": ${error}`);
throw new Error(`Error reading file "${path}": ${error}`);
}
}
/**
* @description Writes data to a file.
* @summary Writes the provided data to a file at the specified path.
*
* @param {string} path - The path to the file to be written.
* @param {string | Buffer} data - The data to be written to the file.
* @return {void}
*
* @function writeFile
*
* @memberOf module:utils
*/
export function writeFile(path, data) {
const log = logger.for(writeFile);
try {
log.verbose(`Writing file "${path} with ${data.length} bytes...`);
fs.writeFileSync(path, data, "utf8");
}
catch (error) {
log.verbose(`Error writing file "${path}": ${error}`);
throw new Error(`Error writing file "${path}": ${error}`);
}
}
/**
* @description Retrieves all files recursively from a directory.
* @summary Traverses through directories and subdirectories to collect all file paths.
*
* @param {string} p - The path to start searching from.
* @param {function} [filter] - Optional function to filter files by name or index.
* @return {string[]} Array of file paths.
*
* @function getAllFiles
*
* @memberOf module:utils
*/
export function getAllFiles(p, filter) {
const log = logger.for(getAllFiles);
const files = [];
try {
log.verbose(`Retrieving all files from "${p}"...`);
const entries = fs.readdirSync(p);
entries.forEach((entry) => {
const fullPath = path.join(p, entry);
const stat = fs.statSync(fullPath);
if (stat.isFile()) {
files.push(fullPath);
}
else if (stat.isDirectory()) {
files.push(...getAllFiles(fullPath));
}
});
if (!filter)
return files;
return files.filter(filter);
}
catch (error) {
log.verbose(`Error retrieving files from "${p}": ${error}`);
throw new Error(`Error retrieving files from "${p}": ${error}`);
}
}
/**
* @description Renames a file or directory.
* @summary Moves a file or directory from the source path to the destination path.
*
* @param {string} source - The source path of the file or directory.
* @param {string} dest - The destination path for the file or directory.
* @return {Promise<void>} A promise that resolves when the rename operation is complete.
*
* @function renameFile
*
* @memberOf module:utils
*/
export async function renameFile(source, dest) {
const log = logger.for(renameFile);
let descriptorSource, descriptorDest;
try {
descriptorSource = fs.statSync(source);
}
catch (error) {
log.verbose(`Source path "${source}" does not exist: ${error}`);
throw new Error(`Source path "${source}" does not exist: ${error}`);
}
try {
descriptorDest = fs.statSync(dest);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
}
catch (e) {
// do nothing. its ok
}
if (descriptorDest) {
log.verbose(`Destination path "${dest}" already exists`);
throw new Error(`Destination path "${dest}" already exists`);
}
try {
log.verbose(`Renaming ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}...`);
fs.renameSync(source, dest);
log.verbose(`Successfully renamed to "${dest}"`);
}
catch (error) {
log.verbose(`Error renaming ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}": ${error}`);
throw new Error(`Error renaming ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}": ${error}`);
}
}
/**
* @description Copies a file or directory.
* @summary Creates a copy of a file or directory from the source path to the destination path.
*
* @param {string} source - The source path of the file or directory.
* @param {string} dest - The destination path for the file or directory.
* @return {void}
*
* @function copyFile
*
* @memberOf module:utils
*/
export function copyFile(source, dest) {
const log = logger.for(copyFile);
let descriptorSource, descriptorDest;
try {
descriptorSource = fs.statSync(source);
}
catch (error) {
log.verbose(`Source path "${source}" does not exist: ${error}`);
throw new Error(`Source path "${source}" does not exist: ${error}`);
}
try {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
descriptorDest = fs.statSync(dest);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
}
catch (error) {
if (descriptorSource.isDirectory()) {
log.verbose(`Dest path "${dest}" does not exist. creating`);
fs.mkdirSync(dest, { recursive: true });
}
}
try {
log.verbose(`Copying ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}...`);
fs.cpSync(source, dest, { recursive: true });
}
catch (error) {
log.verbose(`Error copying ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}: ${error}`);
throw new Error(`Error copying ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}: ${error}`);
}
}
/**
* @description Deletes a file or directory.
* @summary Removes a file or directory at the specified path, with recursive and force options enabled.
*
* @param {string} p - The path to the file or directory to delete.
* @return {void}
*
* @function deletePath
*
* @memberOf module:utils
*/
export function deletePath(p) {
const log = logger.for(deletePath);
try {
const descriptor = fs.statSync(p);
if (descriptor.isFile()) {
log.verbose(`Deleting file "${p}...`);
fs.rmSync(p, { recursive: true, force: true });
}
else if (descriptor.isDirectory())
fs.rmSync(p, { recursive: true, force: true });
}
catch (error) {
log.verbose(`Error Deleting "${p}": ${error}`);
throw new Error(`Error Deleting "${p}": ${error}`);
}
}
/**
* @description Retrieves package information from package.json.
* @summary Loads and parses the package.json file from a specified directory or the current working directory. Can return the entire package object or a specific property.
* @param {string} [p=process.cwd()] - The directory path where the package.json file is located.
* @param {string} [property] - Optional. The specific property to retrieve from package.json.
* @return {object | string} The parsed contents of package.json or the value of the specified property.
* @function getPackage
* @mermaid
* sequenceDiagram
* participant Caller
* participant getPackage
* participant readFile
* participant JSON
* Caller->>getPackage: Call with path and optional property
* getPackage->>readFile: Read package.json
* readFile-->>getPackage: Return file content
* getPackage->>JSON: Parse file content
* JSON-->>getPackage: Return parsed object
* alt property specified
* getPackage->>getPackage: Check if property exists
* alt property exists
* getPackage-->>Caller: Return property value
* else property doesn't exist
* getPackage-->>Caller: Throw Error
* end
* else no property specified
* getPackage-->>Caller: Return entire package object
* end
* @memberOf module:utils
*/
export function getPackage(p = process.cwd(), property) {
let pkg;
try {
pkg = JSON.parse(readFile(path.join(p, `package.json`)));
}
catch (error) {
throw new Error(`Failed to retrieve package information" ${error}`);
}
if (property) {
if (!(property in pkg))
throw new Error(`Property "${property}" not found in package.json`);
return pkg[property];
}
return pkg;
}
/**
* @description Sets an attribute in the package.json file.
* @summary Updates a specific attribute in the package.json file with the provided value.
*
* @param {string} attr - The attribute name to set in package.json.
* @param {string | number | object} value - The value to set for the attribute.
* @param {string} [p=process.cwd()] - The directory path where the package.json file is located.
* @return {void}
*
* @function setPackageAttribute
*
* @memberOf module:utils
*/
export function setPackageAttribute(attr, value, p = process.cwd()) {
const pkg = getPackage(p);
pkg[attr] = value;
writeFile(path.join(p, `package.json`), JSON.stringify(pkg, null, 2));
}
/**
* @description Retrieves the version from package.json.
* @summary A convenience function that calls getPackage to retrieve the "version" property from package.json.
* @param {string} [p=process.cwd()] - The directory path where the package.json file is located.
* @return {string} The version string from package.json.
* @function getPackageVersion
* @memberOf module:utils
*/
export function getPackageVersion(p = process.cwd()) {
return getPackage(p, "version");
}
/**
* @description Retrieves all dependencies from the project.
* @summary Executes 'npm ls --json' command to get a detailed list of all dependencies (production, development, and peer) and their versions.
* @param {string} [path=process.cwd()] - The directory path of the project.
* @return {Promise<{prod: Array<{name: string, version: string}>, dev: Array<{name: string, version: string}>, peer: Array<{name: string, version: string}>}>} An object containing arrays of production, development, and peer dependencies.
* @function getDependencies
* @mermaid
* sequenceDiagram
* participant Caller
* participant getDependencies
* participant runCommand
* participant JSON
* Caller->>getDependencies: Call with optional path
* getDependencies->>runCommand: Execute 'npm ls --json'
* runCommand-->>getDependencies: Return command output
* getDependencies->>JSON: Parse command output
* JSON-->>getDependencies: Return parsed object
* getDependencies->>getDependencies: Process dependencies
* getDependencies-->>Caller: Return processed dependencies
* @memberOf module:utils
*/
export async function getDependencies(path = process.cwd()) {
let pkg;
try {
pkg = JSON.parse(await runCommand(`npm ls --json`, { cwd: path }).promise);
}
catch (e) {
throw new Error(`Failed to retrieve dependencies: ${e}`);
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const mapper = (entry, index) => ({
name: entry[0],
version: entry[1].version,
});
return {
prod: Object.entries(pkg.dependencies || {}).map(mapper),
dev: Object.entries(pkg.devDependencies || {}).map(mapper),
peer: Object.entries(pkg.peerDependencies || {}).map(mapper),
};
}
/**
* @description Updates project dependencies to their latest versions.
* @summary Runs npm-check-updates to update package.json and then installs the updated dependencies.
*
* @return {Promise<void>} A promise that resolves when dependencies are updated.
*
* @function updateDependencies
*
* @memberOf module:utils
*/
export async function updateDependencies() {
const log = logger.for(updateDependencies);
log.info("checking for updates...");
await runCommand("npx npm-check-updates -u").promise;
log.info("updating...");
await runCommand("npx npm run do-install").promise;
}
/**
* @description Installs dependencies if they are not already available.
* @summary Checks if specified dependencies are installed and installs any that are missing.
*
* @param {string[] | string} deps - The dependencies to check and potentially install.
* @param {SimpleDependencyMap} [dependencies] - Optional map of existing dependencies.
* @return {Promise<SimpleDependencyMap>} Updated map of dependencies.
*
* @function installIfNotAvailable
*
* @memberOf module:utils
*/
export async function installIfNotAvailable(deps, dependencies) {
if (!dependencies) {
const d = await getDependencies();
dependencies = {
prod: d.prod?.map((p) => p.name) || [],
dev: d.dev?.map((d) => d.name) || [],
peer: d.peer?.map((p) => p.name) || [],
};
}
const { prod, dev, peer } = dependencies;
const installed = Array.from(new Set([...(prod || []), ...(dev || []), ...(peer || [])]));
deps = typeof deps === "string" ? [deps] : deps;
const toInstall = deps.filter((d) => !installed.includes(d));
if (toInstall.length)
await installDependencies({ dev: toInstall });
dependencies.dev = dependencies.dev || [];
dependencies.dev.push(...toInstall);
return dependencies;
}
/**
* @description Pushes changes to Git repository.
* @summary Temporarily changes Git user configuration, commits all changes, pushes to remote, and restores original user configuration.
*
* @return {Promise<void>} A promise that resolves when changes are pushed.
*
* @function pushToGit
*
* @memberOf module:utils
*/
export async function pushToGit() {
const log = logger.for(pushToGit);
const gitUser = await runCommand("git config user.name").promise;
const gitEmail = await runCommand("git config user.email").promise;
log.verbose(`cached git id: ${gitUser}/${gitEmail}. changing to automation`);
await runCommand('git config user.email "automation@decaf.ts"').promise;
await runCommand('git config user.name "decaf"').promise;
log.info("Pushing changes to git...");
await runCommand("git add .").promise;
await runCommand(`git commit -m "refs #1 - after repo setup"`).promise;
await runCommand("git push").promise;
await runCommand(`git config user.email "${gitEmail}"`).promise;
await runCommand(`git config user.name "${gitUser}"`).promise;
log.verbose(`reverted to git id: ${gitUser}/${gitEmail}`);
}
/**
* @description Installs project dependencies.
* @summary Installs production, development, and peer dependencies as specified.
*
* @param {object} dependencies - Object containing arrays of dependencies to install.
* @param {string[]} [dependencies.prod] - Production dependencies to install.
* @param {string[]} [dependencies.dev] - Development dependencies to install.
* @param {string[]} [dependencies.peer] - Peer dependencies to install.
* @return {Promise<void>} A promise that resolves when all dependencies are installed.
*
* @function installDependencies
*
* @memberOf module:utils
*/
export async function installDependencies(dependencies) {
const log = logger.for(installDependencies);
const prod = dependencies.prod || [];
const dev = dependencies.dev || [];
const peer = dependencies.peer || [];
if (prod.length) {
log.info(`Installing dependencies ${prod.join(", ")}...`);
await runCommand(`npm install ${prod.join(" ")}`, { cwd: process.cwd() })
.promise;
}
if (dev.length) {
log.info(`Installing devDependencies ${dev.join(", ")}...`);
await runCommand(`npm install --save-dev ${dev.join(" ")}`, {
cwd: process.cwd(),
}).promise;
}
if (peer.length) {
log.info(`Installing peerDependencies ${peer.join(", ")}...`);
await runCommand(`npm install --save-peer ${peer.join(" ")}`, {
cwd: process.cwd(),
}).promise;
}
}
/**
* @description Normalizes imports to handle both CommonJS and ESModule formats.
* @summary Utility function to handle module import differences between formats.
*
* @template T - Type of the imported module.
* @param {Promise<T>} importPromise - Promise returned by dynamic import.
* @return {Promise<T>} Normalized module.
*
* @function normalizeImport
*
* @memberOf module:utils
*/
export async function normalizeImport(importPromise) {
// CommonJS's `module.exports` is wrapped as `default` in ESModule.
return importPromise.then((m) => (m.default || m));
}
//# sourceMappingURL=data:application/json;base64,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