@zenfs/core 2.0.0 → 2.1.0

package/tests/fs/write.test.ts

@@ -1,27 +1,33 @@
 import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-const fn = 'write.txt';
-suite('write', () => {
-	test('write file with specified content', async () => {
+import { data as dataPath } from '../setup.js';
+
+const fileName = 'write.txt';
+const utf8example = readFileSync(join(dataPath, 'utf8.txt'), 'utf8');
+
+suite('Writes', () => {
+	test('Using FileHandle and UTF-8', async () => {
 		const expected = 'ümlaut.';
 
-		const handle = await fs.promises.open(fn, 'w', 0o644);
+		const handle = await fs.promises.open(fileName, 'w', 0o644);
 		await handle.write('', 0, 'utf8');
 		const { bytesWritten } = await handle.write(expected, 0, 'utf8');
 		assert.equal(bytesWritten, Buffer.from(expected).length);
 		await handle.close();
 
-		const data = await fs.promises.readFile(fn, 'utf8');
+		const data = await fs.promises.readFile(fileName, 'utf8');
 		assert.equal(data, expected);
 
-		await fs.promises.unlink(fn);
+		await fs.promises.unlink(fileName);
 	});
 
-	test('write a buffer to a file', async () => {
+	test('Using FileHandle with buffer', async () => {
 		const expected = Buffer.from('hello');
 
-		const handle = await fs.promises.open(fn, 'w', 0o644);
+		const handle = await fs.promises.open(fileName, 'w', 0o644);
 
 		const written = await handle.write(expected, 0, expected.length, null);
 
@@ -29,13 +35,13 @@ suite('write', () => {
 
 		await handle.close();
 
-		assert.deepEqual(await fs.promises.readFile(fn), expected);
+		assert.deepEqual(await fs.promises.readFile(fileName), expected);
 
-		await fs.promises.unlink(fn);
+		await fs.promises.unlink(fileName);
 	});
 
-	test('writeSync file with specified content', () => {
-		const fd = fs.openSync(fn, 'w');
+	test('Using sync path functions', () => {
+		const fd = fs.openSync(fileName, 'w');
 
 		let written = fs.writeSync(fd, '');
 		assert.equal(written, 0);
@@ -48,6 +54,64 @@ suite('write', () => {
 
 		fs.closeSync(fd);
 
-		assert.equal(fs.readFileSync(fn, 'utf8'), 'foobár');
+		assert.equal(fs.readFileSync(fileName, 'utf8'), 'foobár');
+	});
+
+	test('Using promises API', async () => {
+		const filename = 'test.txt';
+		await fs.promises.writeFile(filename, utf8example);
+		const data = await fs.promises.readFile(filename);
+		assert.equal(data.length, Buffer.from(utf8example).length);
+		await fs.promises.unlink(filename);
+	});
+
+	test('Using promises API with buffer', async () => {
+		const filename = 'test2.txt';
+		const expected = Buffer.from(utf8example, 'utf8');
+
+		await fs.promises.writeFile(filename, expected);
+		const actual = await fs.promises.readFile(filename);
+		assert.equal(actual.length, expected.length);
+
+		await fs.promises.unlink(filename);
+	});
+
+	test('Promises API with base64 data', async () => {
+		const data = readFileSync(join(dataPath, 'image.jpg'), 'base64');
+
+		const buffer = Buffer.from(data, 'base64');
+		const filePath = 'test.jpg';
+
+		await fs.promises.writeFile(filePath, buffer);
+
+		const read = await fs.promises.readFile(filePath, 'base64');
+		assert.equal(read, data);
+	});
+
+	test('Using sync path functions with custom mode', () => {
+		const file = 'testWriteFileSync.txt';
+		const mode = 0o755;
+
+		fs.writeFileSync(file, '123', { mode });
+
+		const content = fs.readFileSync(file, 'utf8');
+		assert.equal(content, '123');
+		assert.equal(fs.statSync(file).mode & 0o777, mode);
+
+		fs.unlinkSync(file);
+	});
+
+	test('Appending to a file synchronously with custom mode', () => {
+		const file = 'testAppendFileSync.txt';
+		const mode = 0o755;
+
+		fs.appendFileSync(file, 'abc', { mode });
+
+		const content = fs.readFileSync(file, { encoding: 'utf8' });
+		assert.equal(content, 'abc');
+
+		assert.equal(fs.statSync(file).mode & 0o777, mode);
+
+		fs.unlinkSync(file);
 	});
 });

package/tests/fs/xattr.test.ts

@@ -11,8 +11,8 @@ suite('Extended Attributes', () => {
 	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('Non-user attribute set fails', async () => {
+		await assert.rejects(fs.xattr.set(testFile, 'system.test', 'value'), { code: 'ENOTSUP' });
 	});
 
 	test('set and get attributes', async () => {
@@ -32,7 +32,7 @@ suite('Extended Attributes', () => {
 		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' });
+		await assert.rejects(fs.xattr.get(testFile, 'user.to-remove', { encoding: 'utf8' }), { code: 'ENODATA' });
 	});
 
 	test('list attributes', async () => {
@@ -49,17 +49,17 @@ suite('Extended Attributes', () => {
 
 		await fs.xattr.set(testFile, flagTestName, 'original', { create: true });
 
-		assert.rejects(fs.xattr.set(testFile, flagTestName, 'new value', { create: true }), { code: 'EEXIST' });
+		await 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' });
+		await 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('file must exist', async () => {
+		await assert.rejects(fs.xattr.set('nonexistent-file.txt', testName, 'value'), { code: 'ENOENT' });
 	});
 
 	test('synchronous operations', () => {

package/tests/logs.js

@@ -1,9 +1,9 @@
-import * as log from '../dist/internal/log.js';
+import { log } from 'kerium';
 
 export function setupLogs(prefix) {
 	const { ZENFS_LOG_LEVEL } = process.env;
 
-	let level = log.Level.CRIT;
+	let level = log.Level.ERR;
 
 	if (ZENFS_LOG_LEVEL) {
 		const tmp = parseInt(ZENFS_LOG_LEVEL);

package/tests/setup/port.ts

@@ -1,3 +1,4 @@
+import { after } from 'node:test';
 import { MessageChannel } from 'node:worker_threads';
 import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount } from '../../dist/index.js';
 import { copySync, data } from '../setup.js';
@@ -13,3 +14,8 @@ copySync(data, fs);
 await resolveRemoteMount(remotePort, tmpfs);
 
 await configureSingle({ backend: Port, port: localPort });
+
+after(() => {
+	localPort.close();
+	remotePort.close();
+});

package/dist/internal/log.d.ts

@@ -1,139 +0,0 @@
-import { List } from 'utilium';
-import { ErrnoError } from './error.js';
-import type { FileSystem } from './filesystem.js';
-export declare const enum Level {
-    /** Emergency */
-    EMERG = 0,
-    /** Alert */
-    ALERT = 1,
-    /** Critical */
-    CRIT = 2,
-    /** Error */
-    ERR = 3,
-    /** Warning */
-    WARN = 4,
-    /** Notice */
-    NOTICE = 5,
-    /** Informational */
-    INFO = 6,
-    /** Debug */
-    DEBUG = 7
-}
-/** An object mapping log levels to a textual representation of them */
-export declare const levels: {
-    readonly 0: "emergency";
-    readonly 1: "alert";
-    readonly 2: "critical";
-    readonly 3: "error";
-    readonly 4: "warning";
-    readonly 5: "notice";
-    readonly 6: "info";
-    readonly 7: "debug";
-};
-export declare function levelOf(value: (typeof levels)[Level]): Level;
-/** A log entry */
-export interface Entry {
-    level: Level;
-    timestamp: Date;
-    elapsedMs: number;
-    message: string;
-}
-/** The list of log entries */
-export declare const entries: List<Entry>;
-export declare function log(level: Level, message: string): void;
-interface LogShortcutOptions {
-    fs?: FileSystem;
-}
-/** Shortcut for logging emergencies */
-export declare const emerg: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/** Shortcut for logging alerts */
-export declare const alert: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/** Shortcut for logging critical errors */
-export declare const crit: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/** Shortcut for logging non-critical errors */
-export declare const err: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/** Shortcut for logging warnings */
-export declare const warn: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/** Shortcut for logging notices */
-export declare const notice: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/** Shortcut for logging informational messages */
-export declare const info: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/** Shortcut for logging debug messages */
-export declare const debug: <T extends {
-    toString(): string;
-} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
-/**
- * Shortcut for logging usage of deprecated functions at runtime
- * @param symbol The thing that is deprecated
- * @internal @hidden
- */
-export declare function log_deprecated(symbol: string): void;
-export interface FormatOptions {
-    /**
-     * Whether to use ANSI escape codes (e.g. for Xterm) or CSS (for browsers) to colorize the log
-     */
-    style: 'ansi' | 'css';
-    /**
-     * How to colorize the message:
-     * - `level`: Colorize the level.
-     * - `message`: Colorize the message. For EMERG and ALERT, the level is also included.
-     */
-    colorize: 'level' | 'message';
-}
-/**
- * Various format functions included to make using the logger easier.
- * These are not the only formats you can use.
- */
-export declare function fancy({ style, colorize }: FormatOptions): (entry: Entry) => Generator<string, void, unknown>;
-export declare function format(entry: Entry): string[];
-/** Whether log entries are being recorded */
-export declare let isEnabled: boolean;
-export interface LogConfiguration {
-    /**
-     * If false, log messages will not be recorded or outputted
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * The minimum level needed to output a message
-     * @default Level.ALERT
-     */
-    level?: Level | (typeof levels)[Level];
-    /**
-     * Whether to include stack traces.
-     * @default false
-     */
-    stack?: boolean;
-    /**
-     * Formats a log entry into a string
-     * @default `[${ms / 1000}] ${message}`
-     */
-    format?(this: void, entry: Entry): string | Iterable<string>;
-    /**
-     * Outputs a log message
-     * @default console.error()
-     */
-    output?(this: void, ...message: string[]): unknown;
-    /**
-     * If set, output() all current entries after `configure` is done
-     * @default false
-     */
-    dumpBacklog?: boolean;
-}
-/** Configure logging behavior */
-export declare function configure(options: LogConfiguration): void;
-export {};

package/dist/internal/log.js

@@ -1,219 +0,0 @@
-/* Logging utilities. The things in this file are named to work nicely when you import as a namespace. */
-import { List } from 'utilium';
-import { join } from '../path.js';
-import { ErrnoError } from './error.js';
-export var Level;
-(function (Level) {
-    /** Emergency */
-    Level[Level["EMERG"] = 0] = "EMERG";
-    /** Alert */
-    Level[Level["ALERT"] = 1] = "ALERT";
-    /** Critical */
-    Level[Level["CRIT"] = 2] = "CRIT";
-    /** Error */
-    Level[Level["ERR"] = 3] = "ERR";
-    /** Warning */
-    Level[Level["WARN"] = 4] = "WARN";
-    /** Notice */
-    Level[Level["NOTICE"] = 5] = "NOTICE";
-    /** Informational */
-    Level[Level["INFO"] = 6] = "INFO";
-    /** Debug */
-    Level[Level["DEBUG"] = 7] = "DEBUG";
-})(Level || (Level = {}));
-/** An object mapping log levels to a textual representation of them */
-export const levels = {
-    [Level.EMERG]: 'emergency',
-    [Level.ALERT]: 'alert',
-    [Level.CRIT]: 'critical',
-    [Level.ERR]: 'error',
-    [Level.WARN]: 'warning',
-    [Level.NOTICE]: 'notice',
-    [Level.INFO]: 'info',
-    [Level.DEBUG]: 'debug',
-};
-export function levelOf(value) {
-    return Object.values(levels).indexOf(value);
-}
-/** The list of log entries */
-export const entries = new List();
-export function log(level, message) {
-    if (!isEnabled)
-        return;
-    const entry = {
-        level,
-        message,
-        timestamp: new Date(),
-        elapsedMs: performance.now(),
-    };
-    entries.add(entry);
-    output(entry);
-}
-function _messageString(msg, options) {
-    var _a, _b;
-    if (!(msg instanceof ErrnoError))
-        return msg.toString();
-    const beforePath = msg.code + ': ' + msg.message;
-    if (!msg.path)
-        return beforePath;
-    const mountPoint = typeof options.fs == 'string' ? options.fs : ((_b = (_a = options.fs) === null || _a === void 0 ? void 0 : _a._mountPoint) !== null && _b !== void 0 ? _b : '<unknown>');
-    return (beforePath
-        + ': '
-        + join(mountPoint, msg.path)
-        + (includeStack
-            ? '\n'
-                + msg.stack
-                    .split('\n')
-                    .map(line => '\t' + line)
-                    .slice(1)
-                    .join('\n')
-            : ''));
-}
-function _shortcut(level) {
-    return function (message, options = {}) {
-        log(level, _messageString(message, options));
-        return message;
-    };
-}
-// Shortcuts
-/** Shortcut for logging emergencies */
-export const emerg = _shortcut(Level.EMERG);
-/** Shortcut for logging alerts */
-export const alert = _shortcut(Level.ALERT);
-/** Shortcut for logging critical errors */
-export const crit = _shortcut(Level.CRIT);
-/** Shortcut for logging non-critical errors */
-export const err = _shortcut(Level.ERR);
-/** Shortcut for logging warnings */
-export const warn = _shortcut(Level.WARN);
-/** Shortcut for logging notices */
-export const notice = _shortcut(Level.NOTICE);
-/** Shortcut for logging informational messages */
-export const info = _shortcut(Level.INFO);
-/** Shortcut for logging debug messages */
-export const debug = _shortcut(Level.DEBUG);
-/**
- * Shortcut for logging usage of deprecated functions at runtime
- * @param symbol The thing that is deprecated
- * @internal @hidden
- */
-export function log_deprecated(symbol) {
-    log(Level.WARN, symbol + ' is deprecated and should not be used.');
-}
-// Formatting and output
-/**
- * @internal @hidden
- */
-function ansi(text, format) {
-    return `\x1b[${format}m${text}\x1b[0m`;
-}
-function _prettyMs(entry, style) {
-    const text = '[' + (entry.elapsedMs / 1000).toFixed(3).padStart(10) + '] ';
-    switch (style) {
-        case 'ansi':
-            return [ansi(text, '2;37')];
-        case 'css':
-            return ['%c' + text, 'opacity: 0.8; color: white;'];
-        default:
-            return [text];
-    }
-}
-const levelColor = {
-    ansi: {
-        [Level.EMERG]: '1;4;37;41',
-        [Level.ALERT]: '1;37;41',
-        [Level.CRIT]: '1;35',
-        [Level.ERR]: '1;31',
-        [Level.WARN]: '1;33',
-        [Level.NOTICE]: '1;36',
-        [Level.INFO]: '1;37',
-        [Level.DEBUG]: '0;2;37',
-    },
-    css: {
-        [Level.EMERG]: 'font-weight: bold; text-decoration: underline; color: white; background-color: red;',
-        [Level.ALERT]: 'font-weight: bold; color: white; background-color: red;',
-        [Level.CRIT]: 'font-weight: bold; color: magenta;',
-        [Level.ERR]: 'font-weight: bold; color: red;',
-        [Level.WARN]: 'font-weight: bold; color: yellow;',
-        [Level.NOTICE]: 'font-weight: bold; color: cyan;',
-        [Level.INFO]: 'font-weight: bold; color: white;',
-        [Level.DEBUG]: 'opacity: 0.8; color: white;',
-    },
-};
-const messageColor = {
-    ansi: {
-        [Level.EMERG]: '1;31',
-        [Level.ALERT]: '1;31',
-        [Level.CRIT]: '1;31',
-        [Level.ERR]: '31',
-        [Level.WARN]: '33',
-        [Level.NOTICE]: '1;37',
-        [Level.INFO]: '37',
-        [Level.DEBUG]: '2;37',
-    },
-    css: {
-        [Level.EMERG]: 'font-weight: bold; color: red;',
-        [Level.ALERT]: 'font-weight: bold; color: red;',
-        [Level.CRIT]: 'font-weight: bold; color: red;',
-        [Level.ERR]: 'color: red;',
-        [Level.WARN]: 'color: yellow;',
-        [Level.NOTICE]: 'font-weight: bold; color: white;',
-        [Level.INFO]: 'color: white;',
-        [Level.DEBUG]: 'opacity: 0.8; color: white;',
-    },
-};
-/**
- * Various format functions included to make using the logger easier.
- * These are not the only formats you can use.
- */
-export function fancy({ style, colorize }) {
-    return function* (entry) {
-        yield* _prettyMs(entry, style);
-        const levelText = style == 'ansi'
-            ? [ansi(levels[entry.level].toUpperCase(), levelColor.ansi[entry.level])]
-            : ['%c' + levels[entry.level].toUpperCase(), levelColor.css[entry.level]];
-        if (colorize == 'level') {
-            yield* levelText;
-            yield entry.message;
-            return;
-        }
-        if (entry.level < Level.CRIT) {
-            yield* levelText;
-            yield ': ';
-        }
-        if (colorize == 'message')
-            yield ansi(entry.message, messageColor.ansi[entry.level]);
-        else
-            yield* ['%c' + entry.message, messageColor.css[entry.level]];
-    };
-}
-let _format = (entry) => [..._prettyMs(entry), entry.message];
-export function format(entry) {
-    const formatted = _format(entry);
-    return typeof formatted == 'string' ? [formatted] : Array.from(formatted);
-}
-let _output = console.error;
-function output(entry) {
-    if (entry.level > minLevel)
-        return;
-    _output(...format(entry));
-}
-let minLevel = Level.ALERT;
-let includeStack = false;
-// Configuration
-/** Whether log entries are being recorded */
-export let isEnabled = true;
-/** Configure logging behavior */
-export function configure(options) {
-    var _a, _b, _c, _d, _e;
-    _format = (_a = options.format) !== null && _a !== void 0 ? _a : _format;
-    _output = (_b = options.output) !== null && _b !== void 0 ? _b : _output;
-    minLevel = typeof options.level == 'string' ? levelOf(options.level) : ((_c = options.level) !== null && _c !== void 0 ? _c : minLevel);
-    isEnabled = (_d = options.enabled) !== null && _d !== void 0 ? _d : isEnabled;
-    includeStack = (_e = options.stack) !== null && _e !== void 0 ? _e : includeStack;
-    if (!options.dumpBacklog)
-        return;
-    for (const entry of entries) {
-        output(entry);
-    }
-}

package/tests/fs/writeFile.test.ts

@@ -1,70 +0,0 @@
-import assert from 'node:assert/strict';
-import { suite, test } from 'node:test';
-import { readFileSync } from 'node:fs';
-import { fs } from '../common.js';
-import { join } from 'node:path/posix';
-import { data as dataPath } from '../setup.js';
-
-const utf8example = readFileSync(join(dataPath, 'utf8.txt'), 'utf8');
-
-suite('writeFile', () => {
-	test('write and read file with specified content', async () => {
-		const filename = 'test.txt';
-		await fs.promises.writeFile(filename, utf8example);
-		const data = await fs.promises.readFile(filename);
-		assert.equal(data.length, Buffer.from(utf8example).length);
-		await fs.promises.unlink(filename);
-	});
-
-	test('write and read file using buffer', async () => {
-		const filename = 'test2.txt';
-		const expected = Buffer.from(utf8example, 'utf8');
-
-		await fs.promises.writeFile(filename, expected);
-		const actual = await fs.promises.readFile(filename);
-		assert.equal(actual.length, expected.length);
-
-		await fs.promises.unlink(filename);
-	});
-
-	test('write base64 data to a file and read it back asynchronously', async () => {
-		const data = readFileSync(join(dataPath, 'image.jpg'), 'base64');
-
-		const buffer = Buffer.from(data, 'base64');
-		const filePath = 'test.jpg';
-
-		await fs.promises.writeFile(filePath, buffer);
-
-		const read = await fs.promises.readFile(filePath, 'base64');
-		assert.equal(read, data);
-	});
-});
-
-suite('File Writing with Custom Mode', () => {
-	test('write file synchronously with custom mode', () => {
-		const file = 'testWriteFileSync.txt';
-		const mode = 0o755;
-
-		fs.writeFileSync(file, '123', { mode });
-
-		const content = fs.readFileSync(file, 'utf8');
-		assert.equal(content, '123');
-		assert((fs.statSync(file).mode & 0o777) === mode);
-
-		fs.unlinkSync(file);
-	});
-
-	test('append to a file synchronously with custom mode', () => {
-		const file = 'testAppendFileSync.txt';
-		const mode = 0o755;
-
-		fs.appendFileSync(file, 'abc', { mode });
-
-		const content = fs.readFileSync(file, { encoding: 'utf8' });
-		assert.equal(content, 'abc');
-
-		assert((fs.statSync(file).mode & 0o777) === mode);
-
-		fs.unlinkSync(file);
-	});
-});