alepha 0.14.4 → 0.15.1

package/dist/file/index.d.ts

@@ -2,6 +2,11 @@ import * as alepha0 from "alepha";
 import { FileLike, StreamLike } from "alepha";
 import { Readable } from "node:stream";
 
+//#region ../../src/file/errors/FileError.d.ts
+declare class FileError extends Error {
+  constructor(message: string, cause?: Error);
+}
+//#endregion
 //#region ../../src/file/providers/FileSystemProvider.d.ts
 /**
  * Options for creating a file from a URL
@@ -278,6 +283,134 @@ declare abstract class FileSystemProvider {
   abstract writeFile(path: string, data: Uint8Array | Buffer | string | FileLike): Promise<void>;
 }
 //#endregion
+//#region ../../src/file/providers/MemoryFileSystemProvider.d.ts
+interface MemoryFileSystemProviderOptions {
+  /**
+   * Error to throw on mkdir operations (for testing error handling)
+   */
+  mkdirError?: Error | null;
+  /**
+   * Error to throw on writeFile operations (for testing error handling)
+   */
+  writeFileError?: Error | null;
+  /**
+   * Error to throw on readFile operations (for testing error handling)
+   */
+  readFileError?: Error | null;
+}
+/**
+ * In-memory implementation of FileSystemProvider for testing.
+ *
+ * This provider stores all files and directories in memory, making it ideal for
+ * unit tests that need to verify file operations without touching the real file system.
+ *
+ * @example
+ * ```typescript
+ * // In tests, substitute the real FileSystemProvider with MemoryFileSystemProvider
+ * const alepha = Alepha.create().with({
+ *   provide: FileSystemProvider,
+ *   use: MemoryFileSystemProvider,
+ * });
+ *
+ * // Run code that uses FileSystemProvider
+ * const service = alepha.inject(MyService);
+ * await service.saveFile("test.txt", "Hello World");
+ *
+ * // Verify the file was written
+ * const memoryFs = alepha.inject(MemoryFileSystemProvider);
+ * expect(memoryFs.files.get("test.txt")?.toString()).toBe("Hello World");
+ * ```
+ */
+declare class MemoryFileSystemProvider implements FileSystemProvider {
+  /**
+   * In-memory storage for files (path -> content)
+   */
+  files: Map<string, Buffer<ArrayBufferLike>>;
+  /**
+   * In-memory storage for directories
+   */
+  directories: Set<string>;
+  /**
+   * Track mkdir calls for test assertions
+   */
+  mkdirCalls: Array<{
+    path: string;
+    options?: MkdirOptions;
+  }>;
+  /**
+   * Track writeFile calls for test assertions
+   */
+  writeFileCalls: Array<{
+    path: string;
+    data: string;
+  }>;
+  /**
+   * Track join calls for test assertions
+   */
+  joinCalls: Array<string[]>;
+  /**
+   * Error to throw on mkdir (for testing error handling)
+   */
+  mkdirError: Error | null;
+  /**
+   * Error to throw on writeFile (for testing error handling)
+   */
+  writeFileError: Error | null;
+  /**
+   * Error to throw on readFile (for testing error handling)
+   */
+  readFileError: Error | null;
+  constructor(options?: MemoryFileSystemProviderOptions);
+  /**
+   * Join path segments using forward slashes.
+   */
+  join(...paths: string[]): string;
+  /**
+   * Create a FileLike object from various sources.
+   */
+  createFile(options: CreateFileOptions): FileLike;
+  /**
+   * Remove a file or directory from memory.
+   */
+  rm(path: string, options?: RmOptions): Promise<void>;
+  /**
+   * Copy a file or directory in memory.
+   */
+  cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+  /**
+   * Move/rename a file or directory in memory.
+   */
+  mv(src: string, dest: string): Promise<void>;
+  /**
+   * Create a directory in memory.
+   */
+  mkdir(path: string, options?: MkdirOptions): Promise<void>;
+  /**
+   * List files in a directory.
+   */
+  ls(path: string, options?: LsOptions): Promise<string[]>;
+  /**
+   * Check if a file or directory exists in memory.
+   */
+  exists(path: string): Promise<boolean>;
+  /**
+   * Read a file from memory.
+   */
+  readFile(path: string): Promise<Buffer>;
+  /**
+   * Write a file to memory.
+   */
+  writeFile(path: string, data: Uint8Array | Buffer | string | FileLike): Promise<void>;
+  /**
+   * Reset all in-memory state (useful between tests).
+   */
+  reset(): void;
+  /**
+   * Get the content of a file as a string (convenience method for testing).
+   */
+  getFileContent(path: string): string | undefined;
+}
+//#endregion
 //#region ../../src/file/services/FileDetector.d.ts
 interface FileTypeResult {
   /**
@@ -702,5 +835,5 @@ declare class NodeFileSystemProvider implements FileSystemProvider {
  */
 declare const AlephaFile: alepha0.Service<alepha0.Module>;
 //#endregion
-export { AlephaFile, CpOptions, CreateFileFromArrayBufferOptions, CreateFileFromBufferOptions, CreateFileFromPathOptions, CreateFileFromResponseOptions, CreateFileFromStreamOptions, CreateFileFromTextOptions, CreateFileFromUrlOptions, CreateFileFromWebFileOptions, CreateFileOptions, FileDetector, FileSystemProvider, FileTypeResult, LsOptions, MkdirOptions, NodeFileSystemProvider, RmOptions };
+export { AlephaFile, CpOptions, CreateFileFromArrayBufferOptions, CreateFileFromBufferOptions, CreateFileFromPathOptions, CreateFileFromResponseOptions, CreateFileFromStreamOptions, CreateFileFromTextOptions, CreateFileFromUrlOptions, CreateFileFromWebFileOptions, CreateFileOptions, FileDetector, FileError, FileSystemProvider, FileTypeResult, LsOptions, MemoryFileSystemProvider, MemoryFileSystemProviderOptions, MkdirOptions, NodeFileSystemProvider, RmOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/file/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/file/providers/FileSystemProvider.ts","../../src/file/services/FileDetector.ts","../../src/file/providers/NodeFileSystemProvider.ts","../../src/file/index.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/file/errors/FileError.ts","../../src/file/providers/FileSystemProvider.ts","../../src/file/providers/MemoryFileSystemProvider.ts","../../src/file/services/FileDetector.ts","../../src/file/providers/NodeFileSystemProvider.ts","../../src/file/index.ts"],"mappings":"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"}

package/dist/file/index.js

@@ -11,6 +11,247 @@ import { fileURLToPath } from "node:url";
 */
 var FileSystemProvider = class {};
 
+//#endregion
+//#region ../../src/file/providers/MemoryFileSystemProvider.ts
+/**
+* In-memory implementation of FileSystemProvider for testing.
+*
+* This provider stores all files and directories in memory, making it ideal for
+* unit tests that need to verify file operations without touching the real file system.
+*
+* @example
+* ```typescript
+* // In tests, substitute the real FileSystemProvider with MemoryFileSystemProvider
+* const alepha = Alepha.create().with({
+*   provide: FileSystemProvider,
+*   use: MemoryFileSystemProvider,
+* });
+*
+* // Run code that uses FileSystemProvider
+* const service = alepha.inject(MyService);
+* await service.saveFile("test.txt", "Hello World");
+*
+* // Verify the file was written
+* const memoryFs = alepha.inject(MemoryFileSystemProvider);
+* expect(memoryFs.files.get("test.txt")?.toString()).toBe("Hello World");
+* ```
+*/
+var MemoryFileSystemProvider = class {
+	/**
+	* In-memory storage for files (path -> content)
+	*/
+	files = /* @__PURE__ */ new Map();
+	/**
+	* In-memory storage for directories
+	*/
+	directories = /* @__PURE__ */ new Set();
+	/**
+	* Track mkdir calls for test assertions
+	*/
+	mkdirCalls = [];
+	/**
+	* Track writeFile calls for test assertions
+	*/
+	writeFileCalls = [];
+	/**
+	* Track join calls for test assertions
+	*/
+	joinCalls = [];
+	/**
+	* Error to throw on mkdir (for testing error handling)
+	*/
+	mkdirError = null;
+	/**
+	* Error to throw on writeFile (for testing error handling)
+	*/
+	writeFileError = null;
+	/**
+	* Error to throw on readFile (for testing error handling)
+	*/
+	readFileError = null;
+	constructor(options = {}) {
+		this.mkdirError = options.mkdirError ?? null;
+		this.writeFileError = options.writeFileError ?? null;
+		this.readFileError = options.readFileError ?? null;
+	}
+	/**
+	* Join path segments using forward slashes.
+	*/
+	join(...paths) {
+		this.joinCalls.push(paths);
+		return paths.filter(Boolean).join("/").replace(/\/+/g, "/");
+	}
+	/**
+	* Create a FileLike object from various sources.
+	*/
+	createFile(options) {
+		if ("buffer" in options) {
+			const buffer = options.buffer;
+			return {
+				name: options.name ?? "file",
+				type: options.type ?? "application/octet-stream",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => buffer.toString("utf-8")
+			};
+		}
+		if ("text" in options) {
+			const buffer = Buffer.from(options.text, "utf-8");
+			return {
+				name: options.name ?? "file.txt",
+				type: options.type ?? "text/plain",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => options.text
+			};
+		}
+		throw new Error("MemoryFileSystemProvider.createFile: unsupported options. Only buffer and text are supported.");
+	}
+	/**
+	* Remove a file or directory from memory.
+	*/
+	async rm(path, options) {
+		if (!(this.files.has(path) || this.directories.has(path)) && !options?.force) throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
+		if (this.directories.has(path)) if (options?.recursive) {
+			this.directories.delete(path);
+			for (const filePath of this.files.keys()) if (filePath.startsWith(`${path}/`)) this.files.delete(filePath);
+			for (const dirPath of this.directories) if (dirPath.startsWith(`${path}/`)) this.directories.delete(dirPath);
+		} else throw new Error(`EISDIR: illegal operation on a directory, rm '${path}'`);
+		else this.files.delete(path);
+	}
+	/**
+	* Copy a file or directory in memory.
+	*/
+	async cp(src, dest, options) {
+		if (this.directories.has(src)) {
+			if (!options?.recursive) throw new Error(`Cannot copy directory without recursive option: ${src}`);
+			this.directories.add(dest);
+			for (const [filePath, content] of this.files) if (filePath.startsWith(`${src}/`)) {
+				const newPath = filePath.replace(src, dest);
+				this.files.set(newPath, Buffer.from(content));
+			}
+		} else if (this.files.has(src)) {
+			const content = this.files.get(src);
+			this.files.set(dest, Buffer.from(content));
+		} else throw new Error(`ENOENT: no such file or directory, cp '${src}'`);
+	}
+	/**
+	* Move/rename a file or directory in memory.
+	*/
+	async mv(src, dest) {
+		if (this.directories.has(src)) {
+			this.directories.delete(src);
+			this.directories.add(dest);
+			for (const [filePath, content] of this.files) if (filePath.startsWith(`${src}/`)) {
+				const newPath = filePath.replace(src, dest);
+				this.files.delete(filePath);
+				this.files.set(newPath, content);
+			}
+		} else if (this.files.has(src)) {
+			const content = this.files.get(src);
+			this.files.delete(src);
+			this.files.set(dest, content);
+		} else throw new Error(`ENOENT: no such file or directory, mv '${src}'`);
+	}
+	/**
+	* Create a directory in memory.
+	*/
+	async mkdir(path, options) {
+		this.mkdirCalls.push({
+			path,
+			options
+		});
+		if (this.mkdirError) throw this.mkdirError;
+		if (this.directories.has(path) && !options?.recursive) throw new Error(`EEXIST: file already exists, mkdir '${path}'`);
+		this.directories.add(path);
+		if (options?.recursive) {
+			const parts = path.split("/").filter(Boolean);
+			let current = "";
+			for (const part of parts) {
+				current = current ? `${current}/${part}` : part;
+				this.directories.add(current);
+			}
+		}
+	}
+	/**
+	* List files in a directory.
+	*/
+	async ls(path, options) {
+		const normalizedPath = path.replace(/\/$/, "");
+		const entries = /* @__PURE__ */ new Set();
+		for (const filePath of this.files.keys()) if (filePath.startsWith(`${normalizedPath}/`)) {
+			const relativePath = filePath.slice(normalizedPath.length + 1);
+			const parts = relativePath.split("/");
+			if (options?.recursive) entries.add(relativePath);
+			else entries.add(parts[0]);
+		}
+		for (const dirPath of this.directories) if (dirPath.startsWith(`${normalizedPath}/`) && dirPath !== normalizedPath) {
+			const relativePath = dirPath.slice(normalizedPath.length + 1);
+			const parts = relativePath.split("/");
+			if (options?.recursive) entries.add(relativePath);
+			else if (parts.length === 1) entries.add(parts[0]);
+		}
+		let result = Array.from(entries);
+		if (!options?.hidden) result = result.filter((entry) => !entry.startsWith("."));
+		return result.sort();
+	}
+	/**
+	* Check if a file or directory exists in memory.
+	*/
+	async exists(path) {
+		return this.files.has(path) || this.directories.has(path);
+	}
+	/**
+	* Read a file from memory.
+	*/
+	async readFile(path) {
+		if (this.readFileError) throw this.readFileError;
+		const content = this.files.get(path);
+		if (!content) throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+		return content;
+	}
+	/**
+	* Write a file to memory.
+	*/
+	async writeFile(path, data) {
+		const dataStr = typeof data === "string" ? data : data instanceof Buffer || data instanceof Uint8Array ? data.toString("utf-8") : await data.text();
+		this.writeFileCalls.push({
+			path,
+			data: dataStr
+		});
+		if (this.writeFileError) throw this.writeFileError;
+		const buffer = typeof data === "string" ? Buffer.from(data, "utf-8") : data instanceof Buffer ? data : data instanceof Uint8Array ? Buffer.from(data) : Buffer.from(await data.text(), "utf-8");
+		this.files.set(path, buffer);
+	}
+	/**
+	* Reset all in-memory state (useful between tests).
+	*/
+	reset() {
+		this.files.clear();
+		this.directories.clear();
+		this.mkdirCalls = [];
+		this.writeFileCalls = [];
+		this.joinCalls = [];
+		this.mkdirError = null;
+		this.writeFileError = null;
+		this.readFileError = null;
+	}
+	/**
+	* Get the content of a file as a string (convenience method for testing).
+	*/
+	getFileContent(path) {
+		return this.files.get(path)?.toString("utf-8");
+	}
+};
+
 //#endregion
 //#region ../../src/file/services/FileDetector.ts
 /**
@@ -1179,6 +1420,16 @@ var NodeFileSystemProvider = class {
 	}
 };
 
+//#endregion
+//#region ../../src/file/errors/FileError.ts
+var FileError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.name = "FileError";
+		this.cause = cause;
+	}
+};
+
 //#endregion
 //#region ../../src/file/index.ts
 /**
@@ -1198,6 +1449,7 @@ const AlephaFile = $module({
 	services: [
 		FileDetector,
 		FileSystemProvider,
+		MemoryFileSystemProvider,
 		NodeFileSystemProvider
 	],
 	register: (alepha) => alepha.with({
@@ -1208,5 +1460,5 @@ const AlephaFile = $module({
 });
 
 //#endregion
-export { AlephaFile, FileDetector, FileSystemProvider, NodeFileSystemProvider };
+export { AlephaFile, FileDetector, FileError, FileSystemProvider, MemoryFileSystemProvider, NodeFileSystemProvider };
 //# sourceMappingURL=index.js.map