@zenfs/core 1.11.3 → 2.0.0

package/tests/common/readline.test.ts

@@ -0,0 +1,104 @@
+import assert from 'node:assert/strict';
+import { PassThrough } from 'node:stream';
+import { suite, test } from 'node:test';
+import { wait } from 'utilium';
+import { createInterface, Interface } from '../../dist/readline.js';
+
+suite('Readline interface', { skip: true }, () => {
+	test('creates interface with readable stream', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		assert.ok(rl instanceof Interface);
+		assert.equal(rl.input, input);
+	});
+
+	test('emits line events when receiving data', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		input.write('first line\n');
+		input.write('second line\r\n');
+		input.write('third line\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['first line', 'second line', 'third line']);
+	});
+
+	test('handles partial lines correctly', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		input.write('partial ');
+		input.write('line\n');
+		input.write('another ');
+		input.write('partial line\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['partial line', 'another partial line']);
+	});
+
+	test('emits remaining buffer on close', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		input.write('line with newline\n');
+		input.write('line without newline');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['line with newline']);
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['line with newline', 'line without newline']);
+	});
+
+	test('tracks history correctly', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		let history: string[] = [];
+		rl.on('history', (h: string[]) => (history = h));
+
+		input.write('first command\n');
+		input.write('second command\n');
+
+		await wait(10);
+
+		assert.deepEqual(history, ['first command', 'second command']);
+	});
+
+	test('pause and resume functionality', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		rl.pause();
+		input.write('should not be processed\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, []);
+
+		rl.resume();
+		input.write('should be processed\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['should be processed']);
+	});
+});

package/tests/common.ts

@@ -1,26 +1,11 @@
 import { join, resolve } from 'node:path';
-import { fs as defaultFS, log } from '../dist/index.js';
+import { fs as defaultFS } from '../dist/index.js';
+import { setupLogs } from './logs.js';
 export type * from '../dist/index.js';
 
-const { ZENFS_LOG_LEVEL, SETUP } = process.env;
+setupLogs();
 
-let level: log.Level | (typeof log.levels)[log.Level] = log.Level.CRIT;
-
-if (ZENFS_LOG_LEVEL) {
-	const tmp = parseInt(ZENFS_LOG_LEVEL);
-	if (Number.isSafeInteger(tmp)) level = tmp;
-	else level = ZENFS_LOG_LEVEL as (typeof log.levels)[log.Level];
-}
-
-log.configure({
-	enabled: true,
-	format: log.formats.ansi_message,
-	dumpBacklog: true,
-	level,
-	output: console.error,
-});
-
-const setupPath = resolve(SETUP || join(import.meta.dirname, 'setup/memory.ts'));
+const setupPath = resolve(process.env.SETUP || join(import.meta.dirname, 'setup/memory.ts'));
 
 const setup = await import(setupPath).catch(error => {
 	console.log('Failed to import test setup:');

package/tests/fetch/fetch.ts

@@ -13,7 +13,7 @@ await configure({
 	log: {
 		enabled: true,
 		output: console.error,
-		format: log.formats.ansi_message,
+		format: log.fancy({ style: 'ansi', colorize: 'message' }),
 		level: log.Level.INFO,
 		dumpBacklog: true,
 	},

package/tests/fs/links.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { join } from '../../dist/vfs/path.js';
+import { join } from '../../dist/path.js';
 import { fs } from '../common.js';
 import type { ErrnoError } from '../../dist/index.js';
 

package/tests/fs/permissions.test.ts

@@ -1,9 +1,10 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { credentials, ErrnoError } from '../../dist/index.js';
-import { encodeUTF8 } from '../../dist/utils.js';
+import { encodeUTF8 } from 'utilium';
+import { ErrnoError } from '../../dist/index.js';
+import { defaultContext } from '../../dist/internal/contexts.js';
+import { join } from '../../dist/path.js';
 import { R_OK, W_OK, X_OK } from '../../dist/vfs/constants.js';
-import { join } from '../../dist/vfs/path.js';
 import { fs } from '../common.js';
 
 const asyncMode = 0o777;
@@ -87,8 +88,8 @@ suite('Permissions', () => {
 		assert(stats.hasAccess(R_OK));
 	}
 
-	const copy = { ...credentials };
-	Object.assign(credentials, { uid: 1000, gid: 1000, euid: 1000, egid: 1000 });
+	const copy = { ...defaultContext.credentials };
+	Object.assign(defaultContext.credentials, { uid: 1000, gid: 1000, euid: 1000, egid: 1000 });
 	test('Access controls: /', () => test_item('/'));
-	Object.assign(credentials, copy);
+	Object.assign(defaultContext.credentials, copy);
 });

package/tests/fs/readFile.test.ts

@@ -36,7 +36,7 @@ suite('Read and Unlink', () => {
 	});
 });
 
-suite('Read File Test', () => {
+suite('Read File', () => {
 	const fn = 'empty.txt';
 
 	test('read file asynchronously', async () => {
@@ -64,10 +64,10 @@ suite('fs file reading', () => {
 	test('read file synchronously and verify the content', () => {
 		const content = fs.readFileSync('elipses.txt', 'utf8');
 
+		assert.equal(content.length, 10000);
+
 		for (let i = 0; i < content.length; i++) {
 			assert.equal(content[i], '…');
 		}
-
-		assert.equal(content.length, 10000);
 	});
 });

package/tests/fs/stat.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { credentials } from '../../dist/index.js';
-import { Stats } from '../../dist/stats.js';
+import { defaultContext } from '../../dist/internal/contexts.js';
+import { Stats } from '../../dist/vfs/stats.js';
 import { fs } from '../common.js';
 
 suite('Stats', () => {
@@ -40,7 +40,7 @@ suite('Stats', () => {
 
 		fs.writeFileSync(newFile, 'hello', { mode: 0o640 });
 
-		const prevCredentials = { ...credentials };
+		const prevCredentials = { ...defaultContext.credentials };
 		const uid = 33;
 		const nonRootCredentials = {
 			uid,
@@ -53,7 +53,7 @@ suite('Stats', () => {
 
 		fs.chownSync(newFile, 0, nonRootCredentials.gid); // creating with root-user so that non-root user can access
 
-		Object.assign(credentials, nonRootCredentials);
+		Object.assign(defaultContext.credentials, nonRootCredentials);
 		const stat = fs.statSync(newFile);
 
 		assert.equal(stat.gid, nonRootCredentials.gid);
@@ -63,13 +63,13 @@ suite('Stats', () => {
 		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
 		// changing group
 
-		Object.assign(credentials, { ...nonRootCredentials, gid: 44 });
+		Object.assign(defaultContext.credentials, { ...nonRootCredentials, gid: 44 });
 
 		assert.equal(stat.hasAccess(fs.constants.R_OK), false);
 		assert.equal(stat.hasAccess(fs.constants.W_OK), false);
 		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
 
-		Object.assign(credentials, prevCredentials);
+		Object.assign(defaultContext.credentials, prevCredentials);
 	});
 
 	test('stat file', async () => {

package/tests/fs/streams.test.ts

@@ -129,21 +129,12 @@ suite('Streams', () => {
 	test('FileHandle.createReadStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePath, 'r');
 		await fileHandle.close();
-		const stream = fileHandle.createReadStream();
-		const { promise, resolve, reject } = Promise.withResolvers();
-		setTimeout(resolve, 100);
-		stream.on('error', reject);
-		assert.rejects(promise);
+		assert.throws(() => fileHandle.createReadStream(), { code: 'EBADF' });
 	});
 
 	test('FileHandle.createWriteStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePathWrite, 'w');
 		await fileHandle.close();
-		const stream = fileHandle.createWriteStream();
-		const { promise, resolve, reject } = Promise.withResolvers();
-		setTimeout(resolve, 100);
-		stream.on('error', reject);
-		assert.rejects(promise);
-		stream.write('Nuh-uh');
+		assert.throws(() => fileHandle.createWriteStream(), { code: 'EBADF' });
 	});
 });

package/tests/fs/times.test.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
 import { ErrnoError } from '../../dist/index.js';
-import type { StatsLike } from '../../dist/stats.js';
+import type { StatsLike } from '../../dist/vfs/stats.js';
 import { fs } from '../common.js';
 
 const path = 'x.txt';

package/tests/fs/xattr.test.ts

@@ -0,0 +1,85 @@
+import { Buffer } from 'buffer';
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+suite('Extended Attributes', () => {
+	const testFile = 'xattr-test.txt';
+	const testValue = 'test value';
+	const testName = 'user.test';
+
+	test.before(() => fs.promises.writeFile(testFile, 'test content'));
+	test.after(() => fs.promises.unlink(testFile));
+
+	test('Non-user attribute set fails', () => {
+		assert.rejects(fs.xattr.set(testFile, 'system.test', 'value'), { code: 'EPERM' });
+	});
+
+	test('set and get attributes', async () => {
+		await fs.xattr.set(testFile, testName, testValue);
+		const value = await fs.xattr.get(testFile, testName, { encoding: 'utf8' });
+		assert.equal(value, testValue);
+	});
+
+	test('get attributes with buffer encoding', async () => {
+		await fs.xattr.set(testFile, 'user.buffer', 'buffer value');
+		const buffer = await fs.xattr.get(testFile, 'user.buffer', { encoding: 'buffer' });
+		assert(buffer instanceof Uint8Array);
+		assert.equal(Buffer.from(buffer).toString(), 'buffer value');
+	});
+
+	test('remove attributes', async () => {
+		await fs.xattr.set(testFile, 'user.to-remove', testValue);
+		await fs.xattr.remove(testFile, 'user.to-remove');
+
+		assert.rejects(fs.xattr.get(testFile, 'user.to-remove', { encoding: 'utf8' }), { code: 'ENODATA' });
+	});
+
+	test('list attributes', async () => {
+		await fs.xattr.set(testFile, 'user.list1', 'value1');
+		await fs.xattr.set(testFile, 'user.list2', 'value2');
+
+		const attrs = await fs.xattr.list(testFile);
+		assert(attrs.includes('user.list1'));
+		assert(attrs.includes('user.list2'));
+	});
+
+	test('handle create and replace options', async () => {
+		const flagTestName = 'user.flag-test';
+
+		await fs.xattr.set(testFile, flagTestName, 'original', { create: true });
+
+		assert.rejects(fs.xattr.set(testFile, flagTestName, 'new value', { create: true }), { code: 'EEXIST' });
+
+		await fs.xattr.set(testFile, flagTestName, 'updated', { replace: true });
+		const value = await fs.xattr.get(testFile, flagTestName, { encoding: 'utf8' });
+		assert.equal(value, 'updated');
+
+		assert.rejects(fs.xattr.set(testFile, 'user.nonexistent', 'value', { replace: true }), { code: 'ENODATA' });
+	});
+
+	test('file must exist', () => {
+		assert.rejects(fs.xattr.set('nonexistent-file.txt', testName, 'value'), { code: 'ENOENT' });
+	});
+
+	test('synchronous operations', () => {
+		const syncAttrName = 'user.sync-test';
+
+		fs.xattr.setSync(testFile, syncAttrName, testValue);
+		const value = fs.xattr.getSync(testFile, syncAttrName, { encoding: 'utf8' });
+		assert.equal(value, testValue);
+
+		fs.xattr.removeSync(testFile, syncAttrName);
+
+		assert.throws(() => fs.xattr.getSync(testFile, syncAttrName, { encoding: 'utf8' }), { code: 'ENODATA' });
+
+		const syncList1 = 'user.sync-list1';
+		const syncList2 = 'user.sync-list2';
+		fs.xattr.setSync(testFile, syncList1, 'value1');
+		fs.xattr.setSync(testFile, syncList2, 'value2');
+
+		const attrs = fs.xattr.listSync(testFile);
+		assert(attrs.includes(syncList1));
+		assert(attrs.includes(syncList2));
+	});
+});

package/tests/logs.js

@@ -0,0 +1,22 @@
+import * as log from '../dist/internal/log.js';
+
+export function setupLogs(prefix) {
+	const { ZENFS_LOG_LEVEL } = process.env;
+
+	let level = log.Level.CRIT;
+
+	if (ZENFS_LOG_LEVEL) {
+		const tmp = parseInt(ZENFS_LOG_LEVEL);
+		if (Number.isSafeInteger(tmp)) level = tmp;
+		else level = ZENFS_LOG_LEVEL;
+	}
+
+	log.configure({
+		enabled: true,
+		format: log.fancy({ style: 'ansi', colorize: 'message' }),
+		dumpBacklog: true,
+		level,
+		stack: true,
+		output: (...msg) => (prefix ? console.error(prefix, ...msg) : console.error(...msg)),
+	});
+}

package/tests/setup/context.ts

@@ -4,6 +4,6 @@ import { copySync, data } from '../setup.js';
 
 _fs.mkdirSync('/new_root');
 
-export const { fs } = bindContext('/new_root');
+export const { fs } = bindContext({ root: '/new_root' });
 
 copySync(data, fs);

package/tests/setup/index.ts

@@ -1,6 +1,6 @@
 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 { configureSingle, CopyOnWrite, InMemory, InMemoryStore, mounts, Readonly, StoreFS } from '../../dist/index.js';
 import { S_IFDIR } from '../../dist/vfs/constants.js';
 import { copySync, data } from '../setup.js';
 
@@ -32,7 +32,7 @@ const readable = new MockFS();
 await readable.ready();
 
 await configureSingle({
-	backend: Overlay,
+	backend: CopyOnWrite,
 	readable,
-	writable: await resolveMountConfig({ backend: InMemory, name: 'cow' }),
+	writable: { backend: InMemory, label: 'cow' },
 });

package/tests/setup/port.ts

@@ -5,7 +5,7 @@ import { copySync, data } from '../setup.js';
 const { port1: localPort, port2: remotePort } = new MessageChannel();
 
 fs.umount('/');
-const tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
+const tmpfs = await resolveMountConfig({ backend: InMemory, label: 'tmp' });
 
 fs.mount('/', tmpfs);
 copySync(data, fs);

package/dist/backends/port/fs.d.ts

@@ -1,84 +0,0 @@
-import type { ExtractProperties } from 'utilium';
-import type { Inode, InodeLike } from '../..//internal/inode.js';
-import type { MountConfiguration } from '../../config.js';
-import type { File } from '../../internal/file.js';
-import type { CreationOptions, UsageInfo } from '../../internal/filesystem.js';
-import type { Backend, FilesystemOf } from '../backend.js';
-import { FileSystem } from '../../internal/filesystem.js';
-import { Stats } from '../../stats.js';
-import * as RPC from './rpc.js';
-type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | UsageInfo>;
-type FSMethod = keyof FSMethods;
-export type FSRequest<TMethod extends FSMethod = FSMethod> = RPC.Message & {
-    [M in TMethod]: {
-        method: M;
-        args: Parameters<FSMethods[M]>;
-    };
-}[TMethod];
-declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, import("../../mixins/async.js").AsyncMixin>;
-/**
- * PortFS lets you access an FS instance that is running in a port, or the other way around.
- *
- * Note that *direct* synchronous operations are not permitted on the PortFS,
- * regardless of the configuration option of the remote FS.
- */
-export declare class PortFS extends PortFS_base {
-    readonly options: RPC.Options;
-    readonly port: RPC.Port;
-    /**`
-     * @hidden
-     */
-    _sync: import("../index.js").StoreFS<import("../memory.js").InMemoryStore>;
-    /**
-     * Constructs a new PortFS instance that connects with the FS running on `options.port`.
-     */
-    constructor(options: RPC.Options);
-    protected rpc<const T extends FSMethod>(method: T, ...args: Parameters<FSMethods[T]>): Promise<Awaited<ReturnType<FSMethods[T]>>>;
-    ready(): Promise<void>;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    stat(path: string): Promise<Stats>;
-    sync(path: string, data: Uint8Array | undefined, stats: Readonly<InodeLike | Inode>): Promise<void>;
-    openFile(path: string, flag: string): Promise<File>;
-    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
-    unlink(path: string): Promise<void>;
-    rmdir(path: string): Promise<void>;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    readdir(path: string): Promise<string[]>;
-    exists(path: string): Promise<boolean>;
-    link(srcpath: string, dstpath: string): Promise<void>;
-    read(path: string, buffer: Uint8Array, offset: number, length: number): Promise<void>;
-    write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
-}
-/** @internal */
-export declare function handleRequest(port: RPC.Port, fs: FileSystem & {
-    _descriptors?: Map<number, File>;
-}, request: FSRequest): Promise<void>;
-export declare function attachFS(port: RPC.Port, fs: FileSystem): void;
-export declare function detachFS(port: RPC.Port, fs: FileSystem): void;
-declare const _Port: {
-    name: string;
-    options: {
-        port: {
-            type: "object";
-            required: true;
-            validator(port: RPC.Port): void;
-        };
-        timeout: {
-            type: "number";
-            required: false;
-        };
-    };
-    create(options: RPC.Options): PortFS;
-};
-type _Port = typeof _Port;
-export interface Port extends _Port {
-}
-/**
- * @category Backends and Configuration
- */
-export declare const Port: Port;
-/**
- * @category Backends and Configuration
- */
-export declare function resolveRemoteMount<T extends Backend>(port: RPC.Port, config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
-export {};

package/dist/backends/port/fs.js

@@ -1,151 +0,0 @@
-import { pick } from 'utilium';
-import { resolveMountConfig } from '../../config.js';
-import { Errno, ErrnoError } from '../../internal/error.js';
-import { FileSystem } from '../../internal/filesystem.js';
-import { err, info } from '../../internal/log.js';
-import { Async } from '../../mixins/async.js';
-import { Stats } from '../../stats.js';
-import { InMemory } from '../memory.js';
-import * as RPC from './rpc.js';
-/**
- * PortFS lets you access an FS instance that is running in a port, or the other way around.
- *
- * Note that *direct* synchronous operations are not permitted on the PortFS,
- * regardless of the configuration option of the remote FS.
- */
-export class PortFS extends Async(FileSystem) {
-    /**
-     * Constructs a new PortFS instance that connects with the FS running on `options.port`.
-     */
-    constructor(options) {
-        super(0x706f7274, 'portfs');
-        this.options = options;
-        /**`
-         * @hidden
-         */
-        this._sync = InMemory.create({ name: 'tmpfs:port' });
-        this.port = options.port;
-        RPC.attach(this.port, RPC.handleResponse);
-    }
-    rpc(method, ...args) {
-        return RPC.request({ method, args }, {
-            ...this.options,
-            fs: this,
-        });
-    }
-    async ready() {
-        await this.rpc('ready');
-        await super.ready();
-    }
-    rename(oldPath, newPath) {
-        return this.rpc('rename', oldPath, newPath);
-    }
-    async stat(path) {
-        return new Stats(await this.rpc('stat', path));
-    }
-    sync(path, data, stats) {
-        stats = 'toJSON' in stats ? stats.toJSON() : stats;
-        return this.rpc('sync', path, data, stats);
-    }
-    openFile(path, flag) {
-        return this.rpc('openFile', path, flag);
-    }
-    createFile(path, flag, mode, options) {
-        return this.rpc('createFile', path, flag, mode, options);
-    }
-    unlink(path) {
-        return this.rpc('unlink', path);
-    }
-    rmdir(path) {
-        return this.rpc('rmdir', path);
-    }
-    mkdir(path, mode, options) {
-        return this.rpc('mkdir', path, mode, options);
-    }
-    readdir(path) {
-        return this.rpc('readdir', path);
-    }
-    exists(path) {
-        return this.rpc('exists', path);
-    }
-    link(srcpath, dstpath) {
-        return this.rpc('link', srcpath, dstpath);
-    }
-    async read(path, buffer, offset, length) {
-        const _buf = (await this.rpc('read', path, buffer, offset, length));
-        buffer.set(_buf);
-    }
-    write(path, buffer, offset) {
-        return this.rpc('write', path, buffer, offset);
-    }
-}
-/** @internal */
-export async function handleRequest(port, fs, request) {
-    if (!RPC.isMessage(request))
-        return;
-    const { method, args, id, stack } = request;
-    let value, error = false;
-    try {
-        // @ts-expect-error 2556
-        value = await fs[method](...args);
-        switch (method) {
-            case 'openFile':
-            case 'createFile': {
-                value = {
-                    path: args[0],
-                    flag: args[1],
-                    stats: await fs.stat(args[0]),
-                };
-                break;
-            }
-            case 'read':
-                value = args[1];
-                break;
-        }
-    }
-    catch (e) {
-        value = e instanceof ErrnoError ? e.toJSON() : pick(e, 'message', 'stack');
-        error = true;
-    }
-    port.postMessage({ _zenfs: true, id, error, method, stack, value });
-}
-export function attachFS(port, fs) {
-    RPC.attach(port, request => handleRequest(port, fs, request));
-}
-export function detachFS(port, fs) {
-    RPC.detach(port, request => handleRequest(port, fs, request));
-}
-const _Port = {
-    name: 'Port',
-    options: {
-        port: {
-            type: 'object',
-            required: true,
-            validator(port) {
-                // Check for a `postMessage` function.
-                if (typeof (port === null || port === void 0 ? void 0 : port.postMessage) != 'function') {
-                    throw err(new ErrnoError(Errno.EINVAL, 'option must be a port'));
-                }
-            },
-        },
-        timeout: { type: 'number', required: false },
-    },
-    create(options) {
-        return new PortFS(options);
-    },
-};
-/**
- * @category Backends and Configuration
- */
-export const Port = _Port;
-/**
- * @category Backends and Configuration
- */
-export async function resolveRemoteMount(port, config, _depth = 0) {
-    const stopAndReplay = RPC.catchMessages(port);
-    const fs = await resolveMountConfig(config, _depth);
-    attachFS(port, fs);
-    await stopAndReplay(fs);
-    info('Resolved remote mount: ' + fs.toString());
-    return fs;
-}