@zenfs/core 0.9.7 → 0.10.0

package/src/config.ts

@@ -1,9 +1,10 @@
-import { ApiError, ErrorCode } from './ApiError.js';
+import { ErrnoError, Errno } from './error.js';
 import type { Backend, BackendConfiguration } from './backends/backend.js';
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import * as fs from './emulation/index.js';
-import { setCred, type MountMapping } from './emulation/shared.js';
+import { setCred, type MountObject } from './emulation/shared.js';
 import { FileSystem } from './filesystem.js';
+import type { AbsolutePath } from './emulation/path.js';
 
 /**
  * Configuration for a specific mount point
@@ -20,11 +21,11 @@ function isMountConfig(arg: unknown): arg is MountConfiguration {
  */
 export async function resolveMountConfig<FS extends FileSystem, TOptions extends object = object>(config: MountConfiguration<FS, TOptions>, _depth = 0): Promise<FS> {
 	if (typeof config !== 'object' || config == null) {
-		throw new ApiError(ErrorCode.EINVAL, 'Invalid options on mount configuration');
+		throw new ErrnoError(Errno.EINVAL, 'Invalid options on mount configuration');
 	}
 
 	if (!isMountConfig(config)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Invalid mount configuration');
+		throw new ErrnoError(Errno.EINVAL, 'Invalid mount configuration');
 	}
 
 	if (config instanceof FileSystem) {
@@ -45,7 +46,7 @@ export async function resolveMountConfig<FS extends FileSystem, TOptions extends
 		}
 
 		if (_depth > 10) {
-			throw new ApiError(ErrorCode.EINVAL, 'Invalid configuration, too deep and possibly infinite');
+			throw new ErrnoError(Errno.EINVAL, 'Invalid configuration, too deep and possibly infinite');
 		}
 
 		(<Record<string, FileSystem>>config)[key] = await resolveMountConfig(value, ++_depth);
@@ -54,7 +55,7 @@ export async function resolveMountConfig<FS extends FileSystem, TOptions extends
 	const { backend } = config;
 
 	if (!(await backend.isAvailable())) {
-		throw new ApiError(ErrorCode.EPERM, 'Backend not available: ' + backend);
+		throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend);
 	}
 	checkOptions(backend, config);
 	const mount = backend.create(config);
@@ -63,39 +64,34 @@ export async function resolveMountConfig<FS extends FileSystem, TOptions extends
 }
 
 /**
- *A mapping of mount points to their configurations
+ * Configuration
  */
-export type MappingConfiguration = Partial<{
-	uid: number;
-	gid: number;
-}> &
-	Record<string, FileSystem | BackendConfiguration | Backend>;
-
-/**
- * Configuration for the file systems
- */
-export type Configuration = MountConfiguration | MappingConfiguration;
+export interface Configuration {
+	mounts: Record<AbsolutePath, MountConfiguration>;
+	uid?: number;
+	gid?: number;
+}
 
 /**
  * Creates filesystems with the given configuration, and initializes ZenFS with it.
  * @see Configuration for more info on the configuration object.
  */
-export async function configure(config: Configuration): Promise<void> {
+export async function configure(config: MountConfiguration | Configuration): Promise<void> {
 	const uid = 'uid' in config ? config.uid || 0 : 0;
 	const gid = 'gid' in config ? config.gid || 0 : 0;
 
 	if (isMountConfig(config)) {
 		// single FS
-		config = { '/': config };
+		config = { mounts: { '/': config } };
 	}
 
-	for (const [point, value] of Object.entries(config)) {
-		if (point == 'uid' || point == 'gid' || typeof value == 'number') {
-			continue;
+	for (const [point, value] of Object.entries(config.mounts) as [AbsolutePath, MountConfiguration][]) {
+		if (!point.startsWith('/')) {
+			throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
 		}
-		config[point] = await resolveMountConfig(value);
+		config.mounts[point] = await resolveMountConfig(value);
 	}
 
-	fs.mountMapping(<MountMapping>config);
+	fs.mountObject(config.mounts as MountObject);
 	setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
 }

package/src/emulation/async.ts

@@ -1,5 +1,5 @@
 import type * as fs from 'node:fs';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
 import { nop, normalizeMode, type Callback } from '../utils.js';
@@ -262,7 +262,7 @@ export function ftruncate(fd: number, lenOrCB?: any, cb: Callback = nop): void {
 	cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
 	const file = fd2file(fd);
 	if (length < 0) {
-		throw new ApiError(ErrorCode.EINVAL);
+		throw new ErrnoError(Errno.EINVAL);
 	}
 	file.truncate(length)
 		.then(() => cb())
@@ -335,7 +335,7 @@ export function write(fd: number, data: FileContents, cbPosOff?: any, cbLenEnc?:
 			default:
 				// ...try to find the callback and get out of here!
 				cb = typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPos === 'function' ? cbPos : cb;
-				(<Callback<[number, Uint8Array | string]>>cb)(new ApiError(ErrorCode.EINVAL, 'Invalid arguments.'));
+				(<Callback<[number, Uint8Array | string]>>cb)(new ErrnoError(Errno.EINVAL, 'Invalid arguments.'));
 				return;
 		}
 		buffer = Buffer.from(data);
@@ -661,7 +661,7 @@ access satisfies Omit<typeof fs.access, '__promisify__'>;
 export function watchFile(path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void): void;
 export function watchFile(path: fs.PathLike, options: { persistent?: boolean; interval?: number }, listener: (curr: Stats, prev: Stats) => void): void;
 export function watchFile(path: fs.PathLike, optsListener: any, listener: (curr: Stats, prev: Stats) => void = nop): void {
-	throw ApiError.With('ENOSYS', path.toString(), 'watchFile');
+	throw ErrnoError.With('ENOSYS', path.toString(), 'watchFile');
 }
 watchFile satisfies Omit<typeof fs.watchFile, '__promisify__'>;
 
@@ -669,7 +669,7 @@ watchFile satisfies Omit<typeof fs.watchFile, '__promisify__'>;
  * @todo Implement
  */
 export function unwatchFile(path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void = nop): void {
-	throw ApiError.With('ENOSYS', path.toString(), 'unwatchFile');
+	throw ErrnoError.With('ENOSYS', path.toString(), 'unwatchFile');
 }
 unwatchFile satisfies Omit<typeof fs.unwatchFile, '__promisify__'>;
 
@@ -679,7 +679,7 @@ unwatchFile satisfies Omit<typeof fs.unwatchFile, '__promisify__'>;
 export function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): fs.FSWatcher;
 export function watch(path: fs.PathLike, options: { persistent?: boolean }, listener?: (event: string, filename: string) => any): fs.FSWatcher;
 export function watch(path: fs.PathLike, options: any, listener: (event: string, filename: string) => any = nop): fs.FSWatcher {
-	throw ApiError.With('ENOSYS', path.toString(), 'watch');
+	throw ErrnoError.With('ENOSYS', path.toString(), 'watch');
 }
 watch satisfies Omit<typeof fs.watch, '__promisify__'>;
 

package/src/emulation/dir.ts

@@ -2,7 +2,7 @@ import type { Dirent as _Dirent, Dir as _Dir } from 'fs';
 import type { Callback } from '../utils.js';
 import type { Stats } from '../stats.js';
 import { readdir } from './promises.js';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { readdirSync } from './sync.js';
 import { basename } from './path.js';
 
@@ -47,7 +47,7 @@ export class Dir implements _Dir {
 
 	protected checkClosed(): void {
 		if (this.closed) {
-			throw new ApiError(ErrorCode.EBADF, 'Can not use closed Dir');
+			throw new ErrnoError(Errno.EBADF, 'Can not use closed Dir');
 		}
 	}
 

package/src/emulation/index.ts

@@ -4,5 +4,5 @@ export * as promises from './promises.js';
 export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
-export { mountMapping, mounts, mount, umount } from './shared.js';
+export { mountObject, mounts, mount, umount } from './shared.js';
 export { Stats, BigIntStats, StatsFs } from '../stats.js';

package/src/emulation/path.ts

@@ -22,12 +22,14 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 /*
-This is the POSIX path code of NodeJS
+This is derived from the POSIX path code of NodeJS
 https://raw.githubusercontent.com/nodejs/node/3907bd1/lib/path.js 
 */
 
 import type { ParsedPath } from 'node:path';
 
+export type AbsolutePath = `/${string}`;
+
 export let cwd = '/';
 
 export function cd(path: string): void {
@@ -36,12 +38,6 @@ export function cd(path: string): void {
 
 export const sep = '/';
 
-function validateString(str: unknown, name: string): void {
-	if (typeof str != 'string') {
-		throw new TypeError(`"${name}" is not a string`);
-	}
-}
-
 function validateObject(str: unknown, name: string): void {
 	if (typeof str != 'object') {
 		throw new TypeError(`"${name}" is not an object`);
@@ -113,23 +109,23 @@ export function formatExt(ext: string): string {
 	return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
 }
 
-export function resolve(...args: string[]): string {
+export function resolve(...parts: string[]): AbsolutePath {
 	let resolved = '';
-	let absolute = false;
 
-	for (let i = args.length - 1; i >= -1 && !absolute; i--) {
-		const path = i >= 0 ? args[i] : cwd;
-		validateString(path, `paths[${i}]`);
-
-		// Skip empty entries
-		if (!path.length) {
+	for (const part of [...parts.reverse(), cwd]) {
+		if (!part.length) {
 			continue;
 		}
 
-		resolved = `${path}/${resolved}`;
-		absolute = path[0] == '/';
+		resolved = `${part}/${resolved}`;
+
+		if (part.startsWith('/')) {
+			break;
+		}
 	}
 
+	const absolute = resolved.startsWith('/');
+
 	// At this point the path should be resolved to a full absolute path, but
 	// handle relative paths to be safe (might happen when cwd fails)
 
@@ -139,21 +135,19 @@ export function resolve(...args: string[]): string {
 	if (absolute) {
 		return `/${resolved}`;
 	}
-	return resolved.length > 0 ? resolved : '/';
+	return resolved.length ? (resolved as AbsolutePath) : '/';
 }
 
 export function normalize(path: string): string {
-	validateString(path, 'path');
-
-	if (path.length === 0) return '.';
+	if (!path.length) return '.';
 
-	const isAbsolute = path[0] === '/';
-	const trailingSeparator = path.at(-1) === '/';
+	const isAbsolute = path.startsWith('/');
+	const trailingSeparator = path.endsWith('/');
 
 	// Normalize the path
 	path = normalizeString(path, !isAbsolute);
 
-	if (path.length === 0) {
+	if (!path.length) {
 		if (isAbsolute) return '/';
 		return trailingSeparator ? './' : '.';
 	}
@@ -163,29 +157,17 @@ export function normalize(path: string): string {
 }
 
 export function isAbsolute(path: string): boolean {
-	validateString(path, 'path');
-	return path.length > 0 && path[0] === '/';
+	return path.startsWith('/');
 }
 
-export function join(...args: string[]): string {
-	if (args.length === 0) return '.';
-	let joined;
-	for (let i = 0; i < args.length; ++i) {
-		const arg = args[i];
-		validateString(arg, 'path');
-		if (arg.length > 0) {
-			if (joined === undefined) joined = arg;
-			else joined += `/${arg}`;
-		}
-	}
-	if (joined === undefined) return '.';
+export function join(...parts: string[]): string {
+	if (!parts.length) return '.';
+	const joined = parts.join('/');
+	if (!joined?.length) return '.';
 	return normalize(joined);
 }
 
-export function relative(from: string, to: string) {
-	validateString(from, 'from');
-	validateString(to, 'to');
-
+export function relative(from: string, to: string): string {
 	if (from === to) return '';
 
 	// Trim leading forward slashes.
@@ -249,7 +231,6 @@ export function relative(from: string, to: string) {
 }
 
 export function dirname(path: string): string {
-	validateString(path, 'path');
 	if (path.length === 0) return '.';
 	const hasRoot = path[0] === '/';
 	let end = -1;
@@ -272,9 +253,6 @@ export function dirname(path: string): string {
 }
 
 export function basename(path: string, suffix?: string): string {
-	if (suffix !== undefined) validateString(suffix, 'ext');
-	validateString(path, 'path');
-
 	let start = 0;
 	let end = -1;
 	let matchedSlash = true;
@@ -341,7 +319,6 @@ export function basename(path: string, suffix?: string): string {
 }
 
 export function extname(path: string): string {
-	validateString(path, 'path');
 	let startDot = -1;
 	let startPart = 0;
 	let end = -1;
@@ -400,8 +377,7 @@ export function format(pathObject: ParsedPath): string {
 }
 
 export function parse(path: string): ParsedPath {
-	validateString(path, 'path');
-	const isAbsolute = path[0] === '/';
+	const isAbsolute = path.startsWith('/');
 	const ret = { root: isAbsolute ? '/' : '', dir: '', base: '', ext: '', name: '' };
 	if (path.length === 0) return ret;