@zenfs/core 1.7.2 → 1.8.1

package/dist/vfs/shared.js

@@ -113,6 +113,7 @@ export function fixError(e, paths) {
         e.path = fixPaths(e.path, paths);
     return e;
 }
+/* node:coverage disable */
 /**
  * @internal @deprecated
  */
@@ -124,6 +125,7 @@ export function mountObject(mounts) {
         mount(point, fs);
     }
 }
+/* node:coverage enable */
 /**
  * @internal @hidden
  */

package/dist/vfs/sync.js

@@ -134,7 +134,7 @@ lstatSync;
 export function truncateSync(path, len = 0) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const file = __addDisposableResource(env_1, _openSync.call(this, path, 'r+'), false);
+        const file = __addDisposableResource(env_1, _openSync.call(this, path, { flag: 'r+' }), false);
         len || (len = 0);
         if (len < 0) {
             throw new ErrnoError(Errno.EINVAL);
@@ -176,11 +176,11 @@ function applySetId(file, uid, gid) {
     file.chownSync(parent.mode & constants.S_ISUID ? parent.uid : uid, // manually apply setuid/setgid
     parent.mode & constants.S_ISGID ? parent.gid : gid);
 }
-function _openSync(path, _flag, _mode, resolveSymlinks = true) {
+function _openSync(path, opt) {
     var _a;
     path = normalizePath(path);
-    const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks ? realpathSync.call(this, path) : path;
+    const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
+    path = opt.preserveSymlinks ? path : realpathSync.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     let stats;
     try {
@@ -203,6 +203,8 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
         }
         const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
         const file = fs.createFileSync(resolved, flag, mode, { uid, gid });
+        if (!opt.allowDirectory && mode & constants.S_IFDIR)
+            throw ErrnoError.With('EISDIR', path, '_open');
         applySetId(file, uid, gid);
         return file;
     }
@@ -216,6 +218,8 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
     if (isTruncating(flag)) {
         file.truncateSync(0);
     }
+    if (!opt.allowDirectory && stats.mode & constants.S_IFDIR)
+        throw ErrnoError.With('EISDIR', path, '_open');
     return file;
 }
 /**
@@ -223,7 +227,7 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
  * @see http://www.manpagez.com/man/2/open/
  */
 export function openSync(path, flag, mode = constants.F_OK) {
-    return file2fd(_openSync.call(this, path, flag, mode, true));
+    return file2fd(_openSync.call(this, path, { flag, mode }));
 }
 openSync;
 /**
@@ -231,13 +235,13 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return file2fd(_openSync.call(this, path, flag, mode, false));
+    return file2fd(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
 }
-function _readFileSync(fname, flag, resolveSymlinks) {
+function _readFileSync(fname, flag, preserveSymlinks) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         // Get file.
-        const file = __addDisposableResource(env_2, _openSync.call(this, fname, flag, 0o644, resolveSymlinks), false);
+        const file = __addDisposableResource(env_2, _openSync.call(this, fname, { flag, mode: 0o644, preserveSymlinks }), false);
         const stat = file.statSync();
         // Allocate buffer.
         const data = new Uint8Array(stat.size);
@@ -258,7 +262,7 @@ export function readFileSync(path, _options = {}) {
     if (!isReadable(flag)) {
         throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, true));
+    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, false));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
@@ -277,7 +281,11 @@ export function writeFileSync(path, data, _options = {}) {
         if (!encodedData) {
             throw new ErrnoError(Errno.EINVAL, 'Data not specified');
         }
-        const file = __addDisposableResource(env_3, _openSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true), false);
+        const file = __addDisposableResource(env_3, _openSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), {
+            flag,
+            mode: options.mode,
+            preserveSymlinks: true,
+        }), false);
         file.writeSync(encodedData, 0, encodedData.byteLength, 0);
         emitChange('change', path.toString());
     }
@@ -308,7 +316,11 @@ export function appendFileSync(filename, data, _options = {}) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        const file = __addDisposableResource(env_4, _openSync.call(this, typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true), false);
+        const file = __addDisposableResource(env_4, _openSync.call(this, typeof filename == 'number' ? fd2file(filename).path : filename.toString(), {
+            flag,
+            mode: options.mode,
+            preserveSymlinks: true,
+        }), false);
         file.writeSync(encodedData, 0, encodedData.byteLength);
     }
     catch (e_4) {
@@ -560,12 +572,12 @@ export function symlinkSync(target, path, type = 'file') {
         throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
     }
     writeFileSync.call(this, path, target.toString());
-    const file = _openSync.call(this, path, 'r+', 0o644, false);
+    const file = _openSync.call(this, path, { flag: 'r+', mode: 0o644, preserveSymlinks: true });
     file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = Buffer.from(_readFileSync.call(this, path.toString(), 'r', false));
+    const value = Buffer.from(_readFileSync.call(this, path.toString(), 'r', true));
     const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
     if (encoding == 'buffer') {
         return value;

package/dist/vfs/types.d.ts

@@ -11,6 +11,21 @@ export interface InternalOptions {
      */
     _isIndirect?: boolean;
 }
+/**
+ * @internal @hidden Used for the internal `_open` functions
+ */
+export interface OpenOptions {
+    flag: fs.OpenMode;
+    mode?: fs.Mode | null;
+    /**
+     * If true, do not resolve symlinks
+     */
+    preserveSymlinks?: boolean;
+    /**
+     * If true, allows opening directories
+     */
+    allowDirectory?: boolean;
+}
 export interface ReaddirOptions extends InternalOptions {
     withFileTypes?: boolean;
     recursive?: boolean;

package/eslint.shared.js

@@ -45,6 +45,7 @@ export default [
 			'@typescript-eslint/no-unsafe-call': 'off',
 			'@typescript-eslint/restrict-plus-operands': 'off',
 			'@typescript-eslint/no-base-to-string': 'off',
+			'@typescript-eslint/no-unused-expressions': 'warn',
 		},
 	},
 	{

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.7.2",
+	"version": "1.8.1",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -57,8 +57,7 @@
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
 		"lint": "eslint src tests",
-		"test": "tsx --test --experimental-test-coverage",
-		"pretest": "npm run build",
+		"test": "npx zenfs-test --clean && npx zenfs-test -abcfp && tests/fetch/run.sh && npx zenfs-test --report",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc",
 		"dev": "npm run build -- --watch",

package/readme.md

@@ -1,6 +1,6 @@
 # ZenFS
 
-ZenFS is a file system that emulates the [NodeJS filesystem API](http://nodejs.org/api/fs.html). It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate with other tools.
+ZenFS is a cross-platform library that emulates the [NodeJS filesystem API](http://nodejs.org/api/fs.html). It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate with other tools.
 
 ## Backends
 
@@ -8,7 +8,7 @@ ZenFS is modular and extensible. The core includes some built-in backends:
 
 -   `InMemory`: Stores files in-memory. This is cleared when the runtime ends (e.g. a user navigating away from a web page or a Node process exiting)
 -   `Overlay`: Use a read-only file system as read-write by overlaying a writable file system on top of it. ([copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write))
--   `Fetch`: Downloads files over HTTP with the `fetch` API (_readonly_)
+-   `Fetch`: Downloads files over HTTP with the `fetch` API
 -   `Port`: Interacts with a remote over a `MessagePort`-like interface (e.g. a worker)
 -   `Passthrough`: Use an existing `node:fs` interface with ZenFS
 

package/scripts/test.js

@@ -16,7 +16,10 @@ const { values: options, positionals } = parseArgs({
 		build: { short: 'b', type: 'boolean', default: false },
 		common: { short: 'c', type: 'boolean', default: false },
 		coverage: { type: 'string', default: 'tests/.coverage' },
+		preserve: { short: 'p', type: 'boolean' },
 		'exit-on-fail': { short: 'e', type: 'boolean' },
+		report: { type: 'boolean' },
+		clean: { type: 'boolean' },
 	},
 	allowPositionals: true,
 });
@@ -36,7 +39,12 @@ Options:
     -q, --quiet         Don't output normal messages
     -t, --test <glob>   Which FS test suite(s) to run
     -f, --force         Whether to use --test-force-exit
-    --coverage <dir>    Override the default coverage data directory`);
+
+Coverage:
+    --coverage <dir>    Override the default coverage data directory
+    -p,--preserve       Do not delete or report coverage data
+	--report            ONLY report coverage
+    --clean             ONLY clean up coverage directory`);
 	process.exit();
 }
 
@@ -45,6 +53,19 @@ if (options.quiet && options.verbose) {
 	process.exit(1);
 }
 
+process.env.NODE_V8_COVERAGE = options.coverage;
+
+if (options.clean) {
+	rmSync(options.coverage, { recursive: true, force: true });
+	process.exit();
+}
+
+if (options.report) {
+	execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
+	rmSync(options.coverage, { recursive: true, force: true });
+	process.exit();
+}
+
 options.verbose && options.force && console.debug('Forcing tests to exit (--test-force-exit)');
 
 if (options.build) {
@@ -73,19 +94,56 @@ if (options.auto) {
 	!options.quiet && console.log(`Auto-detected ${sum} test setup files`);
 }
 
-if (existsSync(options.coverage)) rmSync(options.coverage, { recursive: true });
-mkdirSync(options.coverage);
-process.env.NODE_V8_COVERAGE = options.coverage;
+/**
+ * Colorizes some text
+ * @param {string} text Text to color
+ * @param {string | number} code ANSI escape code
+ * @returns
+ */
+function color(text, code) {
+	return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+function status(name) {
+	const start = performance.now();
+
+	const time = () => {
+		let delta = Math.round(performance.now() - start),
+			unit = 'ms';
+
+		if (delta > 5000) {
+			delta /= 1000;
+			unit = 's';
+		}
+
+		return color(`(${delta} ${unit})`, '2;37');
+	};
+
+	return {
+		pass() {
+			if (!options.quiet) console.log(`${color('passed', 32)}: ${name} ${time()}`);
+		},
+		fail() {
+			console.error(`${color('failed', '1;31')}: ${name} ${time()}`);
+			process.exitCode = 1;
+			if (options['exit-on-fail']) process.exit();
+		},
+	};
+}
+
+if (!options.preserve) rmSync(options.coverage, { force: true, recursive: true });
+mkdirSync(options.coverage, { recursive: true });
 
 if (options.common) {
 	!options.quiet && console.log('Running common tests...');
+	const { pass, fail } = status('Common tests');
 	try {
 		execSync("tsx --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'", {
 			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 		});
+		pass();
 	} catch {
-		console.error('Common tests failed');
-		if (options['exit-on-fail']) process.exit(1);
+		fail();
 	}
 }
 
@@ -97,18 +155,22 @@ for (const setupFile of positionals) {
 		continue;
 	}
 
-	!options.quiet && console.debug('Running tests using setup:', setupFile);
+	!options.quiet && console.log('Running tests:', setupFile);
 	process.env.SETUP = setupFile;
 
+	const { pass, fail } = status(setupFile);
+
 	try {
 		execSync(['tsx --test --experimental-test-coverage', options.force ? '--test-force-exit' : '', testsGlob, process.env.CMD].join(' '), {
 			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 		});
+		pass();
 	} catch {
-		!options.quiet && console.error('Tests failed:', setupFile);
-		if (options['exit-on-fail']) process.exit(1);
+		fail();
 	}
 }
 
-execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
-rmSync(options.coverage, { recursive: true });
+if (!options.preserve) {
+	execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
+	rmSync(options.coverage, { recursive: true });
+}

package/tests/common/mutex.test.ts

@@ -51,7 +51,7 @@ suite('LockFS mutex', () => {
 
 		async function foo() {
 			const lock = await fs.lock('raceConditions', 'test');
-			await wait(100);
+			await wait(25);
 			x++;
 			lock.unlock();
 		}

package/tests/fetch/run.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/bash
+
+# Credit: Dave Dopson, https://stackoverflow.com/a/246128/17637456
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+npx tsx $SCRIPT_DIR/server.ts &
+PID=$!
+
+echo "Waiting for server to start..."
+until nc -z localhost 26514; do
+  sleep 0.5
+done
+
+npx zenfs-test $SCRIPT_DIR/setup.ts --preserve --force $@
+
+kill $PID

package/tests/fetch/server.ts

@@ -0,0 +1,49 @@
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { data, tmp } from '../setup.js';
+
+// If you change the port please update the setup file as well
+const port = 26514;
+
+const statusCodes = {
+	ENOENT: 404,
+};
+
+try {
+	execSync(`npm exec make-index -- ${data} --output ${tmp}/index.json --quiet`, { stdio: 'inherit' });
+} catch (e: any) {
+	if (e.signal == 'SIGINT') {
+		console.log('Aborted whilst creating index.');
+		process.exit(0);
+	} else {
+		console.error('Index creation failed: ' + e.message);
+		process.exit(1);
+	}
+}
+
+const server = createServer((request, response) => {
+	const { url = '' } = request;
+
+	if (url == '/.ping') {
+		response.statusCode = 200;
+		response.end('pong');
+		return;
+	}
+
+	const path = url == '/.index.json' ? join(tmp, 'index.json') : join(data, url.slice(1) || '');
+	try {
+		response.statusCode = 200;
+		response.end(readFileSync(path));
+	} catch (e: any) {
+		response.statusCode = statusCodes[e.code as keyof typeof statusCodes] || 400;
+		response.end();
+	}
+});
+
+server.listen(port);
+
+process.on('beforeExit', () => {
+	server.close().unref();
+});

package/tests/fetch/setup.ts

@@ -0,0 +1,13 @@
+import { configureSingle, Fetch, InMemory, Overlay, resolveMountConfig } from '../../dist/index.js';
+
+const baseUrl = 'http://localhost:26514';
+
+await configureSingle({
+	backend: Overlay,
+	readable: await resolveMountConfig({
+		backend: Fetch,
+		baseUrl,
+		index: baseUrl + '/.index.json',
+	}),
+	writable: InMemory.create({ name: 'cow' }),
+});

package/tests/fs/read.test.ts

@@ -1,17 +1,17 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
+import { Buffer } from 'buffer';
 
-const filepath: string = 'x.txt';
-const expected: string = 'xyz\n';
+const filepath = 'x.txt';
+const expected = 'xyz\n';
 
 suite('read', () => {
 	test('read file asynchronously', async () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
-
 		assert.equal(bytesRead, expected.length);
-		assert(buffer.toString() == expected);
+		assert.equal(buffer.toString(), expected);
 	});
 
 	test('read file synchronously', () => {
@@ -20,19 +20,19 @@ suite('read', () => {
 		const bytesRead = fs.readSync(fd, buffer, 0, expected.length, 0);
 
 		assert.equal(bytesRead, expected.length);
-		assert(buffer.toString() == expected);
+		assert.equal(buffer.toString(), expected);
 	});
 });
 
 suite('read binary', () => {
 	test('Read a file and check its binary bytes (asynchronous)', async () => {
 		const buff = await fs.promises.readFile('elipses.txt');
-		assert(((buff[1] << 8) | buff[0]) === 32994);
+		assert.strictEqual((buff[1] << 8) | buff[0], 32994);
 	});
 
 	test('Read a file and check its binary bytes (synchronous)', () => {
 		const buff = fs.readFileSync('elipses.txt');
-		assert(((buff[1] << 8) | buff[0]) === 32994);
+		assert.strictEqual((buff[1] << 8) | buff[0], 32994);
 	});
 });
 
@@ -45,14 +45,14 @@ suite('read buffer', () => {
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
 		assert.strictEqual(bytesRead, expected.length);
-		assert(bufferAsync.toString() === expected);
+		assert.strictEqual(bufferAsync.toString(), expected);
 	});
 
 	test('read file synchronously', () => {
 		const fd = fs.openSync(filepath, 'r');
 		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);
 
-		assert(bufferSync.toString() === expected);
+		assert.strictEqual(bufferSync.toString(), expected);
 		assert.strictEqual(bytesRead, expected.length);
 	});
 
@@ -61,7 +61,7 @@ suite('read buffer', () => {
 		const buffer = Buffer.alloc(expected.length + 10);
 		const bytesRead = fs.readSync(fd, buffer, 10, expected.length, 0);
 
-		assert(buffer.subarray(10, buffer.length).toString() === expected);
+		assert.strictEqual(buffer.subarray(10, buffer.length).toString(), expected);
 		assert.strictEqual(bytesRead, expected.length);
 	});
 });

package/tests/fs/times.test.ts

@@ -69,7 +69,7 @@ suite('times', () => {
 	test('read changes atime', async () => {
 		const before = fs.statSync(path).atimeMs;
 		fs.readFileSync(path);
-		await wait(100);
+		await wait(25);
 		const after = fs.statSync(path).atimeMs;
 		assert(before < after);
 	});
@@ -77,7 +77,7 @@ suite('times', () => {
 	test('write changes mtime', async () => {
 		const before = fs.statSync(path).mtimeMs;
 		fs.writeFileSync(path, 'cool');
-		await wait(100);
+		await wait(25);
 		const after = fs.statSync(path).mtimeMs;
 		assert(before < after);
 	});

package/tests/fs/write.test.ts

@@ -1,10 +1,9 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-
+const fn = 'write.txt';
 suite('write', () => {
 	test('write file with specified content', async () => {
-		const fn = 'write.txt';
 		const expected = 'ümlaut.';
 
 		const handle = await fs.promises.open(fn, 'w', 0o644);
@@ -20,10 +19,9 @@ suite('write', () => {
 	});
 
 	test('write a buffer to a file', async () => {
-		const filename = 'write.txt';
 		const expected = Buffer.from('hello');
 
-		const handle = await fs.promises.open(filename, 'w', 0o644);
+		const handle = await fs.promises.open(fn, 'w', 0o644);
 
 		const written = await handle.write(expected, 0, expected.length, null);
 
@@ -31,15 +29,12 @@ suite('write', () => {
 
 		await handle.close();
 
-		assert((await fs.promises.readFile(filename)).equals(expected));
+		assert((await fs.promises.readFile(fn)).equals(expected));
 
-		await fs.promises.unlink(filename);
+		await fs.promises.unlink(fn);
 	});
-});
 
-suite('writeSync', () => {
-	test('write file with specified content', () => {
-		const fn = 'write.txt';
+	test('writeSync file with specified content', () => {
 		const fd = fs.openSync(fn, 'w');
 
 		let written = fs.writeSync(fd, '');
@@ -53,6 +48,6 @@ suite('writeSync', () => {
 
 		fs.closeSync(fd);
 
-		assert(fs.readFileSync(fn, 'utf8') === 'foobár');
+		assert.strictEqual(fs.readFileSync(fn, 'utf8'), 'foobár');
 	});
 });

package/tests/setup/index.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path/posix';
+import { configureSingle, InMemory, InMemoryStore, mounts, Overlay, Readonly, resolveMountConfig, StoreFS } from '../../dist/index.js';
+import { S_IFDIR } from '../../dist/vfs/constants.js';
+import { copy, data } from '../setup.js';
+
+copy(data);
+
+const index = (mounts.get('/') as StoreFS).createIndexSync();
+
+class MockFS extends Readonly(StoreFS) {
+	constructor() {
+		super(new InMemoryStore());
+		this.loadIndexSync(index);
+
+		using tx = this.store.transaction();
+
+		for (const [path, node] of index) {
+			if (node.mode & S_IFDIR) continue;
+
+			const content = readFileSync(join(data, path));
+
+			tx.setSync(node.data, content);
+		}
+
+		tx.commitSync();
+	}
+}
+
+const readable = new MockFS();
+
+await readable.ready();
+
+await configureSingle({
+	backend: Overlay,
+	readable,
+	writable: await resolveMountConfig({ backend: InMemory, name: 'cow' }),
+});

package/tests/setup/port.ts

@@ -0,0 +1,15 @@
+import { MessageChannel } from 'node:worker_threads';
+import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount } from '../../dist/index.js';
+import { copy, data } from '../setup.js';
+
+const { port1: localPort, port2: remotePort } = new MessageChannel();
+
+fs.umount('/');
+const tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
+
+fs.mount('/', tmpfs);
+copy(data, fs);
+
+await resolveRemoteMount(remotePort, tmpfs);
+
+await configureSingle({ backend: Port, port: localPort });