@zenfs/core 0.18.0 → 1.0.0-rc.0

package/dist/mixins/shared.d.ts

@@ -10,3 +10,4 @@ export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...a
  * @internal
  */
 export type _AsyncFSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>;
+export type ConcreteFS = ExtractProperties<FileSystem, any>;

package/dist/mixins/shared.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /*
     Code shared by various mixins
 */

package/dist/stats.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as Node from 'fs';
-import type { Credentials } from './credentials.js';
+import { type Credentials } from './credentials.js';
 import { S_IFDIR, S_IFLNK, S_IFREG } from './emulation/constants.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
@@ -146,11 +146,10 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     /**
      * Checks if a given user/group has access to this item
      * @param mode The requested access, combination of W_OK, R_OK, and X_OK
-     * @param cred The requesting credentials
      * @returns True if the request has access, false if the request does not
      * @internal
      */
-    hasAccess(mode: number, cred: Credentials): boolean;
+    hasAccess(mode: number): boolean;
     /**
      * Convert the current stats object into a credentials object
      * @internal

package/dist/stats.js

@@ -1,3 +1,4 @@
+import { credentials } from './credentials.js';
 import { S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRWXG, S_IRWXO, S_IRWXU } from './emulation/constants.js';
 import { size_max } from './inode.js';
 /**
@@ -115,17 +116,16 @@ export class StatsCommon {
     /**
      * Checks if a given user/group has access to this item
      * @param mode The requested access, combination of W_OK, R_OK, and X_OK
-     * @param cred The requesting credentials
      * @returns True if the request has access, false if the request does not
      * @internal
      */
-    hasAccess(mode, cred) {
-        if (cred.euid === 0 || cred.egid === 0) {
+    hasAccess(mode) {
+        if (credentials.euid === 0 || credentials.egid === 0) {
             //Running as root
             return true;
         }
         // Mask for
-        const adjusted = (cred.uid == this.uid ? S_IRWXU : 0) | (cred.gid == this.gid ? S_IRWXG : 0) | S_IRWXO;
+        const adjusted = (credentials.uid == this.uid ? S_IRWXU : 0) | (credentials.gid == this.gid ? S_IRWXG : 0) | S_IRWXO;
         return (mode & this.mode & adjusted) == mode;
     }
     /**

package/dist/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import type * as fs from 'node:fs';
-import type { OptionalTuple } from 'utilium';
+import type { ClassLike, OptionalTuple } from 'utilium';
 import { type AbsolutePath } from './emulation/path.js';
 import { ErrnoError } from './error.js';
 import type { FileSystem } from './filesystem.js';
@@ -81,3 +81,4 @@ export declare function normalizeOptions(options: fs.WriteFileOptions | (fs.Enco
     flag: string;
     mode: number;
 };
+export type Concrete<T extends ClassLike> = Pick<T, keyof T> & (new (...args: any[]) => InstanceType<T>);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.18.0",
+	"version": "1.0.0-rc.0",
 	"description": "A filesystem, anywhere",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/readme.md

@@ -17,7 +17,7 @@ ZenFS is modular and extensible. The core includes some built-in backends:
 
 ZenFS supports a number of other backends. Many are provided as separate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
 
-As an added bonus, all ZenFS backends support syncrohnous operations. All of the backends included with the core are cross-platform.
+As an added bonus, all ZenFS backends support synchronous operations. All of the backends included with the core are cross-platform.
 
 For more information, see the [docs](https://zen-fs.github.io/core).
 

package/src/backends/overlay.ts

@@ -432,31 +432,29 @@ export class UnmutexedOverlayFS extends FileSystem {
 	 * should they not exist. Use modes from the read-only storage.
 	 */
 	private createParentDirectoriesSync(path: string): void {
-		let parent = dirname(path),
-			toCreate: string[] = [];
+		let parent = dirname(path);
+		const toCreate: string[] = [];
 		while (!this.writable.existsSync(parent)) {
 			toCreate.push(parent);
 			parent = dirname(parent);
 		}
-		toCreate = toCreate.reverse();
 
-		for (const p of toCreate) {
-			this.writable.mkdirSync(p, this.statSync(p).mode);
+		for (const path of toCreate.reverse()) {
+			this.writable.mkdirSync(path, this.statSync(path).mode);
 		}
 	}
 
 	private async createParentDirectories(path: string): Promise<void> {
-		let parent = dirname(path),
-			toCreate: string[] = [];
+		let parent = dirname(path);
+		const toCreate: string[] = [];
 		while (!(await this.writable.exists(parent))) {
 			toCreate.push(parent);
 			parent = dirname(parent);
 		}
-		toCreate = toCreate.reverse();
 
-		for (const p of toCreate) {
-			const stats = await this.stat(p);
-			await this.writable.mkdir(p, stats.mode);
+		for (const path of toCreate.reverse()) {
+			const stats = await this.stat(path);
+			await this.writable.mkdir(path, stats.mode);
 		}
 	}
 

package/src/backends/port/fs.ts

@@ -22,12 +22,12 @@ interface FileRequest<TMethod extends FileMethod = FileMethod> extends RPC.Reque
 
 export class PortFile extends File {
 	constructor(
-		public readonly fs: PortFS,
+		public fs: PortFS,
 		public readonly fd: number,
-		public readonly path: string,
+		path: string,
 		public position: number
 	) {
-		super();
+		super(fs, path);
 	}
 
 	public rpc<const T extends FileMethod>(method: T, ...args: Parameters<FileMethods[T]>): Promise<Awaited<ReturnType<FileMethods[T]>>> {
@@ -43,7 +43,7 @@ export class PortFile extends File {
 	}
 
 	protected _throwNoSync(syscall: string): never {
-		throw new ErrnoError(Errno.ENOTSUP, 'Syncrohnous operations not support on PortFile', this.path, syscall);
+		throw new ErrnoError(Errno.ENOTSUP, 'Synchronous operations not supported on PortFile', this.path, syscall);
 	}
 
 	public async stat(): Promise<Stats> {

package/src/emulation/promises.ts

@@ -18,7 +18,6 @@ import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
-import { credentials } from '../credentials.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
@@ -220,7 +219,7 @@ export class FileHandle implements promises.FileHandle {
 	public async stat(opts?: fs.StatOptions & { bigint?: false }): Promise<Stats>;
 	public async stat(opts?: fs.StatOptions): Promise<Stats | BigIntStats> {
 		const stats = await this.file.stat();
-		if (!stats.hasAccess(constants.R_OK, credentials)) {
+		if (!stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', this.file.path, 'stat');
 		}
 		return opts?.bigint ? new BigIntStats(stats) : stats;
@@ -396,7 +395,7 @@ export async function rename(oldPath: fs.PathLike, newPath: fs.PathLike): Promis
 	newPath = normalizePath(newPath);
 	const src = resolveMount(oldPath);
 	const dst = resolveMount(newPath);
-	if (!(await stat(dirname(oldPath))).hasAccess(constants.W_OK, credentials)) {
+	if (!(await stat(dirname(oldPath))).hasAccess(constants.W_OK)) {
 		throw ErrnoError.With('EACCES', oldPath, 'rename');
 	}
 	try {
@@ -444,7 +443,7 @@ export async function stat(path: fs.PathLike, options?: fs.StatOptions): Promise
 	const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
 	try {
 		const stats = await fs.stat(resolved);
-		if (!stats.hasAccess(constants.R_OK, credentials)) {
+		if (!stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', path, 'stat');
 		}
 		return options?.bigint ? new BigIntStats(stats) : stats;
@@ -496,7 +495,7 @@ export async function unlink(path: fs.PathLike): Promise<void> {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (!(await fs.stat(resolved)).hasAccess(constants.W_OK, credentials)) {
+		if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		await fs.unlink(resolved);
@@ -527,7 +526,7 @@ async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o6
 		}
 		// Create the file
 		const parentStats: Stats = await fs.stat(dirname(resolved));
-		if (!parentStats.hasAccess(constants.W_OK, credentials)) {
+		if (!parentStats.hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', dirname(path), '_open');
 		}
 		if (!parentStats.isDirectory()) {
@@ -536,7 +535,7 @@ async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o6
 		return new FileHandle(await fs.createFile(resolved, flag, mode));
 	}
 
-	if (!stats.hasAccess(flagToMode(flag), credentials)) {
+	if (!stats.hasAccess(flagToMode(flag))) {
 		throw ErrnoError.With('EACCES', path, '_open');
 	}
 
@@ -663,7 +662,7 @@ export async function rmdir(path: fs.PathLike): Promise<void> {
 	path = (await exists(path)) ? await realpath(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (!(await fs.stat(resolved)).hasAccess(constants.W_OK, credentials)) {
+		if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'rmdir');
 		}
 		await fs.rmdir(resolved);
@@ -694,7 +693,7 @@ export async function mkdir(path: fs.PathLike, options?: fs.Mode | fs.MakeDirect
 
 	try {
 		if (!options?.recursive) {
-			if (!(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK, credentials)) {
+			if (!(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK)) {
 				throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
 			}
 			await fs.mkdir(resolved, mode);
@@ -708,7 +707,7 @@ export async function mkdir(path: fs.PathLike, options?: fs.Mode | fs.MakeDirect
 			errorPaths[dir] = origDir;
 		}
 		for (const dir of dirs) {
-			if (!(await fs.stat(dirname(dir))).hasAccess(constants.W_OK, credentials)) {
+			if (!(await fs.stat(dirname(dir))).hasAccess(constants.W_OK)) {
 				throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
 			}
 			await fs.mkdir(dir, mode);
@@ -738,7 +737,7 @@ export async function readdir(
 	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
 ): Promise<string[] | Dirent[] | Buffer[]> {
 	path = normalizePath(path);
-	if (!(await stat(path)).hasAccess(constants.R_OK, credentials)) {
+	if (!(await stat(path)).hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
 	}
 	path = (await exists(path)) ? await realpath(path) : path;
@@ -776,11 +775,11 @@ readdir satisfies typeof promises.readdir;
  */
 export async function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Promise<void> {
 	targetPath = normalizePath(targetPath);
-	if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK, credentials)) {
+	if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
 	}
 	linkPath = normalizePath(linkPath);
-	if (!(await stat(dirname(linkPath))).hasAccess(constants.W_OK, credentials)) {
+	if (!(await stat(dirname(linkPath))).hasAccess(constants.W_OK)) {
 		throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
 	}
 
@@ -790,7 +789,7 @@ export async function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Prom
 		throw ErrnoError.With('EXDEV', linkPath, 'link');
 	}
 	try {
-		if (!(await fs.stat(path)).hasAccess(constants.W_OK, credentials)) {
+		if (!(await fs.stat(path)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', path, 'link');
 		}
 		return await fs.link(path, link.path);
@@ -969,7 +968,7 @@ watch satisfies typeof promises.watch;
  */
 export async function access(path: fs.PathLike, mode: number = constants.F_OK): Promise<void> {
 	const stats = await stat(path);
-	if (!stats.hasAccess(mode, credentials)) {
+	if (!stats.hasAccess(mode)) {
 		throw new ErrnoError(Errno.EACCES);
 	}
 }

package/src/emulation/sync.ts

@@ -10,7 +10,6 @@ import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
-import { credentials } from '../credentials.js';
 import { emitChange } from './watchers.js';
 
 /**
@@ -23,7 +22,7 @@ export function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void {
 	newPath = normalizePath(newPath);
 	const oldMount = resolveMount(oldPath);
 	const newMount = resolveMount(newPath);
-	if (!statSync(dirname(oldPath)).hasAccess(constants.W_OK, credentials)) {
+	if (!statSync(dirname(oldPath)).hasAccess(constants.W_OK)) {
 		throw ErrnoError.With('EACCES', oldPath, 'rename');
 	}
 	try {
@@ -73,7 +72,7 @@ export function statSync(path: fs.PathLike, options?: fs.StatOptions): Stats | B
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	try {
 		const stats = fs.statSync(resolved);
-		if (!stats.hasAccess(constants.R_OK, credentials)) {
+		if (!stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', path, 'stat');
 		}
 		return options?.bigint ? new BigIntStats(stats) : stats;
@@ -126,7 +125,7 @@ export function unlinkSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (!fs.statSync(resolved).hasAccess(constants.W_OK, credentials)) {
+		if (!fs.statSync(resolved).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		fs.unlinkSync(resolved);
@@ -151,7 +150,7 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
 		}
 		// Create the file
 		const parentStats: Stats = fs.statSync(dirname(resolved));
-		if (!parentStats.hasAccess(constants.W_OK, credentials)) {
+		if (!parentStats.hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', dirname(path), '_open');
 		}
 		if (!parentStats.isDirectory()) {
@@ -162,7 +161,7 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
 
 	const stats: Stats = fs.statSync(resolved);
 
-	if (!stats.hasAccess(mode, credentials) || !stats.hasAccess(flagToMode(flag), credentials)) {
+	if (!stats.hasAccess(mode) || !stats.hasAccess(flagToMode(flag))) {
 		throw ErrnoError.With('EACCES', path, '_open');
 	}
 
@@ -466,7 +465,7 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	try {
-		if (!fs.statSync(resolved).hasAccess(constants.W_OK, credentials)) {
+		if (!fs.statSync(resolved).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'rmdir');
 		}
 		fs.rmdirSync(resolved);
@@ -496,7 +495,7 @@ export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirector
 
 	try {
 		if (!options?.recursive) {
-			if (!fs.statSync(dirname(resolved)).hasAccess(constants.W_OK, credentials)) {
+			if (!fs.statSync(dirname(resolved)).hasAccess(constants.W_OK)) {
 				throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
 			}
 			return fs.mkdirSync(resolved, mode);
@@ -508,7 +507,7 @@ export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirector
 			errorPaths[dir] = original;
 		}
 		for (const dir of dirs) {
-			if (!fs.statSync(dirname(dir)).hasAccess(constants.W_OK, credentials)) {
+			if (!fs.statSync(dirname(dir)).hasAccess(constants.W_OK)) {
 				throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
 			}
 			fs.mkdirSync(dir, mode);
@@ -536,7 +535,7 @@ export function readdirSync(
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	let entries: string[];
-	if (!statSync(path).hasAccess(constants.R_OK, credentials)) {
+	if (!statSync(path).hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
 	}
 	try {
@@ -578,11 +577,11 @@ readdirSync satisfies typeof fs.readdirSync;
  */
 export function linkSync(targetPath: fs.PathLike, linkPath: fs.PathLike): void {
 	targetPath = normalizePath(targetPath);
-	if (!statSync(dirname(targetPath)).hasAccess(constants.R_OK, credentials)) {
+	if (!statSync(dirname(targetPath)).hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
 	}
 	linkPath = normalizePath(linkPath);
-	if (!statSync(dirname(linkPath)).hasAccess(constants.W_OK, credentials)) {
+	if (!statSync(dirname(linkPath)).hasAccess(constants.W_OK)) {
 		throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
 	}
 
@@ -592,7 +591,7 @@ export function linkSync(targetPath: fs.PathLike, linkPath: fs.PathLike): void {
 		throw ErrnoError.With('EXDEV', linkPath, 'link');
 	}
 	try {
-		if (!fs.statSync(path).hasAccess(constants.W_OK, credentials)) {
+		if (!fs.statSync(path).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', path, 'link');
 		}
 		return fs.linkSync(path, linkPath);
@@ -753,7 +752,7 @@ realpathSync satisfies Omit<typeof fs.realpathSync, 'native'>;
  */
 export function accessSync(path: fs.PathLike, mode: number = 0o600): void {
 	const stats = statSync(path);
-	if (!stats.hasAccess(mode, credentials)) {
+	if (!stats.hasAccess(mode)) {
 		throw new ErrnoError(Errno.EACCES);
 	}
 }

package/src/file.ts

@@ -146,16 +146,23 @@ export function isExclusive(flag: string): boolean {
 }
 
 export abstract class File {
+	constructor(
+		/**
+		 * @internal
+		 * The file system that created the file
+		 */
+		public fs: FileSystem,
+		/**
+		 * The path to the file
+		 */
+		public readonly path: string
+	) {}
+
 	/**
 	 * Get the current file position.
 	 */
 	public abstract position: number;
 
-	/**
-	 * The path to the file
-	 */
-	public abstract readonly path: string;
-
 	/**
 	 * Asynchronous `stat`.
 	 */
@@ -355,17 +362,15 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	constructor(
 		/**
 		 * The file system that created the file.
+		 * @internal
 		 */
-		protected fs: FS,
-		/**
-		 * Path to the file
-		 */
-		public readonly path: string,
+		public fs: FS,
+		path: string,
 		public readonly flag: string,
 		public readonly stats: Stats,
 		protected _buffer: Uint8Array = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }))
 	) {
-		super();
+		super(fs, path);
 
 		/*
 			Note: