pinata 1.7.1 → 1.8.0

package/dist/index.js

@@ -110,20 +110,101 @@ var testAuthentication = async (config) => {
   }
 };
 
+// src/utils/resumable.ts
+function getFileIdFromUrl(url) {
+  const match = url.match(/\/files\/([^\/]+)/);
+  if (match && match[1]) {
+    return match[1];
+  }
+  throw new NetworkError("File ID not found in URL", 400, url);
+}
+
 // src/core/uploads/file.ts
 var uploadFile = async (config, file, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
   const jwt = options?.keys || config.pinataJwt;
-  const data = new FormData();
-  data.append("file", file, file.name);
-  data.append("name", options?.metadata?.name || file.name || "File from SDK");
-  if (options?.groupId) {
-    data.append("group_id", options.groupId);
+  let endpoint = "https://uploads.pinata.cloud/v3";
+  if (config.uploadUrl) {
+    endpoint = config.uploadUrl;
   }
-  if (options?.metadata?.keyvalues) {
-    data.append("keyvalues", JSON.stringify(options.metadata.keyvalues));
+  if (file.size > 94371840) {
+    let headers2;
+    if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+      headers2 = {
+        Authorization: `Bearer ${jwt}`,
+        ...config.customHeaders
+      };
+    } else {
+      headers2 = {
+        Authorization: `Bearer ${jwt}`,
+        Source: "sdk/file"
+      };
+    }
+    const name = options?.metadata?.name || file.name || "File from SDK";
+    let metadata = `filename ${btoa(name)},filetype ${btoa(file.type)}`;
+    if (options?.groupId) {
+      metadata + `,group_id ${btoa(options.groupId)}`;
+    }
+    if (options?.metadata?.keyvalues) {
+      metadata + `,keyvalues ${btoa(JSON.stringify(options.metadata.keyvalues))}`;
+    }
+    const urlReq = await fetch(`${endpoint}/files`, {
+      method: "POST",
+      headers: {
+        "Upload-Length": `${file.size}`,
+        "Upload-Metadata": metadata,
+        ...headers2
+      }
+    });
+    const url = urlReq.headers.get("Location");
+    if (!url) {
+      throw new NetworkError("Upload URL not provided", urlReq.status, "");
+    }
+    const chunkSize = 50 * 1024 * 1024;
+    const totalChunks = Math.ceil(file.size / chunkSize);
+    let offset = 0;
+    let uploadReq;
+    for (let i = 0; i < totalChunks; i++) {
+      const chunk = file.slice(offset, offset + chunkSize);
+      uploadReq = await fetch(url, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/offset+octet-stream",
+          "Upload-Offset": offset.toString(),
+          ...headers2
+        },
+        body: chunk
+      });
+      if (!uploadReq.ok) {
+        const errorData = await uploadReq.text();
+        throw new NetworkError(
+          `HTTP error during chunk upload: ${errorData}`,
+          uploadReq.status,
+          errorData
+        );
+      }
+      offset += chunk.size;
+    }
+    if (uploadReq.status === 204) {
+      const fileId = getFileIdFromUrl(url);
+      let dataEndpoint;
+      if (config.endpointUrl) {
+        dataEndpoint = config.endpointUrl;
+      } else {
+        dataEndpoint = "https://api.pinata.cloud/v3";
+      }
+      const fileInfoReq = await fetch(`${dataEndpoint}/files/${fileId}`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${process.env.PINATA_JWT}`
+        }
+      });
+      const fileInfo = await fileInfoReq.json();
+      const data2 = fileInfo.data;
+      return data2;
+    }
   }
   let headers;
   if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
@@ -137,9 +218,14 @@ var uploadFile = async (config, file, options) => {
       Source: "sdk/file"
     };
   }
-  let endpoint = "https://uploads.pinata.cloud/v3";
-  if (config.uploadUrl) {
-    endpoint = config.uploadUrl;
+  const data = new FormData();
+  data.append("file", file, file.name);
+  data.append("name", options?.metadata?.name || file.name || "File from SDK");
+  if (options?.groupId) {
+    data.append("group_id", options.groupId);
+  }
+  if (options?.metadata?.keyvalues) {
+    data.append("keyvalues", JSON.stringify(options.metadata.keyvalues));
   }
   try {
     const request = await fetch(`${endpoint}/files`, {
@@ -1366,7 +1452,6 @@ var deleteGroup = async (config, options) => {
       "Content-Type": "application/json",
       ...config.customHeaders
     };
-    headers = { ...config.customHeaders };
   } else {
     headers = {
       Authorization: `Bearer ${config.pinataJwt}`,
@@ -1411,6 +1496,211 @@ var deleteGroup = async (config, options) => {
   }
 };
 
+// src/core/analytics/analyticsTopUsage.ts
+var analyticsTopUsage = async (config, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration 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,
+      sort_by,
+      attribute
+    } = options;
+    const domain = gateway_domain || config.pinataGateway;
+    if (domain) {
+      const cleanDomain = domain.replace(/^https?:\/\//, "");
+      params.append("gateway_domain", cleanDomain);
+    }
+    if (cid) {
+      params.append("cid", cid);
+    }
+    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/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const url = `${endpoint}/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.text();
+      if (request.status === 401 || request.status === 403) {
+        throw new AuthenticationError(
+          `Authentication failed: ${errorData}`,
+          request.status,
+          errorData
+        );
+      }
+      throw new NetworkError(
+        `HTTP error: ${errorData}`,
+        request.status,
+        errorData
+      );
+    }
+    const res = await request.json();
+    return res;
+  } 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/analytics/analyticsDateInterval.ts
+var analyticsDateInterval = async (config, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration 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/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const url = `${endpoint}/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.text();
+      if (request.status === 401 || request.status === 403) {
+        throw new AuthenticationError(
+          `Authentication failed: ${errorData}`,
+          request.status,
+          errorData
+        );
+      }
+      throw new NetworkError(
+        `HTTP error: ${errorData}`,
+        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/files/swapCid.ts
 var swapCid = async (config, options) => {
   if (!config) {
@@ -1746,6 +2036,7 @@ var PinataSDK = class {
     this.gateways = new Gateways(this.config);
     this.keys = new Keys(this.config);
     this.groups = new Groups(this.config);
+    this.analytics = new Analytics(this.config);
   }
   setNewHeaders(headers) {
     if (!this.config) {
@@ -1757,6 +2048,7 @@ var PinataSDK = class {
     this.gateways.updateConfig(this.config);
     this.keys.updateConfig(this.config);
     this.groups.updateConfig(this.config);
+    this.analytics.updateConfig(this.config);
   }
   setNewJwt(jwt) {
     if (!this.config) {
@@ -1768,6 +2060,7 @@ var PinataSDK = class {
     this.gateways.updateConfig(this.config);
     this.keys.updateConfig(this.config);
     this.groups.updateConfig(this.config);
+    this.analytics.updateConfig(this.config);
   }
   testAuthentication() {
     return testAuthentication(this.config);
@@ -2222,6 +2515,251 @@ var FilterGroups = class {
     return allItems;
   }
 };
+var Analytics = class {
+  constructor(config) {
+    this.config = formatConfig(config);
+    this.requests = new AnalyticsRequests(this.config);
+    this.bandwidth = new AnalyticsBandwidth(this.config);
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+    this.requests.updateConfig(newConfig);
+    this.bandwidth.updateConfig(newConfig);
+  }
+  // detailed(options: {
+  // 	domain: string;
+  // 	start: string;
+  // 	end: string;
+  // 	sortBy: "requests" | "bandwidth";
+  // 	attribute:
+  // 		| "cid"
+  // 		| "country"
+  // 		| "region"
+  // 		| "user_agent"
+  // 		| "referer"
+  // 		| "file_name";
+  // }): TopAnalyticsBuilder {
+  // 	return new TopAnalyticsBuilder(
+  // 		this.config,
+  // 		options.domain,
+  // 		options.start,
+  // 		options.end,
+  // 		options.sortBy,
+  // 		options.attribute,
+  // 	);
+  // }
+  summary(options) {
+    return new TimeIntervalAnalyticsBuilder(
+      this.config,
+      options.domain,
+      options.start,
+      options.end,
+      options.interval
+    );
+  }
+};
+var calculateDates = (days) => {
+  const end = /* @__PURE__ */ new Date();
+  const start = /* @__PURE__ */ new Date();
+  start.setDate(start.getDate() - days);
+  return {
+    start: start.toISOString().split("T")[0],
+    end: end.toISOString().split("T")[0]
+  };
+};
+var AnalyticsFilter = class {
+  constructor(config, domain, start, end) {
+    this.config = config;
+    this.query = {
+      gateway_domain: domain,
+      start_date: start,
+      end_date: end,
+      sort_by: "requests",
+      // Will be overridden in child classes
+      attribute: "cid"
+    };
+  }
+  cid(cid) {
+    this.query.attribute = "cid";
+    if (cid) {
+      this.query.cid = cid;
+    }
+    return this;
+  }
+  fileName(fileName) {
+    this.query.attribute = "file_name";
+    if (fileName) {
+      this.query.file_name = fileName;
+    }
+    return this;
+  }
+  userAgent(userAgent) {
+    this.query.attribute = "user_agent";
+    if (userAgent) {
+      this.query.user_agent = userAgent;
+    }
+    return this;
+  }
+  country(country) {
+    this.query.attribute = "country";
+    if (country) {
+      this.query.country = country;
+    }
+    return this;
+  }
+  region(region) {
+    this.query.attribute = "region";
+    if (region) {
+      this.query.region = region;
+    }
+    return this;
+  }
+  referer(referer) {
+    this.query.attribute = "referer";
+    if (referer) {
+      this.query.referer = referer;
+    }
+    return this;
+  }
+  limit(limit) {
+    this.query.limit = limit;
+    return this;
+  }
+  sort(order) {
+    this.query.sort_order = order;
+    return this;
+  }
+  days(numberOfDays) {
+    const { start, end } = calculateDates(numberOfDays);
+    this.query.start_date = start;
+    this.query.end_date = end;
+    return this;
+  }
+  then(onfulfilled) {
+    return analyticsTopUsage(this.config, this.query).then(onfulfilled);
+  }
+};
+var AnalyticsRequests = class extends AnalyticsFilter {
+  constructor(config) {
+    super(config, "", "", "");
+    this.query.sort_by = "requests";
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
+  customDates(start, end) {
+    if (start)
+      this.query.start_date = start;
+    if (end)
+      this.query.end_date = end;
+    return this;
+  }
+  from(domain) {
+    this.query.gateway_domain = domain;
+    return this;
+  }
+};
+var AnalyticsBandwidth = class extends AnalyticsFilter {
+  constructor(config) {
+    super(config, "", "", "");
+    this.query.sort_by = "bandwidth";
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+  }
+  customDates(start, end) {
+    if (start)
+      this.query.start_date = start;
+    if (end)
+      this.query.end_date = end;
+    return this;
+  }
+  from(domain) {
+    this.query.gateway_domain = domain;
+    return this;
+  }
+};
+var AnalyticsBuilder = 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;
+  }
+  // private async rateLimit(): Promise<void> {
+  // 	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() {
+    throw new Error("getAnalytics method must be implemented in derived class");
+  }
+  then(onfulfilled) {
+    return this.getAnalytics().then(onfulfilled);
+  }
+};
+var TimeIntervalAnalyticsBuilder = class extends AnalyticsBuilder {
+  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();
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PinataSDK