@gadgetinc/ggt 1.0.2 → 1.0.4

package/lib/services/filesync/filesync.js

@@ -40,12 +40,12 @@ import { MergeConflictPreference } from "./strategy.js";
  * single request.
  */ export const MAX_PUSH_CONTENT_LENGTH = 50 * 1024 * 1024; // 50mb
 export class FileSync {
-    async hashes(ctx) {
-        const spinner = spin({
+    async hashes(ctx, quietly) {
+        const spinner = !quietly ? spin({
             ensureEmptyLineAbove: true
         })`
       Calculating file changes.
-    `;
+    ` : undefined;
         try {
             const [localHashes, { localFilesVersionHashes, environmentHashes, environmentFilesVersion }] = await Promise.all([
                 // get the hashes of our local files
@@ -125,10 +125,12 @@ export class FileSync {
             });
             const onlyDotGadgetFilesChanged = Array.from(environmentChangesToPull.keys()).every((filepath)=>filepath.startsWith(".gadget/"));
             const bothChanged = localChanges.size > 0 && environmentChanges.size > 0 && !onlyDotGadgetFilesChanged;
-            if (inSync) {
-                spinner.succeed`Your files are up to date. ${ts()}`;
-            } else {
-                spinner.succeed`Calculated file changes. ${ts()}`;
+            if (spinner) {
+                if (inSync) {
+                    spinner.succeed`Your files are up to date. ${ts()}`;
+                } else {
+                    spinner.succeed`Calculated file changes. ${ts()}`;
+                }
             }
             return {
                 inSync,
@@ -144,7 +146,9 @@ export class FileSync {
                 bothChanged
             };
         } catch (error) {
-            spinner.fail();
+            if (spinner) {
+                spinner.fail();
+            }
             throw error;
         }
     }
@@ -270,14 +274,14 @@ export class FileSync {
                         changed: changed.map((file)=>file.path),
                         deleted: deleted.map((file)=>file.path)
                     });
-                    const changes = await this._writeToLocalFilesystem(ctx, {
+                    const changes = await this.writeToLocalFilesystem(ctx, {
                         filesVersion: remoteFilesVersion,
                         files: changed,
                         delete: deleted.map((file)=>file.path),
                         printEnvironmentChangesOptions: {
                             tense: "past",
                             ensureEmptyLineAbove: true,
-                            title: sprintln`{green ${symbol.tick}} Pulled ${pluralize("file", changed.length + deleted.length)}. ${symbol.arrowLeft} ${ts()}`,
+                            title: sprintln`{greenBright ${symbol.tick}} Pulled ${pluralize("file", changed.length + deleted.length)}. ${ts()}`,
                             limit: 5,
                             ...printEnvironmentChangesOptions
                         }
@@ -294,13 +298,13 @@ export class FileSync {
    * - All non-conflicting changes are automatically merged.
    * - Conflicts are resolved by prompting the user to either keep their local changes or keep Gadget's changes.
    * - This function will not return until the filesystem is in sync.
-   */ async merge(ctx, { hashes, maxAttempts = 10, printLocalChangesOptions, printEnvironmentChangesOptions } = {}) {
+   */ async merge(ctx, { hashes, maxAttempts = 10, printLocalChangesOptions, printEnvironmentChangesOptions, quietly } = {}) {
         let attempt = 0;
         do {
             if (attempt === 0) {
-                hashes ??= await this.hashes(ctx);
+                hashes ??= await this.hashes(ctx, quietly);
             } else {
-                hashes = await this.hashes(ctx);
+                hashes = await this.hashes(ctx, quietly);
             }
             if (hashes.inSync) {
                 this._syncOperations.clear();
@@ -384,6 +388,166 @@ export class FileSync {
             printEnvironmentChangesOptions
         });
     }
+    async writeToLocalFilesystem(ctx, options) {
+        const filesVersion = BigInt(options.filesVersion);
+        assert(filesVersion >= this.syncJson.filesVersion, "filesVersion must be greater than or equal to current filesVersion");
+        ctx.log.debug("writing to local filesystem", {
+            filesVersion,
+            files: options.files.map((file)=>file.path),
+            delete: options.delete
+        });
+        const changes = new Changes();
+        const directoriesWithDeletedFiles = new Set();
+        await pMap(options.delete, async (pathToDelete)=>{
+            // add all the directories that contain this file to
+            // directoriesWithDeletedFiles so we can clean them up later
+            let dir = path.dirname(pathToDelete);
+            while(dir !== "."){
+                directoriesWithDeletedFiles.add(this.syncJson.directory.normalize(dir, true));
+                dir = path.dirname(dir);
+            }
+            const currentPath = this.syncJson.directory.absolute(pathToDelete);
+            const backupPath = this.syncJson.directory.absolute(".gadget/backup", this.syncJson.directory.relative(pathToDelete));
+            // rather than `rm -rf`ing files, we move them to
+            // `.gadget/backup/` so that users can recover them if something
+            // goes wrong. We've seen a lot of EBUSY/EINVAL errors when moving
+            // files so we retry a few times.
+            await pRetry(async ()=>{
+                try {
+                    // remove the current backup file in case it exists and is a
+                    // different type (file vs directory)
+                    await fs.remove(backupPath);
+                    await fs.move(currentPath, backupPath);
+                    changes.set(pathToDelete, {
+                        type: "delete"
+                    });
+                } catch (error) {
+                    if (isENOENTError(error)) {
+                        // replicate the behavior of `rm -rf` and ignore ENOENT
+                        return;
+                    }
+                    if (isENOTDIRError(error) || isEEXISTError(error)) {
+                        // the backup path already exists and ends in a file
+                        // rather than a directory, so we have to remove the file
+                        // before we can move the current path to the backup path
+                        let dir = path.dirname(backupPath);
+                        while(dir !== this.syncJson.directory.absolute(".gadget/backup")){
+                            const stats = await fs.stat(dir);
+                            // eslint-disable-next-line max-depth
+                            if (!stats.isDirectory()) {
+                                // this file is in the way, so remove it
+                                ctx.log.debug("removing file in the way of backup path", {
+                                    currentPath,
+                                    backupPath,
+                                    file: dir
+                                });
+                                await fs.remove(dir);
+                            }
+                            dir = path.dirname(dir);
+                        }
+                    // still throw the error so we retry
+                    }
+                    throw error;
+                }
+            }, {
+                // windows tends to run into these issues way more often than
+                // mac/linux, so we retry more times
+                retries: config.windows ? 4 : 2,
+                minTimeout: ms("100ms"),
+                onFailedAttempt: (error)=>{
+                    ctx.log.warn("failed to move file to backup", {
+                        error,
+                        currentPath,
+                        backupPath
+                    });
+                }
+            });
+        });
+        for (const directoryWithDeletedFile of Array.from(directoriesWithDeletedFiles.values()).sort().reverse()){
+            if (options.files.some((file)=>file.path === directoryWithDeletedFile)) {
+                continue;
+            }
+            try {
+                // delete any empty directories that contained a deleted file.
+                // if the empty directory should continue to exist, we would
+                // have received an event to create it above
+                await fs.rmdir(this.syncJson.directory.absolute(directoryWithDeletedFile));
+                changes.set(directoryWithDeletedFile, {
+                    type: "delete"
+                });
+            } catch (error) {
+                if (isENOENTError(error) || isENOTEMPTYError(error)) {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        await pMap(options.files, async (file)=>{
+            const absolutePath = this.syncJson.directory.absolute(file.path);
+            if (await fs.pathExists(absolutePath)) {
+                if (!file.path.endsWith("/")) {
+                    // only track file updates, not directory updates
+                    changes.set(file.path, {
+                        type: "update"
+                    });
+                }
+            } else {
+                changes.set(file.path, {
+                    type: "create"
+                });
+            }
+            if (file.path.endsWith("/")) {
+                await fs.ensureDir(absolutePath);
+            } else {
+                await fs.outputFile(absolutePath, Buffer.from(file.content, file.encoding));
+            }
+            if (supportsPermissions) {
+                // the os's default umask makes setting the mode during creation
+                // not work, so an additional fs.chmod call is necessary to
+                // ensure the file has the correct mode
+                await fs.chmod(absolutePath, file.mode & 0o777);
+            }
+            if (absolutePath === this.syncJson.directory.absolute(".ignore")) {
+                await this.syncJson.directory.loadIgnoreFile();
+            }
+        });
+        await this.syncJson.save(String(filesVersion));
+        options.spinner?.clear();
+        printChanges(ctx, {
+            changes,
+            tense: "past",
+            title: sprint`{greenBright ${symbol.arrowDown}} Pulled ${pluralize("file", changes.size)}. ${ts()}`,
+            ...options.printEnvironmentChangesOptions,
+            includeDotGadget: !!ctx.args["--verbose"]
+        });
+        if (changes.has("yarn.lock")) {
+            const spinner = spin({
+                ensureEmptyLineAbove: true
+            })('Running "yarn install --check-files"');
+            try {
+                await execa("yarn", [
+                    "install",
+                    "--check-files"
+                ], {
+                    cwd: this.syncJson.directory.path
+                });
+                spinner.succeed`Ran "yarn install --check-files" ${ts()}`;
+            } catch (error) {
+                spinner.fail();
+                ctx.log.error("yarn install failed", {
+                    error
+                });
+                const message = serializeError(error).message;
+                if (message) {
+                    println({
+                        ensureEmptyLineAbove: true,
+                        indent: 2
+                    })(message);
+                }
+            }
+        }
+        return changes;
+    }
     async _merge(ctx, { hashes: { localChanges, environmentChanges, environmentFilesVersion }, printLocalChangesOptions, printEnvironmentChangesOptions }) {
         const conflicts = getConflicts({
             localChanges,
@@ -455,7 +619,7 @@ export class FileSync {
         })(sprintChanges(ctx, {
             changes,
             tense: "present",
-            title: sprint`Pulling ${pluralize("file", changes.size)}. ${symbol.arrowLeft}`,
+            title: sprint`Pulling ${pluralize("file", changes.size)}.`,
             ...printEnvironmentChangesOptions
         }));
         try {
@@ -474,7 +638,7 @@ export class FileSync {
                 });
                 files = fileSyncFiles.files;
             }
-            await this._writeToLocalFilesystem(ctx, {
+            await this.writeToLocalFilesystem(ctx, {
                 filesVersion,
                 files,
                 delete: changes.deleted(),
@@ -611,165 +775,6 @@ export class FileSync {
             throw error;
         }
     }
-    async _writeToLocalFilesystem(ctx, options) {
-        const filesVersion = BigInt(options.filesVersion);
-        assert(filesVersion >= this.syncJson.filesVersion, "filesVersion must be greater than or equal to current filesVersion");
-        ctx.log.debug("writing to local filesystem", {
-            filesVersion,
-            files: options.files.map((file)=>file.path),
-            delete: options.delete
-        });
-        const changes = new Changes();
-        const directoriesWithDeletedFiles = new Set();
-        await pMap(options.delete, async (pathToDelete)=>{
-            // add all the directories that contain this file to
-            // directoriesWithDeletedFiles so we can clean them up later
-            let dir = path.dirname(pathToDelete);
-            while(dir !== "."){
-                directoriesWithDeletedFiles.add(this.syncJson.directory.normalize(dir, true));
-                dir = path.dirname(dir);
-            }
-            const currentPath = this.syncJson.directory.absolute(pathToDelete);
-            const backupPath = this.syncJson.directory.absolute(".gadget/backup", this.syncJson.directory.relative(pathToDelete));
-            // rather than `rm -rf`ing files, we move them to
-            // `.gadget/backup/` so that users can recover them if something
-            // goes wrong. We've seen a lot of EBUSY/EINVAL errors when moving
-            // files so we retry a few times.
-            await pRetry(async ()=>{
-                try {
-                    // remove the current backup file in case it exists and is a
-                    // different type (file vs directory)
-                    await fs.remove(backupPath);
-                    await fs.move(currentPath, backupPath);
-                    changes.set(pathToDelete, {
-                        type: "delete"
-                    });
-                } catch (error) {
-                    if (isENOENTError(error)) {
-                        // replicate the behavior of `rm -rf` and ignore ENOENT
-                        return;
-                    }
-                    if (isENOTDIRError(error) || isEEXISTError(error)) {
-                        // the backup path already exists and ends in a file
-                        // rather than a directory, so we have to remove the file
-                        // before we can move the current path to the backup path
-                        let dir = path.dirname(backupPath);
-                        while(dir !== this.syncJson.directory.absolute(".gadget/backup")){
-                            const stats = await fs.stat(dir);
-                            // eslint-disable-next-line max-depth
-                            if (!stats.isDirectory()) {
-                                // this file is in the way, so remove it
-                                ctx.log.debug("removing file in the way of backup path", {
-                                    currentPath,
-                                    backupPath,
-                                    file: dir
-                                });
-                                await fs.remove(dir);
-                            }
-                            dir = path.dirname(dir);
-                        }
-                    // still throw the error so we retry
-                    }
-                    throw error;
-                }
-            }, {
-                // windows tends to run into these issues way more often than
-                // mac/linux, so we retry more times
-                retries: config.windows ? 4 : 2,
-                minTimeout: ms("100ms"),
-                onFailedAttempt: (error)=>{
-                    ctx.log.warn("failed to move file to backup", {
-                        error,
-                        currentPath,
-                        backupPath
-                    });
-                }
-            });
-        });
-        for (const directoryWithDeletedFile of Array.from(directoriesWithDeletedFiles.values()).sort().reverse()){
-            if (options.files.some((file)=>file.path === directoryWithDeletedFile)) {
-                continue;
-            }
-            try {
-                // delete any empty directories that contained a deleted file.
-                // if the empty directory should continue to exist, we would
-                // have received an event to create it above
-                await fs.rmdir(this.syncJson.directory.absolute(directoryWithDeletedFile));
-                changes.set(directoryWithDeletedFile, {
-                    type: "delete"
-                });
-            } catch (error) {
-                if (isENOENTError(error) || isENOTEMPTYError(error)) {
-                    continue;
-                }
-                throw error;
-            }
-        }
-        await pMap(options.files, async (file)=>{
-            const absolutePath = this.syncJson.directory.absolute(file.path);
-            if (await fs.pathExists(absolutePath)) {
-                if (!file.path.endsWith("/")) {
-                    // only track file updates, not directory updates
-                    changes.set(file.path, {
-                        type: "update"
-                    });
-                }
-            } else {
-                changes.set(file.path, {
-                    type: "create"
-                });
-            }
-            if (file.path.endsWith("/")) {
-                await fs.ensureDir(absolutePath);
-            } else {
-                await fs.outputFile(absolutePath, Buffer.from(file.content, file.encoding));
-            }
-            if (supportsPermissions) {
-                // the os's default umask makes setting the mode during creation
-                // not work, so an additional fs.chmod call is necessary to
-                // ensure the file has the correct mode
-                await fs.chmod(absolutePath, file.mode & 0o777);
-            }
-            if (absolutePath === this.syncJson.directory.absolute(".ignore")) {
-                await this.syncJson.directory.loadIgnoreFile();
-            }
-        });
-        await this.syncJson.save(String(filesVersion));
-        options.spinner?.clear();
-        printChanges(ctx, {
-            changes,
-            tense: "past",
-            title: sprint`{green ${symbol.tick}} Pulled ${pluralize("file", changes.size)}. ${symbol.arrowLeft} ${ts()}`,
-            ...options.printEnvironmentChangesOptions
-        });
-        if (changes.has("yarn.lock")) {
-            const spinner = spin({
-                ensureEmptyLineAbove: true
-            })('Running "yarn install --check-files"');
-            try {
-                await execa("yarn", [
-                    "install",
-                    "--check-files"
-                ], {
-                    cwd: this.syncJson.directory.path
-                });
-                spinner.succeed`Ran "yarn install --check-files" ${ts()}`;
-            } catch (error) {
-                spinner.fail();
-                ctx.log.error("yarn install failed", {
-                    error
-                });
-                const message = serializeError(error).message;
-                if (message) {
-                    println({
-                        ensureEmptyLineAbove: true,
-                        indent: 2
-                    })(message);
-                }
-            }
-        }
-        return changes;
-    }
     constructor(syncJson){
         _define_property(this, "syncJson", void 0);
         /**