feat(web): async disposable semaphore

Author: Dwynr

packages/filen-web/eslint.config.mjs

@@ -57,7 +57,16 @@ export default [
 			"@typescript-eslint/ban-types": "off",
 			"react/react-in-jsx-scope": "off",
 			"react/prop-types": "off",
-			"react-compiler/react-compiler": "error"
+			"react-compiler/react-compiler": "error",
+			"@typescript-eslint/no-unused-vars": [
+				"error",
+				{
+					argsIgnorePattern: "^_",
+					varsIgnorePattern: "^_",
+					caughtErrorsIgnorePattern: "^_",
+					destructuredArrayIgnorePattern: "^_"
+				}
+			]
 		}
 	},
 	{

packages/filen-web/src/components/socket.tsx

@@ -11,11 +11,11 @@ export const Socket = memo(() => {
 	const listenerRef = useRef<EventListenerHandle | undefined>(undefined)
 
 	const registerListener = useCallback(async () => {
-		try {
-			if (listenerRef.current || !sdk) {
-				return
-			}
+		if (listenerRef.current || !sdk) {
+			return
+		}
 
+		try {
 			listenerRef.current = await sdk.addSocketListener(null, async e => {
 				try {
 					switch (e.type) {

packages/filen-web/src/lib/semaphore.ts

@@ -1,42 +1,47 @@
-/**
- * Semaphore
- *
- * @export
- * @class Semaphore
- * @typedef {Semaphore}
- */
+export class DisposeSemaphoreWrapper implements AsyncDisposable {
+	private readonly semaphore: Semaphore
+	private released: boolean = false
+
+	public constructor(semaphore: Semaphore) {
+		this.semaphore = semaphore
+	}
+
+	async [Symbol.asyncDispose](): Promise<void> {
+		if (this.released) {
+			return Promise.resolve()
+		}
+
+		this.semaphore.release()
+
+		this.released = true
+
+		return Promise.resolve()
+	}
+}
+
 export class Semaphore {
 	private counter: number = 0
 	private waiting: Array<{
-		resolve: (value: void | PromiseLike<void>) => void
+		resolve: (value: DisposeSemaphoreWrapper | PromiseLike<DisposeSemaphoreWrapper>) => void
 		reject: (reason?: unknown) => void
 	}> = []
 	private maxCount: number
 
-	/**
-	 * Creates an instance of Semaphore.
-	 *
-	 * @constructor
-	 * @public
-	 * @param {number} [max=1]
-	 */
 	public constructor(max: number = 1) {
+		if (max < 1) {
+			throw new Error("Max must be at least 1")
+		}
+
 		this.maxCount = max
 	}
 
-	/**
-	 * Acquire a lock.
-	 *
-	 * @public
-	 * @returns {Promise<void>}
-	 */
-	public acquire(): Promise<void> {
+	public acquire(): Promise<DisposeSemaphoreWrapper> {
 		if (this.counter < this.maxCount) {
 			this.counter++
 
-			return Promise.resolve()
+			return Promise.resolve(new DisposeSemaphoreWrapper(this))
 		} else {
-			return new Promise<void>((resolve, reject) => {
+			return new Promise<DisposeSemaphoreWrapper>((resolve, reject) => {
 				this.waiting.push({
 					resolve,
 					reject
@@ -45,11 +50,6 @@ export class Semaphore {
 		}
 	}
 
-	/**
-	 * Release a lock.
-	 *
-	 * @public
-	 */
 	public release(): void {
 		if (this.counter <= 0) {
 			return
@@ -60,63 +60,29 @@ export class Semaphore {
 		this.processQueue()
 	}
 
-	/**
-	 * Returns the locks in the queue.
-	 *
-	 * @public
-	 * @returns {number}
-	 */
-	public count(): number {
-		return this.counter
-	}
-
-	/**
-	 * Set max number of concurrent locks.
-	 *
-	 * @public
-	 * @param {number} newMax
-	 */
-	public setMax(newMax: number): void {
-		this.maxCount = newMax
-
-		this.processQueue()
-	}
-
-	/**
-	 * Purge all waiting promises.
-	 *
-	 * @public
-	 * @returns {number}
-	 */
-	public purge(): number {
-		const unresolved = this.waiting.length
-
-		for (const waiter of this.waiting) {
-			waiter.reject("Task has been purged")
-		}
-
-		this.counter = 0
-		this.waiting = []
-
-		return unresolved
-	}
-
-	/**
-	 * Internal process queue.
-	 *
-	 * @private
-	 */
 	private processQueue(): void {
 		if (this.waiting.length > 0 && this.counter < this.maxCount) {
 			this.counter++
 
 			const waiter = this.waiting.shift()
 
 			if (waiter) {
-				waiter.resolve()
+				waiter.resolve(new DisposeSemaphoreWrapper(this))
 			}
 		}
 	}
 }
 
+export class Mutex {
+	private semaphore: Semaphore = new Semaphore(1)
+
+	public acquire(): Promise<DisposeSemaphoreWrapper> {
+		return this.semaphore.acquire()
+	}
+
+	public release(): void {
+		this.semaphore.release()
+	}
+}
+
 export default Semaphore

packages/filen-web/src/queries/client.ts

@@ -23,6 +23,10 @@ export const queryClientPersisterKv = {
 		return await idb.get<T>(`${QUERY_CLIENT_PERSISTER_PREFIX}-${key}`)
 	},
 	setItem: async (key: string, value: unknown): Promise<void> => {
+		if (!value) {
+			return
+		}
+
 		await persisterMutex.acquire()
 
 		try {
@@ -35,7 +39,7 @@ export const queryClientPersisterKv = {
 		await persisterMutex.acquire()
 
 		try {
-			return await idb.remove(`${QUERY_CLIENT_PERSISTER_PREFIX}-${key}`)
+			await idb.remove(`${QUERY_CLIENT_PERSISTER_PREFIX}-${key}`)
 		} finally {
 			persisterMutex.release()
 		}
@@ -130,29 +134,70 @@ export const DEFAULT_QUERY_OPTIONS: Pick<
 	| "refetchIntervalInBackground"
 	| "retry"
 	| "retryDelay"
+	| "networkMode"
+	| "notifyOnChangeProps"
 > = {
 	refetchOnMount: "always",
 	refetchOnReconnect: "always",
 	refetchOnWindowFocus: "always",
 	staleTime: 0,
 	gcTime: QUERY_CLIENT_CACHE_TIME,
 	refetchInterval: false,
-	experimental_prefetchInRender: true,
+	experimental_prefetchInRender: false,
 	refetchIntervalInBackground: false,
 	retry: true,
 	retryDelay: 1000,
 	retryOnMount: true,
+	networkMode: "always",
 	throwOnError(err) {
 		console.error(err)
 
 		return false
 	}
-} as const
+} as Omit<UseQueryOptions, "queryKey" | "queryFn">
+
+export const DEFAULT_QUERY_OPTIONS_ETERNAL: Pick<
+	UseQueryOptions,
+	| "refetchOnMount"
+	| "refetchOnReconnect"
+	| "refetchOnWindowFocus"
+	| "staleTime"
+	| "gcTime"
+	| "refetchInterval"
+	| "throwOnError"
+	| "retryOnMount"
+	| "experimental_prefetchInRender"
+	| "refetchIntervalInBackground"
+	| "retry"
+	| "retryDelay"
+	| "networkMode"
+	| "notifyOnChangeProps"
+> = {
+	notifyOnChangeProps: undefined,
+	refetchOnMount: false,
+	refetchOnReconnect: false,
+	refetchOnWindowFocus: false,
+	staleTime: Infinity,
+	gcTime: Infinity,
+	refetchInterval: false,
+	experimental_prefetchInRender: false,
+	refetchIntervalInBackground: false,
+	retry: true,
+	retryDelay: 1000,
+	retryOnMount: true,
+	networkMode: "always",
+	throwOnError(err) {
+		console.error(err)
+
+		return false
+	}
+} as Omit<UseQueryOptions, "queryKey" | "queryFn">
 
 export const queryClient = new QueryClient({
 	defaultOptions: {
 		queries: {
 			...DEFAULT_QUERY_OPTIONS,
+			persister: queryClientPersister.persisterFn,
 			queryKeyHashFn: queryKey => pack(queryKey).toString("base64")
 		}
 	}