@b9g/filesystem 0.1.4 → 0.1.6

package/src/node.js

@@ -1,266 +1,152 @@
 /// <reference types="./node.d.ts" />
 // src/node.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-import { createWriteStream } from "fs";
-var NodeFileSystemWritableFileStream = class extends WritableStream {
-  constructor(filePath) {
-    const writeStream = createWriteStream(filePath);
-    super({
-      write(chunk) {
-        return new Promise((resolve, reject) => {
-          writeStream.write(chunk, (error) => {
-            if (error)
-              reject(error);
-            else
-              resolve();
-          });
-        });
-      },
-      close() {
-        return new Promise((resolve, reject) => {
-          writeStream.end((error) => {
-            if (error)
-              reject(error);
-            else
-              resolve();
-          });
-        });
-      },
-      abort() {
-        writeStream.destroy();
-        return Promise.resolve();
-      }
-    });
-    this.filePath = filePath;
-  }
-  // File System Access API compatibility methods
-  async write(data) {
-    const writer = this.getWriter();
+import { ShovelDirectoryHandle } from "./index.js";
+import * as FS from "fs/promises";
+import * as Path from "path";
+var NodeFileSystemBackend = class {
+  #rootPath;
+  constructor(rootPath) {
+    this.#rootPath = rootPath;
+  }
+  async stat(filePath) {
     try {
-      if (typeof data === "string") {
-        await writer.write(new TextEncoder().encode(data));
+      const fullPath = this.#resolvePath(filePath);
+      const stats = await FS.stat(fullPath);
+      if (stats.isFile()) {
+        return { kind: "file" };
+      } else if (stats.isDirectory()) {
+        return { kind: "directory" };
       } else {
-        await writer.write(data);
+        return null;
       }
-    } finally {
-      writer.releaseLock();
-    }
-  }
-  async close() {
-    const writer = this.getWriter();
-    try {
-      await writer.close();
-    } finally {
-      writer.releaseLock();
-    }
-  }
-};
-var NodeFileSystemFileHandle = class _NodeFileSystemFileHandle {
-  constructor(filePath) {
-    this.filePath = filePath;
-    this.name = path.basename(filePath);
-  }
-  kind = "file";
-  name;
-  async getFile() {
-    try {
-      const stats = await fs.stat(this.filePath);
-      const buffer = await fs.readFile(this.filePath);
-      return new File([buffer], this.name, {
-        lastModified: stats.mtime.getTime(),
-        // Attempt to determine MIME type from extension
-        type: this.getMimeType(this.filePath)
-      });
     } catch (error) {
       if (error.code === "ENOENT") {
-        throw new DOMException("File not found", "NotFoundError");
+        return null;
       }
       throw error;
     }
   }
-  async createWritable() {
-    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
-    return new NodeFileSystemWritableFileStream(this.filePath);
-  }
-  async createSyncAccessHandle() {
-    throw new DOMException(
-      "Synchronous access handles are only available in workers",
-      "InvalidStateError"
-    );
-  }
-  async isSameEntry(other) {
-    if (other.kind !== "file")
-      return false;
-    if (!(other instanceof _NodeFileSystemFileHandle))
-      return false;
-    return this.filePath === other.filePath;
-  }
-  async queryPermission() {
-    return "granted";
-  }
-  async requestPermission() {
-    return "granted";
-  }
-  getMimeType(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    const mimeTypes = {
-      ".txt": "text/plain",
-      ".html": "text/html",
-      ".css": "text/css",
-      ".js": "text/javascript",
-      ".json": "application/json",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".gif": "image/gif",
-      ".svg": "image/svg+xml",
-      ".pdf": "application/pdf",
-      ".zip": "application/zip"
-    };
-    return mimeTypes[ext] || "application/octet-stream";
-  }
-};
-var NodeFileSystemDirectoryHandle = class _NodeFileSystemDirectoryHandle {
-  constructor(dirPath) {
-    this.dirPath = dirPath;
-    this.name = path.basename(dirPath);
-  }
-  kind = "directory";
-  name;
-  async getFileHandle(name, options) {
-    const filePath = path.join(this.dirPath, name);
+  async readFile(filePath) {
     try {
-      const stats = await fs.stat(filePath);
-      if (!stats.isFile()) {
-        throw new DOMException(
-          "Path exists but is not a file",
-          "TypeMismatchError"
-        );
-      }
+      const fullPath = this.#resolvePath(filePath);
+      const [buffer, stats] = await Promise.all([
+        FS.readFile(fullPath),
+        FS.stat(fullPath)
+      ]);
+      return {
+        content: new Uint8Array(buffer),
+        lastModified: stats.mtimeMs
+      };
     } catch (error) {
       if (error.code === "ENOENT") {
-        if (options?.create) {
-          await fs.mkdir(this.dirPath, { recursive: true });
-          await fs.writeFile(filePath, "");
-        } else {
-          throw new DOMException("File not found", "NotFoundError");
-        }
-      } else {
-        throw error;
+        throw new DOMException("File not found", "NotFoundError");
       }
+      throw error;
     }
-    return new NodeFileSystemFileHandle(filePath);
   }
-  async getDirectoryHandle(name, options) {
-    const subDirPath = path.join(this.dirPath, name);
+  async writeFile(filePath, data) {
     try {
-      const stats = await fs.stat(subDirPath);
-      if (!stats.isDirectory()) {
-        throw new DOMException(
-          "Path exists but is not a directory",
-          "TypeMismatchError"
-        );
-      }
+      const fullPath = this.#resolvePath(filePath);
+      await FS.mkdir(Path.dirname(fullPath), { recursive: true });
+      await FS.writeFile(fullPath, data);
     } catch (error) {
-      if (error.code === "ENOENT") {
-        if (options?.create) {
-          await fs.mkdir(subDirPath, { recursive: true });
-        } else {
-          throw new DOMException("Directory not found", "NotFoundError");
-        }
-      } else {
-        throw error;
-      }
+      throw new DOMException(
+        `Failed to write file: ${error}`,
+        "InvalidModificationError"
+      );
     }
-    return new _NodeFileSystemDirectoryHandle(subDirPath);
   }
-  async removeEntry(name, options) {
-    const entryPath = path.join(this.dirPath, name);
+  async listDir(dirPath) {
     try {
-      const stats = await fs.stat(entryPath);
-      if (stats.isDirectory()) {
-        await fs.rmdir(entryPath, { recursive: options?.recursive });
-      } else {
-        await fs.unlink(entryPath);
+      const fullPath = this.#resolvePath(dirPath);
+      const entries = await FS.readdir(fullPath, { withFileTypes: true });
+      const results = [];
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          results.push({ name: entry.name, kind: "file" });
+        } else if (entry.isDirectory()) {
+          results.push({ name: entry.name, kind: "directory" });
+        }
       }
+      return results;
     } catch (error) {
       if (error.code === "ENOENT") {
-        throw new DOMException("Entry not found", "NotFoundError");
+        throw new DOMException("Directory not found", "NotFoundError");
       }
       throw error;
     }
   }
-  async resolve(_possibleDescendant) {
-    return null;
+  async createDir(dirPath) {
+    try {
+      const fullPath = this.#resolvePath(dirPath);
+      await FS.mkdir(fullPath, { recursive: true });
+    } catch (error) {
+      throw new DOMException(
+        `Failed to create directory: ${error}`,
+        "InvalidModificationError"
+      );
+    }
   }
-  async *entries() {
+  async remove(entryPath, recursive) {
     try {
-      const entries = await fs.readdir(this.dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const entryPath = path.join(this.dirPath, entry.name);
-        if (entry.isDirectory()) {
-          yield [entry.name, new _NodeFileSystemDirectoryHandle(entryPath)];
-        } else if (entry.isFile()) {
-          yield [entry.name, new NodeFileSystemFileHandle(entryPath)];
+      const fullPath = this.#resolvePath(entryPath);
+      const stats = await FS.stat(fullPath);
+      if (stats.isFile()) {
+        await FS.unlink(fullPath);
+      } else if (stats.isDirectory()) {
+        if (recursive) {
+          await FS.rm(fullPath, { recursive: true, force: true });
+        } else {
+          const entries = await FS.readdir(fullPath);
+          if (entries.length > 0) {
+            throw new DOMException(
+              "Directory is not empty",
+              "InvalidModificationError"
+            );
+          }
+          await FS.rmdir(fullPath);
         }
       }
     } catch (error) {
       if (error.code === "ENOENT") {
-        throw new DOMException("Directory not found", "NotFoundError");
+        throw new DOMException("Entry not found", "NotFoundError");
       }
       throw error;
     }
   }
-  async *keys() {
-    for await (const [name] of this.entries()) {
-      yield name;
+  #resolvePath(relativePath) {
+    const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
+    if (!cleanPath) {
+      return this.#rootPath;
     }
-  }
-  async *values() {
-    for await (const [, handle] of this.entries()) {
-      yield handle;
+    if (cleanPath.includes("..") || cleanPath.includes("\0")) {
+      throw new DOMException(
+        "Invalid path: contains path traversal or null bytes",
+        "NotAllowedError"
+      );
     }
-  }
-  async isSameEntry(other) {
-    if (other.kind !== "directory")
-      return false;
-    if (!(other instanceof _NodeFileSystemDirectoryHandle))
-      return false;
-    return this.dirPath === other.dirPath;
-  }
-  async queryPermission() {
-    return "granted";
-  }
-  async requestPermission() {
-    return "granted";
+    const resolvedPath = Path.resolve(this.#rootPath, cleanPath);
+    if (!resolvedPath.startsWith(Path.resolve(this.#rootPath))) {
+      throw new DOMException(
+        "Invalid path: outside of root directory",
+        "NotAllowedError"
+      );
+    }
+    return resolvedPath;
   }
 };
-var LocalBucket = class {
-  config;
-  rootPath;
-  constructor(config = {}) {
-    this.config = {
-      name: "node",
-      ...config
-    };
-    this.rootPath = config.rootPath || path.join(process.cwd(), "dist");
-  }
-  async getDirectoryHandle(name) {
-    const dirPath = name ? path.join(this.rootPath, name) : this.rootPath;
-    try {
-      await fs.mkdir(dirPath, { recursive: true });
-    } catch (error) {
-    }
-    return new NodeFileSystemDirectoryHandle(dirPath);
+var NodeBucket = class extends ShovelDirectoryHandle {
+  #rootPath;
+  constructor(rootPath) {
+    super(new NodeFileSystemBackend(rootPath), "/");
+    this.#rootPath = rootPath;
   }
-  getConfig() {
-    return { ...this.config };
+  // Override name to use the directory basename instead of "/"
+  get name() {
+    return Path.basename(this.#rootPath) || "root";
   }
 };
 export {
-  LocalBucket,
-  NodeFileSystemDirectoryHandle,
-  NodeFileSystemFileHandle,
-  NodeFileSystemWritableFileStream
+  NodeBucket,
+  NodeFileSystemBackend
 };

package/src/directory-storage.d.ts

@@ -1,50 +0,0 @@
-import type { Bucket } from "./types.js";
-/**
- * BucketStorage implements bucket storage with a configurable factory
- * The factory function receives the bucket name and can return different filesystem types
- * This mirrors the CustomCacheStorage pattern for consistency
- *
- * Example usage:
- * ```typescript
- * const buckets = new BucketStorage((name) => {
- *   if (name === 'uploads') return new S3Bucket('my-bucket');
- *   if (name === 'temp') return new LocalBucket('/tmp');
- *   return new LocalBucket('./dist'); // Default to dist
- * });
- * ```
- */
-export declare class BucketStorage {
-    private factory;
-    private instances;
-    constructor(factory: (name: string) => Bucket | Promise<Bucket>);
-    /**
-     * Opens a bucket with the given name
-     * Returns existing instance if already opened, otherwise creates a new one
-     */
-    open(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Returns true if a bucket with the given name exists (has been opened)
-     */
-    has(name: string): Promise<boolean>;
-    /**
-     * Deletes a bucket with the given name
-     * Disposes of the instance if it exists
-     */
-    delete(name: string): Promise<boolean>;
-    /**
-     * Returns a list of all opened bucket names
-     */
-    keys(): Promise<string[]>;
-    /**
-     * Get statistics about the bucket storage
-     */
-    getStats(): {
-        openInstances: number;
-        bucketNames: string[];
-    };
-    /**
-     * Dispose of all open adapter instances
-     * Useful for cleanup during shutdown
-     */
-    dispose(): Promise<void>;
-}

package/src/directory-storage.js

@@ -1,74 +0,0 @@
-/// <reference types="./directory-storage.d.ts" />
-// src/directory-storage.ts
-var BucketStorage = class {
-  constructor(factory) {
-    this.factory = factory;
-  }
-  instances = /* @__PURE__ */ new Map();
-  /**
-   * Opens a bucket with the given name
-   * Returns existing instance if already opened, otherwise creates a new one
-   */
-  async open(name) {
-    const existingInstance = this.instances.get(name);
-    if (existingInstance) {
-      return await existingInstance.getDirectoryHandle("");
-    }
-    const adapter = await this.factory(name);
-    this.instances.set(name, adapter);
-    return await adapter.getDirectoryHandle("");
-  }
-  /**
-   * Returns true if a bucket with the given name exists (has been opened)
-   */
-  async has(name) {
-    return this.instances.has(name);
-  }
-  /**
-   * Deletes a bucket with the given name
-   * Disposes of the instance if it exists
-   */
-  async delete(name) {
-    const instance = this.instances.get(name);
-    if (instance) {
-      if (instance.dispose) {
-        await instance.dispose();
-      }
-      this.instances.delete(name);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Returns a list of all opened bucket names
-   */
-  async keys() {
-    return Array.from(this.instances.keys());
-  }
-  /**
-   * Get statistics about the bucket storage
-   */
-  getStats() {
-    return {
-      openInstances: this.instances.size,
-      bucketNames: Array.from(this.instances.keys())
-    };
-  }
-  /**
-   * Dispose of all open adapter instances
-   * Useful for cleanup during shutdown
-   */
-  async dispose() {
-    const disposePromises = [];
-    for (const [_name, instance] of this.instances) {
-      if (instance.dispose) {
-        disposePromises.push(instance.dispose());
-      }
-    }
-    await Promise.all(disposePromises);
-    this.instances.clear();
-  }
-};
-export {
-  BucketStorage
-};

package/src/registry.d.ts

@@ -1,52 +0,0 @@
-/**
- * Filesystem adapter registry
- * Manages registration and retrieval of filesystem adapters
- */
-import type { FileSystemAdapter } from "./types.js";
-/**
- * Global registry of filesystem adapters
- */
-declare class Registry {
-    private adapters;
-    private defaultAdapter;
-    constructor();
-    /**
-     * Register a filesystem adapter with a name
-     */
-    register(name: string, adapter: FileSystemAdapter): void;
-    /**
-     * Get a filesystem adapter by name
-     */
-    get(name?: string): FileSystemAdapter | null;
-    /**
-     * Set the default filesystem adapter
-     */
-    setDefault(adapter: FileSystemAdapter): void;
-    /**
-     * Get all registered adapter names
-     */
-    getAdapterNames(): string[];
-    /**
-     * Clear all registered adapters
-     */
-    clear(): void;
-}
-/**
- * Global filesystem registry instance
- */
-export declare const FileSystemRegistry: Registry;
-/**
- * Get a file system directory handle using the registered adapters
- * @param name Directory name. Use "" for root directory
- * @param adapterName Optional adapter name (uses default if not specified)
- */
-export declare function getDirectoryHandle(name: string, adapterName?: string): Promise<FileSystemDirectoryHandle>;
-/**
- * @deprecated Use getDirectoryHandle() instead
- */
-export declare function getBucket(name?: string, adapterName?: string): Promise<FileSystemDirectoryHandle>;
-/**
- * @deprecated Use getDirectoryHandle() instead
- */
-export declare function getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
-export {};

package/src/registry.js

@@ -1,79 +0,0 @@
-/// <reference types="./registry.d.ts" />
-// src/registry.ts
-import { MemoryBucket } from "./memory.js";
-var Registry = class {
-  adapters = /* @__PURE__ */ new Map();
-  defaultAdapter;
-  constructor() {
-    this.defaultAdapter = new MemoryBucket();
-  }
-  /**
-   * Register a filesystem adapter with a name
-   */
-  register(name, adapter) {
-    this.adapters.set(name, adapter);
-    if (!this.defaultAdapter) {
-      this.defaultAdapter = adapter;
-    }
-  }
-  /**
-   * Get a filesystem adapter by name
-   */
-  get(name) {
-    if (!name) {
-      return this.defaultAdapter;
-    }
-    return this.adapters.get(name) || this.defaultAdapter;
-  }
-  /**
-   * Set the default filesystem adapter
-   */
-  setDefault(adapter) {
-    this.defaultAdapter = adapter;
-  }
-  /**
-   * Get all registered adapter names
-   */
-  getAdapterNames() {
-    return Array.from(this.adapters.keys());
-  }
-  /**
-   * Clear all registered adapters
-   */
-  clear() {
-    this.adapters.clear();
-    this.defaultAdapter = null;
-  }
-};
-var FileSystemRegistry = new Registry();
-async function getDirectoryHandle(name, adapterName) {
-  const adapter = FileSystemRegistry.get(adapterName);
-  if (!adapter) {
-    if (adapterName) {
-      throw new Error(`No filesystem adapter registered with name: ${adapterName}`);
-    } else {
-      throw new Error("No default filesystem adapter registered");
-    }
-  }
-  return await adapter.getDirectoryHandle(name);
-}
-async function getBucket(name, adapterName) {
-  const adapter = FileSystemRegistry.get(adapterName);
-  if (!adapter) {
-    throw new Error("No default filesystem adapter registered");
-  }
-  return await adapter.getDirectoryHandle(name || "");
-}
-async function getFileSystemRoot(name) {
-  const adapter = FileSystemRegistry.get();
-  if (!adapter) {
-    throw new Error("No default filesystem adapter registered");
-  }
-  return await adapter.getDirectoryHandle(name || "");
-}
-export {
-  FileSystemRegistry,
-  getBucket,
-  getDirectoryHandle,
-  getFileSystemRoot
-};

package/src/types.d.ts

@@ -1,31 +0,0 @@
-/**
- * Core filesystem adapter interface and types
- */
-/**
- * Configuration for filesystem adapters
- */
-export interface FileSystemConfig {
-    /** Human readable name for this filesystem */
-    name?: string;
-    /** Platform-specific configuration */
-    [key: string]: any;
-}
-/**
- * Core interface that all buckets must implement
- * Provides File System Access API compatibility across all platforms
- */
-export interface Bucket {
-    /**
-     * Get a directory handle for the bucket
-     * @param name Directory name. Use "" for root directory
-     */
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Get configuration for this bucket
-     */
-    getConfig(): FileSystemConfig;
-    /**
-     * Cleanup resources when bucket is no longer needed
-     */
-    dispose?(): Promise<void>;
-}

package/src/types.js

@@ -1 +0,0 @@
-/// <reference types="./types.d.ts" />