feat: toggle large deletion confirmation, physical .filenignore, bump deps

Author: Dwynr

package-lock.json

@@ -1,6 +1,6 @@
 {
 	"name": "@filen/sync",
-	"version": "0.1.99",
+	"version": "0.1.100",
 	"description": "Filen Sync",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -54,7 +54,7 @@
 		"wait-on": "^7.2.0"
 	},
 	"dependencies": {
-		"@filen/sdk": "^0.1.192",
+		"@filen/sdk": "^0.1.193",
 		"@parcel/watcher": "^2.5.1",
 		"fast-glob": "^3.3.3",
 		"fs-extra": "^11.3.0",

package.json

@@ -3,6 +3,7 @@ import type Sync from "./lib/sync"
 import pathModule from "path"
 import fs from "fs-extra"
 import writeFileAtomic from "write-file-atomic"
+import { Semaphore } from "./semaphore"
 
 export const IGNORER_VERSION = 1
 
@@ -11,47 +12,96 @@ export class Ignorer {
 	public instance = ignore()
 	public name: string = "ignorer"
 	public pattern: string[] = []
+	private readonly mutex = new Semaphore(1)
 
 	public constructor(sync: Sync, name: string = "ignorer") {
 		this.sync = sync
 		this.name = name
 	}
 
 	public async fetch(): Promise<string> {
-		const filePath = pathModule.join(this.sync.dbPath, this.name, `v${IGNORER_VERSION}`, this.sync.syncPair.uuid, "filenIgnore")
+		await this.mutex.acquire()
+
+		try {
+			const filePath = pathModule.join(this.sync.dbPath, this.name, `v${IGNORER_VERSION}`, this.sync.syncPair.uuid, "filenIgnore")
+			const physicalFilePath = pathModule.join(this.sync.syncPair.localPath, ".filenignore")
+			let content: string = ""
+			const [exists, physicalExists] = await Promise.all([fs.exists(filePath), fs.exists(physicalFilePath)])
+
+			if (exists) {
+				const stats = await fs.stat(filePath)
+
+				if (stats.size > 0) {
+					content += await fs.readFile(filePath, {
+						encoding: "utf-8"
+					})
+				}
+			}
+
+			if (physicalExists) {
+				const stats = await fs.stat(physicalFilePath)
+
+				if (stats.size > 0) {
+					content += `${content.length > 0 ? "\n" : ""}${await fs.readFile(physicalFilePath, {
+						encoding: "utf-8"
+					})}`
+				}
+			}
+
+			return content
+		} finally {
+			this.mutex.release()
+		}
+	}
 
-		await fs.ensureDir(pathModule.dirname(filePath))
+	public async write(content: string): Promise<void> {
+		await this.mutex.acquire()
 
-		const exists = await fs.exists(filePath)
+		try {
+			const filePath = pathModule.join(this.sync.syncPair.localPath, ".filenignore")
 
-		if (!exists) {
-			return ""
-		}
+			await fs.ensureDir(pathModule.dirname(filePath))
 
-		const stats = await fs.stat(filePath)
-
-		if (stats.size === 0) {
-			return ""
+			await writeFileAtomic(filePath, content, {
+				encoding: "utf-8"
+			})
+		} finally {
+			this.mutex.release()
 		}
+	}
 
-		return await fs.readFile(filePath, {
-			encoding: "utf-8"
-		})
+	public async clearFile(): Promise<void> {
+		await this.mutex.acquire()
+
+		try {
+			const filePath = pathModule.join(this.sync.dbPath, this.name, `v${IGNORER_VERSION}`, this.sync.syncPair.uuid, "filenIgnore")
+			const physicalFilePath = pathModule.join(this.sync.syncPair.localPath, ".filenignore")
+			const [exists, physicalExists] = await Promise.all([fs.exists(filePath), fs.exists(physicalFilePath)])
+
+			if (exists) {
+				await writeFileAtomic(filePath, "", {
+					encoding: "utf-8"
+				})
+			}
+
+			if (physicalExists) {
+				await writeFileAtomic(physicalFilePath, "", {
+					encoding: "utf-8"
+				})
+			}
+		} finally {
+			this.mutex.release()
+		}
 	}
 
 	public async initialize(passedContent?: string): Promise<void> {
 		this.sync.localFileSystem.ignoredCache.clear()
 		this.sync.remoteFileSystem.ignoredCache.clear()
 
 		let content: string[] = []
-		const filePath = pathModule.join(this.sync.dbPath, this.name, `v${IGNORER_VERSION}`, this.sync.syncPair.uuid, "filenIgnore")
-
-		await fs.ensureDir(pathModule.dirname(filePath))
 
 		if (typeof passedContent === "string") {
-			await writeFileAtomic(filePath, passedContent, {
-				encoding: "utf-8"
-			})
+			await this.write(passedContent)
 
 			content = passedContent
 				.split("\n")
@@ -80,19 +130,6 @@ export class Ignorer {
 		this.instance = ignore()
 	}
 
-	public async clearFile(): Promise<void> {
-		const filePath = pathModule.join(this.sync.dbPath, this.name, `v${IGNORER_VERSION}`, this.sync.syncPair.uuid, "filenIgnore")
-
-		await fs.ensureDir(pathModule.dirname(filePath))
-
-		await fs.rm(filePath, {
-			force: true,
-			maxRetries: 60 * 10,
-			recursive: true,
-			retryDelay: 100
-		})
-	}
-
 	public ignores(path: string): boolean {
 		const normalizedPath = path.startsWith("\\") ? path.slice(1) : path.startsWith("/") ? path.slice(1) : path
 

src/ignorer.ts

@@ -256,10 +256,10 @@ export class SyncWorker {
 		}
 	}
 
-	public updateIgnorerContent(uuid: string, content?: string): void {
+	public async updateIgnorerContent(uuid: string, content?: string): Promise<void> {
 		for (const syncUUID in this.syncs) {
 			if (syncUUID === uuid) {
-				this.syncs[syncUUID]!.ignorer.update(content)
+				await this.syncs[syncUUID]!.ignorer.update(content)
 
 				this.syncs[syncUUID]!.localFileSystem.ignoredCache.clear()
 				this.syncs[syncUUID]!.remoteFileSystem.ignoredCache.clear()
@@ -269,6 +269,16 @@ export class SyncWorker {
 		}
 	}
 
+	public updateRequireConfirmationOnLargeDeletion(uuid: string, requireConfirmationOnLargeDeletion: boolean): void {
+		for (const syncUUID in this.syncs) {
+			if (syncUUID === uuid) {
+				this.syncs[syncUUID]!.requireConfirmationOnLargeDeletion = requireConfirmationOnLargeDeletion
+
+				break
+			}
+		}
+	}
+
 	public async fetchIgnorerContent(uuid: string): Promise<string> {
 		for (const syncUUID in this.syncs) {
 			if (syncUUID === uuid) {

src/index.ts

@@ -252,7 +252,7 @@ export class LocalFileSystem {
 
 				const pathsAdded: Record<string, boolean> = {}
 				let size = 0
-				const entries = await FastGlob.glob("**/*", {
+				const entries = await FastGlob.async("**/*", {
 					dot: true,
 					onlyDirectories: false,
 					onlyFiles: false,