@wener/common 2.0.2 → 2.0.5

package/src/fs/createSandboxFileSystem.ts

@@ -0,0 +1,136 @@
+import { join, normalize, relative, sep } from 'pathe';
+import type { IFileStat, IServerFileSystem, ReadFileOptions } from './IFileSystem';
+import { getPath } from './utils';
+
+class SandboxSecurityError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = 'SandboxSecurityError';
+	}
+}
+
+export function createSandboxFileSystem(
+	fs: IServerFileSystem,
+	basePath: string,
+): IServerFileSystem & {
+	fs: IServerFileSystem;
+	basePath: string;
+} {
+	return new SandboxFS(fs, basePath);
+}
+
+class SandboxFS implements IServerFileSystem {
+	fs: IServerFileSystem;
+	basePath: string;
+
+	constructor(fs: IServerFileSystem, basePath: string) {
+		this.fs = fs;
+		this.basePath = normalize(basePath);
+	}
+
+	private _resolvePath(userPath: string): string {
+		const fullPath = join(this.basePath, userPath);
+
+		const normalizedFullPath = normalize(fullPath);
+
+		const rel = relative(this.basePath, normalizedFullPath);
+		if (rel.startsWith('..') || rel === '..') {
+			throw new SandboxSecurityError(`Path traversal attempt detected: ${userPath}`);
+		}
+		return normalizedFullPath;
+	}
+
+	private _stripPath(fullPath: string): string {
+		const relPath = relative(this.basePath, fullPath);
+		// 保证返回的是一个以 '/' 开头的绝对路径（在沙箱内）
+		return sep + relPath.split(sep).join('/');
+	}
+
+	private _processStat(stat: IFileStat): IFileStat {
+		stat.path = this._stripPath(stat.path);
+		stat.directory = this._stripPath(stat.directory);
+		return stat;
+	}
+
+	async stat(path: string, options?: any): Promise<IFileStat> {
+		const fullPath = this._resolvePath(path);
+		const result = await this.fs.stat(fullPath, options);
+		return this._processStat(result);
+	}
+
+	async readdir(dir: string, options?: any): Promise<IFileStat[]> {
+		const fullPath = this._resolvePath(dir);
+		const results = await this.fs.readdir(fullPath, options);
+		return results.map((stat) => this._processStat(stat));
+	}
+
+	async exists(path: string): Promise<boolean> {
+		try {
+			const fullPath = this._resolvePath(path);
+			return await this.fs.exists(fullPath);
+		} catch (e) {
+			if (e instanceof SandboxSecurityError) {
+				return false; // 越界访问视为不存在
+			}
+			throw e;
+		}
+	}
+
+	mkdir(path: string, options?: any): Promise<void> {
+		const fullPath = this._resolvePath(path);
+		return this.fs.mkdir(fullPath, options);
+	}
+
+	readFile(path: string, options?: ReadFileOptions & { encoding: 'text' }): Promise<string>;
+	readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+	readFile(path: string, options?: ReadFileOptions): Promise<string | Uint8Array> {
+		const fullPath = this._resolvePath(path);
+		return this.fs.readFile(fullPath, options);
+	}
+
+	writeFile(path: string, data: any, options?: any): Promise<void> {
+		const fullPath = this._resolvePath(path);
+		return this.fs.writeFile(fullPath, data, options);
+	}
+
+	rm(path: string, options?: any): Promise<void> {
+		const fullPath = this._resolvePath(path);
+		return this.fs.rm(fullPath, options);
+	}
+
+	rename(oldPath: string, newPath: string, options?: any): Promise<void> {
+		const fullOldPath = this._resolvePath(oldPath);
+		const fullNewPath = this._resolvePath(newPath);
+		return this.fs.rename(fullOldPath, fullNewPath, options);
+	}
+
+	copy(src: string, dest: string, options?: any): Promise<void> {
+		const fullSrc = this._resolvePath(src);
+		const fullDest = this._resolvePath(dest);
+		return this.fs.copy(fullSrc, fullDest, options);
+	}
+
+	createReadStream(path: string, options?: any): any {
+		const fullPath = this._resolvePath(path);
+		if (!this.fs.createReadStream) {
+			throw new Error('Underlying filesystem does not support createReadStream');
+		}
+		return this.fs.createReadStream(fullPath, options);
+	}
+
+	createWriteStream(path: string, options?: any): any {
+		const fullPath = this._resolvePath(path);
+		if (!this.fs.createWriteStream) {
+			throw new Error('Underlying filesystem does not support createWriteStream');
+		}
+		return this.fs.createWriteStream(fullPath, options);
+	}
+
+	getUrl(file: IFileStat, options?: any): string | undefined {
+		let path = this._resolvePath(getPath(file.path));
+		if (this.fs.getUrl) {
+			return this.fs.getUrl(path, options);
+		}
+		return;
+	}
+}

package/src/fs/createWebDavFileSystem.ts

@@ -0,0 +1,190 @@
+import type { Readable, Writable } from 'node:stream';
+import { maybeFunction, type MaybeFunction } from '@wener/utils';
+import type { FileStat, GetDirectoryContentsOptions, ResponseDataDetailed, WebDAVClient } from 'webdav';
+import type {
+	IFileStat,
+	IFileSystem,
+	MkdirOptions,
+	ReaddirOptions,
+	ReadFileOptions,
+	RmOptions,
+	StatOptions,
+	WritableData,
+	WriteFileOptions,
+} from './IFileSystem';
+
+export function createWebDavFileSystem({ client }: { client: MaybeFunction<WebDAVClient> }): IFileSystem {
+	let fs = new WebdavFS({ client });
+	return fs;
+}
+
+class WebdavFS implements IFileSystem {
+	_client: MaybeFunction<WebDAVClient>;
+
+	constructor({
+		client = () => {
+			throw new Error('WebdavFS client not initialized');
+		},
+	}: {
+		client?: MaybeFunction<WebDAVClient>;
+	}) {
+		this._client = client;
+	}
+
+	set client(client: MaybeFunction<WebDAVClient>) {
+		this._client = client;
+	}
+
+	get client(): WebDAVClient {
+		return maybeFunction(this._client);
+	}
+
+	private toEntry(input: FileStat): IFileStat {
+		const { filename: path, basename, lastmod, type: kind, etag, size, mime } = input;
+		let meta: Record<string, any> = {};
+		if (etag) {
+			meta.etag = etag;
+		}
+		if (mime) {
+			meta.mime = mime;
+		}
+		return {
+			directory: path.substring(0, path.lastIndexOf('/')) || '/',
+			path,
+			name: basename,
+			mtime: +new Date(lastmod),
+			kind,
+			meta,
+			size,
+		};
+	}
+
+	private getData<T>(input: ResponseDataDetailed<T> | T): T {
+		if (
+			input &&
+			typeof input === 'object' &&
+			'data' in input &&
+			// 'headers' in input &&
+			'status' in input &&
+			typeof input.status === 'number'
+		) {
+			return input.data;
+		}
+		return input as T;
+	}
+
+	async readdir(
+		path: string,
+		{ glob, recursive, depth, kind, hidden, signal }: ReaddirOptions = {},
+	): Promise<IFileStat[]> {
+		// webdav depth 只支持 0,1
+		let o: GetDirectoryContentsOptions = {};
+		if (recursive) {
+			o.deep = true;
+		}
+		let res = await this.client.getDirectoryContents(path, {
+			deep: recursive,
+			signal,
+		});
+
+		let out: FileStat[] = this.getData(res);
+
+		if (!recursive && typeof depth === 'number' && depth >= 2) {
+			let l = depth;
+			let cur = out;
+			while (l-- > 1) {
+				let sub = (
+					await Promise.all(
+						cur.map(async (v) => {
+							if (v.type === 'directory') {
+								return this.getData(await this.client.getDirectoryContents(v.filename, { signal }));
+							}
+							return [];
+						}),
+					)
+				).flat();
+				out = out.concat(...sub);
+				cur = sub;
+			}
+		}
+
+		if (glob) {
+			const { default: def, matcher = def.matcher } = await import('micromatch');
+			const match = matcher(glob);
+			out = out.filter((v) => match(v.filename));
+		}
+		if (kind) {
+			out = out.filter((v) => v.type === kind);
+		}
+		if (!hidden) {
+			out = out.filter((v) => !v.basename.startsWith('.'));
+		}
+		return out.map((stat) => this.toEntry(stat));
+	}
+
+	async stat(path: string, { signal }: StatOptions = {}): Promise<IFileStat> {
+		const res = await this.client.stat(path, { details: true, signal });
+		return this.toEntry(this.getData(res));
+	}
+
+	async mkdir(path: string, { recursive, signal }: MkdirOptions = {}): Promise<void> {
+		await this.client.createDirectory(path, { recursive, signal });
+	}
+
+	async readFile(path: string, options: ReadFileOptions = {}): Promise<any> {
+		const format = options.encoding === 'text' ? 'text' : 'binary';
+		const res = await this.client.getFileContents(path, { format, ...options });
+		return this.getData(res);
+	}
+
+	async writeFile(path: string, data: WritableData, options: WriteFileOptions = {}): Promise<void> {
+		// Convert web ReadableStream to something WebDAV client can handle
+		let webdavData: string | Buffer | ArrayBuffer | Readable = data as string | Buffer | ArrayBuffer | Readable;
+		if (data instanceof ReadableStream) {
+			// Convert web ReadableStream to Buffer
+			const reader = data.getReader();
+			const chunks: Uint8Array[] = [];
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				if (value) chunks.push(value);
+			}
+			webdavData = Buffer.concat(chunks);
+		} else if (ArrayBuffer.isView(data) && !(data instanceof Buffer)) {
+			// Convert ArrayBufferView to Buffer
+			webdavData = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+		}
+		await this.client.putFileContents(path, webdavData, options);
+	}
+
+	async rm(path: string, { signal: _signal, force, recursive: _recursive }: RmOptions = {}): Promise<void> {
+		try {
+			await this.client.deleteFile(path);
+		} catch (e: any) {
+			if (force && e.status === 404) {
+				return;
+			}
+			throw e;
+		}
+	}
+
+	async rename(oldPath: string, newPath: string, options = {}): Promise<void> {
+		await this.client.moveFile(oldPath, newPath, options);
+	}
+
+	async exists(path: string): Promise<boolean> {
+		return await this.client.exists(path);
+	}
+
+	async copy(src: string, dest: string, options = {}): Promise<void> {
+		await this.client.copyFile(src, dest, options);
+	}
+
+	createReadStream(path: string, options = {}): Readable {
+		return this.client.createReadStream(path, options);
+	}
+
+	createWriteStream(path: string, options = {}): Writable {
+		return this.client.createWriteStream(path, options);
+	}
+}

package/src/fs/createWebFileSystem.ts

@@ -0,0 +1,242 @@
+import { basename, dirname, join, normalize } from 'pathe';
+import { FileSystemError } from './FileSystemError';
+import type {
+	CopyOptions,
+	IFileStat,
+	IFileSystem,
+	MkdirOptions,
+	ReadFileOptions,
+	ReaddirOptions,
+	RenameOptions,
+	RmOptions,
+	StatOptions,
+	WriteFileOptions,
+} from './IFileSystem';
+
+export function createWebFileSystem(options: { root: FileSystemDirectoryHandle }): IFileSystem {
+	return new WebFileSystem(options);
+}
+
+class WebFileSystem implements IFileSystem {
+	private readonly root: FileSystemDirectoryHandle;
+
+	constructor({ root }: { root: FileSystemDirectoryHandle }) {
+		this.root = root;
+	}
+
+	private async _getHandle(path: string): Promise<FileSystemHandle> {
+		const parts = normalize(path).split('/').filter(Boolean);
+		if (parts.length === 0) return this.root;
+
+		let current: FileSystemDirectoryHandle = this.root;
+
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			const isLast = i === parts.length - 1;
+
+			try {
+				// Try to get as directory first
+				current = await current.getDirectoryHandle(part);
+			} catch (e: any) {
+				if (e.name === 'TypeMismatchError' || e.name === 'NotFoundError') {
+					if (isLast) {
+						// Might be a file
+						try {
+							return await current.getFileHandle(part);
+						} catch (_e2) {
+							throw new FileSystemError(`File not found: ${path}`, 'ENOENT');
+						}
+					}
+				}
+				if (e.name === 'NotFoundError') {
+					throw new FileSystemError(`Path not found: ${path}`, 'ENOENT');
+				}
+				throw e;
+			}
+		}
+		return current;
+	}
+
+	private async _getParent(path: string): Promise<{ parent: FileSystemDirectoryHandle; name: string }> {
+		const normalized = normalize(path);
+		const parentPath = dirname(normalized);
+		const name = basename(normalized);
+
+		if (!name) throw new FileSystemError('Invalid path', 'EINVAL');
+
+		const parentHandle = await this._getHandle(parentPath);
+		if (parentHandle.kind !== 'directory') {
+			throw new FileSystemError(`Parent is not a directory: ${parentPath}`, 'ENOTDIR');
+		}
+
+		return { parent: parentHandle as FileSystemDirectoryHandle, name };
+	}
+
+	async stat(path: string, options?: StatOptions): Promise<IFileStat> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		const handle = await this._getHandle(path);
+		return this._handleToStat(handle, path);
+	}
+
+	private async _handleToStat(handle: FileSystemHandle, path: string): Promise<IFileStat> {
+		let size = 0;
+		let mtime = 0;
+
+		if (handle.kind === 'file') {
+			const file = await (handle as FileSystemFileHandle).getFile();
+			size = file.size;
+			mtime = file.lastModified;
+		}
+
+		return {
+			path,
+			directory: dirname(path),
+			name: handle.name,
+			kind: handle.kind,
+			size,
+			mtime,
+			meta: {},
+		};
+	}
+
+	async exists(path: string): Promise<boolean> {
+		try {
+			await this._getHandle(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	async readdir(path: string, options?: ReaddirOptions): Promise<IFileStat[]> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		const handle = await this._getHandle(path);
+		if (handle.kind !== 'directory') {
+			throw new FileSystemError(`Not a directory: ${path}`, 'ENOTDIR');
+		}
+
+		const entries: IFileStat[] = [];
+		// @ts-expect-error - FileSystemDirectoryHandle is async iterable in modern browsers
+		for await (const entry of (handle as FileSystemDirectoryHandle).values()) {
+			entries.push(await this._handleToStat(entry, join(path, entry.name)));
+		}
+		return entries;
+	}
+
+	async mkdir(path: string, options?: MkdirOptions): Promise<void> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		const normalized = normalize(path);
+		const parts = normalized.split('/').filter(Boolean);
+		let current = this.root;
+
+		if (options?.recursive) {
+			for (const part of parts) {
+				current = await current.getDirectoryHandle(part, { create: true });
+			}
+		} else {
+			const parentPath = dirname(normalized);
+			const name = basename(normalized);
+			try {
+				const parent = await this._getHandle(parentPath);
+				if (parent.kind !== 'directory') throw new FileSystemError(`Parent not a directory: ${parentPath}`, 'ENOTDIR');
+				await (parent as FileSystemDirectoryHandle).getDirectoryHandle(name, { create: true });
+			} catch (e: any) {
+				if (e.code === 'ENOENT' || e.name === 'NotFoundError') {
+					throw new FileSystemError(`Parent does not exist: ${parentPath}`, 'ENOENT');
+				}
+				throw e;
+			}
+		}
+	}
+
+	readFile(path: string, options?: ReadFileOptions & { encoding: 'text' }): Promise<string>;
+	readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+	async readFile(path: string, options?: ReadFileOptions): Promise<string | Uint8Array> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		const handle = await this._getHandle(path);
+		if (handle.kind !== 'file') throw new FileSystemError(`Is a directory: ${path}`, 'EISDIR');
+
+		const file = await (handle as FileSystemFileHandle).getFile();
+
+		if (options?.encoding === 'text') {
+			return await file.text();
+		} else {
+			const buffer = await file.arrayBuffer();
+			return new Uint8Array(buffer);
+		}
+	}
+
+	async writeFile(
+		path: string,
+		data: string | ArrayBuffer | ArrayBufferView<ArrayBufferLike> | ReadableStream,
+		options?: WriteFileOptions,
+	): Promise<void> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		if (options?.overwrite === false) {
+			if (await this.exists(path)) {
+				throw new FileSystemError(`File already exists: ${path}`, 'EEXIST');
+			}
+		}
+
+		const { parent, name } = await this._getParent(path);
+		const handle = await parent.getFileHandle(name, { create: true });
+
+		const writable = await (handle as any).createWritable();
+		await writable.write(data);
+		await writable.close();
+	}
+
+	async rm(path: string, options?: RmOptions): Promise<void> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		const { parent, name } = await this._getParent(path);
+
+		try {
+			await (parent as any).removeEntry(name, { recursive: options?.recursive });
+		} catch (e: any) {
+			if (e.name === 'NotFoundError') {
+				if (!options?.force) throw new FileSystemError(`File not found: ${path}`, 'ENOENT');
+			} else if (e.name === 'InvalidModificationError') {
+				throw new FileSystemError(`Directory not empty: ${path}`, 'ENOTEMPTY');
+			} else {
+				throw e;
+			}
+		}
+	}
+
+	async rename(oldPath: string, newPath: string, options?: RenameOptions): Promise<void> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		// File System Access API doesn't support move/rename directly
+		// Fallback to copy + delete
+		await this.copy(oldPath, newPath, { overwrite: options?.overwrite });
+		await this.rm(oldPath, { recursive: true });
+	}
+
+	async copy(src: string, dest: string, options?: CopyOptions): Promise<void> {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+
+		const srcHandle = await this._getHandle(src);
+
+		if (srcHandle.kind === 'file') {
+			const file = await (srcHandle as FileSystemFileHandle).getFile();
+			await this.writeFile(dest, await file.arrayBuffer(), { overwrite: options?.overwrite });
+		} else {
+			// Directory copy
+			await this.mkdir(dest);
+			const entries = await this.readdir(src);
+			for (const entry of entries) {
+				await this.copy(entry.path, join(dest, entry.name), options);
+			}
+		}
+	}
+
+	getUrl(_file: IFileStat | string): string | undefined {
+		return undefined;
+	}
+}

package/src/fs/findMimeType.ts

@@ -0,0 +1,20 @@
+import { types } from 'mime-types';
+import pathe from 'pathe';
+
+export function findMimeType(path: string | undefined | null) {
+	// fix extname error
+	// https://github.com/jshttp/mime-types/issues/111
+
+	if (!path || typeof path !== 'string') {
+		return false;
+	}
+
+	// get the extension ("ext" or ".ext" or full path)
+	const extension = pathe.extname(`x.${path}`).toLowerCase().slice(1);
+
+	if (!extension) {
+		return false;
+	}
+
+	return types[extension] || false;
+}

package/src/fs/index.ts

@@ -0,0 +1,8 @@
+export type * from './IFileSystem';
+export { createSandboxFileSystem } from './createSandboxFileSystem';
+export { createMemoryFileSystem } from './createMemoryFileSystem';
+export { createBrowserFileSystem } from './createBrowserFileSystem';
+export { createWebFileSystem } from './createWebFileSystem';
+export { findMimeType } from './findMimeType';
+export { type FileUrlOptions, FileUrlOptionsSchema } from './types';
+export { FileSystemError, FileSystemErrorCode } from './FileSystemError';