@pelatform/storage 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pelatform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,10 @@
+# @pelatform/storage
+
+A comprehensive storage utilities for SaaS applications. This package provides a unified interface for working with various storage providers including AWS S3, Cloudflare R2, MinIO, DigitalOcean Spaces, Supabase, and Cloudinary Storage.
+
+[![Version](https://img.shields.io/npm/v/@pelatform/storage.svg)](https://www.npmjs.com/package/@pelatform/storage)
+[![License](https://img.shields.io/npm/l/@pelatform/storage.svg)](https://github.com/devpelatform/storage/blob/main/LICENSE)
+
+## Getting Started
+
+Visit https://devpelatform.github.io/storage to get started with this package.

package/dist/chunk-KJMGBTTL.js

@@ -0,0 +1,413 @@
+// src/helpers.ts
+import { lookup } from "mime-types";
+function generateFileKey(originalName, prefix) {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  const extension = originalName.split(".").pop();
+  const baseName = originalName.split(".").slice(0, -1).join(".");
+  const fileName = `${baseName}-${timestamp}-${random}${extension ? `.${extension}` : ""}`;
+  return prefix ? `${prefix}/${fileName}` : fileName;
+}
+function getMimeType(fileName) {
+  const mimeType = lookup(fileName);
+  return mimeType || "application/octet-stream";
+}
+function validateFileSize(fileSize, maxSize) {
+  if (fileSize > maxSize) {
+    return {
+      valid: false,
+      error: `File size ${formatFileSize(fileSize)} exceeds maximum allowed size ${formatFileSize(maxSize)}`
+    };
+  }
+  return { valid: true };
+}
+function validateFileType(fileName, allowedTypes) {
+  const mimeType = getMimeType(fileName);
+  const extension = fileName.split(".").pop()?.toLowerCase();
+  const isValidMime = allowedTypes.some((type) => {
+    if (type.includes("*")) {
+      const baseType = type.split("/")[0];
+      return mimeType.startsWith(baseType);
+    }
+    return mimeType === type;
+  });
+  const isValidExtension = extension && allowedTypes.includes(`.${extension}`);
+  if (!isValidMime && !isValidExtension) {
+    return {
+      valid: false,
+      error: `File type not allowed. Allowed types: ${allowedTypes.join(", ")}`
+    };
+  }
+  return { valid: true };
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+function sanitizeFileName(fileName) {
+  return fileName.replace(/[^a-zA-Z0-9.-]/g, "_").replace(/_{2,}/g, "_").replace(/^_|_$/g, "").toLowerCase();
+}
+function getFileExtension(fileName) {
+  const extension = fileName.split(".").pop();
+  return extension ? `.${extension.toLowerCase()}` : "";
+}
+function generateCacheControl(maxAge = 31536e3, isPublic = true) {
+  const visibility = isPublic ? "public" : "private";
+  return `${visibility}, max-age=${maxAge}`;
+}
+function parseS3Url(url) {
+  try {
+    const urlObj = new URL(url);
+    if (urlObj.hostname.includes("amazonaws.com")) {
+      if (urlObj.hostname.startsWith("s3")) {
+        const pathParts2 = urlObj.pathname.split("/").filter(Boolean);
+        return {
+          bucket: pathParts2[0],
+          key: pathParts2.slice(1).join("/")
+        };
+      } else {
+        const bucket = urlObj.hostname.split(".")[0];
+        const key = urlObj.pathname.substring(1);
+        return { bucket, key };
+      }
+    }
+    const pathParts = urlObj.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  } catch {
+    return {};
+  }
+}
+function buildPublicUrl(baseUrl, bucket, key) {
+  const cleanBaseUrl = baseUrl.replace(/\/$/, "");
+  const cleanKey = key.replace(/^\//, "");
+  return `${cleanBaseUrl}/${bucket}/${cleanKey}`;
+}
+function validateS3Key(key) {
+  if (!key || key.length === 0) {
+    return { valid: false, error: "Key cannot be empty" };
+  }
+  if (key.length > 1024) {
+    return { valid: false, error: "Key cannot exceed 1024 characters" };
+  }
+  if (key.startsWith("/") || key.endsWith("/")) {
+    return {
+      valid: false,
+      error: "Key cannot start or end with forward slash"
+    };
+  }
+  const invalidChars = /[^\w\-_./]/;
+  if (invalidChars.test(key)) {
+    return { valid: false, error: "Key contains invalid characters" };
+  }
+  return { valid: true };
+}
+async function fileToBuffer(file) {
+  const arrayBuffer = await file.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+function getFileInfo(file) {
+  return {
+    name: file.name,
+    size: file.size,
+    type: file.type || getMimeType(file.name),
+    lastModified: new Date(file.lastModified)
+  };
+}
+function generateUniqueKey(fileName, prefix, includeTimestamp = true) {
+  const sanitized = sanitizeFileName(fileName);
+  const extension = getFileExtension(sanitized);
+  const baseName = sanitized.replace(extension, "");
+  let uniquePart = "";
+  if (includeTimestamp) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    uniquePart = `-${timestamp}-${random}`;
+  }
+  const finalName = `${baseName}${uniquePart}${extension}`;
+  return prefix ? `${prefix}/${finalName}` : finalName;
+}
+function extractS3Info(url) {
+  try {
+    const urlObj = new URL(url);
+    if (urlObj.hostname.includes("amazonaws.com")) {
+      if (urlObj.hostname.startsWith("s3")) {
+        const pathParts2 = urlObj.pathname.split("/").filter(Boolean);
+        const region = urlObj.hostname.split(".")[1];
+        return {
+          bucket: pathParts2[0],
+          key: pathParts2.slice(1).join("/"),
+          region
+        };
+      } else {
+        const hostParts = urlObj.hostname.split(".");
+        const bucket = hostParts[0];
+        const region = hostParts[2];
+        const key = urlObj.pathname.substring(1);
+        return { bucket, key, region };
+      }
+    }
+    const pathParts = urlObj.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  } catch {
+    return {};
+  }
+}
+function validateS3Config(config) {
+  const errors = [];
+  if (!config.provider) {
+    errors.push("Provider is required");
+  }
+  if (!config.region) {
+    errors.push("Region is required");
+  }
+  if (!config.bucket) {
+    errors.push("Bucket is required");
+  }
+  if (!config.accessKeyId) {
+    errors.push("Access Key ID is required");
+  }
+  if (!config.secretAccessKey) {
+    errors.push("Secret Access Key is required");
+  }
+  if (config.bucket && typeof config.bucket === "string") {
+    const bucketValidation = validateBucketName(config.bucket);
+    if (!bucketValidation.valid) {
+      errors.push(`Invalid bucket name: ${bucketValidation.error}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateBucketName(bucketName) {
+  if (!bucketName || bucketName.length === 0) {
+    return { valid: false, error: "Bucket name cannot be empty" };
+  }
+  if (bucketName.length < 3 || bucketName.length > 63) {
+    return {
+      valid: false,
+      error: "Bucket name must be between 3 and 63 characters"
+    };
+  }
+  if (!/^[a-z0-9.-]+$/.test(bucketName)) {
+    return {
+      valid: false,
+      error: "Bucket name can only contain lowercase letters, numbers, dots, and hyphens"
+    };
+  }
+  if (bucketName.startsWith(".") || bucketName.endsWith(".")) {
+    return {
+      valid: false,
+      error: "Bucket name cannot start or end with a dot"
+    };
+  }
+  if (bucketName.startsWith("-") || bucketName.endsWith("-")) {
+    return {
+      valid: false,
+      error: "Bucket name cannot start or end with a hyphen"
+    };
+  }
+  if (bucketName.includes("..")) {
+    return {
+      valid: false,
+      error: "Bucket name cannot contain consecutive dots"
+    };
+  }
+  return { valid: true };
+}
+function getContentDisposition(fileName, disposition = "attachment") {
+  const sanitizedName = fileName.replace(/[^\w\s.-]/gi, "");
+  return `${disposition}; filename="${sanitizedName}"`;
+}
+function isImageFile(fileName) {
+  const mimeType = getMimeType(fileName);
+  return mimeType.startsWith("image/");
+}
+function isVideoFile(fileName) {
+  const mimeType = getMimeType(fileName);
+  return mimeType.startsWith("video/");
+}
+function isAudioFile(fileName) {
+  const mimeType = getMimeType(fileName);
+  return mimeType.startsWith("audio/");
+}
+function isDocumentFile(fileName) {
+  const mimeType = getMimeType(fileName);
+  const documentTypes = [
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "text/plain",
+    "text/csv"
+  ];
+  return documentTypes.includes(mimeType);
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/|\/$/g, "");
+}
+function joinPath(...segments) {
+  return segments.filter((segment) => segment && segment.trim() !== "").map((segment) => segment.replace(/^\/+|\/+$/g, "")).filter((segment) => segment !== "").join("/");
+}
+function getParentPath(key) {
+  const normalizedKey = normalizePath(key);
+  const lastSlashIndex = normalizedKey.lastIndexOf("/");
+  return lastSlashIndex === -1 ? "" : normalizedKey.substring(0, lastSlashIndex);
+}
+function getFileName(key) {
+  const normalizedKey = normalizePath(key);
+  const lastSlashIndex = normalizedKey.lastIndexOf("/");
+  return lastSlashIndex === -1 ? normalizedKey : normalizedKey.substring(lastSlashIndex + 1);
+}
+function base64ToBuffer(base64) {
+  const cleanBase64 = base64.includes(",") ? base64.split(",")[1] : base64;
+  return Buffer.from(cleanBase64, "base64");
+}
+function bufferToBase64(buffer, includeDataUrl = false, mimeType) {
+  const base64 = buffer.toString("base64");
+  if (includeDataUrl) {
+    if (!mimeType) {
+      throw new Error("MIME type is required when includeDataUrl is true");
+    }
+    return `data:${mimeType};base64,${base64}`;
+  }
+  return base64;
+}
+async function generateFileHash(content, algorithm = "md5") {
+  const crypto = await import("crypto");
+  const hash = crypto.createHash(algorithm);
+  hash.update(content);
+  return hash.digest("hex");
+}
+function generateBatchKeys(fileNames, prefix) {
+  return fileNames.map((fileName) => generateFileKey(fileName, prefix));
+}
+function validateBatchFiles(files, options) {
+  const results = [];
+  if (options.maxFiles && files.length > options.maxFiles) {
+    return files.map((file) => ({
+      valid: false,
+      fileName: file.name,
+      errors: [`Maximum ${options.maxFiles} files allowed, but ${files.length} files provided`]
+    }));
+  }
+  for (const file of files) {
+    const errors = [];
+    if (options.maxSize) {
+      const sizeResult = validateFileSize(file.size, options.maxSize);
+      if (!sizeResult.valid && sizeResult.error) {
+        errors.push(sizeResult.error);
+      }
+    }
+    if (options.allowedTypes) {
+      const typeResult = validateFileType(file.name, options.allowedTypes);
+      if (!typeResult.valid && typeResult.error) {
+        errors.push(typeResult.error);
+      }
+    }
+    results.push({
+      valid: errors.length === 0,
+      fileName: file.name,
+      errors: errors.length > 0 ? errors : void 0
+    });
+  }
+  return results;
+}
+function detectFileTypeFromContent(buffer) {
+  if (buffer.length === 0) {
+    return "application/octet-stream";
+  }
+  const header = buffer.subarray(0, 16);
+  if (header.subarray(0, 4).toString() === "%PDF") {
+    return "application/pdf";
+  }
+  if (header[0] === 255 && header[1] === 216 && header[2] === 255) {
+    return "image/jpeg";
+  }
+  if (header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (header.subarray(0, 6).toString() === "GIF87a" || header.subarray(0, 6).toString() === "GIF89a") {
+    return "image/gif";
+  }
+  if (header.subarray(0, 4).toString() === "RIFF" && header.subarray(8, 12).toString() === "WEBP") {
+    return "image/webp";
+  }
+  if (header[0] === 80 && header[1] === 75 && (header[2] === 3 || header[2] === 5)) {
+    const zipContent = buffer.toString("utf8", 0, Math.min(buffer.length, 1e3));
+    if (zipContent.includes("word/"))
+      return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    if (zipContent.includes("xl/"))
+      return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    if (zipContent.includes("ppt/"))
+      return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    return "application/zip";
+  }
+  if (header.subarray(4, 8).toString() === "ftyp") {
+    return "video/mp4";
+  }
+  if (header[0] === 255 && (header[1] & 224) === 224 || header.subarray(0, 3).toString() === "ID3") {
+    return "audio/mpeg";
+  }
+  let isText = true;
+  const sampleSize = Math.min(buffer.length, 512);
+  for (let i = 0; i < sampleSize; i++) {
+    const byte = buffer[i];
+    if (byte === 0 || byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
+      isText = false;
+      break;
+    }
+  }
+  if (isText) {
+    return "text/plain";
+  }
+  return "application/octet-stream";
+}
+
+export {
+  generateFileKey,
+  getMimeType,
+  validateFileSize,
+  validateFileType,
+  formatFileSize,
+  sanitizeFileName,
+  getFileExtension,
+  generateCacheControl,
+  parseS3Url,
+  buildPublicUrl,
+  validateS3Key,
+  fileToBuffer,
+  getFileInfo,
+  generateUniqueKey,
+  extractS3Info,
+  validateS3Config,
+  validateBucketName,
+  getContentDisposition,
+  isImageFile,
+  isVideoFile,
+  isAudioFile,
+  isDocumentFile,
+  normalizePath,
+  joinPath,
+  getParentPath,
+  getFileName,
+  base64ToBuffer,
+  bufferToBase64,
+  generateFileHash,
+  generateBatchKeys,
+  validateBatchFiles,
+  detectFileTypeFromContent
+};

package/dist/chunk-ZTZZCC52.js

@@ -0,0 +1,169 @@
+// src/config.ts
+var ENV_VARS = {
+  // S3 Configuration
+  PELATFORM_S3_PROVIDER: "PELATFORM_S3_PROVIDER",
+  PELATFORM_S3_REGION: "PELATFORM_S3_REGION",
+  PELATFORM_S3_BUCKET: "PELATFORM_S3_BUCKET",
+  PELATFORM_S3_ACCESS_KEY_ID: "PELATFORM_S3_ACCESS_KEY_ID",
+  PELATFORM_S3_SECRET_ACCESS_KEY: "PELATFORM_S3_SECRET_ACCESS_KEY",
+  PELATFORM_S3_ENDPOINT: "PELATFORM_S3_ENDPOINT",
+  PELATFORM_S3_FORCE_PATH_STYLE: "PELATFORM_S3_FORCE_PATH_STYLE",
+  PELATFORM_S3_PUBLIC_URL: "PELATFORM_S3_PUBLIC_URL",
+  // Cloudinary Configuration
+  PELATFORM_CLOUDINARY_CLOUD_NAME: "PELATFORM_CLOUDINARY_CLOUD_NAME",
+  PELATFORM_CLOUDINARY_API_KEY: "PELATFORM_CLOUDINARY_API_KEY",
+  PELATFORM_CLOUDINARY_API_SECRET: "PELATFORM_CLOUDINARY_API_SECRET",
+  PELATFORM_CLOUDINARY_SECURE: "PELATFORM_CLOUDINARY_SECURE",
+  PELATFORM_CLOUDINARY_FOLDER: "PELATFORM_CLOUDINARY_FOLDER"
+};
+function getEnvVar(key) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  return void 0;
+}
+function getRequiredEnvVar(key) {
+  const value = getEnvVar(key);
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${key}`);
+  }
+  return value;
+}
+function getBooleanEnvVar(key, defaultValue = false) {
+  const value = getEnvVar(key);
+  if (!value) return defaultValue;
+  return value.toLowerCase() === "true" || value === "1";
+}
+function loadS3Config() {
+  const provider = getRequiredEnvVar(ENV_VARS.PELATFORM_S3_PROVIDER);
+  const validProviders = [
+    "aws",
+    "cloudflare-r2",
+    "minio",
+    "digitalocean",
+    "supabase",
+    "custom"
+  ];
+  if (!validProviders.includes(provider)) {
+    throw new Error(
+      `Invalid S3 provider: ${provider}. Must be one of: ${validProviders.join(", ")}`
+    );
+  }
+  return {
+    provider,
+    region: getRequiredEnvVar(ENV_VARS.PELATFORM_S3_REGION),
+    bucket: getRequiredEnvVar(ENV_VARS.PELATFORM_S3_BUCKET),
+    accessKeyId: getRequiredEnvVar(ENV_VARS.PELATFORM_S3_ACCESS_KEY_ID),
+    secretAccessKey: getRequiredEnvVar(ENV_VARS.PELATFORM_S3_SECRET_ACCESS_KEY),
+    endpoint: getEnvVar(ENV_VARS.PELATFORM_S3_ENDPOINT),
+    forcePathStyle: getBooleanEnvVar(ENV_VARS.PELATFORM_S3_FORCE_PATH_STYLE),
+    publicUrl: getEnvVar(ENV_VARS.PELATFORM_S3_PUBLIC_URL)
+  };
+}
+function loadCloudinaryConfig() {
+  return {
+    provider: "cloudinary",
+    cloudName: getRequiredEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_CLOUD_NAME),
+    apiKey: getRequiredEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_API_KEY),
+    apiSecret: getRequiredEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_API_SECRET),
+    secure: getBooleanEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_SECURE, true),
+    folder: getEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_FOLDER)
+  };
+}
+function loadStorageConfig() {
+  const provider = getEnvVar(ENV_VARS.PELATFORM_S3_PROVIDER);
+  if (provider) {
+    if (provider === "cloudinary") {
+      return loadCloudinaryConfig();
+    } else {
+      return loadS3Config();
+    }
+  }
+  const hasCloudinaryVars = getEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_CLOUD_NAME) && getEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_API_KEY) && getEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_API_SECRET);
+  const hasS3Vars = getEnvVar(ENV_VARS.PELATFORM_S3_BUCKET) && getEnvVar(ENV_VARS.PELATFORM_S3_ACCESS_KEY_ID) && getEnvVar(ENV_VARS.PELATFORM_S3_SECRET_ACCESS_KEY);
+  if (hasCloudinaryVars) {
+    return loadCloudinaryConfig();
+  } else if (hasS3Vars) {
+    const config = loadS3Config();
+    if (!config.provider) {
+      config.provider = "aws";
+    }
+    return config;
+  }
+  throw new Error(
+    "No storage configuration found. Please set either:\n- S3: PELATFORM_S3_PROVIDER, PELATFORM_S3_REGION, PELATFORM_S3_BUCKET, PELATFORM_S3_ACCESS_KEY_ID, PELATFORM_S3_SECRET_ACCESS_KEY\n- Cloudinary: PELATFORM_CLOUDINARY_CLOUD_NAME, PELATFORM_CLOUDINARY_API_KEY, PELATFORM_CLOUDINARY_API_SECRET"
+  );
+}
+function hasStorageConfig() {
+  try {
+    loadStorageConfig();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isStorageConfigured() {
+  return hasStorageConfig();
+}
+function getStorageProvider() {
+  const provider = getEnvVar(ENV_VARS.PELATFORM_S3_PROVIDER);
+  if (provider) return provider;
+  const hasCloudinaryVars = getEnvVar(ENV_VARS.PELATFORM_CLOUDINARY_CLOUD_NAME);
+  const hasS3Vars = getEnvVar(ENV_VARS.PELATFORM_S3_BUCKET);
+  if (hasCloudinaryVars) return "cloudinary";
+  if (hasS3Vars) return "aws";
+  return void 0;
+}
+function validateS3EnvVars() {
+  const required = [
+    ENV_VARS.PELATFORM_S3_PROVIDER,
+    ENV_VARS.PELATFORM_S3_REGION,
+    ENV_VARS.PELATFORM_S3_BUCKET,
+    ENV_VARS.PELATFORM_S3_ACCESS_KEY_ID,
+    ENV_VARS.PELATFORM_S3_SECRET_ACCESS_KEY
+  ];
+  const missing = required.filter((key) => !getEnvVar(key));
+  return {
+    valid: missing.length === 0,
+    missing
+  };
+}
+function validateCloudinaryEnvVars() {
+  const required = [
+    ENV_VARS.PELATFORM_CLOUDINARY_CLOUD_NAME,
+    ENV_VARS.PELATFORM_CLOUDINARY_API_KEY,
+    ENV_VARS.PELATFORM_CLOUDINARY_API_SECRET
+  ];
+  const missing = required.filter((key) => !getEnvVar(key));
+  return {
+    valid: missing.length === 0,
+    missing
+  };
+}
+function getStorageEnvVars() {
+  const result = {};
+  Object.values(ENV_VARS).forEach((key) => {
+    const value = getEnvVar(key);
+    if (value) {
+      if (key.includes("SECRET") || key.includes("API_SECRET")) {
+        result[key] = `${value.substring(0, 4)}***`;
+      } else {
+        result[key] = value;
+      }
+    }
+  });
+  return result;
+}
+
+export {
+  ENV_VARS,
+  loadS3Config,
+  loadCloudinaryConfig,
+  loadStorageConfig,
+  hasStorageConfig,
+  isStorageConfigured,
+  getStorageProvider,
+  validateS3EnvVars,
+  validateCloudinaryEnvVars,
+  getStorageEnvVars
+};