refactoring to ts

2025-01-15 05:43:18 +01:00
parent 4c45eba321
commit 222d1a4372
11 changed files with 90 additions and 87 deletions
@@ -0,0 +1,176 @@
+// @ts-check
+
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import delay from "../../utils/delay";
+import { SyncFoldersFnParams, SyncFoldersSyncFnParams } from "../../types";
+
+let timeout: any;
+const UPDATE_TIMEOUT = 2000;
+
+export default async function watchFolders({
+    folders,
+    options,
+}: SyncFoldersFnParams) {
+    try {
+        const dirs = folders;
+
+        console.log(`Now handling ${dirs.length} Directories`);
+
+        const INTERVAL = options?.interval ? options.interval : UPDATE_TIMEOUT;
+
+        for (let i = 0; i < dirs.length; i++) {
+            const dir = dirs[i];
+
+            if (!dir) {
+                console.log(`Dir: ${dir} doesn't exist`);
+                continue;
+            }
+
+            const dirPath = typeof dir == "string" ? dir : dir.path;
+            if (
+                (typeof dir == "string" && !fs.existsSync(dirPath)) ||
+                (typeof dir == "object" &&
+                    dir.path &&
+                    !dir.host &&
+                    !fs.existsSync(dir.path))
+            ) {
+                console.log(`Dir ${dirPath} does not exist. Creating ...`);
+
+                try {
+                    const existingDirPath = dirs.find((dr) => {
+                        if (typeof dr == "string") return fs.existsSync(dr);
+                        if (!dr.host) return fs.existsSync(dr.path); // TODO handle remote
+                        return false;
+                    });
+
+                    console.log(`Existing Dir to clone: ${existingDirPath}`);
+
+                    if (!existingDirPath) {
+                        throw new Error(
+                            "No existing Directories for reference"
+                        );
+                    }
+
+                    fs.mkdirSync(dirPath, {
+                        recursive: true,
+                    });
+
+                    if (typeof existingDirPath == "string") {
+                        sync({
+                            dirPath: existingDirPath,
+                            dirs,
+                            options,
+                            init: true,
+                        });
+                    } else {
+                        sync({
+                            dirPath: existingDirPath.path,
+                            dirs,
+                            options,
+                            init: true,
+                        });
+                    }
+                } catch (error: any) {
+                    console.log("Error:", error.message);
+
+                    throw new Error(
+                        `Folder Doesn't exist and couldn't be created. Please check if Directory exists.\nERROR => ${error.message}`
+                    );
+                }
+            }
+
+            if (typeof dir == "string") {
+                sync({ dirPath, dirs, options });
+
+                await delay();
+
+                fs.watch(dirPath, { recursive: true }, (evt, fileName) => {
+                    clearTimeout(timeout);
+
+                    timeout = setTimeout(() => {
+                        sync({ dirPath, dirs, options });
+                        process.exit(1);
+                    }, INTERVAL);
+                });
+            }
+        }
+    } catch (error: any) {
+        console.log("ERROR:", error.message);
+        process.exit(0);
+    }
+}
+
+function sync({ options, dirs, dirPath, init }: SyncFoldersSyncFnParams) {
+    const dstDirs = dirs.filter((dr) => {
+        if (typeof dr == "string") return dr !== dirPath;
+        if (dr?.path) return dr.path !== dirPath;
+        return false;
+    });
+
+    for (let j = 0; j < dstDirs.length; j++) {
+        let cmdArray = ["rsync", "-avh"];
+
+        if (options?.delete) {
+            cmdArray.push("--delete");
+        }
+
+        if (options?.exclude?.[0]) {
+            options.exclude.forEach((excl) => {
+                cmdArray.push(`--exclude '${excl}'`);
+            });
+        }
+
+        const dstDr = dstDirs[j];
+        if (typeof dstDr == "string") {
+            if (!fs.existsSync(dstDr)) continue;
+
+            if (dirPath === dstDr) {
+                console.log(
+                    `You can't sync the same paths. Please check your configuration and resolve duplicate paths`
+                );
+                process.exit(6);
+            }
+
+            cmdArray.push(
+                path.normalize(dirPath) + "/",
+                path.normalize(dstDr) + "/"
+            );
+            const cmd = cmdArray.join(" ");
+            execSync(cmd, {
+                stdio: "inherit",
+            });
+        } else if (dstDr.path) {
+            if (!dstDr.host && !fs.existsSync(dstDr.path)) continue;
+
+            if (dirPath === dstDr.path) {
+                console.log(
+                    `You can't sync the same paths. Please check your configuration and resolve duplicate paths`
+                );
+                process.exit(6);
+            }
+
+            if (dstDr.host && dstDr.ssh_key && dstDr.user) {
+                cmdArray.push("-e", `'ssh -i ${dstDr.ssh_key}'`);
+                cmdArray.push(
+                    path.normalize(dirPath) + "/",
+                    `${dstDr.user}@${dstDr.host}:${dstDr.path}/`
+                );
+                const cmd = cmdArray.join(" ");
+                execSync(cmd, {
+                    stdio: "inherit",
+                });
+            } else {
+                cmdArray.push(
+                    path.normalize(dirPath),
+                    path.normalize(dstDr.path)
+                );
+                const cmd = cmdArray.join(" ");
+                execSync(cmd, {
+                    stdio: "inherit",
+                });
+            }
+        }
+    }
+}