@sanvika/cloudinary 0.1.2 → 0.1.4

package/dist/client.js

@@ -0,0 +1,139 @@
+"use client";
+
+// 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 };
+}
+
+// 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" }
+};
+export {
+  SanvikaCloudinaryProvider,
+  TRANSFORM_PRESETS,
+  extractPublicId,
+  getFolderPath,
+  getOptimizedUrl,
+  isCloudinaryUrl,
+  useCloudinaryUpload,
+  useSanvikaCloudinary,
+  validatePublicId
+};

package/dist/index.js

@@ -1,5 +1,3 @@
-"use client";
-
 // src/cloudinaryCore.js
 import { v2 as cloudinary } from "cloudinary";
 
@@ -148,10 +146,17 @@ async function uploadImage(fileOrBuffer, options = {}) {
     folder,
     resourceType = "image",
     tags = [],
+    eager,
     transforms,
+    eagerAsync,
+    eagerNotificationUrl,
     publicId,
     overwrite = false,
-    notificationUrl
+    notificationUrl,
+    chunked,
+    chunkSize = 6 * 1024 * 1024,
+    timeout,
+    maxAttempts = 3
   } = options;
   const uploadFolder = getFolderPath(_appName, folder);
   const uploadOpts = {
@@ -161,22 +166,40 @@ async function uploadImage(fileOrBuffer, options = {}) {
     tags: [_appName, ...tags]
   };
   if (publicId) uploadOpts.public_id = publicId;
-  if (transforms) uploadOpts.eager = transforms;
+  const eagerValue = eager || transforms;
+  if (eagerValue) uploadOpts.eager = eagerValue;
+  if (eagerAsync) uploadOpts.eager_async = true;
+  if (eagerNotificationUrl) uploadOpts.eager_notification_url = eagerNotificationUrl;
   if (notificationUrl) uploadOpts.notification_url = notificationUrl;
+  if (timeout) uploadOpts.timeout = timeout;
+  const fileSize = Buffer.isBuffer(fileOrBuffer) ? fileOrBuffer.length : null;
+  const useChunked = chunked || resourceType === "video" && fileSize !== null && fileSize > 10 * 1024 * 1024;
+  if (useChunked) {
+    uploadOpts.chunk_size = chunkSize;
+  }
   return withRetry(
     () => {
       if (Buffer.isBuffer(fileOrBuffer)) {
         return new Promise((resolve, reject) => {
-          const stream = cloudinary.uploader.upload_stream(uploadOpts, (err, result) => {
+          const streamFactory = useChunked ? cloudinary.uploader.upload_chunked_stream : cloudinary.uploader.upload_stream;
+          const stream = streamFactory.call(cloudinary.uploader, uploadOpts, (err, result) => {
             if (err) return reject(err);
             resolve(result);
           });
           stream.end(fileOrBuffer);
         });
       }
+      if (useChunked) {
+        return new Promise((resolve, reject) => {
+          cloudinary.uploader.upload_large(fileOrBuffer, uploadOpts, (err, result) => {
+            if (err) return reject(err);
+            resolve(result);
+          });
+        });
+      }
       return cloudinary.uploader.upload(fileOrBuffer, uploadOpts);
     },
-    { operationName: "uploadImage", maxAttempts: 3 }
+    { operationName: "uploadImage", maxAttempts }
   );
 }
 async function uploadVideo(fileOrBuffer, options = {}) {
@@ -255,99 +278,115 @@ 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 });
+async function getCloudinaryUsage(options = {}) {
+  ensureConfigured();
+  const { resourceType } = options;
+  return cloudinary.api.usage(resourceType ? { resource_type: resourceType } : {});
 }
-function useSanvikaCloudinary() {
-  const ctx = useContext(SanvikaCloudinaryContext);
-  if (!ctx) {
-    throw new Error("useSanvikaCloudinary must be used within a SanvikaCloudinaryProvider");
-  }
-  return ctx;
+function getCloudinarySdkVersion() {
+  return cloudinary.CLOUDINARY_VERSION;
 }
 
-// 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);
-      }
+// src/cloudinaryDiagnostics.js
+import crypto from "crypto";
+function testCloudinaryWebhookSignature(apiSecret, options = {}) {
+  try {
+    if (!apiSecret) {
+      return { success: false, error: "apiSecret is required" };
+    }
+    const testPayload = { test: "data", timestamp: Math.floor(Date.now() / 1e3) };
+    const testPayloadString = JSON.stringify(testPayload);
+    const testTimestamp = testPayload.timestamp.toString();
+    const signatureData = testTimestamp + testPayloadString;
+    const signature = crypto.createHmac("sha1", apiSecret).update(signatureData).digest("hex");
+    return {
+      success: true,
+      testPayload,
+      testTimestamp,
+      signature,
+      headers: {
+        "X-Cld-Timestamp": testTimestamp,
+        "X-Cld-Signature": signature
+      },
+      testEndpoint: options.testEndpoint || "/api/webhooks/cloudinary/debug"
+    };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function runCloudinaryDiagnostics(options = {}) {
+  const {
+    testWebhook = false,
+    webhookSecret,
+    testFolder = "diagnostics"
+  } = options;
+  const report = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    cloudinaryVersion: getCloudinarySdkVersion(),
+    nodeVersion: process.version,
+    configuration: {
+      cloudName: process.env.CLOUDINARY_CLOUD_NAME || process.env.CLOUDINARY_NAME ? "set" : "missing",
+      apiKey: process.env.CLOUDINARY_API_KEY ? "set" : "missing",
+      apiSecret: process.env.CLOUDINARY_API_SECRET ? "set" : "missing",
+      uploadPreset: process.env.CLOUDINARY_UPLOAD_PRESET ? "set" : "missing"
     },
-    [appName, cloudName, uploadPreset, folder, resourceType, onProgress]
+    tests: {}
+  };
+  report.tests.ping = await pingCloudinary().then(
+    (result) => ({ success: true, result }),
+    (error) => ({ success: false, error: error.message })
+  );
+  const testBuffer = Buffer.from("Cloudinary diagnostic test");
+  report.tests.upload = await uploadImage(testBuffer, {
+    folder: testFolder,
+    resourceType: "raw",
+    tags: ["test", "diagnostics"],
+    publicId: `diagnostic_${Date.now()}`,
+    overwrite: true
+  }).then(
+    (result) => ({
+      success: true,
+      publicId: result.public_id,
+      url: result.secure_url,
+      bytes: result.bytes
+    }),
+    (error) => ({
+      success: false,
+      error: error.message,
+      httpCode: error.http_code,
+      name: error.name
+    })
+  );
+  report.tests.videoLimits = await getCloudinaryUsage({ resourceType: "video" }).then(
+    (result) => ({ success: true, result }),
+    (error) => ({ success: false, error: error.message })
   );
-  return { upload, uploading, error, reset };
+  if (testWebhook) {
+    report.tests.webhook = testCloudinaryWebhookSignature(webhookSecret);
+  }
+  return report;
 }
 export {
   CloudinaryError,
-  SanvikaCloudinaryProvider,
   TRANSFORM_PRESETS,
   configureSanvikaCloudinary,
   deleteImage,
   deleteImages,
   extractPublicId,
   getAppName,
+  getCloudinarySdkVersion,
+  getCloudinaryUsage,
   getFolderPath,
   getOptimizedUrl,
   isCloudinaryUrl,
   isRetriableError,
   pingCloudinary,
+  runCloudinaryDiagnostics,
+  testCloudinaryWebhookSignature,
   uploadImage,
   uploadImages,
   uploadRawFile,
   uploadVideo,
-  useCloudinaryUpload,
-  useSanvikaCloudinary,
   validatePublicId,
   withRetry
 };

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@sanvika/cloudinary",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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"
+    ".": "./dist/index.js",
+    "./client": "./dist/client.js"
   },
   "files": [
     "dist"
@@ -36,8 +37,12 @@
     "react-dom": ">=18.0.0"
   },
   "peerDependenciesMeta": {
-    "react": { "optional": true },
-    "react-dom": { "optional": true }
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=18.0.0"