pinata 0.1.10 → 0.2.0

package/dist/index.mjs

@@ -31,21 +31,24 @@ var testAuthentication = async (config) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/testAuthentication"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/testAuthentication";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/data/testAuthentication",
-      {
-        method: "GET",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/data/testAuthentication`, {
+      method: "GET",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -96,26 +99,29 @@ var uploadFile = async (config, file, options) => {
   data.append(
     "pinataMetadata",
     JSON.stringify({
-      name: options?.metadata ? options.metadata.name : file.name,
+      name: options?.metadata?.name || file.name || "File from SDK",
       keyvalues: options?.metadata?.keyValues
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      Source: "sdk/file"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/file";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -150,7 +156,7 @@ var uploadFileArray = async (config, files, options) => {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
-  const folder = options?.metadata?.name ?? "folder_from_sdk";
+  const folder = options?.metadata?.name || "folder_from_sdk";
   const data = new FormData();
   for (const file of Array.from(files)) {
     data.append("file", file, `${folder}/${file.name}`);
@@ -169,22 +175,25 @@ var uploadFileArray = async (config, files, options) => {
       groupId: options?.groupId
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      Source: "sdk/fileArray"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/fileArray";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -240,22 +249,25 @@ var uploadBase64 = async (config, base64String, options) => {
       keyvalues: options?.metadata?.keyValues
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      Source: "sdk/base64"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/base64";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -321,22 +333,25 @@ var uploadUrl = async (config, url, options) => {
       keyvalues: options?.metadata?.keyValues
     })
   );
-  const headers = {
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      Source: "sdk/url"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/url";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinFileToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -378,27 +393,30 @@ var uploadJson = async (config, jsonData, options) => {
       groupId: options?.groupId
     },
     pinataMetadata: {
-      name: options?.metadata ? options.metadata.name : "json",
+      name: options?.metadata?.name || "json",
       keyvalues: options?.metadata?.keyValues
     }
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/json"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/json";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/pinJSONToIPFS",
-      {
-        method: "POST",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/pinJSONToIPFS`, {
+      method: "POST",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -433,14 +451,16 @@ var uploadCid = async (config, cid, options) => {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const jwt = options?.keys || config?.pinataJwt;
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${jwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${jwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/cid"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/cid";
   const data = JSON.stringify({
     hashToPin: cid,
     pinataMetadata: {
@@ -452,8 +472,12 @@ var uploadCid = async (config, cid, options) => {
       groupId: options?.groupId
     }
   });
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch("https://api.pinata.cloud/pinning/pinByHash", {
+    const request = await fetch(`${endpoint}/pinning/pinByHash`, {
       method: "POST",
       headers,
       body: data
@@ -497,23 +521,25 @@ var unpinFile = async (config, files) => {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const responses = [];
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/unpin"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/unpin";
   for (const hash of files) {
     try {
-      const response = await fetch(
-        `https://api.pinata.cloud/pinning/unpin/${hash}`,
-        {
-          method: "DELETE",
-          headers
-        }
-      );
+      const response = await fetch(`${endpoint}/pinning/unpin/${hash}`, {
+        method: "DELETE",
+        headers
+      });
       await wait(300);
       if (!response.ok) {
         const errorData = await response.json();
@@ -601,15 +627,21 @@ var listFiles = async (config, options) => {
       params.append("metadata[keyvalues]", keyValueParam);
     }
   }
-  const url = `https://api.pinata.cloud/data/pinList?status=pinned&${params.toString()}`;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const url = `${endpoint}/data/pinList?status=pinned&${params.toString()}`;
   try {
-    const headers = {
-      Authorization: `Bearer ${config?.pinataJwt}`
-    };
-    if (config.customHeaders) {
-      Object.assign(headers, config.customHeaders);
+    let headers;
+    if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+      headers = { ...config.customHeaders };
+    } else {
+      headers = {
+        Authorization: `Bearer ${config.pinataJwt}`,
+        Source: "sdk/listFiles"
+      };
     }
-    headers["Source"] = headers["Source"] || "sdk/listFiles";
     const request = await fetch(url, {
       method: "GET",
       headers
@@ -652,23 +684,26 @@ var updateMetadata = async (config, options) => {
     name: options.name,
     keyvalues: options.keyValues
   };
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/updateMetadata"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/updateMetadata";
   try {
-    const request = await fetch(
-      "https://api.pinata.cloud/pinning/hashMetadata",
-      {
-        method: "PUT",
-        headers,
-        body: JSON.stringify(data)
-      }
-    );
+    const request = await fetch(`${endpoint}/pinning/hashMetadata`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(data)
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -883,14 +918,20 @@ var pinJobs = async (config, options) => {
     if (offset)
       params.append("offset", offset.toString());
   }
-  const url = `https://api.pinata.cloud/pinning/pinJobs?${params.toString()}`;
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const url = `${endpoint}/pinning/pinJobs?${params.toString()}`;
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/pinJobs"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/pinJobs";
   try {
     const request = await fetch(url, {
       method: "GET",
@@ -929,16 +970,21 @@ var pinnedFileCount = async (config) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const url = "https://api.pinata.cloud/data/userPinnedDataTotal";
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/pinnedFileUsage"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/pinnedFileUsage";
   try {
-    const request = await fetch(url, {
+    const request = await fetch(`${endpoint}/data/userPinnedDataTotal`, {
       method: "GET",
       headers
     });
@@ -979,16 +1025,21 @@ var totalStorageUsage = async (config) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const url = "https://api.pinata.cloud/data/userPinnedDataTotal";
-  const headers = {
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/totalStorageUsage"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/totalStorageUsage";
   try {
-    const request = await fetch(url, {
+    const request = await fetch(`${endpoint}/data/userPinnedDataTotal`, {
       method: "GET",
       headers
     });
@@ -1029,17 +1080,23 @@ var createKey = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/createKey"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/createKey";
   const data = JSON.stringify(options);
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch("https://api.pinata.cloud/v3/pinata/keys", {
+    const request = await fetch(`${endpoint}/v3/pinata/keys`, {
       method: "POST",
       headers,
       body: data
@@ -1077,14 +1134,16 @@ var listKeys = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/listKeys"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/listKeys";
   const params = new URLSearchParams();
   if (options) {
     const { offset, name, revoked, limitedUse, exhausted } = options;
@@ -1099,12 +1158,18 @@ var listKeys = async (config, options) => {
     if (name)
       params.append("name", name);
   }
-  const url = `https://api.pinata.cloud/v3/pinata/keys?${params.toString()}`;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch(url, {
-      method: "GET",
-      headers
-    });
+    const request = await fetch(
+      `${endpoint}/v3/pinata/keys?${params.toString()}`,
+      {
+        method: "GET",
+        headers
+      }
+    );
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1143,24 +1208,27 @@ var revokeKeys = async (config, keys) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/revokeKeys"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/revokeKeys";
   const responses = [];
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   for (const key of keys) {
     try {
-      const request = await fetch(
-        `https://api.pinata.cloud/v3/pinata/keys/${key}`,
-        {
-          method: "PUT",
-          headers
-        }
-      );
+      const request = await fetch(`${endpoint}/v3/pinata/keys/${key}`, {
+        method: "PUT",
+        headers
+      });
       await wait2(300);
       if (!request.ok) {
         const errorData = await request.json();
@@ -1206,16 +1274,22 @@ var createGroup = async (config, options) => {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
   const data = JSON.stringify(options);
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/createGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/createGroup";
   try {
-    const request = await fetch("https://api.pinata.cloud/groups", {
+    const request = await fetch(`${endpoint}/groups`, {
       method: "POST",
       headers,
       body: data
@@ -1253,14 +1327,16 @@ var listGroups = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/listGroups"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/listGroups";
   const params = new URLSearchParams();
   if (options) {
     const { offset, nameContains, limit } = options;
@@ -1271,9 +1347,12 @@ var listGroups = async (config, options) => {
     if (limit !== void 0)
       params.append("limit", limit.toString());
   }
-  const url = `https://api.pinata.cloud/groups?${params.toString()}`;
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch(url, {
+    const request = await fetch(`${endpoint}/groups?${params.toString()}`, {
       method: "GET",
       headers
     });
@@ -1310,22 +1389,25 @@ var getGroup = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/getGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/getGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}`,
-      {
-        method: "GET",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
+      method: "GET",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1364,23 +1446,26 @@ var addToGroup = async (config, options) => {
   const data = JSON.stringify({
     cids: options.cids
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/addToGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/addToGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}/cids`,
-      {
-        method: "PUT",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}/cids`, {
+      method: "PUT",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1419,23 +1504,26 @@ var updateGroup = async (config, options) => {
   const data = JSON.stringify({
     name: options.name
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/updateGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/updateGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}`,
-      {
-        method: "PUT",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
+      method: "PUT",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1469,26 +1557,29 @@ var removeFromGroup = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/removeFromGroup"
+    };
   }
-  headers["Source"] = headers["Source"] || "sdk/removeFromGroup";
   const data = JSON.stringify({
     cids: options.cids
   });
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}/cids`,
-      {
-        method: "DELETE",
-        headers,
-        body: data
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}/cids`, {
+      method: "DELETE",
+      headers,
+      body: data
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1526,22 +1617,25 @@ var deleteGroup = async (config, options) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/deleteGroup"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/deleteGroup";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/groups/${options.groupId}`,
-      {
-        method: "DELETE",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/groups/${options.groupId}`, {
+      method: "DELETE",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1578,17 +1672,23 @@ var addSignature = async (config, options) => {
   const data = JSON.stringify({
     signature: options.signature
   });
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/addSignature"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/addSignature";
   try {
     const request = await fetch(
-      `https://api.pinata.cloud/v3/ipfs/signature/${options.cid}`,
+      `${endpoint}/v3/ipfs/signature/${options.cid}`,
       {
         method: "POST",
         headers,
@@ -1637,22 +1737,25 @@ var getSignature = async (config, cid) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/getSignature"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/getSignature";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/v3/ipfs/signature/${cid}`,
-      {
-        method: "GET",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/v3/ipfs/signature/${cid}`, {
+      method: "GET",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1688,22 +1791,25 @@ var removeSignature = async (config, cid) => {
   if (!config || !config.pinataJwt) {
     throw new ValidationError("Pinata configuration or JWT is missing");
   }
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config?.pinataJwt}`
-  };
-  if (config.customHeaders) {
-    Object.assign(headers, config.customHeaders);
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = { ...config.customHeaders };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      Source: "sdk/removeSignature"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
   }
-  headers["Source"] = headers["Source"] || "sdk/removeSignature";
   try {
-    const request = await fetch(
-      `https://api.pinata.cloud/v3/ipfs/signature/${cid}`,
-      {
-        method: "DELETE",
-        headers
-      }
-    );
+    const request = await fetch(`${endpoint}/v3/ipfs/signature/${cid}`, {
+      method: "DELETE",
+      headers
+    });
     if (!request.ok) {
       const errorData = await request.json();
       if (request.status === 401) {
@@ -1733,6 +1839,210 @@ var removeSignature = async (config, cid) => {
   }
 };
 
+// src/core/gateway/analyticsTopUsage.ts
+var analyticsTopUsage = async (config, options) => {
+  if (!config || !config.pinataJwt) {
+    throw new ValidationError("Pinata configuration or JWT is missing");
+  }
+  const params = new URLSearchParams({
+    includesCount: "false"
+  });
+  if (options) {
+    const {
+      cid,
+      gateway_domain,
+      start_date,
+      end_date,
+      file_name,
+      user_agent,
+      country,
+      region,
+      referer,
+      limit,
+      sort_order,
+      sort_by,
+      attribute
+    } = options;
+    if (cid)
+      params.append("cid", cid);
+    if (gateway_domain)
+      params.append("gateway_domain", gateway_domain);
+    if (start_date)
+      params.append("start_date", start_date);
+    if (end_date)
+      params.append("end_date", end_date);
+    if (file_name)
+      params.append("file_name", file_name);
+    if (user_agent)
+      params.append("user_agent", user_agent.toString());
+    if (country)
+      params.append("country", country.toString());
+    if (region)
+      params.append("region", region);
+    if (referer)
+      params.append("referer", referer.toString());
+    if (limit)
+      params.append("limit", limit.toString());
+    if (sort_order)
+      params.append("sort_order", sort_order);
+    if (sort_by)
+      params.append("sort_by", sort_by);
+    if (attribute)
+      params.append("by", attribute);
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const url = `${endpoint}/v3/ipfs/gateway_analytics_top?${params.toString()}`;
+  try {
+    let headers;
+    if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+      headers = { ...config.customHeaders };
+    } else {
+      headers = {
+        Authorization: `Bearer ${config.pinataJwt}`,
+        Source: "sdk/analyticsTopUsage"
+      };
+    }
+    const request = await fetch(url, {
+      method: "GET",
+      headers
+    });
+    if (!request.ok) {
+      const errorData = await request.json();
+      if (request.status === 401) {
+        throw new AuthenticationError(
+          "Authentication failed",
+          request.status,
+          errorData
+        );
+      }
+      throw new NetworkError(
+        `HTTP error! status: ${request.status}`,
+        request.status,
+        errorData
+      );
+    }
+    const res = await request.json();
+    const resData = res.data;
+    return resData;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing anaytics usage: ${error.message}`
+      );
+    }
+    throw new PinataError(
+      "An unknown error occurred while fetching gateway usage"
+    );
+  }
+};
+
+// src/core/gateway/analyticsDateInterval.ts
+var analyticsDateInterval = async (config, options) => {
+  if (!config || !config.pinataJwt) {
+    throw new ValidationError("Pinata configuration or JWT is missing");
+  }
+  const params = new URLSearchParams();
+  if (options) {
+    const {
+      cid,
+      gateway_domain,
+      start_date,
+      end_date,
+      file_name,
+      user_agent,
+      country,
+      region,
+      referer,
+      limit,
+      sort_order,
+      date_interval,
+      sort_by
+    } = options;
+    if (cid)
+      params.append("cid", cid);
+    if (gateway_domain)
+      params.append("gateway_domain", gateway_domain);
+    if (start_date)
+      params.append("start_date", start_date);
+    if (end_date)
+      params.append("end_date", end_date);
+    if (file_name)
+      params.append("file_name", file_name);
+    if (user_agent)
+      params.append("user_agent", user_agent.toString());
+    if (country)
+      params.append("country", country.toString());
+    if (region)
+      params.append("region", region);
+    if (referer)
+      params.append("referer", referer.toString());
+    if (limit)
+      params.append("limit", limit.toString());
+    if (sort_order)
+      params.append("sort_order", sort_order);
+    if (sort_by)
+      params.append("sort_by", sort_by);
+    if (date_interval)
+      params.append("by", date_interval);
+  }
+  let endpoint = "https://api.pinata.cloud";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const url = `${endpoint}/v3/ipfs/gateway_analytics_time_series?${params.toString()}`;
+  try {
+    let headers;
+    if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+      headers = { ...config.customHeaders };
+    } else {
+      headers = {
+        Authorization: `Bearer ${config.pinataJwt}`,
+        Source: "sdk/analyticsDateInterval"
+      };
+    }
+    const request = await fetch(url, {
+      method: "GET",
+      headers
+    });
+    if (!request.ok) {
+      const errorData = await request.json();
+      if (request.status === 401) {
+        throw new AuthenticationError(
+          "Authentication failed",
+          request.status,
+          errorData
+        );
+      }
+      throw new NetworkError(
+        `HTTP error! status: ${request.status}`,
+        request.status,
+        errorData
+      );
+    }
+    const res = await request.json();
+    const resData = res.data;
+    return resData;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing anaytics usage: ${error.message}`
+      );
+    }
+    throw new PinataError(
+      "An unknown error occurred while fetching gateway usage"
+    );
+  }
+};
+
 // src/core/pinataSDK.ts
 var formatConfig = (config) => {
   let gateway = config?.pinataGateway;
@@ -1754,6 +2064,18 @@ var PinataSDK = class {
     this.groups = new Groups(this.config);
     this.signatures = new Signatures(this.config);
   }
+  setNewHeaders(headers) {
+    if (!this.config) {
+      this.config = { pinataJwt: "", customHeaders: {} };
+    }
+    this.config.customHeaders = { ...this.config.customHeaders, ...headers };
+    this.upload.updateConfig(this.config);
+    this.gateways.updateConfig(this.config);
+    this.usage.updateConfig(this.config);
+    this.keys.updateConfig(this.config);
+    this.groups.updateConfig(this.config);
+    this.signatures.updateConfig(this.config);
+  }
   testAuthentication() {
     return testAuthentication(this.config);
   }
@@ -1825,6 +2147,9 @@ var Upload = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   file(file, options) {
     return new UploadBuilder(this.config, uploadFile, file, options);
   }
@@ -1946,12 +2271,34 @@ var Gateways = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   get(cid) {
     return getCid(this.config, cid);
   }
   convert(url) {
     return convertIPFSUrl(this.config, url);
   }
+  topUsageAnalytics(options) {
+    return new TopGatewayAnalyticsBuilder(
+      this.config,
+      options.domain,
+      options.start,
+      options.end,
+      options.sortBy,
+      options.attribute
+    );
+  }
+  dateIntervalAnalytics(options) {
+    return new TimeIntervalGatewayAnalyticsBuilder(
+      this.config,
+      options.domain,
+      options.start,
+      options.end,
+      options.interval
+    );
+  }
 };
 var FilterPinJobs = class {
   constructor(config) {
@@ -2031,6 +2378,9 @@ var Usage = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   pinnedFileCount() {
     return pinnedFileCount(this.config);
   }
@@ -2042,6 +2392,9 @@ var Keys = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   create(options) {
     return createKey(this.config, options);
   }
@@ -2128,6 +2481,9 @@ var Groups = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   create(options) {
     return createGroup(this.config, options);
   }
@@ -2218,6 +2574,9 @@ var Signatures = class {
   constructor(config) {
     this.config = formatConfig(config);
   }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
   add(options) {
     return addSignature(this.config, options);
   }
@@ -2228,6 +2587,105 @@ var Signatures = class {
     return removeSignature(this.config, cid);
   }
 };
+var GatewayAnalyticsBuilder = class {
+  constructor(config, query) {
+    this.requestCount = 0;
+    this.lastRequestTime = 0;
+    this.MAX_REQUESTS_PER_MINUTE = 30;
+    this.MINUTE_IN_MS = 6e4;
+    this.config = config;
+    this.query = query;
+  }
+  cid(cid) {
+    this.query.cid = cid;
+    return this;
+  }
+  fileName(fileName) {
+    this.query.file_name = fileName;
+    return this;
+  }
+  userAgent(userAgent) {
+    this.query.user_agent = userAgent;
+    return this;
+  }
+  country(country) {
+    this.query.country = country;
+    return this;
+  }
+  region(region) {
+    this.query.region = region;
+    return this;
+  }
+  referer(referer) {
+    this.query.referer = referer;
+    return this;
+  }
+  limit(limit) {
+    this.query.limit = limit;
+    return this;
+  }
+  sort(order) {
+    this.query.sort_order = order;
+    return this;
+  }
+  async rateLimit() {
+    this.requestCount++;
+    const now = Date.now();
+    if (this.requestCount >= this.MAX_REQUESTS_PER_MINUTE) {
+      const timePassedSinceLastRequest = now - this.lastRequestTime;
+      if (timePassedSinceLastRequest < this.MINUTE_IN_MS) {
+        const delayTime = this.MINUTE_IN_MS - timePassedSinceLastRequest;
+        await new Promise((resolve) => setTimeout(resolve, delayTime));
+      }
+      this.requestCount = 0;
+    }
+    this.lastRequestTime = Date.now();
+  }
+  async getAnalytics() {
+    await this.rateLimit();
+    throw new Error("getAnalytics method must be implemented in derived class");
+  }
+  then(onfulfilled) {
+    return this.getAnalytics().then(onfulfilled);
+  }
+};
+var TopGatewayAnalyticsBuilder = class extends GatewayAnalyticsBuilder {
+  constructor(config, domain, start, end, sortBy, attribute) {
+    super(config, {
+      gateway_domain: domain,
+      start_date: start,
+      end_date: end,
+      sort_by: sortBy,
+      attribute
+    });
+  }
+  async getAnalytics() {
+    return analyticsTopUsage(this.config, this.query);
+  }
+  async all() {
+    return this.getAnalytics();
+  }
+};
+var TimeIntervalGatewayAnalyticsBuilder = class extends GatewayAnalyticsBuilder {
+  constructor(config, domain, start, end, dateInterval) {
+    super(config, {
+      gateway_domain: domain,
+      start_date: start,
+      end_date: end,
+      date_interval: dateInterval
+    });
+  }
+  sortBy(sortBy) {
+    this.query.sort_by = sortBy;
+    return this;
+  }
+  async getAnalytics() {
+    return analyticsDateInterval(this.config, this.query);
+  }
+  async all() {
+    return this.getAnalytics();
+  }
+};
 export {
   PinataSDK
 };