@decaf-ts/utils
Version:
module management utils for decaf-ts
511 lines • 60.3 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.patchFile = patchFile;
exports.readFile = readFile;
exports.writeFile = writeFile;
exports.getAllFiles = getAllFiles;
exports.renameFile = renameFile;
exports.copyFile = copyFile;
exports.deletePath = deletePath;
exports.getPackage = getPackage;
exports.setPackageAttribute = setPackageAttribute;
exports.getPackageVersion = getPackageVersion;
exports.getDependencies = getDependencies;
exports.updateDependencies = updateDependencies;
exports.installIfNotAvailable = installIfNotAvailable;
exports.pushToGit = pushToGit;
exports.installDependencies = installDependencies;
exports.normalizeImport = normalizeImport;
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const text_1 = require("./text.cjs");
const utils_1 = require("./utils.cjs");
const logging_1 = require("@decaf-ts/logging");
const logger = logging_1.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
*/
function patchFile(path, values) {
const log = logger.for(patchFile);
if (!fs_1.default.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 = (0, text_1.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
*/
function readFile(path) {
const log = logger.for(readFile);
try {
log.verbose(`Reading file "${path}"...`);
return fs_1.default.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
*/
function writeFile(path, data) {
const log = logger.for(writeFile);
try {
log.verbose(`Writing file "${path} with ${data.length} bytes...`);
fs_1.default.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
*/
function getAllFiles(p, filter) {
const log = logger.for(getAllFiles);
const files = [];
try {
log.verbose(`Retrieving all files from "${p}"...`);
const entries = fs_1.default.readdirSync(p);
entries.forEach((entry) => {
const fullPath = path_1.default.join(p, entry);
const stat = fs_1.default.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
*/
async function renameFile(source, dest) {
const log = logger.for(renameFile);
let descriptorSource, descriptorDest;
try {
descriptorSource = fs_1.default.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_1.default.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_1.default.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
*/
function copyFile(source, dest) {
const log = logger.for(copyFile);
let descriptorSource, descriptorDest;
try {
descriptorSource = fs_1.default.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_1.default.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_1.default.mkdirSync(dest, { recursive: true });
}
}
try {
log.verbose(`Copying ${descriptorSource.isFile() ? "file" : "directory"} "${source}" to "${dest}...`);
fs_1.default.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
*/
function deletePath(p) {
const log = logger.for(deletePath);
try {
const descriptor = fs_1.default.statSync(p);
if (descriptor.isFile()) {
log.verbose(`Deleting file "${p}...`);
fs_1.default.rmSync(p, { recursive: true, force: true });
}
else if (descriptor.isDirectory())
fs_1.default.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
*/
function getPackage(p = process.cwd(), property) {
let pkg;
try {
pkg = JSON.parse(readFile(path_1.default.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
*/
function setPackageAttribute(attr, value, p = process.cwd()) {
const pkg = getPackage(p);
pkg[attr] = value;
writeFile(path_1.default.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
*/
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
*/
async function getDependencies(path = process.cwd()) {
let pkg;
try {
pkg = JSON.parse(await (0, utils_1.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
*/
async function updateDependencies() {
const log = logger.for(updateDependencies);
log.info("checking for updates...");
await (0, utils_1.runCommand)("npx npm-check-updates -u").promise;
log.info("updating...");
await (0, utils_1.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
*/
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
*/
async function pushToGit() {
const log = logger.for(pushToGit);
const gitUser = await (0, utils_1.runCommand)("git config user.name").promise;
const gitEmail = await (0, utils_1.runCommand)("git config user.email").promise;
log.verbose(`cached git id: ${gitUser}/${gitEmail}. changing to automation`);
await (0, utils_1.runCommand)('git config user.email "automation@decaf.ts"').promise;
await (0, utils_1.runCommand)('git config user.name "decaf"').promise;
log.info("Pushing changes to git...");
await (0, utils_1.runCommand)("git add .").promise;
await (0, utils_1.runCommand)(`git commit -m "refs #1 - after repo setup"`).promise;
await (0, utils_1.runCommand)("git push").promise;
await (0, utils_1.runCommand)(`git config user.email "${gitEmail}"`).promise;
await (0, utils_1.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
*/
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 (0, utils_1.runCommand)(`npm install ${prod.join(" ")}`, { cwd: process.cwd() })
.promise;
}
if (dev.length) {
log.info(`Installing devDependencies ${dev.join(", ")}...`);
await (0, utils_1.runCommand)(`npm install --save-dev ${dev.join(" ")}`, {
cwd: process.cwd(),
}).promise;
}
if (peer.length) {
log.info(`Installing peerDependencies ${peer.join(", ")}...`);
await (0, utils_1.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
*/
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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