@gravito/nebula 3.0.1 → 4.0.0

package/dist/index.cjs

@@ -20,93 +20,354 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  LocalStorageProvider: () => LocalStorageProvider,
+  LocalStorageProvider: () => LocalStore,
+  LocalStore: () => LocalStore,
+  MemoryStore: () => MemoryStore,
+  NullStore: () => NullStore,
   OrbitNebula: () => OrbitNebula,
   OrbitStorage: () => OrbitStorage,
+  StorageManager: () => StorageManager,
+  StorageRepository: () => StorageRepository,
   default: () => orbitStorage
 });
 module.exports = __toCommonJS(index_exports);
+
+// src/StorageRepository.ts
+var StorageRepository = class {
+  constructor(store, hooks) {
+    this.store = store;
+    this.hooks = hooks;
+  }
+  async put(key, data) {
+    const finalData = this.hooks ? await this.hooks.applyFilter("storage:upload", data, { key }) : data;
+    await this.store.put(key, finalData);
+    if (this.hooks) {
+      await this.hooks.doAction("storage:uploaded", { key });
+    }
+  }
+  async get(key) {
+    const data = await this.store.get(key);
+    if (this.hooks) {
+      if (data) {
+        await this.hooks.doAction("storage:hit", { key });
+      } else {
+        await this.hooks.doAction("storage:miss", { key });
+      }
+    }
+    return data;
+  }
+  async delete(key) {
+    const deleted = await this.store.delete(key);
+    if (deleted && this.hooks) {
+      await this.hooks.doAction("storage:deleted", { key });
+    }
+    return deleted;
+  }
+  async exists(key) {
+    return this.store.exists(key);
+  }
+  async copy(from, to) {
+    await this.store.copy(from, to);
+    if (this.hooks) {
+      await this.hooks.doAction("storage:copied", { from, to });
+    }
+  }
+  async move(from, to) {
+    await this.store.move(from, to);
+    if (this.hooks) {
+      await this.hooks.doAction("storage:moved", { from, to });
+    }
+  }
+  async *list(prefix) {
+    if (!this.store.list) {
+      throw new Error("[StorageRepository] This storage driver does not support listing files.");
+    }
+    yield* this.store.list(prefix);
+  }
+  async getMetadata(key) {
+    return this.store.getMetadata(key);
+  }
+  getUrl(key) {
+    return this.store.getUrl(key);
+  }
+  async getSignedUrl(key, expiresIn) {
+    if (!this.store.getSignedUrl) {
+      throw new Error("[StorageRepository] This storage driver does not support signed URLs.");
+    }
+    return this.store.getSignedUrl(key, expiresIn);
+  }
+};
+
+// src/StorageManager.ts
+var StorageManager = class {
+  constructor(storeFactory, options, hooks) {
+    this.storeFactory = storeFactory;
+    this.options = options;
+    this.hooks = hooks;
+  }
+  stores = /* @__PURE__ */ new Map();
+  repositories = /* @__PURE__ */ new Map();
+  disk(name) {
+    const diskName = name ?? this.options.default;
+    if (!this.repositories.has(diskName)) {
+      const store = this.resolveStore(diskName);
+      this.repositories.set(diskName, new StorageRepository(store, this.hooks));
+    }
+    return this.repositories.get(diskName);
+  }
+  resolveStore(name) {
+    if (!this.stores.has(name)) {
+      this.stores.set(name, this.storeFactory(name));
+    }
+    return this.stores.get(name);
+  }
+  put(key, data) {
+    return this.disk().put(key, data);
+  }
+  get(key) {
+    return this.disk().get(key);
+  }
+  delete(key) {
+    return this.disk().delete(key);
+  }
+  exists(key) {
+    return this.disk().exists(key);
+  }
+  copy(from, to) {
+    return this.disk().copy(from, to);
+  }
+  move(from, to) {
+    return this.disk().move(from, to);
+  }
+  list(prefix) {
+    return this.disk().list(prefix);
+  }
+  getMetadata(key) {
+    return this.disk().getMetadata(key);
+  }
+  getUrl(key) {
+    return this.disk().getUrl(key);
+  }
+  getSignedUrl(key, expiresIn) {
+    return this.disk().getSignedUrl(key, expiresIn);
+  }
+};
+
+// src/stores/LocalStore.ts
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
 var import_core = require("@gravito/core");
-var LocalStorageProvider = class {
-  rootDir;
-  baseUrl;
-  runtime = (0, import_core.getRuntimeAdapter)();
-  /**
-   * Create a new LocalStorageProvider.
-   *
-   * @param rootDir - The absolute path to the local storage directory.
-   * @param baseUrl - The public URL path for accessing stored files (e.g., '/storage').
-   */
+var LocalStore = class {
   constructor(rootDir, baseUrl = "/storage") {
     this.rootDir = rootDir;
     this.baseUrl = baseUrl;
   }
-  /**
-   * Write data to the local disk.
-   */
+  runtime = (0, import_core.getRuntimeAdapter)();
   async put(key, data) {
-    const path = this.resolveKeyPath(key);
-    const dir = path.substring(0, path.lastIndexOf("/"));
-    if (dir && dir !== this.rootDir) {
-      await (0, import_promises.mkdir)(dir, { recursive: true });
-    }
+    const path = this.resolvePath(key);
+    await this.ensureDirectory(path);
     await this.runtime.writeFile(path, data);
   }
-  /**
-   * Read data from the local disk.
-   */
   async get(key) {
-    const path = this.resolveKeyPath(key);
-    if (!await this.runtime.exists(path)) {
+    if (!await this.exists(key)) {
       return null;
     }
-    return await this.runtime.readFileAsBlob(path);
+    const path = this.resolvePath(key);
+    return this.runtime.readFileAsBlob(path);
   }
-  /**
-   * Delete a file from the local disk.
-   */
   async delete(key) {
-    await this.runtime.deleteFile(this.resolveKeyPath(key));
+    if (!await this.exists(key)) {
+      return false;
+    }
+    const path = this.resolvePath(key);
+    await this.runtime.deleteFile(path);
+    return true;
+  }
+  async exists(key) {
+    const path = this.resolvePath(key);
+    return this.runtime.exists(path);
+  }
+  async copy(from, to) {
+    const data = await this.get(from);
+    if (!data) {
+      throw new Error(`[LocalStore] Source file not found: ${from}`);
+    }
+    await this.put(to, data);
+  }
+  async move(from, to) {
+    await this.copy(from, to);
+    await this.delete(from);
+  }
+  list(prefix = "") {
+    throw new Error(
+      "[LocalStore] list() is not yet implemented. Requires RuntimeAdapter.readDir() support in @gravito/core."
+    );
+  }
+  async getMetadata(key) {
+    if (!await this.exists(key)) {
+      return null;
+    }
+    const path = this.resolvePath(key);
+    const stat = await this.runtime.stat(path);
+    return {
+      key,
+      size: stat.size,
+      mimeType: this.guessMimeType(key),
+      lastModified: /* @__PURE__ */ new Date()
+    };
   }
-  /**
-   * Resolve the public URL for a locally stored file.
-   */
   getUrl(key) {
     const safeKey = this.normalizeKey(key);
     return `${this.baseUrl}/${safeKey}`;
   }
   normalizeKey(key) {
     if (!key || key.includes("\0")) {
-      throw new Error("Invalid storage key.");
+      throw new Error("[LocalStore] Invalid storage key: empty or contains null byte.");
     }
     const normalized = (0, import_node_path.normalize)(key).replace(/^[/\\]+/, "");
-    if (normalized === "." || normalized === ".." || normalized.startsWith(`..${import_node_path.sep}`) || (0, import_node_path.isAbsolute)(normalized)) {
-      throw new Error("Invalid storage key.");
+    if (normalized === "." || normalized === ".." || normalized.startsWith(`..${import_node_path.sep}`) || normalized.startsWith(`.${import_node_path.sep}`) || (0, import_node_path.isAbsolute)(normalized)) {
+      throw new Error("[LocalStore] Invalid storage key: path traversal attempt.");
     }
     return normalized.replace(/\\/g, "/");
   }
-  resolveKeyPath(key) {
+  resolvePath(key) {
     const normalized = this.normalizeKey(key);
     const root = (0, import_node_path.resolve)(this.rootDir);
     const resolved = (0, import_node_path.resolve)(root, normalized);
     const rootPrefix = root.endsWith(import_node_path.sep) ? root : `${root}${import_node_path.sep}`;
     if (!resolved.startsWith(rootPrefix) && resolved !== root) {
-      throw new Error("Invalid storage key.");
+      throw new Error("[LocalStore] Invalid storage key: resolved path outside root.");
     }
     return resolved;
   }
+  async ensureDirectory(filePath) {
+    const dir = filePath.substring(0, filePath.lastIndexOf(import_node_path.sep));
+    if (dir && dir !== this.rootDir) {
+      await (0, import_promises.mkdir)(dir, { recursive: true });
+    }
+  }
+  guessMimeType(key) {
+    const ext = key.split(".").pop()?.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";
+  }
+};
+
+// src/stores/MemoryStore.ts
+var MemoryStore = class {
+  files = /* @__PURE__ */ new Map();
+  async put(key, data) {
+    let blob;
+    if (data instanceof Blob) {
+      blob = data;
+    } else if (typeof data === "string") {
+      blob = new Blob([data]);
+    } else {
+      blob = new Blob([new Uint8Array(data)]);
+    }
+    this.files.set(key, {
+      data: blob,
+      metadata: {
+        key,
+        size: blob.size,
+        mimeType: blob.type || "application/octet-stream",
+        lastModified: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  async get(key) {
+    return this.files.get(key)?.data ?? null;
+  }
+  async delete(key) {
+    return this.files.delete(key);
+  }
+  async exists(key) {
+    return this.files.has(key);
+  }
+  async copy(from, to) {
+    const file = this.files.get(from);
+    if (!file) {
+      throw new Error(`[MemoryStore] Source file not found: ${from}`);
+    }
+    this.files.set(to, {
+      data: file.data,
+      metadata: { ...file.metadata, key: to, lastModified: /* @__PURE__ */ new Date() }
+    });
+  }
+  async move(from, to) {
+    await this.copy(from, to);
+    await this.delete(from);
+  }
+  async *list(prefix = "") {
+    for (const [key, file] of this.files.entries()) {
+      if (key.startsWith(prefix)) {
+        yield {
+          key,
+          isDirectory: false,
+          size: file.metadata.size,
+          lastModified: file.metadata.lastModified
+        };
+      }
+    }
+  }
+  async getMetadata(key) {
+    return this.files.get(key)?.metadata ?? null;
+  }
+  getUrl(key) {
+    return `/memory/${key}`;
+  }
+};
+
+// src/stores/NullStore.ts
+var NullStore = class {
+  async put(_key, _data) {
+  }
+  async get(_key) {
+    return null;
+  }
+  async delete(_key) {
+    return false;
+  }
+  async exists(_key) {
+    return false;
+  }
+  async copy(_from, _to) {
+  }
+  async move(_from, _to) {
+  }
+  async *list(_prefix) {
+  }
+  async getMetadata(_key) {
+    return null;
+  }
+  getUrl(key) {
+    return `/null/${key}`;
+  }
 };
+
+// src/index.ts
 var OrbitNebula = class {
   constructor(options) {
     this.options = options;
   }
+  manager;
   /**
    * Install storage service into PlanetCore.
    *
    * @param core - The PlanetCore instance.
-   * @throws {Error} If configuration or provider is missing.
    */
   install(core) {
     const config = this.options || core.config.get("storage");
@@ -116,62 +377,86 @@ var OrbitNebula = class {
       );
     }
     const { exposeAs = "storage" } = config;
-    const logger = core.logger;
-    logger.info(`[OrbitNebula] Initializing Storage (Exposed as: ${exposeAs})`);
-    let provider = config.provider;
-    if (!provider && config.local) {
-      logger.info(`[OrbitNebula] Using LocalStorageProvider at ${config.local.root}`);
-      provider = new LocalStorageProvider(config.local.root, config.local.baseUrl);
-    }
-    if (!provider) {
-      throw new Error(
-        "[OrbitNebula] No provider configured. Please provide a provider instance or local configuration."
-      );
+    core.logger.info(`[OrbitNebula] Initializing Storage (Exposed as: ${exposeAs})`);
+    let defaultDisk = config.default;
+    if (!defaultDisk) {
+      if (config.local) defaultDisk = "local";
+      else if (config.provider) defaultDisk = "custom";
+      else defaultDisk = "local";
     }
-    const storageService = {
-      put: async (key, data) => {
-        const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
-        await provider?.put(key, finalData);
-        await core.hooks.doAction("storage:uploaded", { key });
-      },
-      get: (key) => provider?.get(key),
-      delete: (key) => provider?.delete(key),
-      getUrl: (key) => provider?.getUrl(key)
+    const managerOptions = {
+      default: defaultDisk
+    };
+    const storageHooks = {
+      applyFilter: (h, v, c) => core.hooks.applyFilters(h, v, c),
+      doAction: (h, c) => core.hooks.doAction(h, c)
     };
-    core.container.instance(exposeAs, storageService);
+    const storeFactory = this.createStoreFactory(config);
+    this.manager = new StorageManager(storeFactory, managerOptions, storageHooks);
+    this.manager.disk();
+    core.container.instance(exposeAs, this.manager);
     core.adapter.use("*", async (c, next) => {
-      c.set(exposeAs, storageService);
+      c.set(exposeAs, this.manager);
       await next();
       return void 0;
     });
-    core.hooks.doAction("storage:init", storageService);
+    core.hooks.doAction("storage:init", { manager: this.manager });
+  }
+  /**
+   * Get the installed StorageManager instance.
+   *
+   * @returns The StorageManager instance.
+   * @throws {Error} If not installed.
+   */
+  getStorage() {
+    if (!this.manager) {
+      throw new Error("[OrbitNebula] StorageManager not initialized. Call install() first.");
+    }
+    return this.manager;
+  }
+  createStoreFactory(options) {
+    return (name) => {
+      const config = options.disks?.[name];
+      if (config) {
+        if (config.driver === "local") {
+          return new LocalStore(config.root, config.baseUrl);
+        }
+        if (config.driver === "memory") {
+          return new MemoryStore();
+        }
+        if (config.driver === "null") {
+          return new NullStore();
+        }
+        if (config.driver === "custom") {
+          return config.store;
+        }
+      }
+      if (name === "local" && options.local) {
+        return new LocalStore(options.local.root, options.local.baseUrl);
+      }
+      if (options.provider) {
+        if (name === "custom" || !options.disks && !options.local) {
+          return options.provider;
+        }
+      }
+      throw new Error(`[OrbitNebula] Driver not configured for disk: ${name}`);
+    };
   }
 };
 function orbitStorage(core, options) {
   const orbit = new OrbitNebula(options);
   orbit.install(core);
-  let provider = options.provider;
-  if (!provider && options.local) {
-    provider = new LocalStorageProvider(options.local.root, options.local.baseUrl);
-  }
-  if (!provider) {
-    throw new Error("[OrbitNebula] No provider configured.");
-  }
-  return {
-    put: async (key, data) => {
-      const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
-      await provider?.put(key, finalData);
-      await core.hooks.doAction("storage:uploaded", { key });
-    },
-    get: (key) => provider?.get(key),
-    delete: (key) => provider?.delete(key),
-    getUrl: (key) => provider?.getUrl(key)
-  };
+  return orbit.getStorage();
 }
 var OrbitStorage = OrbitNebula;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LocalStorageProvider,
+  LocalStore,
+  MemoryStore,
+  NullStore,
   OrbitNebula,
-  OrbitStorage
+  OrbitStorage,
+  StorageManager,
+  StorageRepository
 });