@sanvika/cloudinary 0.1.0

package/dist/index.js

@@ -0,0 +1,340 @@
+"use client";
+
+// src/cloudinaryCore.js
+import { v2 as cloudinary } from "cloudinary";
+
+// src/cloudinaryErrors.js
+var CloudinaryError = class extends Error {
+  constructor(message, operation, details = {}, originalError = null) {
+    super(message);
+    this.name = "CloudinaryError";
+    this.operation = operation;
+    this.details = details;
+    this.originalError = originalError;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  toJSON() {
+    var _a;
+    return {
+      name: this.name,
+      message: this.message,
+      operation: this.operation,
+      details: this.details,
+      originalError: (_a = this.originalError) == null ? void 0 : _a.message,
+      timestamp: this.timestamp
+    };
+  }
+};
+function isRetriableError(error) {
+  var _a;
+  const msg = ((_a = error == null ? void 0 : error.message) == null ? void 0 : _a.toLowerCase()) || "";
+  if (msg.includes("rate limit") || msg.includes("network") || msg.includes("timeout") || msg.includes("socket") || msg.includes("econnreset")) {
+    return true;
+  }
+  if (msg.includes("not found") || msg.includes("unauthorized") || msg.includes("invalid") || msg.includes("signature")) {
+    return false;
+  }
+  return true;
+}
+async function withRetry(fn, options = {}) {
+  const { maxAttempts = 3, initialDelay = 500, operationName = "cloudinary_op" } = options;
+  let attempts = 0;
+  let lastError = null;
+  while (attempts < maxAttempts) {
+    try {
+      attempts++;
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempts === maxAttempts || !isRetriableError(error)) break;
+      const delay = initialDelay * Math.pow(2, attempts - 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw new CloudinaryError(
+    `${operationName} failed after ${attempts} attempts: ${lastError.message}`,
+    operationName,
+    { attempts, maxAttempts },
+    lastError
+  );
+}
+
+// src/cloudinaryUtils.js
+function isCloudinaryUrl(url) {
+  return typeof url === "string" && (url.includes("res.cloudinary.com") || url.includes("cloudinary.com"));
+}
+function extractPublicId(url) {
+  if (!isCloudinaryUrl(url)) return null;
+  try {
+    const parts = url.split("/");
+    const uploadIdx = parts.indexOf("upload");
+    if (uploadIdx === -1) return null;
+    let publicIdPath = parts.slice(uploadIdx + 1).join("/");
+    const versionMatch = publicIdPath.match(/^v\d+\//);
+    if (versionMatch) {
+      publicIdPath = publicIdPath.substring(versionMatch[0].length);
+    }
+    const lastDot = publicIdPath.lastIndexOf(".");
+    if (lastDot !== -1) {
+      const ext = publicIdPath.substring(lastDot + 1);
+      if (/^[a-zA-Z0-9]{2,5}$/.test(ext)) {
+        publicIdPath = publicIdPath.substring(0, lastDot);
+      }
+    }
+    return publicIdPath || null;
+  } catch {
+    return null;
+  }
+}
+function validatePublicId(publicId) {
+  if (!publicId || typeof publicId !== "string") return false;
+  const parts = publicId.split("/");
+  return parts.length >= 2 && parts.every((p) => p.length > 0);
+}
+function getFolderPath(appName, subfolder) {
+  if (!appName) throw new Error("appName is required for getFolderPath");
+  const parts = [appName];
+  if (subfolder) {
+    const cleaned = subfolder.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean).join("/");
+    if (cleaned) parts.push(cleaned);
+  }
+  return parts.join("/");
+}
+function getOptimizedUrl(cloudName, publicId, transforms = {}, resourceType = "image") {
+  const base = `https://res.cloudinary.com/${cloudName}/${resourceType}/upload`;
+  const parts = Object.entries(transforms).map(([k, v]) => `${k}_${v}`).join(",");
+  return parts ? `${base}/${parts}/${publicId}` : `${base}/${publicId}`;
+}
+var TRANSFORM_PRESETS = {
+  thumbnail: { w: 150, h: 150, c: "fill", g: "auto", q: "auto", f: "auto" },
+  adCard: { w: 300, h: 200, c: "fill", g: "auto", q: "auto", f: "auto" },
+  profilePicture: { w: 100, h: 100, c: "fill", g: "face", r: "max", q: "auto", f: "auto" },
+  adDetail: { w: 800, h: 600, c: "fill", q: "auto", f: "auto" },
+  responsive: { w: "auto", dpr: "auto", q: "auto", f: "auto" }
+};
+
+// src/cloudinaryCore.js
+var _appName = null;
+var _configured = false;
+function configureSanvikaCloudinary({ appName, cloudName, apiKey, apiSecret } = {}) {
+  if (!appName) throw new Error("appName is required for configureSanvikaCloudinary");
+  const cn = cloudName || process.env.CLOUDINARY_CLOUD_NAME || process.env.CLOUDINARY_NAME;
+  const ak = apiKey || process.env.CLOUDINARY_API_KEY;
+  const as = apiSecret || process.env.CLOUDINARY_API_SECRET;
+  if (!cn || !ak || !as) {
+    throw new Error("Cloudinary credentials missing. Set CLOUDINARY_CLOUD_NAME, CLOUDINARY_API_KEY, CLOUDINARY_API_SECRET in env.");
+  }
+  cloudinary.config({ cloud_name: cn, api_key: ak, api_secret: as, secure: true });
+  _appName = appName;
+  _configured = true;
+}
+function ensureConfigured() {
+  if (!_configured) {
+    const envApp = process.env.SANVIKA_CLOUDINARY_APP_NAME;
+    if (envApp) {
+      configureSanvikaCloudinary({ appName: envApp });
+    } else {
+      throw new Error("Call configureSanvikaCloudinary({ appName }) before using SDK operations.");
+    }
+  }
+}
+function getAppName() {
+  ensureConfigured();
+  return _appName;
+}
+async function uploadImage(fileOrBuffer, options = {}) {
+  ensureConfigured();
+  const { folder, tags = [], transforms, publicId, overwrite = false } = options;
+  const uploadFolder = getFolderPath(_appName, folder);
+  const uploadOpts = {
+    folder: uploadFolder,
+    resource_type: "image",
+    overwrite,
+    tags: [_appName, ...tags]
+  };
+  if (publicId) uploadOpts.public_id = publicId;
+  if (transforms) uploadOpts.eager = transforms;
+  return withRetry(
+    () => {
+      if (Buffer.isBuffer(fileOrBuffer)) {
+        return new Promise((resolve, reject) => {
+          const stream = cloudinary.uploader.upload_stream(uploadOpts, (err, result) => {
+            if (err) return reject(err);
+            resolve(result);
+          });
+          stream.end(fileOrBuffer);
+        });
+      }
+      return cloudinary.uploader.upload(fileOrBuffer, uploadOpts);
+    },
+    { operationName: "uploadImage", maxAttempts: 3 }
+  );
+}
+async function uploadImages(files, options = {}) {
+  if (!Array.isArray(files) || files.length === 0) return [];
+  return Promise.all(files.map((file) => uploadImage(file, options)));
+}
+async function uploadRawFile(buffer, options = {}) {
+  ensureConfigured();
+  const { folder, filename, tags = [] } = options;
+  if (!buffer || !Buffer.isBuffer(buffer)) throw new Error("Buffer is required for uploadRawFile");
+  const uploadFolder = getFolderPath(_appName, folder);
+  const baseName = filename ? filename.replace(/\.[^.]+$/, "") : "file";
+  return withRetry(
+    () => new Promise((resolve, reject) => {
+      const stream = cloudinary.uploader.upload_stream(
+        {
+          resource_type: "raw",
+          folder: uploadFolder,
+          public_id: baseName,
+          overwrite: true,
+          tags: ["raw", _appName, ...tags]
+        },
+        (err, result) => {
+          if (err) return reject(err);
+          resolve(result);
+        }
+      );
+      stream.end(buffer);
+    }),
+    { operationName: "uploadRawFile", maxAttempts: 3 }
+  );
+}
+async function deleteImage(urlOrPublicId, options = {}) {
+  ensureConfigured();
+  const { resourceType = "image" } = options;
+  const publicId = isCloudinaryUrl(urlOrPublicId) ? extractPublicId(urlOrPublicId) : urlOrPublicId;
+  if (!publicId) throw new CloudinaryError("Cannot extract public ID", "deleteImage", { urlOrPublicId });
+  return withRetry(
+    () => cloudinary.uploader.destroy(publicId, { resource_type: resourceType, type: "upload" }),
+    { operationName: "deleteImage", maxAttempts: 2 }
+  );
+}
+async function deleteImages(urls, options = {}) {
+  ensureConfigured();
+  const { fast = false, resourceType = "image" } = options;
+  if (!Array.isArray(urls) || urls.length === 0) return { success: true, total: 0, successful: 0, failed: 0 };
+  const BATCH_SIZE = fast ? 15 : 10;
+  const DELAY = fast ? 100 : 500;
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const publicIds = urls.map((u) => isCloudinaryUrl(u) ? extractPublicId(u) : u).filter(Boolean);
+  if (publicIds.length === 0) return { success: true, total: urls.length, successful: 0, failed: 0, invalidUrls: urls.length };
+  const allResults = [];
+  for (let i = 0; i < publicIds.length; i += BATCH_SIZE) {
+    const batch = publicIds.slice(i, i + BATCH_SIZE);
+    const batchResults = await Promise.allSettled(
+      batch.map(async (pid) => {
+        try {
+          const result = await cloudinary.uploader.destroy(pid, { resource_type: resourceType, type: "upload" });
+          return { publicId: pid, success: result.result === "ok" || result.result === "not found", result: result.result };
+        } catch (err) {
+          return { publicId: pid, success: false, error: err.message };
+        }
+      })
+    );
+    allResults.push(...batchResults.map((r) => r.status === "fulfilled" ? r.value : { publicId: "unknown", success: false, error: "Promise rejected" }));
+    if (i + BATCH_SIZE < publicIds.length) await sleep(DELAY);
+  }
+  const successful = allResults.filter((r) => r.success).length;
+  const failed = allResults.filter((r) => !r.success).length;
+  return { success: failed === 0, total: urls.length, processed: allResults.length, successful, failed };
+}
+async function pingCloudinary() {
+  ensureConfigured();
+  return cloudinary.api.ping();
+}
+
+// src/SanvikaCloudinaryProvider.jsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var SanvikaCloudinaryContext = createContext(null);
+function SanvikaCloudinaryProvider({ appName, cloudName, uploadPreset = "ml_default", children }) {
+  const value = useMemo(
+    () => ({ appName, cloudName, uploadPreset }),
+    [appName, cloudName, uploadPreset]
+  );
+  return /* @__PURE__ */ jsx(SanvikaCloudinaryContext.Provider, { value, children });
+}
+function useSanvikaCloudinary() {
+  const ctx = useContext(SanvikaCloudinaryContext);
+  if (!ctx) {
+    throw new Error("useSanvikaCloudinary must be used within a SanvikaCloudinaryProvider");
+  }
+  return ctx;
+}
+
+// src/useCloudinaryUpload.js
+import { useState, useCallback } from "react";
+function useCloudinaryUpload(options = {}) {
+  const { folder, resourceType = "image", onProgress } = options;
+  const { appName, cloudName, uploadPreset } = useSanvikaCloudinary();
+  const [uploading, setUploading] = useState(false);
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => {
+    setError(null);
+    setUploading(false);
+  }, []);
+  const upload = useCallback(
+    async (file) => {
+      setError(null);
+      setUploading(true);
+      try {
+        const folderPath = folder ? `${appName}/${folder}` : appName;
+        const formData = new FormData();
+        formData.append("file", file);
+        formData.append("upload_preset", uploadPreset);
+        formData.append("folder", folderPath);
+        const xhr = new XMLHttpRequest();
+        const url = `https://api.cloudinary.com/v1_1/${cloudName}/${resourceType}/upload`;
+        const result = await new Promise((resolve, reject) => {
+          xhr.open("POST", url);
+          if (onProgress) {
+            xhr.upload.onprogress = (e) => {
+              if (e.lengthComputable) onProgress(Math.round(e.loaded / e.total * 100));
+            };
+          }
+          xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+              resolve(JSON.parse(xhr.responseText));
+            } else {
+              reject(new Error(xhr.responseText || "Upload failed"));
+            }
+          };
+          xhr.onerror = () => reject(new Error("Network error during upload"));
+          xhr.send(formData);
+        });
+        return result;
+      } catch (err) {
+        const msg = (err == null ? void 0 : err.message) || "Upload failed";
+        setError(msg);
+        throw err;
+      } finally {
+        setUploading(false);
+      }
+    },
+    [appName, cloudName, uploadPreset, folder, resourceType, onProgress]
+  );
+  return { upload, uploading, error, reset };
+}
+export {
+  CloudinaryError,
+  SanvikaCloudinaryProvider,
+  TRANSFORM_PRESETS,
+  configureSanvikaCloudinary,
+  deleteImage,
+  deleteImages,
+  extractPublicId,
+  getAppName,
+  getFolderPath,
+  getOptimizedUrl,
+  isCloudinaryUrl,
+  isRetriableError,
+  pingCloudinary,
+  uploadImage,
+  uploadImages,
+  uploadRawFile,
+  useCloudinaryUpload,
+  useSanvikaCloudinary,
+  validatePublicId,
+  withRetry
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@sanvika/cloudinary",
+  "version": "0.1.0",
+  "description": "Centralized Cloudinary SDK for the Sanvika ecosystem — upload, delete, transform, and manage media across 50+ projects",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
+  },
+  "dependencies": {
+    "cloudinary": "^2.5.0"
+  },
+  "keywords": [
+    "cloudinary",
+    "sanvika",
+    "image-upload",
+    "media-management",
+    "cdn",
+    "ecosystem"
+  ],
+  "author": "Sanvika Production",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": { "optional": true },
+    "react-dom": { "optional": true }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sanvikaproduction/sanvika-cloudinary",
+    "directory": "packages/sanvika-cloudinary-sdk"
+  }
+}