Updates

lib/watch/files.ts

@@ -1,14 +1,15 @@
-import { execSync } from "child_process";
 import fs from "fs";
 import delay from "../../utils/delay";
-import { SyncFilesFnParams, SyncFilesSyncFnParams } from "../../types";
+import { SyncFilesFnParams } from "../../types";
+
+import sync from "../../utils/sync";
 
 export default async function watchFiles({
     files,
     options,
 }: SyncFilesFnParams) {
     let timeout: any;
-    const UPDATE_TIMEOUT = 2000;
+    const UPDATE_TIMEOUT = 1000;
 
     try {
         for (let i = 0; i < files.length; i++) {
@@ -39,16 +40,6 @@ export default async function watchFiles({
                     }
 
                     fs.writeFileSync(filePath, "");
-
-                    if (typeof existingFilePath == "string") {
-                        sync({ filePath: existingFilePath, files, options });
-                    } else {
-                        sync({
-                            filePath: existingFilePath.path,
-                            files,
-                            options,
-                        });
-                    }
                 } catch (error: any) {
                     throw new Error(
                         `File Doesn't exist and couldn't be created. Please check if Directory exists.\nERROR => ${error.message}`
@@ -62,8 +53,6 @@ export default async function watchFiles({
             if (typeof file == "object" && file.host) {
                 // TODO Handle SSH
             } else if (typeof file == "string") {
-                sync({ options, filePath, files });
-
                 await delay();
 
                 fs.watchFile(
@@ -72,7 +61,7 @@ export default async function watchFiles({
                         interval: interval || 200,
                     },
                     (curr, prev) => {
-                        if (fs.existsSync(global.SYNCING_FILE)) return;
+                        if (global.SYNCING) return;
 
                         const INTERVAL = options?.interval
                             ? options.interval
@@ -81,92 +70,43 @@ export default async function watchFiles({
                         clearTimeout(timeout);
 
                         timeout = setTimeout(() => {
-                            fs.writeFileSync(
-                                global.SYNCING_FILE,
-                                `SYNCING FILE: curr:${curr} :: prev:${prev}`
-                            );
-                            sync({ options, filePath, files });
-                            process.exit(global.SYNC_SUCCESS_EXIT_CODE);
+                            global.SYNCING = true;
+
+                            sync({
+                                options,
+                                dirPath: filePath,
+                                dirs: files,
+                                isFiles: true,
+                            }).finally(() => {
+                                process.exit(global.SYNC_SUCCESS_EXIT_CODE);
+                            });
                         }, INTERVAL);
                     }
                 );
             }
         }
+
+        const lastUpdatedFile = files[0];
+        const lastUpdatedFilePath =
+            typeof lastUpdatedFile == "string"
+                ? lastUpdatedFile
+                : lastUpdatedFile.path;
+
+        global.SYNCING = true;
+
+        await sync({
+            dirPath: lastUpdatedFilePath,
+            dirs: files,
+            options,
+            isFiles: true,
+            firstRun: true,
+        });
+
+        setTimeout(() => {
+            global.SYNCING = false;
+        }, UPDATE_TIMEOUT);
     } catch (error: any) {
         console.log("ERROR:", error.message);
         process.exit(0);
     }
 }
-
-function sync({ options, filePath, files }: SyncFilesSyncFnParams) {
-    const destFiles = files.filter((fl) => {
-        if (typeof fl == "string") return fl !== filePath;
-        if (fl?.path) return fl.path !== filePath;
-        return false;
-    });
-
-    for (let j = 0; j < destFiles.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 dstFl = destFiles[j];
-        if (typeof dstFl == "string") {
-            if (!fs.existsSync(dstFl)) continue;
-
-            if (filePath === dstFl) {
-                console.log(
-                    `You can't sync the same paths. Please check your configuration and resolve duplicate paths`
-                );
-                process.exit(6);
-            }
-
-            cmdArray.push(filePath, dstFl);
-            const cmd = cmdArray.join(" ");
-            console.log(`Running cmd 1 => ${cmd}`);
-
-            execSync(cmd, {
-                stdio: "inherit",
-            });
-        } else if (dstFl.path) {
-            if (!dstFl.host && !fs.existsSync(dstFl.path)) continue;
-
-            if (filePath === dstFl.path) {
-                console.log(
-                    `You can't sync the same paths. Please check your configuration and resolve duplicate paths`
-                );
-                process.exit(6);
-            }
-
-            if (dstFl.host && dstFl.ssh_key && dstFl.user) {
-                cmdArray.push("-e", `'ssh -i ${dstFl.ssh_key}'`);
-                cmdArray.push(
-                    filePath,
-                    `${dstFl.user}@${dstFl.host}:${dstFl.path}`
-                );
-                const cmd = cmdArray.join(" ");
-                execSync(cmd, {
-                    stdio: "inherit",
-                });
-            } else {
-                cmdArray.push(filePath, dstFl.path);
-
-                const cmd = cmdArray.join(" ");
-
-                console.log(`Running cmd 2 => ${cmd}`);
-
-                execSync(cmd, {
-                    stdio: "inherit",
-                });
-            }
-        }
-    }
-}