@zenfs/core 1.2.1 → 1.2.3

package/dist/backends/store/simple.d.ts

@@ -4,6 +4,7 @@ import { SyncTransaction, type Store } from './store.js';
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
+    keys(): Iterable<Ino>;
     get(ino: Ino): Uint8Array | undefined;
     set(ino: Ino, data: Uint8Array): void;
     delete(ino: Ino): void;
@@ -17,6 +18,7 @@ export declare abstract class SimpleAsyncStore implements SimpleSyncStore {
     protected cache: Map<Ino, Uint8Array>;
     protected queue: Set<Promise<unknown>>;
     protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
+    keys(): Iterable<Ino>;
     get(ino: Ino): Uint8Array | undefined;
     set(ino: Ino, data: Uint8Array): void;
     protected abstract _set(ino: Ino, data: Uint8Array): Promise<void>;
@@ -43,6 +45,7 @@ export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore>
      */
     protected modifiedKeys: Set<Ino>;
     protected store: SimpleSyncStore;
+    keysSync(): Iterable<Ino>;
     getSync(ino: Ino): Uint8Array;
     setSync(ino: Ino, data: Uint8Array): void;
     removeSync(ino: Ino): void;

package/dist/backends/store/simple.js

@@ -8,6 +8,9 @@ export class SimpleAsyncStore {
         this.cache = new Map();
         this.queue = new Set();
     }
+    keys() {
+        return this.cache.keys();
+    }
     get(ino) {
         return this.cache.get(ino);
     }
@@ -55,6 +58,9 @@ export class SimpleTransaction extends SyncTransaction {
          */
         this.modifiedKeys = new Set();
     }
+    keysSync() {
+        return this.store.keys();
+    }
     getSync(ino) {
         const val = this.store.get(ino);
         this.stashOldValue(ino, val);

package/dist/backends/store/store.d.ts

@@ -32,9 +32,17 @@ export declare abstract class Transaction<T extends Store = Store> {
     protected store: T;
     constructor(store: T);
     /**
-     * Whether the transaction was commited or aborted
+     * Whether the transaction was committed or aborted
      */
     protected done: boolean;
+    /**
+     * Gets all of the keys
+     */
+    abstract keys(): Promise<Iterable<Ino>>;
+    /**
+     * Gets all of the keys
+     */
+    abstract keysSync(): Iterable<Ino>;
     /**
      * Retrieves the data at `ino`.
      * @param ino The key to look under for data.
@@ -92,6 +100,7 @@ export declare abstract class Transaction<T extends Store = Store> {
  * Transaction that implements asynchronous operations with synchronous ones
  */
 export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
+    keys(): Promise<Iterable<Ino>>;
     get(ino: Ino): Promise<Uint8Array>;
     set(ino: bigint, data: Uint8Array): Promise<void>;
     remove(ino: Ino): Promise<void>;
@@ -102,9 +111,10 @@ export declare abstract class SyncTransaction<T extends Store = Store> extends T
  * Transaction that only supports asynchronous operations
  */
 export declare abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
-    getSync(): Uint8Array;
-    setSync(): void;
-    removeSync(): void;
-    commitSync(): void;
-    abortSync(): void;
+    keysSync(): never;
+    getSync(): never;
+    setSync(): never;
+    removeSync(): never;
+    commitSync(): never;
+    abortSync(): never;
 }

package/dist/backends/store/store.js

@@ -7,7 +7,7 @@ export class Transaction {
     constructor(store) {
         this.store = store;
         /**
-         * Whether the transaction was commited or aborted
+         * Whether the transaction was committed or aborted
          */
         this.done = false;
     }
@@ -29,6 +29,9 @@ export class Transaction {
  */
 export class SyncTransaction extends Transaction {
     /* eslint-disable @typescript-eslint/require-await */
+    async keys() {
+        return this.keysSync();
+    }
     async get(ino) {
         return this.getSync(ino);
     }
@@ -49,6 +52,9 @@ export class SyncTransaction extends Transaction {
  * Transaction that only supports asynchronous operations
  */
 export class AsyncTransaction extends Transaction {
+    keysSync() {
+        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.keysSync');
+    }
     getSync() {
         throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
     }

package/dist/emulation/cache.d.ts

@@ -10,11 +10,23 @@ export declare function setEnabled(value: boolean): void;
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.
  */
-export declare function getStats(path: string): Stats | undefined;
+export declare function getStatsSync(path: string): Stats | undefined;
 /**
  * Adds stats if the cache is enabled
  */
-export declare function setStats(path: string, value: Stats): void;
+export declare function setStatsSync(path: string, value: Stats): void;
+/**
+ * Clears the cache if it is enabled
+ */
+export declare function clearStatsSync(): void;
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export declare function getStats(path: string): Promise<Stats | undefined> | undefined;
+/**
+ * Adds stats if the cache is enabled
+ */
+export declare function setStats(path: string, value: Promise<Stats | undefined>): void;
 /**
  * Clears the cache if it is enabled
  */

package/dist/emulation/cache.js

@@ -9,6 +9,31 @@ export let isEnabled = false;
 export function setEnabled(value) {
     isEnabled = value;
 }
+const statsSync = new Map();
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export function getStatsSync(path) {
+    if (!isEnabled)
+        return;
+    return statsSync.get(path);
+}
+/**
+ * Adds stats if the cache is enabled
+ */
+export function setStatsSync(path, value) {
+    if (!isEnabled)
+        return;
+    statsSync.set(path, value);
+}
+/**
+ * Clears the cache if it is enabled
+ */
+export function clearStatsSync() {
+    if (!isEnabled)
+        return;
+    statsSync.clear();
+}
 const stats = new Map();
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.

package/dist/emulation/promises.js

@@ -435,7 +435,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStats(path) || (await fs.stat(resolved))).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await (cache.getStats(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -584,7 +584,10 @@ export async function rmdir(path) {
     path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        const stats = cache.getStats(path) || (await fs.stat(resolved));
+        const stats = await (cache.getStats(path) || fs.stat(resolved));
+        if (!stats) {
+            throw ErrnoError.With('ENOENT', path, 'readdir');
+        }
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -640,8 +643,12 @@ export async function readdir(path, options) {
         throw fixError(e, { [resolved]: path });
     };
     const { fs, path: resolved } = resolveMount(path);
-    const stats = cache.getStats(path) || (await fs.stat(resolved).catch(handleError));
-    cache.setStats(path, stats);
+    const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
+    cache.setStats(path, _stats);
+    const stats = await _stats;
+    if (!stats) {
+        throw ErrnoError.With('ENOENT', path, 'readdir');
+    }
     if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
@@ -663,8 +670,9 @@ export async function readdir(path, options) {
     const addEntry = async (entry) => {
         let entryStats;
         if (options?.recursive || options?.withFileTypes) {
-            entryStats = cache.getStats(join(path, entry)) || (await fs.stat(join(resolved, entry)).catch(handleError));
-            cache.setStats(join(path, entry), entryStats);
+            const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+            cache.setStats(join(path, entry), _entryStats);
+            entryStats = await _entryStats;
         }
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStats));
@@ -934,15 +942,17 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const stats = cache.getStats(path) ||
-        (await stat(path).catch((error) => {
-            if (error.code != 'ENOENT' || !options?.force)
-                throw error;
-        }));
+    const _stats = cache.getStats(path) ||
+        stat(path).catch((error) => {
+            if (error.code == 'ENOENT' && options?.force)
+                return undefined;
+            throw error;
+        });
+    cache.setStats(path, _stats);
+    const stats = await _stats;
     if (!stats) {
         return;
     }
-    cache.setStats(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {

package/dist/emulation/sync.js

@@ -147,7 +147,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStats(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -394,7 +394,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
-        const stats = cache.getStats(path) || fs.statSync(resolved);
+        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -447,8 +447,8 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
     try {
-        const stats = cache.getStats(path) || fs.statSync(resolved);
-        cache.setStats(path, stats);
+        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+        cache.setStatsSync(path, stats);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -474,8 +474,8 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = cache.getStats(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.setStats(join(path, entry), entryStat);
+        const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+        cache.setStatsSync(join(path, entry), entryStat);
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -501,7 +501,7 @@ export function readdirSync(path, options) {
         }
     }
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.clearStatsSync();
     }
     return values;
 }
@@ -638,7 +638,7 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.getStats(path) || statSync(path);
+        stats = cache.getStatsSync(path) || statSync(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -647,7 +647,7 @@ export function rmSync(path, options) {
     if (!stats) {
         return;
     }
-    cache.setStats(path, stats);
+    cache.setStatsSync(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -666,11 +666,11 @@ export function rmSync(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.clearStats();
+            cache.clearStatsSync();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.clearStatsSync();
     }
 }
 rmSync;

package/dist/mixins/async.js

@@ -45,6 +45,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { StoreFS } from '../backends/store/fs.js';
 import { join } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { parseFlag, PreloadFile } from '../file.js';
@@ -84,6 +85,18 @@ export function Async(FS) {
             }
             this.checkSync();
             await this._sync.ready();
+            // optimization: for 2 storeFS', we copy at a lower abstraction level.
+            if (this._sync instanceof StoreFS && this instanceof StoreFS) {
+                const sync = this._sync['store'].transaction();
+                const async = this['store'].transaction();
+                const promises = [];
+                for (const key of sync.keysSync()) {
+                    promises.push(async.set(key, sync.getSync(key)));
+                }
+                await Promise.all(promises);
+                this._isInitialized = true;
+                return;
+            }
             try {
                 await this.crossCopy('/');
                 this._isInitialized = true;
@@ -187,10 +200,11 @@ export function Async(FS) {
                 const stats = await this.stat(path);
                 this._sync.mkdirSync(path, stats.mode);
             }
-            const files = await this.readdir(path);
-            for (const file of files) {
-                await this.crossCopy(join(path, file));
+            const promises = [];
+            for (const file of await this.readdir(path)) {
+                promises.push(this.crossCopy(join(path, file)));
             }
+            await Promise.all(promises);
         }
         /**
          * @internal

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.2.1",
+	"version": "1.2.3",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/src/backends/store/simple.ts

@@ -5,6 +5,7 @@ import { SyncTransaction, type Store } from './store.js';
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
+	keys(): Iterable<Ino>;
 	get(ino: Ino): Uint8Array | undefined;
 	set(ino: Ino, data: Uint8Array): void;
 	delete(ino: Ino): void;
@@ -23,6 +24,10 @@ export abstract class SimpleAsyncStore implements SimpleSyncStore {
 
 	protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
 
+	public keys(): Iterable<Ino> {
+		return this.cache.keys();
+	}
+
 	public get(ino: Ino): Uint8Array | undefined {
 		return this.cache.get(ino);
 	}
@@ -82,6 +87,10 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 
 	protected declare store: SimpleSyncStore;
 
+	public keysSync(): Iterable<Ino> {
+		return this.store.keys();
+	}
+
 	public getSync(ino: Ino): Uint8Array {
 		const val = this.store.get(ino);
 		this.stashOldValue(ino, val);

package/src/backends/store/store.ts

@@ -39,10 +39,20 @@ export abstract class Transaction<T extends Store = Store> {
 	public constructor(protected store: T) {}
 
 	/**
-	 * Whether the transaction was commited or aborted
+	 * Whether the transaction was committed or aborted
 	 */
 	protected done: boolean = false;
 
+	/**
+	 * Gets all of the keys
+	 */
+	public abstract keys(): Promise<Iterable<Ino>>;
+
+	/**
+	 * Gets all of the keys
+	 */
+	public abstract keysSync(): Iterable<Ino>;
+
 	/**
 	 * Retrieves the data at `ino`.
 	 * @param ino The key to look under for data.
@@ -125,6 +135,9 @@ export abstract class Transaction<T extends Store = Store> {
  */
 export abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
 	/* eslint-disable @typescript-eslint/require-await */
+	public async keys(): Promise<Iterable<Ino>> {
+		return this.keysSync();
+	}
 	public async get(ino: Ino): Promise<Uint8Array> {
 		return this.getSync(ino);
 	}
@@ -151,23 +164,27 @@ export abstract class SyncTransaction<T extends Store = Store> extends Transacti
  * Transaction that only supports asynchronous operations
  */
 export abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
-	public getSync(): Uint8Array {
+	public keysSync(): never {
+		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.keysSync');
+	}
+
+	public getSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
 	}
 
-	public setSync(): void {
+	public setSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.setSync');
 	}
 
-	public removeSync(): void {
+	public removeSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.removeSync');
 	}
 
-	public commitSync(): void {
+	public commitSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.commitSync');
 	}
 
-	public abortSync(): void {
+	public abortSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.abortSync');
 	}
 }

package/src/emulation/cache.ts

@@ -14,12 +14,41 @@ export function setEnabled(value: boolean): void {
 	isEnabled = value;
 }
 
-const stats = new Map<string, Stats>();
+const statsSync = new Map<string, Stats>();
 
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.
  */
-export function getStats(path: string): Stats | undefined {
+export function getStatsSync(path: string): Stats | undefined {
+	if (!isEnabled) return;
+
+	return statsSync.get(path);
+}
+
+/**
+ * Adds stats if the cache is enabled
+ */
+export function setStatsSync(path: string, value: Stats): void {
+	if (!isEnabled) return;
+
+	statsSync.set(path, value);
+}
+
+/**
+ * Clears the cache if it is enabled
+ */
+export function clearStatsSync(): void {
+	if (!isEnabled) return;
+
+	statsSync.clear();
+}
+
+const stats = new Map<string, Promise<Stats | undefined>>();
+
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export function getStats(path: string): Promise<Stats | undefined> | undefined {
 	if (!isEnabled) return;
 
 	return stats.get(path);
@@ -28,7 +57,7 @@ export function getStats(path: string): Stats | undefined {
 /**
  * Adds stats if the cache is enabled
  */
-export function setStats(path: string, value: Stats): void {
+export function setStats(path: string, value: Promise<Stats | undefined>): void {
 	if (!isEnabled) return;
 
 	stats.set(path, value);

package/src/emulation/promises.ts

@@ -471,7 +471,7 @@ export async function unlink(path: fs.PathLike): Promise<void> {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.getStats(path) || (await fs.stat(resolved))).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(await (cache.getStats(path) || fs.stat(resolved)))!.hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		await fs.unlink(resolved);
@@ -624,7 +624,10 @@ export async function rmdir(path: fs.PathLike): Promise<void> {
 	path = await realpath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		const stats = cache.getStats(path) || (await fs.stat(resolved));
+		const stats = await (cache.getStats(path) || fs.stat(resolved));
+		if (!stats) {
+			throw ErrnoError.With('ENOENT', path, 'readdir');
+		}
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -716,8 +719,13 @@ export async function readdir(
 
 	const { fs, path: resolved } = resolveMount(path);
 
-	const stats = cache.getStats(path) || (await fs.stat(resolved).catch(handleError));
-	cache.setStats(path, stats);
+	const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
+	cache.setStats(path, _stats);
+	const stats = await _stats;
+
+	if (!stats) {
+		throw ErrnoError.With('ENOENT', path, 'readdir');
+	}
 
 	if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
@@ -744,8 +752,9 @@ export async function readdir(
 	const addEntry = async (entry: string) => {
 		let entryStats: Stats | undefined;
 		if (options?.recursive || options?.withFileTypes) {
-			entryStats = cache.getStats(join(path, entry)) || (await fs.stat(join(resolved, entry)).catch(handleError));
-			cache.setStats(join(path, entry), entryStats);
+			const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+			cache.setStats(join(path, entry), _entryStats);
+			entryStats = await _entryStats;
 		}
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStats!));
@@ -968,18 +977,20 @@ access satisfies typeof promises.access;
 export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOptions) {
 	path = normalizePath(path);
 
-	const stats =
+	const _stats =
 		cache.getStats(path) ||
-		(await stat(path).catch((error: ErrnoError) => {
-			if (error.code != 'ENOENT' || !options?.force) throw error;
-		}));
+		stat(path).catch((error: ErrnoError) => {
+			if (error.code == 'ENOENT' && options?.force) return undefined;
+			throw error;
+		});
+
+	cache.setStats(path, _stats);
+	const stats = await _stats;
 
 	if (!stats) {
 		return;
 	}
 
-	cache.setStats(path, stats);
-
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
 			if (options?.recursive) {