pinata 1.1.0 → 1.3.0

package/dist/index.mjs

@@ -417,9 +417,19 @@ var listFiles = async (config, options) => {
   }
   const params = new URLSearchParams();
   if (options) {
-    const { limit, pageToken, cidPending } = options;
+    const { name, group, cid, order, limit, mimeType, pageToken, cidPending } = options;
     if (limit)
       params.append("limit", limit.toString());
+    if (name)
+      params.append("name", name);
+    if (group)
+      params.append("group", group);
+    if (cid)
+      params.append("cid", cid);
+    if (mimeType)
+      params.append("mimeType", mimeType);
+    if (order)
+      params.append("order", order);
     if (pageToken)
       params.append("pageToken", pageToken);
     if (cidPending)
@@ -531,13 +541,41 @@ var updateFile = async (config, options) => {
 };
 
 // src/core/gateway/getCid.ts
-var getCid = async (config, cid) => {
+var getCid = async (config, cid, options) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
   let data;
   let newUrl = `${config?.pinataGateway}/files/${cid}`;
   const params = new URLSearchParams();
+  if (options) {
+    if (options.width)
+      params.append("img-width", options.width.toString());
+    if (options.height)
+      params.append("img-height", options.height.toString());
+    if (options.dpr)
+      params.append("img-dpr", options.dpr.toString());
+    if (options.fit)
+      params.append("img-fit", options.fit);
+    if (options.gravity)
+      params.append("img-gravity", options.gravity);
+    if (options.quality)
+      params.append("img-quality", options.quality.toString());
+    if (options.format)
+      params.append("img-format", options.format);
+    if (options.animation !== void 0)
+      params.append("img-anim", options.animation.toString());
+    if (options.sharpen)
+      params.append("img-sharpen", options.sharpen.toString());
+    if (options.onError === true)
+      params.append("img-onerror", "redirect");
+    if (options.metadata)
+      params.append("img-metadata", options.metadata);
+  }
+  const queryString = params.toString();
+  if (queryString) {
+    newUrl += `?${queryString}`;
+  }
   const date = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
   const payload = JSON.stringify({
     url: newUrl,
@@ -545,17 +583,18 @@ var getCid = async (config, cid) => {
     expires: 30,
     method: "GET"
   });
-  const signedUrlRequest = await fetch(
-    "https://api.pinata.cloud/v3/files/sign",
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${config?.pinataJwt}`
-      },
-      body: payload
-    }
-  );
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  const signedUrlRequest = await fetch(`${endpoint}/files/sign`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config?.pinataJwt}`
+    },
+    body: payload
+  });
   const signedUrl = await signedUrlRequest.json();
   try {
     const request = await fetch(signedUrl.data);
@@ -868,13 +907,13 @@ var listGroups = async (config, options) => {
   }
   const params = new URLSearchParams();
   if (options) {
-    const { pageToken, nameContains, limit, isPublic } = options;
+    const { pageToken, name, limit, isPublic } = options;
     if (pageToken)
       params.append("pageToken", pageToken.toString());
     if (isPublic)
       params.append("isPublic", isPublic.toString());
-    if (nameContains !== void 0)
-      params.append("nameContains", nameContains.toString());
+    if (name)
+      params.append("name", name);
     if (limit !== void 0)
       params.append("limit", limit.toString());
   }
@@ -1084,12 +1123,242 @@ var deleteGroup = async (config, options) => {
   }
 };
 
+// src/core/files/swapCid.ts
+var swapCid = async (config, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  const data = JSON.stringify({
+    swap_cid: options.swapCid
+  });
+  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/swapCid"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(`${endpoint}/files/swap/${options.cid}`, {
+      method: "PUT",
+      headers,
+      body: data
+    });
+    if (!request.ok) {
+      const errorData = await request.text();
+      if (request.status === 401 || request.status === 403) {
+        throw new AuthenticationError(
+          `Authentication failed: ${errorData}`,
+          request.status,
+          errorData
+        );
+      }
+      if (request.status === 403) {
+        throw new PinataError(
+          "Unauthorized CID Swap",
+          request.status,
+          errorData
+        );
+      }
+      if (request.status === 404) {
+        throw new PinataError(
+          "CID not pinned to account",
+          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 CID Swap: ${error.message}`);
+    }
+    throw new PinataError("An unknown error occurred while swapping CID");
+  }
+};
+
+// src/core/files/swapHistory.ts
+var swapHistory = async (config, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  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/swapHistory"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(
+      `${endpoint}/files/swap/${options.cid}?domain=${options.domain}`,
+      {
+        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
+        );
+      }
+      if (request.status === 404) {
+        throw new PinataError(
+          "CID does not have history",
+          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 fetching swap history: ${error.message}`);
+    }
+    throw new PinataError(
+      "An unknown error occurred while fetching swap history"
+    );
+  }
+};
+
+// src/core/files/deleteSwap.ts
+var deleteSwap = async (config, cid) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  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/deleteSwap"
+    };
+  }
+  let endpoint = "https://api.pinata.cloud/v3";
+  if (config.endpointUrl) {
+    endpoint = config.endpointUrl;
+  }
+  try {
+    const request = await fetch(`${endpoint}/files/swap/${cid}`, {
+      method: "DELETE",
+      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
+        );
+      }
+      if (request.status === 403) {
+        throw new PinataError(
+          "Unauthorized CID Swap Deletion",
+          request.status,
+          errorData
+        );
+      }
+      if (request.status === 404) {
+        throw new PinataError(
+          "CID not pinned to account",
+          request.status,
+          errorData
+        );
+      }
+      throw new NetworkError(
+        `HTTP error: ${errorData}`,
+        request.status,
+        errorData
+      );
+    }
+    return request.statusText;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(`Error processing deleteSwap: ${error.message}`);
+    }
+    throw new PinataError("An unknown error occurred while deleting swap");
+  }
+};
+
 // src/core/gateway/createSignedURL.ts
-var createSignedURL = async (config, options) => {
+var createSignedURL = async (config, options, imgOpts) => {
   if (!config) {
     throw new ValidationError("Pinata configuration is missing");
   }
   let newUrl = `${config?.pinataGateway}/files/${options.cid}`;
+  const params = new URLSearchParams();
+  if (imgOpts) {
+    if (imgOpts.width)
+      params.append("img-width", imgOpts.width.toString());
+    if (imgOpts.height)
+      params.append("img-height", imgOpts.height.toString());
+    if (imgOpts.dpr)
+      params.append("img-dpr", imgOpts.dpr.toString());
+    if (imgOpts.fit)
+      params.append("img-fit", imgOpts.fit);
+    if (imgOpts.gravity)
+      params.append("img-gravity", imgOpts.gravity);
+    if (imgOpts.quality)
+      params.append("img-quality", imgOpts.quality.toString());
+    if (imgOpts.format)
+      params.append("img-format", imgOpts.format);
+    if (imgOpts.animation !== void 0)
+      params.append("img-anim", imgOpts.animation.toString());
+    if (imgOpts.sharpen)
+      params.append("img-sharpen", imgOpts.sharpen.toString());
+    if (imgOpts.onError === true)
+      params.append("img-onerror", "redirect");
+    if (imgOpts.metadata)
+      params.append("img-metadata", imgOpts.metadata);
+  }
+  const queryString = params.toString();
+  if (queryString) {
+    newUrl += `?${queryString}`;
+  }
   const date = options?.date || Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
   const payload = JSON.stringify({
     url: newUrl,
@@ -1192,6 +1461,15 @@ var Files = class {
   update(options) {
     return updateFile(this.config, options);
   }
+  addSwap(options) {
+    return swapCid(this.config, options);
+  }
+  getSwapHistory(options) {
+    return swapHistory(this.config, options);
+  }
+  deleteSwap(cid) {
+    return deleteSwap(this.config, cid);
+  }
 };
 var UploadBuilder = class {
   constructor(config, uploadFunction, ...args) {
@@ -1269,6 +1547,26 @@ var FilterFiles = class {
     this.query = {};
     this.config = config;
   }
+  name(name) {
+    this.query.name = name;
+    return this;
+  }
+  group(group) {
+    this.query.group = group;
+    return this;
+  }
+  cid(cid) {
+    this.query.cid = cid;
+    return this;
+  }
+  mimeType(mimeType) {
+    this.query.mimeType = mimeType;
+    return this;
+  }
+  order(order) {
+    this.query.order = order;
+    return this;
+  }
   limit(limit) {
     this.query.limit = limit;
     return this;
@@ -1333,20 +1631,11 @@ var Gateways = class {
     this.config = newConfig;
   }
   get(cid) {
-    return getCid(this.config, cid);
+    return new OptimizeImageGetCid(this.config, cid);
   }
   createSignedURL(options) {
-    return createSignedURL(this.config, options);
+    return new OptimizeImageCreateSignedURL(this.config, options);
   }
-  // get(cid: string): OptimizeImage {
-  // 	return new OptimizeImage(this.config, cid);
-  // }
-  // convert(url: string, gatewayPrefix?: string): Promise<string> {
-  // 	return convertIPFSUrl(this.config, url, gatewayPrefix);
-  // }
-  // containsCID(cid: string): Promise<ContainsCIDResponse> {
-  // 	return containsCID(cid);
-  // }
   // topUsageAnalytics(options: {
   // 	domain: string;
   // 	start: string;
@@ -1383,15 +1672,36 @@ var Gateways = class {
   // 		options.interval,
   // 	);
   // }
-  // swapCid(options: SwapCidOptions): Promise<SwapCidResponse> {
-  // 	return swapCid(this.config, options);
-  // }
-  // swapHistory(options: SwapHistoryOptions): Promise<SwapCidResponse[]> {
-  // 	return swapHistory(this.config, options);
-  // }
-  // deleteSwap(cid: string): Promise<string> {
-  // 	return deleteSwap(this.config, cid);
-  // }
+};
+var OptimizeImageGetCid = class {
+  constructor(config, cid) {
+    this.options = {};
+    this.config = config;
+    this.cid = cid;
+  }
+  optimizeImage(options) {
+    this.options = { ...this.options, ...options };
+    return this;
+  }
+  then(onfulfilled) {
+    return getCid(this.config, this.cid, this.options).then(onfulfilled);
+  }
+};
+var OptimizeImageCreateSignedURL = class {
+  constructor(config, urlOpts) {
+    this.imgOpts = {};
+    this.config = config;
+    this.urlOpts = urlOpts;
+  }
+  optimizeImage(options) {
+    this.imgOpts = { ...this.imgOpts, ...options };
+    return this;
+  }
+  then(onfulfilled) {
+    return createSignedURL(this.config, this.urlOpts, this.imgOpts).then(
+      onfulfilled
+    );
+  }
 };
 var Keys = class {
   constructor(config) {
@@ -1514,10 +1824,10 @@ var FilterGroups = class {
     this.query = {};
     this.config = config;
   }
-  // name(nameContains: string): FilterGroups {
-  // 	this.query.nameContains = nameContains;
-  // 	return this;
-  // }
+  name(name) {
+    this.query.name = name;
+    return this;
+  }
   limit(limit) {
     this.query.limit = limit;
     return this;