@pelatform/storage 1.0.0

package/dist/cloudinary.js

@@ -0,0 +1,496 @@
+import {
+  loadCloudinaryConfig
+} from "./chunk-ZTZZCC52.js";
+
+// src/providers/cloudinary.ts
+import { v2 as cloudinary } from "cloudinary";
+var CloudinaryProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+    cloudinary.config({
+      cloud_name: config.cloudName,
+      api_key: config.apiKey,
+      api_secret: config.apiSecret,
+      secure: config.secure !== false
+    });
+  }
+  // File operations
+  async upload(options) {
+    try {
+      let fileData;
+      if (typeof options.file === "string") {
+        fileData = options.file;
+      } else {
+        fileData = `data:${options.contentType || "application/octet-stream"};base64,${Buffer.from(options.file).toString("base64")}`;
+      }
+      let resourceType = "raw";
+      if (options.contentType?.startsWith("image/")) {
+        resourceType = "image";
+      } else if (options.contentType?.startsWith("video/")) {
+        resourceType = "video";
+      }
+      const keyParts = options.key.split("/");
+      let folder = "";
+      let publicId = options.key;
+      if (keyParts.length > 1) {
+        folder = keyParts.slice(0, -1).join("/");
+        publicId = keyParts[keyParts.length - 1];
+      }
+      const uploadOptions = {
+        public_id: publicId,
+        resource_type: resourceType,
+        overwrite: true,
+        invalidate: true,
+        ...options.metadata
+      };
+      if (folder) {
+        uploadOptions.folder = folder;
+      }
+      const result = await cloudinary.uploader.upload(fileData, uploadOptions);
+      const publicUrl = this.getPublicUrl(result.public_id);
+      return {
+        success: true,
+        key: result.public_id,
+        url: result.secure_url,
+        publicUrl,
+        etag: result.etag,
+        size: result.bytes
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Upload failed"
+      };
+    }
+  }
+  async download(options) {
+    try {
+      const publicUrl = this.getPublicUrl(options.key);
+      const response = await fetch(publicUrl);
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `Failed to download: ${response.status} ${response.statusText}`
+        };
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const content = Buffer.from(arrayBuffer);
+      return {
+        success: true,
+        content,
+        // Main content field
+        data: content,
+        // Alias for backward compatibility
+        contentType: response.headers.get("content-type") || void 0,
+        contentLength: content.length,
+        lastModified: response.headers.get("last-modified") ? new Date(response.headers.get("last-modified")) : /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Download failed"
+      };
+    }
+  }
+  async delete(options) {
+    try {
+      const keyParts = options.key.split("/");
+      let publicId = options.key;
+      if (keyParts.length > 1) {
+        const folder = keyParts.slice(0, -1).join("/");
+        const filename = keyParts[keyParts.length - 1];
+        publicId = `${folder}/${filename}`;
+      }
+      let resourceType = "raw";
+      try {
+        await cloudinary.api.resource(publicId, { resource_type: "image" });
+        resourceType = "image";
+      } catch {
+        try {
+          await cloudinary.api.resource(publicId, { resource_type: "video" });
+          resourceType = "video";
+        } catch {
+          resourceType = "raw";
+        }
+      }
+      await cloudinary.uploader.destroy(publicId, {
+        resource_type: resourceType,
+        invalidate: true
+      });
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Delete failed"
+      };
+    }
+  }
+  async batchDelete(options) {
+    try {
+      return {
+        success: false,
+        errors: options.keys.map((key) => ({
+          key,
+          error: "Cloudinary batch delete not implemented yet"
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errors: options.keys.map((key) => ({
+          key,
+          error: error instanceof Error ? error.message : "Batch delete failed"
+        }))
+      };
+    }
+  }
+  async list(options = {}) {
+    try {
+      const prefix = options.prefix || "";
+      const maxResults = options.maxKeys || 50;
+      const [images, videos, rawFiles] = await Promise.all([
+        cloudinary.api.resources({
+          type: "upload",
+          resource_type: "image",
+          prefix,
+          max_results: maxResults,
+          next_cursor: options.continuationToken
+        }).catch(() => ({ resources: [], next_cursor: void 0 })),
+        cloudinary.api.resources({
+          type: "upload",
+          resource_type: "video",
+          prefix,
+          max_results: maxResults,
+          next_cursor: options.continuationToken
+        }).catch(() => ({ resources: [], next_cursor: void 0 })),
+        cloudinary.api.resources({
+          type: "upload",
+          resource_type: "raw",
+          prefix,
+          max_results: maxResults,
+          next_cursor: options.continuationToken
+        }).catch(() => ({ resources: [], next_cursor: void 0 }))
+      ]);
+      const allResources = [
+        ...images.resources || [],
+        ...videos.resources || [],
+        ...rawFiles.resources || []
+      ];
+      const files = allResources.map((resource) => ({
+        key: String(resource.public_id || ""),
+        size: Number(resource.bytes) || 0,
+        lastModified: new Date(String(resource.created_at || /* @__PURE__ */ new Date())),
+        etag: String(resource.etag || ""),
+        contentType: resource.format ? `${resource.resource_type}/${resource.format}` : "application/octet-stream"
+      }));
+      return {
+        success: true,
+        files,
+        isTruncated: !!(images.next_cursor || videos.next_cursor || rawFiles.next_cursor),
+        nextContinuationToken: images.next_cursor || videos.next_cursor || rawFiles.next_cursor
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "List failed"
+      };
+    }
+  }
+  async exists(_key) {
+    try {
+      return {
+        exists: false,
+        error: "Cloudinary exists check not implemented yet"
+      };
+    } catch (error) {
+      return {
+        exists: false,
+        error: error instanceof Error ? error.message : "Check existence failed"
+      };
+    }
+  }
+  async copy(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary copy not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Copy failed"
+      };
+    }
+  }
+  async move(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary move not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Move failed"
+      };
+    }
+  }
+  async duplicate(options) {
+    return this.copy(options);
+  }
+  async getPresignedUrl(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary presigned URL not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Presigned URL generation failed"
+      };
+    }
+  }
+  getPublicUrl(key) {
+    const protocol = this.config.secure !== false ? "https" : "http";
+    const baseUrl = `${protocol}://res.cloudinary.com/${this.config.cloudName}`;
+    const publicId = key;
+    return `${baseUrl}/image/upload/${publicId}`;
+  }
+  // Folder operations
+  async createFolder(options) {
+    try {
+      return {
+        success: true,
+        path: options.path
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Create folder failed"
+      };
+    }
+  }
+  async deleteFolder(options) {
+    try {
+      const folderPath = options.path.endsWith("/") ? options.path.slice(0, -1) : options.path;
+      if (options.recursive) {
+        await cloudinary.api.delete_resources_by_prefix(folderPath);
+      }
+      await cloudinary.api.delete_folder(folderPath);
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Delete folder failed"
+      };
+    }
+  }
+  async listFolders(_options) {
+    try {
+      const result = await cloudinary.api.root_folders();
+      const folders = (result.folders || []).map((folder) => ({
+        name: folder.name,
+        path: folder.path
+      }));
+      return {
+        success: true,
+        folders,
+        isTruncated: false,
+        nextContinuationToken: void 0
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "List folders failed"
+      };
+    }
+  }
+  async folderExists(_path) {
+    try {
+      return {
+        exists: false,
+        error: "Cloudinary folder exists check not implemented yet"
+      };
+    } catch (error) {
+      return {
+        exists: false,
+        error: error instanceof Error ? error.message : "Check folder existence failed"
+      };
+    }
+  }
+  async renameFolder(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary rename folder not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Rename folder failed"
+      };
+    }
+  }
+  async copyFolder(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary copy folder not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Copy folder failed"
+      };
+    }
+  }
+};
+
+// src/services/cloudinary.ts
+var CloudinaryService = class {
+  provider;
+  config;
+  constructor(config) {
+    this.config = config || loadCloudinaryConfig();
+    this.provider = new CloudinaryProvider(this.config);
+  }
+  // Utility methods
+  getConfig() {
+    return { ...this.config };
+  }
+  getProvider() {
+    return this.config.provider;
+  }
+  getPublicUrl(key) {
+    return this.provider.getPublicUrl(key);
+  }
+  // File operations
+  async upload(options) {
+    return this.provider.upload(options);
+  }
+  async download(options) {
+    return this.provider.download(options);
+  }
+  async delete(options) {
+    return this.provider.delete(options);
+  }
+  async batchDelete(options) {
+    return this.provider.batchDelete(options);
+  }
+  async list(options) {
+    return this.provider.list(options);
+  }
+  async exists(key) {
+    return this.provider.exists(key);
+  }
+  async copy(options) {
+    return this.provider.copy(options);
+  }
+  async move(options) {
+    return this.provider.move(options);
+  }
+  async duplicate(options) {
+    return this.provider.duplicate(options);
+  }
+  async getPresignedUrl(options) {
+    return this.provider.getPresignedUrl(options);
+  }
+  // Folder operations
+  async createFolder(options) {
+    return this.provider.createFolder(options);
+  }
+  async deleteFolder(options) {
+    return this.provider.deleteFolder(options);
+  }
+  async listFolders(options) {
+    return this.provider.listFolders(options);
+  }
+  async folderExists(path) {
+    return this.provider.folderExists(path);
+  }
+  async renameFolder(options) {
+    return this.provider.renameFolder(options);
+  }
+  async copyFolder(options) {
+    return this.provider.copyFolder(options);
+  }
+  // Convenience methods
+  async uploadFile(key, file, contentType, metadata) {
+    return this.upload({ key, file, contentType, metadata });
+  }
+  async downloadFile(key) {
+    return this.download({ key });
+  }
+  async deleteFile(key) {
+    return this.delete({ key });
+  }
+  async deleteFiles(keys) {
+    return this.batchDelete({ keys });
+  }
+  async fileExists(key) {
+    const result = await this.exists(key);
+    return result.exists;
+  }
+  async copyFile(sourceKey, destinationKey, metadata) {
+    return this.copy({ sourceKey, destinationKey, metadata });
+  }
+  async moveFile(sourceKey, destinationKey, metadata) {
+    return this.move({ sourceKey, destinationKey, metadata });
+  }
+  async duplicateFile(sourceKey, destinationKey, metadata) {
+    return this.duplicate({ sourceKey, destinationKey, metadata });
+  }
+  async renameFile(sourceKey, destinationKey, metadata) {
+    return this.moveFile(sourceKey, destinationKey, metadata);
+  }
+  async listFiles(prefix, maxKeys) {
+    return this.list({ prefix, maxKeys });
+  }
+  async getDownloadUrl(key, expiresIn) {
+    return this.getPresignedUrl({ key, operation: "get", expiresIn });
+  }
+  async getUploadUrl(key, contentType, expiresIn) {
+    return this.getPresignedUrl({
+      key,
+      operation: "put",
+      contentType,
+      expiresIn
+    });
+  }
+  // Folder convenience methods
+  async createFolderPath(path) {
+    return this.createFolder({ path });
+  }
+  async deleteFolderPath(path, recursive = false) {
+    return this.deleteFolder({ path, recursive });
+  }
+  async folderPathExists(path) {
+    const result = await this.folderExists(path);
+    return result.exists;
+  }
+  async renameFolderPath(oldPath, newPath) {
+    return this.renameFolder({ oldPath, newPath });
+  }
+  async copyFolderPath(sourcePath, destinationPath, recursive = true) {
+    return this.copyFolder({ sourcePath, destinationPath, recursive });
+  }
+};
+
+// src/cloudinary.ts
+function createCloudinary(config) {
+  if (config) {
+    return new CloudinaryService(config);
+  }
+  const envConfig = loadCloudinaryConfig();
+  return new CloudinaryService(envConfig);
+}
+export {
+  CloudinaryService,
+  createCloudinary
+};

package/dist/helpers.cjs

@@ -0,0 +1,68 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkGV7GMZP2cjs = require('./chunk-GV7GMZP2.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.base64ToBuffer = _chunkGV7GMZP2cjs.base64ToBuffer; exports.bufferToBase64 = _chunkGV7GMZP2cjs.bufferToBase64; exports.buildPublicUrl = _chunkGV7GMZP2cjs.buildPublicUrl; exports.detectFileTypeFromContent = _chunkGV7GMZP2cjs.detectFileTypeFromContent; exports.extractS3Info = _chunkGV7GMZP2cjs.extractS3Info; exports.fileToBuffer = _chunkGV7GMZP2cjs.fileToBuffer; exports.formatFileSize = _chunkGV7GMZP2cjs.formatFileSize; exports.generateBatchKeys = _chunkGV7GMZP2cjs.generateBatchKeys; exports.generateCacheControl = _chunkGV7GMZP2cjs.generateCacheControl; exports.generateFileHash = _chunkGV7GMZP2cjs.generateFileHash; exports.generateFileKey = _chunkGV7GMZP2cjs.generateFileKey; exports.generateUniqueKey = _chunkGV7GMZP2cjs.generateUniqueKey; exports.getContentDisposition = _chunkGV7GMZP2cjs.getContentDisposition; exports.getFileExtension = _chunkGV7GMZP2cjs.getFileExtension; exports.getFileInfo = _chunkGV7GMZP2cjs.getFileInfo; exports.getFileName = _chunkGV7GMZP2cjs.getFileName; exports.getMimeType = _chunkGV7GMZP2cjs.getMimeType; exports.getParentPath = _chunkGV7GMZP2cjs.getParentPath; exports.isAudioFile = _chunkGV7GMZP2cjs.isAudioFile; exports.isDocumentFile = _chunkGV7GMZP2cjs.isDocumentFile; exports.isImageFile = _chunkGV7GMZP2cjs.isImageFile; exports.isVideoFile = _chunkGV7GMZP2cjs.isVideoFile; exports.joinPath = _chunkGV7GMZP2cjs.joinPath; exports.normalizePath = _chunkGV7GMZP2cjs.normalizePath; exports.parseS3Url = _chunkGV7GMZP2cjs.parseS3Url; exports.sanitizeFileName = _chunkGV7GMZP2cjs.sanitizeFileName; exports.validateBatchFiles = _chunkGV7GMZP2cjs.validateBatchFiles; exports.validateBucketName = _chunkGV7GMZP2cjs.validateBucketName; exports.validateFileSize = _chunkGV7GMZP2cjs.validateFileSize; exports.validateFileType = _chunkGV7GMZP2cjs.validateFileType; exports.validateS3Config = _chunkGV7GMZP2cjs.validateS3Config; exports.validateS3Key = _chunkGV7GMZP2cjs.validateS3Key;