@withvlibe/storage-sdk 1.0.0 → 1.1.0

package/dist/react.js

@@ -0,0 +1,668 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  VlibeStorage: () => VlibeStorage,
+  useStorage: () => useStorage,
+  useStorageUsage: () => useStorageUsage
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/VlibeStorage.ts
+var DEFAULT_BASE_URL = "https://vlibe.app";
+var VlibeStorage = class {
+  constructor(config) {
+    this.authToken = null;
+    this.storageConfig = null;
+    this.appId = config.appId;
+    this.appSecret = config.appSecret;
+    this.baseUrl = config.baseUrl?.replace(/\/$/, "") || DEFAULT_BASE_URL;
+  }
+  /**
+   * Set the user's auth token (required for authenticated requests)
+   */
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  /**
+   * Clear the auth token
+   */
+  clearAuthToken() {
+    this.authToken = null;
+  }
+  /**
+   * Get storage configuration from the server
+   * This fetches the current storage provider and public URL base
+   */
+  async getStorageConfig() {
+    if (this.storageConfig) {
+      return this.storageConfig;
+    }
+    try {
+      const response = await this.request("/storage/config");
+      if (response.success && response.data) {
+        this.storageConfig = response.data;
+        return response.data;
+      }
+    } catch {
+    }
+    return {
+      provider: "wasabi",
+      publicUrlBase: "https://s3.eu-central-2.wasabisys.com/vlibe.com"
+    };
+  }
+  /**
+   * Clear cached storage config (call if config might have changed)
+   */
+  clearStorageConfigCache() {
+    this.storageConfig = null;
+  }
+  /**
+   * Make an authenticated API request
+   */
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}/api${path}`;
+    const headers = {
+      "X-App-Id": this.appId,
+      "X-App-Secret": this.appSecret,
+      ...options.headers || {}
+    };
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    const data = await response.json();
+    if (!response.ok && !data.error) {
+      return {
+        success: false,
+        error: `HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    return data;
+  }
+  // ============================================
+  // UPLOAD METHODS
+  // ============================================
+  /**
+   * Upload a file directly
+   */
+  async upload(file, options = {}) {
+    const formData = new FormData();
+    formData.append("file", file);
+    if (options.folder) {
+      formData.append("folder", options.folder);
+    }
+    if (options.isPublic) {
+      formData.append("isPublic", "true");
+    }
+    const response = await this.request("/storage", {
+      method: "POST",
+      body: formData
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Upload failed");
+    }
+    return response.data;
+  }
+  /**
+   * Get a presigned URL for direct upload to storage
+   * Useful for large files or when you want upload progress
+   */
+  async getUploadUrl(filename, mimeType, size, options = {}) {
+    const response = await this.request("/storage/upload-url", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        filename,
+        mimeType,
+        size,
+        folder: options.folder,
+        isPublic: options.isPublic
+      })
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to get upload URL");
+    }
+    return response.data;
+  }
+  /**
+   * Upload a file using presigned URL (for progress tracking)
+   */
+  async uploadWithProgress(file, options = {}) {
+    const { uploadUrl, key, expiresIn } = await this.getUploadUrl(
+      file.name,
+      file.type,
+      file.size,
+      options
+    );
+    await new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      if (options.onProgress) {
+        xhr.upload.addEventListener("progress", (e) => {
+          if (e.lengthComputable) {
+            const percent = Math.round(e.loaded / e.total * 100);
+            options.onProgress(percent);
+          }
+        });
+      }
+      xhr.addEventListener("load", () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve();
+        } else {
+          reject(new Error(`Upload failed with status ${xhr.status}`));
+        }
+      });
+      xhr.addEventListener("error", () => {
+        reject(new Error("Upload failed"));
+      });
+      xhr.open("PUT", uploadUrl);
+      xhr.setRequestHeader("Content-Type", file.type);
+      xhr.send(file);
+    });
+    const response = await this.request("/storage/upload-url", {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        key,
+        filename: file.name,
+        mimeType: file.type,
+        size: file.size,
+        folder: options.folder,
+        isPublic: options.isPublic
+      })
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to confirm upload");
+    }
+    return response.data;
+  }
+  // ============================================
+  // DOWNLOAD METHODS
+  // ============================================
+  /**
+   * Get a signed download URL for a file
+   */
+  async getDownloadUrl(fileId, expiresIn) {
+    const params = new URLSearchParams({ download: "true" });
+    if (expiresIn) {
+      params.set("expiresIn", expiresIn.toString());
+    }
+    const response = await this.request(
+      `/storage/${fileId}?${params}`
+    );
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to get download URL");
+    }
+    return response.data.url;
+  }
+  /**
+   * Get a public URL for a file (only works for public files in the public path)
+   * Returns the direct URL based on the configured storage provider
+   *
+   * Note: This is a sync method that uses cached config. Call getStorageConfig()
+   * first to ensure the config is loaded, or use getPublicUrlAsync() for a
+   * guaranteed fresh URL.
+   */
+  getPublicUrl(key) {
+    if (this.storageConfig) {
+      const base = this.storageConfig.publicUrlBase.replace(/\/$/, "");
+      return `${base}/${key}`;
+    }
+    const region = "eu-central-2";
+    const bucket = "vlibe.com";
+    return `https://s3.${region}.wasabisys.com/${bucket}/${key}`;
+  }
+  /**
+   * Get a public URL for a file (async version that ensures fresh config)
+   * Returns the direct URL based on the configured storage provider
+   */
+  async getPublicUrlAsync(key) {
+    const config = await this.getStorageConfig();
+    const base = config.publicUrlBase.replace(/\/$/, "");
+    return `${base}/${key}`;
+  }
+  /**
+   * Check if a storage key is in the public path
+   */
+  isPublicKey(key) {
+    return key.startsWith("vlibe-storage/public/");
+  }
+  // ============================================
+  // FILE MANAGEMENT
+  // ============================================
+  /**
+   * List files
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.folder !== void 0) {
+      params.set("folder", options.folder);
+    }
+    if (options.limit) {
+      params.set("limit", options.limit.toString());
+    }
+    if (options.offset) {
+      params.set("offset", options.offset.toString());
+    }
+    const response = await this.request(
+      `/storage?${params}`
+    );
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to list files");
+    }
+    return response.data;
+  }
+  /**
+   * Get a single file's metadata
+   */
+  async get(fileId) {
+    const response = await this.request(`/storage/${fileId}`);
+    if (!response.success) {
+      if (response.error?.includes("not found")) {
+        return null;
+      }
+      throw new Error(response.error || "Failed to get file");
+    }
+    return response.data || null;
+  }
+  /**
+   * Delete a file
+   */
+  async delete(fileId) {
+    const response = await this.request(`/storage/${fileId}`, {
+      method: "DELETE"
+    });
+    if (!response.success) {
+      if (response.error?.includes("not found")) {
+        return false;
+      }
+      throw new Error(response.error || "Failed to delete file");
+    }
+    return true;
+  }
+  /**
+   * Delete multiple files
+   */
+  async deleteMany(fileIds) {
+    const deleted = [];
+    const failed = [];
+    const batchSize = 10;
+    for (let i = 0; i < fileIds.length; i += batchSize) {
+      const batch = fileIds.slice(i, i + batchSize);
+      const results = await Promise.allSettled(
+        batch.map((id) => this.delete(id))
+      );
+      results.forEach((result, index) => {
+        const id = batch[index];
+        if (result.status === "fulfilled" && result.value) {
+          deleted.push(id);
+        } else {
+          failed.push(id);
+        }
+      });
+    }
+    return { deleted, failed };
+  }
+  // ============================================
+  // USAGE & LIMITS
+  // ============================================
+  /**
+   * Get storage usage statistics
+   */
+  async getUsage() {
+    const response = await this.request("/storage/usage");
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to get usage");
+    }
+    return response.data;
+  }
+  /**
+   * Check if a file of given size can be uploaded
+   */
+  async canUpload(size) {
+    const response = await this.request("/storage/usage", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ size })
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to check upload");
+    }
+    return response.data;
+  }
+  // ============================================
+  // FOLDER MANAGEMENT
+  // ============================================
+  /**
+   * List folders
+   */
+  async listFolders(options = {}) {
+    const params = new URLSearchParams();
+    if (options.parentId !== void 0) {
+      params.set("parentId", options.parentId === null ? "null" : options.parentId);
+    }
+    if (options.projectId) {
+      params.set("projectId", options.projectId);
+    }
+    const response = await this.request(`/storage/folders?${params}`);
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to list folders");
+    }
+    return response.data;
+  }
+  /**
+   * Create a folder
+   */
+  async createFolder(name, options = {}) {
+    const response = await this.request("/storage/folders", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        name,
+        parentId: options.parentId,
+        projectId: options.projectId,
+        isProjectRoot: options.isProjectRoot
+      })
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to create folder");
+    }
+    return response.data;
+  }
+  /**
+   * Rename a folder
+   */
+  async renameFolder(folderId, name) {
+    const response = await this.request(`/storage/folders/${folderId}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ name })
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to rename folder");
+    }
+    return response.data;
+  }
+  /**
+   * Delete a folder (must be empty)
+   */
+  async deleteFolder(folderId) {
+    const response = await this.request(`/storage/folders/${folderId}`, {
+      method: "DELETE"
+    });
+    if (!response.success) {
+      if (response.error?.includes("not found")) {
+        return false;
+      }
+      throw new Error(response.error || "Failed to delete folder");
+    }
+    return true;
+  }
+  // ============================================
+  // FILE COPY & REFERENCE
+  // ============================================
+  /**
+   * Copy a file to another project
+   * Creates a new database record pointing to the same S3 object
+   */
+  async copyFileToProject(fileId, targetProjectId) {
+    const response = await this.request("/storage/files/copy", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ fileId, targetProjectId })
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to copy file");
+    }
+    return response.data;
+  }
+  /**
+   * Create a file reference (link file to another project without copying)
+   * Does not count against storage quota
+   */
+  async createFileReference(fileId, targetProjectId) {
+    const response = await this.request("/storage/files/reference", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ fileId, targetProjectId })
+    });
+    if (!response.success || !response.data) {
+      throw new Error(response.error || "Failed to create file reference");
+    }
+    return response.data;
+  }
+};
+
+// src/hooks/useStorage.ts
+var import_react = require("react");
+function useStorage(client, options = {}) {
+  const { folder, autoFetch = true, limit = 50 } = options;
+  const [files, setFiles] = (0, import_react.useState)([]);
+  const [total, setTotal] = (0, import_react.useState)(0);
+  const [loading, setLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [uploading, setUploading] = (0, import_react.useState)(false);
+  const [uploadProgress, setUploadProgress] = (0, import_react.useState)(0);
+  const [hasMore, setHasMore] = (0, import_react.useState)(false);
+  const offsetRef = (0, import_react.useRef)(0);
+  const fetchFiles = (0, import_react.useCallback)(
+    async (append = false) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const listOptions = {
+          folder,
+          limit,
+          offset: append ? offsetRef.current : 0
+        };
+        const result = await client.list(listOptions);
+        if (append) {
+          setFiles((prev) => [...prev, ...result.files]);
+        } else {
+          setFiles(result.files);
+          offsetRef.current = 0;
+        }
+        setTotal(result.total);
+        setHasMore(result.hasMore);
+        offsetRef.current = (append ? offsetRef.current : 0) + result.files.length;
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to fetch files");
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client, folder, limit]
+  );
+  (0, import_react.useEffect)(() => {
+    if (autoFetch) {
+      fetchFiles();
+    }
+  }, [autoFetch, fetchFiles]);
+  const upload = (0, import_react.useCallback)(
+    async (file, uploadOptions = {}) => {
+      setUploading(true);
+      setUploadProgress(0);
+      setError(null);
+      try {
+        const result = await client.upload(file, {
+          ...uploadOptions,
+          folder: uploadOptions.folder ?? folder
+        });
+        await fetchFiles();
+        return result;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Upload failed";
+        setError(message);
+        throw err;
+      } finally {
+        setUploading(false);
+        setUploadProgress(0);
+      }
+    },
+    [client, folder, fetchFiles]
+  );
+  const uploadWithProgress = (0, import_react.useCallback)(
+    async (file, uploadOptions = {}) => {
+      setUploading(true);
+      setUploadProgress(0);
+      setError(null);
+      try {
+        const result = await client.uploadWithProgress(file, {
+          ...uploadOptions,
+          folder: uploadOptions.folder ?? folder,
+          onProgress: (progress) => {
+            setUploadProgress(progress);
+            uploadOptions.onProgress?.(progress);
+          }
+        });
+        await fetchFiles();
+        return result;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Upload failed";
+        setError(message);
+        throw err;
+      } finally {
+        setUploading(false);
+        setUploadProgress(0);
+      }
+    },
+    [client, folder, fetchFiles]
+  );
+  const remove = (0, import_react.useCallback)(
+    async (fileId) => {
+      setError(null);
+      try {
+        const deleted = await client.delete(fileId);
+        if (deleted) {
+          setFiles((prev) => prev.filter((f) => f.id !== fileId));
+          setTotal((prev) => prev - 1);
+        }
+        return deleted;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Delete failed";
+        setError(message);
+        throw err;
+      }
+    },
+    [client]
+  );
+  const refresh = (0, import_react.useCallback)(async () => {
+    await fetchFiles(false);
+  }, [fetchFiles]);
+  const loadMore = (0, import_react.useCallback)(async () => {
+    if (hasMore && !loading) {
+      await fetchFiles(true);
+    }
+  }, [hasMore, loading, fetchFiles]);
+  return {
+    files,
+    total,
+    loading,
+    error,
+    upload,
+    uploadWithProgress,
+    uploadProgress,
+    uploading,
+    remove,
+    refresh,
+    loadMore,
+    hasMore
+  };
+}
+
+// src/hooks/useStorageUsage.ts
+var import_react2 = require("react");
+function useStorageUsage(client, options = {}) {
+  const { autoFetch = true, refreshInterval = 0 } = options;
+  const [usage, setUsage] = (0, import_react2.useState)(null);
+  const [loading, setLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const fetchUsage = (0, import_react2.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const stats = await client.getUsage();
+      setUsage(stats);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch usage");
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react2.useEffect)(() => {
+    if (autoFetch) {
+      fetchUsage();
+    }
+  }, [autoFetch, fetchUsage]);
+  (0, import_react2.useEffect)(() => {
+    if (refreshInterval > 0) {
+      const interval = setInterval(fetchUsage, refreshInterval);
+      return () => clearInterval(interval);
+    }
+  }, [refreshInterval, fetchUsage]);
+  const canUpload = (0, import_react2.useCallback)(
+    (size) => {
+      if (!usage) return true;
+      if (usage.storageLimit === 0) return true;
+      return usage.bytesUsed + size <= usage.storageLimit;
+    },
+    [usage]
+  );
+  const usagePercent = usage?.usagePercent ?? 0;
+  const isLimitReached = usagePercent >= 100;
+  const isNearLimit = usagePercent >= 80;
+  const usageFormatted = usage ? `${usage.bytesUsedFormatted} of ${usage.storageLimitFormatted}` : "Loading...";
+  return {
+    usage,
+    loading,
+    error,
+    canUpload,
+    refresh: fetchUsage,
+    usagePercent,
+    usageFormatted,
+    isLimitReached,
+    isNearLimit
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VlibeStorage,
+  useStorage,
+  useStorageUsage
+});
+//# sourceMappingURL=react.js.map