Merge pull request #137 from zen-fs/context

src/context.ts

@@ -0,0 +1,47 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type ExtractProperties } from 'utilium';
+import { credentials as defaultCredentials, type Credentials } from './credentials.js';
+import * as fs from './emulation/index.js';
+import type { AbsolutePath } from './emulation/path.js';
+
+type Fn_FS = Omit<ExtractProperties<typeof fs, (...args: any[]) => any>, 'mountObject'>;
+type Fn_Promises = ExtractProperties<typeof fs.promises, (...args: any[]) => any>;
+
+/**
+ * Binds a this value for all of the functions in an object (not recursive)
+ * @internal
+ */
+function _bindFunctions<T extends Record<string, unknown>>(fns: T, thisValue: any): T {
+	return Object.fromEntries(Object.entries(fns).map(([k, v]) => [k, typeof v == 'function' ? v.bind(thisValue) : v])) as T;
+}
+
+export interface FSContext {
+	readonly root: AbsolutePath;
+	readonly credentials: Credentials;
+}
+
+export type V_Context = Partial<FSContext> | void | Record<string, unknown>;
+
+/**
+ * Allows you to restrict operations to a specific root path and set of credentials.
+ * @experimental
+ */
+export interface BoundContext extends Fn_FS, FSContext {
+	promises: Fn_Promises;
+}
+
+/**
+ * Allows you to restrict operations to a specific root path and set of credentials.
+ * @experimental
+ */
+export function bindContext(root: AbsolutePath, credentials: Credentials = defaultCredentials): BoundContext {
+	const ctx = {
+		root,
+		credentials,
+	} satisfies FSContext;
+
+	const fn_fs = _bindFunctions<Fn_FS>(fs, ctx);
+	const fn_promises = _bindFunctions<Fn_Promises>(fs.promises, ctx);
+
+	return { ...ctx, ...fn_fs, promises: fn_promises };
+}

src/emulation/dir.ts

@@ -5,6 +5,7 @@ import type { Callback } from '../utils.js';
 import { basename } from './path.js';
 import { readdir } from './promises.js';
 import { readdirSync } from './sync.js';
+import type { V_Context } from '../context.js';
 
 export class Dirent implements _Dirent {
 	public get name(): string {
@@ -57,7 +58,10 @@ export class Dir implements _Dir {
 
 	protected _entries?: Dirent[];
 
-	public constructor(public readonly path: string) {}
+	public constructor(
+		public readonly path: string,
+		protected readonly context: V_Context
+	) {}
 
 	/**
 	 * Asynchronously close the directory's underlying resource handle.
@@ -83,10 +87,8 @@ export class Dir implements _Dir {
 
 	protected async _read(): Promise<Dirent | null> {
 		this.checkClosed();
-		this._entries ??= await readdir(this.path, { withFileTypes: true });
-		if (!this._entries.length) {
-			return null;
-		}
+		this._entries ??= await readdir.call<V_Context, [string, any], Promise<Dirent[]>>(this.context, this.path, { withFileTypes: true });
+		if (!this._entries.length) return null;
 		return this._entries.shift() ?? null;
 	}
 
@@ -112,10 +114,8 @@ export class Dir implements _Dir {
 	 */
 	public readSync(): Dirent | null {
 		this.checkClosed();
-		this._entries ??= readdirSync(this.path, { withFileTypes: true });
-		if (!this._entries.length) {
-			return null;
-		}
+		this._entries ??= readdirSync.call<V_Context, [string, any], Dirent[]>(this.context, this.path, { withFileTypes: true });
+		if (!this._entries.length) return null;
 		return this._entries.shift() ?? null;
 	}
 

src/emulation/shared.ts

@@ -6,8 +6,9 @@ import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import type { FileSystem } from '../filesystem.js';
 import { normalizePath } from '../utils.js';
-import { resolve, type AbsolutePath } from './path.js';
+import { join, resolve, type AbsolutePath } from './path.js';
 import { size_max } from './constants.js';
+import type { V_Context } from '../context.js';
 import { paths as pathCache } from './cache.js';
 
 // descriptors
@@ -66,24 +67,32 @@ export function umount(mountPoint: string): void {
 	pathCache.clear();
 }
 
+export interface ResolvedMount {
+	fs: FileSystem;
+	path: string;
+	mountPoint: string;
+	root: string;
+}
+
 /**
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
  */
-export function resolveMount(path: string): { fs: FileSystem; path: string; mountPoint: string } {
-	path = normalizePath(path);
+export function resolveMount(path: string, ctx: V_Context): ResolvedMount {
+	const root = typeof ctx == 'object' && typeof ctx.root == 'string' ? ctx.root : '/';
+	path = normalizePath(join(root, path));
 	const sortedMounts = [...mounts].sort((a, b) => (a[0].length > b[0].length ? -1 : 1)); // descending order of the string length
 	for (const [mountPoint, fs] of sortedMounts) {
 		// We know path is normalized, so it would be a substring of the mount point.
 		if (mountPoint.length <= path.length && path.startsWith(mountPoint)) {
 			path = path.slice(mountPoint.length > 1 ? mountPoint.length : 0); // Resolve the path relative to the mount point
 			if (path === '') {
-				path = '/';
+				path = root;
 			}
-			return { fs, path, mountPoint };
+			return { fs, path, mountPoint, root };
 		}
 	}
 
-	throw new ErrnoError(Errno.EIO, 'ZenFS not initialized with a file system');
+	throw new ErrnoError(Errno.EIO, 'No file system');
 }
 
 /**
@@ -120,6 +129,7 @@ export function fixError<E extends ErrnoError>(e: E, paths: Record<string, strin
 	} catch {
 		// `message` is read only
 	}
+	if (e.path) e.path = fixPaths(e.path, paths);
 	return e;
 }