@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/storage/index.js

@@ -0,0 +1,832 @@
+// src/storage/drivers/LocalDriver.ts
+import {
+  readFile,
+  writeFile,
+  unlink,
+  stat,
+  readdir,
+  mkdir,
+  rm,
+  copyFile,
+  rename
+} from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+var LocalDriver = class {
+  root;
+  baseUrl;
+  defaultVisibility;
+  constructor(options) {
+    this.root = options.root;
+    this.baseUrl = options.url ?? "";
+    this.defaultVisibility = options.visibility ?? "private";
+  }
+  /**
+   * Get the full path for a file.
+   */
+  fullPath(path) {
+    return join(this.root, path);
+  }
+  /**
+   * Ensure the directory exists.
+   */
+  async ensureDirectory(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  }
+  async put(path, content, options) {
+    const fullPath = this.fullPath(path);
+    await this.ensureDirectory(fullPath);
+    const buffer = typeof content === "string" ? Buffer.from(content) : content;
+    await writeFile(fullPath, buffer);
+    return path;
+  }
+  async putFile(path, localPath, options) {
+    const content = await readFile(localPath);
+    return this.put(path, content, options);
+  }
+  async get(path) {
+    const fullPath = this.fullPath(path);
+    try {
+      return await readFile(fullPath);
+    } catch {
+      return null;
+    }
+  }
+  async getAsString(path) {
+    const content = await this.get(path);
+    return content ? content.toString("utf-8") : null;
+  }
+  async exists(path) {
+    return existsSync(this.fullPath(path));
+  }
+  async delete(path) {
+    const fullPath = this.fullPath(path);
+    try {
+      await unlink(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async deleteMany(paths) {
+    let deleted = 0;
+    for (const path of paths) {
+      if (await this.delete(path)) {
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  async copy(from, to) {
+    const fromPath = this.fullPath(from);
+    const toPath = this.fullPath(to);
+    await this.ensureDirectory(toPath);
+    await copyFile(fromPath, toPath);
+    return to;
+  }
+  async move(from, to) {
+    const fromPath = this.fullPath(from);
+    const toPath = this.fullPath(to);
+    await this.ensureDirectory(toPath);
+    await rename(fromPath, toPath);
+    return to;
+  }
+  url(path) {
+    return `${this.baseUrl}/${path}`;
+  }
+  async temporaryUrl(path, expiration) {
+    return this.url(path);
+  }
+  async size(path) {
+    const fullPath = this.fullPath(path);
+    const stats = await stat(fullPath);
+    return stats.size;
+  }
+  async lastModified(path) {
+    const fullPath = this.fullPath(path);
+    const stats = await stat(fullPath);
+    return stats.mtime;
+  }
+  async metadata(path) {
+    const fullPath = this.fullPath(path);
+    try {
+      const stats = await stat(fullPath);
+      return {
+        path,
+        size: stats.size,
+        lastModified: stats.mtime,
+        visibility: this.defaultVisibility
+      };
+    } catch {
+      return null;
+    }
+  }
+  async files(directory) {
+    const fullPath = this.fullPath(directory);
+    if (!existsSync(fullPath)) {
+      return [];
+    }
+    const entries = await readdir(fullPath, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile()).map((entry) => join(directory, entry.name));
+  }
+  async directories(directory) {
+    const fullPath = this.fullPath(directory);
+    if (!existsSync(fullPath)) {
+      return [];
+    }
+    const entries = await readdir(fullPath, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => join(directory, entry.name));
+  }
+  async allFiles(directory) {
+    const files = [];
+    const scan = async (dir) => {
+      const fullPath = this.fullPath(dir);
+      if (!existsSync(fullPath)) {
+        return;
+      }
+      const entries = await readdir(fullPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = join(dir, entry.name);
+        if (entry.isFile()) {
+          files.push(entryPath);
+        } else if (entry.isDirectory()) {
+          await scan(entryPath);
+        }
+      }
+    };
+    await scan(directory);
+    return files;
+  }
+  async makeDirectory(path) {
+    const fullPath = this.fullPath(path);
+    await mkdir(fullPath, { recursive: true });
+  }
+  async deleteDirectory(path) {
+    const fullPath = this.fullPath(path);
+    if (existsSync(fullPath)) {
+      await rm(fullPath, { recursive: true, force: true });
+    }
+  }
+  async setVisibility(path, visibility) {
+  }
+  async getVisibility(path) {
+    return this.defaultVisibility;
+  }
+  /**
+   * Get the root directory.
+   */
+  getRoot() {
+    return this.root;
+  }
+};
+
+// src/storage/drivers/S3Driver.ts
+var S3Driver = class {
+  constructor(options) {
+    this.options = options;
+    this.client = options.client;
+    this.bucket = options.bucket;
+    this.region = options.region ?? "us-east-1";
+    this.endpoint = options.endpoint;
+    this.accessKeyId = options.accessKeyId;
+    this.secretAccessKey = options.secretAccessKey;
+    this.prefix = options.prefix ?? "";
+    this.baseUrl = options.url ?? `https://${this.bucket}.s3.${this.region}.amazonaws.com`;
+    this.defaultVisibility = options.visibility ?? "private";
+  }
+  client = null;
+  bucket;
+  region;
+  endpoint;
+  accessKeyId;
+  secretAccessKey;
+  prefix;
+  baseUrl;
+  defaultVisibility;
+  /**
+   * Get or create the S3 client.
+   */
+  async getClient() {
+    if (this.client) {
+      return this.client;
+    }
+    const { S3Client } = await importAwsModule("@aws-sdk/client-s3");
+    const config = {
+      region: this.region
+    };
+    if (this.endpoint) {
+      config.endpoint = this.endpoint;
+      config.forcePathStyle = true;
+    }
+    if (this.accessKeyId && this.secretAccessKey) {
+      config.credentials = {
+        accessKeyId: this.accessKeyId,
+        secretAccessKey: this.secretAccessKey
+      };
+    }
+    this.client = new S3Client(config);
+    return this.client;
+  }
+  /**
+   * Get the prefixed key.
+   */
+  prefixKey(path) {
+    return this.prefix ? `${this.prefix}/${path}` : path;
+  }
+  /**
+   * Get ACL from visibility.
+   */
+  getAcl(visibility) {
+    return visibility === "public" ? "public-read" : "private";
+  }
+  async put(path, content, options) {
+    const client = await this.getClient();
+    const { PutObjectCommand } = await importAwsModule("@aws-sdk/client-s3");
+    const body = typeof content === "string" ? Buffer.from(content) : content;
+    const visibility = options?.visibility ?? this.defaultVisibility;
+    const command = new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: this.prefixKey(path),
+      Body: body,
+      ContentType: options?.contentType,
+      ACL: this.getAcl(visibility),
+      Metadata: options?.metadata
+    });
+    await client.send(command);
+    return path;
+  }
+  async putFile(path, localPath, options) {
+    const { readFile: readFile2 } = await import("fs/promises");
+    const content = await readFile2(localPath);
+    return this.put(path, content, options);
+  }
+  async get(path) {
+    const client = await this.getClient();
+    const { GetObjectCommand } = await importAwsModule("@aws-sdk/client-s3");
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: this.prefixKey(path)
+      });
+      const response = await client.send(command);
+      if (!response.Body) {
+        return null;
+      }
+      const bytes = await response.Body.transformToByteArray();
+      return Buffer.from(bytes);
+    } catch (error) {
+      if (error && typeof error === "object" && "name" in error && error.name === "NoSuchKey") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getAsString(path) {
+    const content = await this.get(path);
+    return content ? content.toString("utf-8") : null;
+  }
+  async exists(path) {
+    const client = await this.getClient();
+    const { HeadObjectCommand } = await importAwsModule("@aws-sdk/client-s3");
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: this.prefixKey(path)
+      });
+      await client.send(command);
+      return true;
+    } catch (error) {
+      if (error && typeof error === "object" && "name" in error && error.name === "NotFound") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async delete(path) {
+    const client = await this.getClient();
+    const { DeleteObjectCommand } = await importAwsModule("@aws-sdk/client-s3");
+    try {
+      const command = new DeleteObjectCommand({
+        Bucket: this.bucket,
+        Key: this.prefixKey(path)
+      });
+      await client.send(command);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async deleteMany(paths) {
+    if (paths.length === 0) {
+      return 0;
+    }
+    const client = await this.getClient();
+    const { DeleteObjectsCommand } = await importAwsModule("@aws-sdk/client-s3");
+    const command = new DeleteObjectsCommand({
+      Bucket: this.bucket,
+      Delete: {
+        Objects: paths.map((path) => ({ Key: this.prefixKey(path) }))
+      }
+    });
+    const response = await client.send(command);
+    return response.Deleted?.length ?? 0;
+  }
+  async copy(from, to) {
+    const client = await this.getClient();
+    const { CopyObjectCommand } = await importAwsModule("@aws-sdk/client-s3");
+    const command = new CopyObjectCommand({
+      Bucket: this.bucket,
+      CopySource: `${this.bucket}/${this.prefixKey(from)}`,
+      Key: this.prefixKey(to)
+    });
+    await client.send(command);
+    return to;
+  }
+  async move(from, to) {
+    await this.copy(from, to);
+    await this.delete(from);
+    return to;
+  }
+  url(path) {
+    return `${this.baseUrl}/${this.prefixKey(path)}`;
+  }
+  async temporaryUrl(path, expiration) {
+    const client = await this.getClient();
+    const { GetObjectCommand } = await importAwsModule("@aws-sdk/client-s3");
+    const { getSignedUrl } = await importAwsModule("@aws-sdk/s3-request-presigner");
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: this.prefixKey(path)
+    });
+    const expiresIn = Math.max(1, Math.floor((expiration.getTime() - Date.now()) / 1e3));
+    return getSignedUrl(client, command, { expiresIn });
+  }
+  async size(path) {
+    const metadata = await this.metadata(path);
+    if (!metadata) {
+      throw new Error(`File not found: ${path}`);
+    }
+    return metadata.size;
+  }
+  async lastModified(path) {
+    const metadata = await this.metadata(path);
+    if (!metadata) {
+      throw new Error(`File not found: ${path}`);
+    }
+    return metadata.lastModified;
+  }
+  async metadata(path) {
+    const client = await this.getClient();
+    const { HeadObjectCommand } = await importAwsModule("@aws-sdk/client-s3");
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: this.prefixKey(path)
+      });
+      const response = await client.send(command);
+      return {
+        path,
+        size: response.ContentLength ?? 0,
+        lastModified: response.LastModified ?? /* @__PURE__ */ new Date(),
+        contentType: response.ContentType,
+        metadata: response.Metadata
+      };
+    } catch (error) {
+      if (error && typeof error === "object" && "name" in error && error.name === "NotFound") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async files(directory) {
+    const client = await this.getClient();
+    const { ListObjectsV2Command } = await importAwsModule("@aws-sdk/client-s3");
+    const prefix = this.prefixKey(directory);
+    const command = new ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix ? `${prefix}/` : "",
+      Delimiter: "/"
+    });
+    const response = await client.send(command);
+    return (response.Contents ?? []).map((item) => item.Key?.replace(this.prefix ? `${this.prefix}/` : "", "") ?? "").filter((key) => key && !key.endsWith("/"));
+  }
+  async directories(directory) {
+    const client = await this.getClient();
+    const { ListObjectsV2Command } = await importAwsModule("@aws-sdk/client-s3");
+    const prefix = this.prefixKey(directory);
+    const command = new ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix ? `${prefix}/` : "",
+      Delimiter: "/"
+    });
+    const response = await client.send(command);
+    return (response.CommonPrefixes ?? []).map(
+      (item) => item.Prefix?.replace(this.prefix ? `${this.prefix}/` : "", "").replace(/\/$/, "") ?? ""
+    ).filter(Boolean);
+  }
+  async allFiles(directory) {
+    const client = await this.getClient();
+    const { ListObjectsV2Command } = await importAwsModule("@aws-sdk/client-s3");
+    const prefix = this.prefixKey(directory);
+    const command = new ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix ? `${prefix}/` : ""
+    });
+    const response = await client.send(command);
+    return (response.Contents ?? []).map((item) => item.Key?.replace(this.prefix ? `${this.prefix}/` : "", "") ?? "").filter((key) => key && !key.endsWith("/"));
+  }
+  async makeDirectory(path) {
+    await this.put(`${path}/.keep`, "");
+  }
+  async deleteDirectory(path) {
+    const files = await this.allFiles(path);
+    if (files.length > 0) {
+      await this.deleteMany(files);
+    }
+  }
+  async setVisibility(path, visibility) {
+    const client = await this.getClient();
+    const { PutObjectAclCommand } = await importAwsModule("@aws-sdk/client-s3");
+    const command = new PutObjectAclCommand({
+      Bucket: this.bucket,
+      Key: this.prefixKey(path),
+      ACL: this.getAcl(visibility)
+    });
+    await client.send(command);
+  }
+  async getVisibility(path) {
+    const client = await this.getClient();
+    const { GetObjectAclCommand } = await importAwsModule("@aws-sdk/client-s3");
+    const command = new GetObjectAclCommand({
+      Bucket: this.bucket,
+      Key: this.prefixKey(path)
+    });
+    const response = await client.send(command);
+    const isPublic = response.Grants?.some(
+      (grant) => grant.Grantee?.URI === "http://acs.amazonaws.com/groups/global/AllUsers" && grant.Permission === "READ"
+    );
+    return isPublic ? "public" : "private";
+  }
+  /**
+   * Get the bucket name.
+   */
+  getBucket() {
+    return this.bucket;
+  }
+  /**
+   * Get the prefix.
+   */
+  getPrefix() {
+    return this.prefix;
+  }
+};
+function isMissingAwsModule(error, moduleName) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  if (code === "ERR_MODULE_NOT_FOUND") return true;
+  const message = String(error.message ?? "");
+  return message.includes(`Cannot find package '${moduleName}'`) || message.includes(`Cannot find module '${moduleName}'`);
+}
+async function importAwsModule(moduleName) {
+  try {
+    return await import(moduleName);
+  } catch (error) {
+    if (isMissingAwsModule(error, moduleName)) {
+      throw new Error(
+        `Missing optional dependency "${moduleName}". Install @aws-sdk/client-s3 and @aws-sdk/s3-request-presigner to use the S3 driver.`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/storage/drivers/MemoryDriver.ts
+var MemoryDriver = class {
+  storage = /* @__PURE__ */ new Map();
+  baseUrl;
+  constructor(options = {}) {
+    this.baseUrl = options.url ?? "memory://";
+  }
+  /**
+   * Normalize path (remove leading/trailing slashes).
+   */
+  normalizePath(path) {
+    return path.replace(/^\/+|\/+$/g, "");
+  }
+  /**
+   * Get directory from path.
+   */
+  getDirectory(path) {
+    const parts = path.split("/");
+    return parts.slice(0, -1).join("/");
+  }
+  /**
+   * Check if a path is in a directory.
+   */
+  isInDirectory(filePath, directory) {
+    const normalized = this.normalizePath(filePath);
+    const normalizedDir = this.normalizePath(directory);
+    if (!normalizedDir) {
+      return !normalized.includes("/");
+    }
+    return normalized.startsWith(normalizedDir + "/") && !normalized.slice(normalizedDir.length + 1).includes("/");
+  }
+  /**
+   * Check if a path is under a directory (recursive).
+   */
+  isUnderDirectory(filePath, directory) {
+    const normalized = this.normalizePath(filePath);
+    const normalizedDir = this.normalizePath(directory);
+    if (!normalizedDir) {
+      return true;
+    }
+    return normalized.startsWith(normalizedDir + "/");
+  }
+  async put(path, content, options) {
+    const normalized = this.normalizePath(path);
+    const buffer = typeof content === "string" ? Buffer.from(content) : content;
+    this.storage.set(normalized, {
+      content: buffer,
+      contentType: options?.contentType,
+      visibility: options?.visibility ?? "private",
+      metadata: options?.metadata,
+      lastModified: /* @__PURE__ */ new Date()
+    });
+    return normalized;
+  }
+  async putFile(path, localPath, options) {
+    throw new Error("putFile is not supported in MemoryDriver");
+  }
+  async get(path) {
+    const normalized = this.normalizePath(path);
+    const file = this.storage.get(normalized);
+    return file?.content ?? null;
+  }
+  async getAsString(path) {
+    const content = await this.get(path);
+    return content ? content.toString("utf-8") : null;
+  }
+  async exists(path) {
+    const normalized = this.normalizePath(path);
+    return this.storage.has(normalized);
+  }
+  async delete(path) {
+    const normalized = this.normalizePath(path);
+    return this.storage.delete(normalized);
+  }
+  async deleteMany(paths) {
+    let deleted = 0;
+    for (const path of paths) {
+      if (await this.delete(path)) {
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  async copy(from, to) {
+    const normalizedFrom = this.normalizePath(from);
+    const normalizedTo = this.normalizePath(to);
+    const file = this.storage.get(normalizedFrom);
+    if (!file) {
+      throw new Error(`File not found: ${from}`);
+    }
+    this.storage.set(normalizedTo, {
+      ...file,
+      content: Buffer.from(file.content),
+      lastModified: /* @__PURE__ */ new Date()
+    });
+    return normalizedTo;
+  }
+  async move(from, to) {
+    await this.copy(from, to);
+    await this.delete(from);
+    return this.normalizePath(to);
+  }
+  url(path) {
+    const normalized = this.normalizePath(path);
+    return `${this.baseUrl}/${normalized}`;
+  }
+  async temporaryUrl(path, expiration) {
+    return this.url(path);
+  }
+  async size(path) {
+    const normalized = this.normalizePath(path);
+    const file = this.storage.get(normalized);
+    if (!file) {
+      throw new Error(`File not found: ${path}`);
+    }
+    return file.content.length;
+  }
+  async lastModified(path) {
+    const normalized = this.normalizePath(path);
+    const file = this.storage.get(normalized);
+    if (!file) {
+      throw new Error(`File not found: ${path}`);
+    }
+    return file.lastModified;
+  }
+  async metadata(path) {
+    const normalized = this.normalizePath(path);
+    const file = this.storage.get(normalized);
+    if (!file) {
+      return null;
+    }
+    return {
+      path: normalized,
+      size: file.content.length,
+      lastModified: file.lastModified,
+      contentType: file.contentType,
+      visibility: file.visibility,
+      metadata: file.metadata
+    };
+  }
+  async files(directory) {
+    const normalized = this.normalizePath(directory);
+    const result = [];
+    for (const path of this.storage.keys()) {
+      if (this.isInDirectory(path, normalized)) {
+        result.push(path);
+      }
+    }
+    return result.sort();
+  }
+  async directories(directory) {
+    const normalized = this.normalizePath(directory);
+    const dirs = /* @__PURE__ */ new Set();
+    for (const path of this.storage.keys()) {
+      if (this.isUnderDirectory(path, normalized)) {
+        const relativePath = normalized ? path.slice(normalized.length + 1) : path;
+        const firstDir = relativePath.split("/")[0];
+        if (relativePath.includes("/")) {
+          dirs.add(normalized ? `${normalized}/${firstDir}` : firstDir);
+        }
+      }
+    }
+    return Array.from(dirs).sort();
+  }
+  async allFiles(directory) {
+    const normalized = this.normalizePath(directory);
+    const result = [];
+    for (const path of this.storage.keys()) {
+      if (this.isUnderDirectory(path, normalized)) {
+        result.push(path);
+      }
+    }
+    return result.sort();
+  }
+  async makeDirectory(path) {
+  }
+  async deleteDirectory(path) {
+    const normalized = this.normalizePath(path);
+    const keysToDelete = [];
+    for (const key of this.storage.keys()) {
+      if (this.isUnderDirectory(key, normalized)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      this.storage.delete(key);
+    }
+  }
+  async setVisibility(path, visibility) {
+    const normalized = this.normalizePath(path);
+    const file = this.storage.get(normalized);
+    if (!file) {
+      throw new Error(`File not found: ${path}`);
+    }
+    file.visibility = visibility;
+  }
+  async getVisibility(path) {
+    const normalized = this.normalizePath(path);
+    const file = this.storage.get(normalized);
+    if (!file) {
+      throw new Error(`File not found: ${path}`);
+    }
+    return file.visibility;
+  }
+  /**
+   * Clear all files (for testing).
+   */
+  clear() {
+    this.storage.clear();
+  }
+  /**
+   * Get the number of stored files.
+   */
+  count() {
+    return this.storage.size;
+  }
+  /**
+   * Get all stored file paths.
+   */
+  getAllPaths() {
+    return Array.from(this.storage.keys());
+  }
+};
+
+// src/storage/StorageManager.ts
+var StorageManager = class {
+  defaultDiskName;
+  diskFactories = /* @__PURE__ */ new Map();
+  resolvedDisks = /* @__PURE__ */ new Map();
+  driverFactories = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.defaultDiskName = config.default ?? "local";
+    this.registerBuiltinDrivers();
+    if (config.disks) {
+      for (const [name, diskConfig] of Object.entries(config.disks)) {
+        this.registerDiskFromConfig(name, diskConfig);
+      }
+    }
+    if (!this.diskFactories.has(this.defaultDiskName) && this.defaultDiskName === "local") {
+      this.diskFactories.set("local", () => new LocalDriver({ root: "./storage" }));
+    }
+  }
+  /**
+   * Register built-in disk drivers.
+   */
+  registerBuiltinDrivers() {
+    this.driverFactories.set("local", (options) => {
+      return new LocalDriver(options);
+    });
+    this.driverFactories.set("s3", (options) => {
+      return new S3Driver(options);
+    });
+    this.driverFactories.set("memory", (options) => {
+      return new MemoryDriver(options);
+    });
+  }
+  /**
+   * Register a disk from configuration.
+   */
+  registerDiskFromConfig(name, config) {
+    const { driver, ...options } = config;
+    const factory = this.driverFactories.get(driver);
+    if (!factory) {
+      throw new Error(`Unknown storage driver: ${driver}`);
+    }
+    this.diskFactories.set(name, () => factory(options));
+  }
+  /**
+   * Get a storage disk by name.
+   * Returns the default disk if no name is specified.
+   */
+  disk(name) {
+    const diskName = name ?? this.defaultDiskName;
+    const cached = this.resolvedDisks.get(diskName);
+    if (cached) {
+      return cached;
+    }
+    const factory = this.diskFactories.get(diskName);
+    if (!factory) {
+      throw new Error(`Storage disk not found: ${diskName}`);
+    }
+    const disk = factory();
+    this.resolvedDisks.set(diskName, disk);
+    return disk;
+  }
+  /**
+   * Register a custom disk factory.
+   */
+  registerDisk(name, factory) {
+    this.diskFactories.set(name, factory);
+    this.resolvedDisks.delete(name);
+  }
+  /**
+   * Register a custom driver.
+   */
+  registerDriver(name, factory) {
+    this.driverFactories.set(name, factory);
+  }
+  /**
+   * Check if a disk is registered.
+   */
+  hasDisk(name) {
+    return this.diskFactories.has(name);
+  }
+  /**
+   * Get the default disk name.
+   */
+  getDefaultDiskName() {
+    return this.defaultDiskName;
+  }
+  /**
+   * Get all registered disk names.
+   */
+  getDiskNames() {
+    return Array.from(this.diskFactories.keys());
+  }
+};
+function createStorageManager(config) {
+  return new StorageManager(config);
+}
+export {
+  LocalDriver,
+  MemoryDriver,
+  S3Driver,
+  StorageManager,
+  createStorageManager
+};