@entergreat/file-utils 1.0.0

package/README.md

@@ -0,0 +1,120 @@
+# @entergreat/file-utils
+
+File utilities for reading, writing, converting and managing files.
+
+## Installation
+
+```bash
+npm install @entergreat/file-utils
+```
+
+## Usage
+
+```js
+import FileUtils from "@entergreat/file-utils";
+
+const fu = new FileUtils("/path/to/base/directory");
+```
+
+## API
+
+### Constructor
+
+```js
+new FileUtils(baseDir)
+```
+
+Creates a new FileUtils instance. All relative paths will be resolved from `baseDir`. Defaults to `process.cwd()`.
+
+### Methods
+
+#### `getFileNamesFromFolder(folderPath)`
+
+Returns an array of file names in the specified folder.
+
+```js
+const files = await fu.getFileNamesFromFolder("data");
+// ["file1.json", "file2.json"]
+```
+
+#### `saveNewFile(text, filename, folderPath)`
+
+Saves text content to a file. Creates the folder if it doesn't exist.
+
+```js
+const filePath = await fu.saveNewFile("Hello world", "greeting.txt", "output");
+```
+
+#### `getFileContent(filename, folderPath)`
+
+Reads and returns the content of a file.
+
+```js
+const content = await fu.getFileContent("config.json", "settings");
+```
+
+#### `deleteFile(fileName, folderPath)`
+
+Deletes a single file.
+
+```js
+await fu.deleteFile("temp.txt", "cache");
+```
+
+#### `deleteDirectory(folderPath)`
+
+Recursively deletes a directory and all its contents. Returns `1` if deleted, `0` if the directory didn't exist.
+
+```js
+await fu.deleteDirectory("temp");
+```
+
+#### `convertJsonToCsv(folderPath, outputFolder)`
+
+Converts all JSON files in a folder to CSV format. Handles nested objects by flattening them with dot notation.
+
+```js
+const csvFiles = await fu.convertJsonToCsv("json-data", "csv-output");
+// ["/path/to/csv-output/file1.csv", "/path/to/csv-output/file2.csv"]
+```
+
+#### `zipFolder(folderPath, zipFileName, outputFolder)`
+
+Compresses a folder into a ZIP file with maximum compression.
+
+```js
+const zipPath = await fu.zipFolder("data", "backup.zip", "archives");
+```
+
+#### `combineJsonFiles(folderPath)`
+
+Combines all JSON files in a folder into a single array. Each item gets a `_sourceFile` property indicating which file it came from.
+
+```js
+const combined = await fu.combineJsonFiles("json-data");
+// [{ name: "item1", _sourceFile: "file1" }, { name: "item2", _sourceFile: "file2" }]
+```
+
+#### `saveAsJsonAndCsv(data, fileName, folderPath)`
+
+Saves an array of objects as both JSON and CSV files.
+
+```js
+const data = [{ name: "Alice", age: 30 }, { name: "Bob", age: 25 }];
+const { jsonPath, csvPath } = await fu.saveAsJsonAndCsv(data, "users", "output");
+```
+
+### Static Methods
+
+#### `FileUtils.extractMainDomainName(url)`
+
+Extracts the main domain name from a URL.
+
+```js
+const domain = await FileUtils.extractMainDomainName("https://www.example.com/page");
+// "example"
+```
+
+## License
+
+UNLICENSED - Private package for EnterGreat internal use.

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@entergreat/file-utils",
+  "version": "1.0.0",
+  "description": "File utilities for reading, writing, converting and managing files",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+    "files": [
+    "src"
+  ],
+  "keywords": [
+    "file",
+    "utils",
+    "json",
+    "csv",
+    "zip"
+  ],
+  "author": "EnterGreat",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/entergreat/file-utils.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "archiver": "^7.0.1"
+  }
+}

package/src/index.js

@@ -0,0 +1,175 @@
+import { readdir, mkdir, writeFile, readFile, access, stat, unlink, rm } from "fs/promises";
+import { createWriteStream } from "fs";
+import archiver from "archiver";
+import path from "path";
+
+class FileUtils {
+  constructor(baseDir = process.cwd()) {
+    this.baseDir = baseDir;
+  }
+
+  resolvePath(folder) {
+    return path.isAbsolute(folder) ? folder : path.join(this.baseDir, folder);
+  }
+
+  static async extractMainDomainName(url) {
+    try {
+      let cleanUrl = url.trim();
+      if (!cleanUrl.startsWith("http://") && !cleanUrl.startsWith("https://")) {
+        cleanUrl = "https://" + cleanUrl;
+      }
+      let hostname = new URL(cleanUrl).hostname;
+      if (hostname.startsWith("www.")) {
+        hostname = hostname.substring(4);
+      }
+      const parts = hostname.split(".");
+      return parts.length >= 2 ? parts[parts.length - 2] : parts[0];
+    } catch {
+      const cleaned = url.trim().replace(/^https?:\/\//, "").replace(/^www\./, "");
+      return cleaned.split("/")[0].split(".")[0] || "unknown";
+    }
+  }
+
+  async getFileNamesFromFolder(folderPath) {
+    return readdir(this.resolvePath(folderPath));
+  }
+
+  async saveNewFile(text, filename, folderPath = "files") {
+    const filesDir = this.resolvePath(folderPath);
+    await mkdir(filesDir, { recursive: true });
+    const filePath = path.join(filesDir, filename);
+    await writeFile(filePath, text, "utf8");
+    return filePath;
+  }
+
+  async getFileContent(filename, folderPath = "files") {
+    return readFile(path.join(this.resolvePath(folderPath), filename), "utf8");
+  }
+
+  async deleteFile(fileName, folderPath) {
+    const filePath = path.join(this.resolvePath(folderPath), fileName);
+    if ((await stat(filePath)).isFile()) {
+      await unlink(filePath);
+    }
+  }
+
+  async deleteDirectory(folderPath = "files") {
+    const filesDir = this.resolvePath(folderPath);
+    try {
+      await access(filesDir);
+      await rm(filesDir, { recursive: true, force: true });
+      return 1;
+    } catch {
+      return 0;
+    }
+  }
+
+  async convertJsonToCsv(folderPath, outputFolder = folderPath) {
+    const sourceDir = this.resolvePath(folderPath);
+    const outputDir = this.resolvePath(outputFolder);
+    const files = (await readdir(sourceDir)).filter((f) => f.endsWith(".json"));
+
+    if (!files.length) {
+      throw new Error(`No JSON files in ${folderPath}`);
+    }
+
+    await mkdir(outputDir, { recursive: true });
+
+    return (
+      await Promise.all(
+        files.map(async (f) => {
+          const arr = [].concat(JSON.parse(await readFile(path.join(sourceDir, f), "utf8")));
+          if (!arr.length) return null;
+
+          const keys = [...new Set(arr.flatMap((o) => Object.keys(FileUtils._flatten(o))))];
+          const csv = [
+            keys.join(","),
+            ...arr.map((o) => {
+              const flat = FileUtils._flatten(o);
+              return keys.map((k) => FileUtils._escape(flat[k] ?? "")).join(",");
+            }),
+          ].join("\n");
+
+          const csvPath = path.join(outputDir, f.replace(".json", ".csv"));
+          await writeFile(csvPath, csv, "utf8");
+          return csvPath;
+        })
+      )
+    ).filter(Boolean);
+  }
+
+  async zipFolder(folderPath, zipFileName = "export.zip", outputFolder = "files") {
+    const sourceDir = this.resolvePath(folderPath);
+    const zipPath = path.join(this.resolvePath(outputFolder), zipFileName);
+    await mkdir(path.dirname(zipPath), { recursive: true });
+
+    return new Promise((resolve, reject) => {
+      const output = createWriteStream(zipPath);
+      const archive = archiver("zip", { zlib: { level: 9 } });
+
+      output.on("close", () => resolve(zipPath));
+      archive.on("error", reject);
+      archive.pipe(output);
+      archive.directory(sourceDir, false);
+      archive.finalize();
+    });
+  }
+
+  async combineJsonFiles(folderPath) {
+    const sourceDir = this.resolvePath(folderPath);
+    const files = (await readdir(sourceDir)).filter((f) => f.endsWith(".json"));
+    const combined = [];
+
+    for (const file of files) {
+      const arr = [].concat(JSON.parse(await readFile(path.join(sourceDir, file), "utf8")));
+      const fileName = file.replace(".json", "");
+      arr.forEach((item) => (item._sourceFile = fileName));
+      combined.push(...arr);
+    }
+
+    return combined;
+  }
+
+  async saveAsJsonAndCsv(data, fileName, folderPath) {
+    if (!Array.isArray(data) || !data.length) {
+      throw new Error("Data must be a non-empty array");
+    }
+
+    const filesDir = this.resolvePath(folderPath);
+    await mkdir(filesDir, { recursive: true });
+
+    await writeFile(path.join(filesDir, `${fileName}.json`), JSON.stringify(data, null, 2), "utf8");
+
+    const keys = Object.keys(data[0]);
+    const csv = [
+      keys.join(","),
+      ...data.map((row) => keys.map((k) => FileUtils._escape(row[k] ?? "")).join(",")),
+    ].join("\n");
+
+    await writeFile(path.join(filesDir, `${fileName}.csv`), csv, "utf8");
+
+    return {
+      jsonPath: path.join(filesDir, `${fileName}.json`),
+      csvPath: path.join(filesDir, `${fileName}.csv`),
+    };
+  }
+
+  static _flatten(obj, prefix = "") {
+    return Object.entries(obj).reduce((acc, [k, v]) => {
+      const key = prefix ? `${prefix}.${k}` : k;
+      if (v && typeof v === "object" && !Array.isArray(v)) {
+        return { ...acc, ...FileUtils._flatten(v, key) };
+      }
+      acc[key] = Array.isArray(v) ? JSON.stringify(v) : (v ?? "");
+      return acc;
+    }, {});
+  }
+
+  static _escape(val) {
+    const s = String(val);
+    return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+  }
+}
+
+export default FileUtils;
+export { FileUtils };