pinata 1.8.1 → 1.9.0

package/dist/index.mjs

@@ -172,11 +172,33 @@ var uploadFile = async (config, file, options) => {
       const fileInfoReq = await fetch(`${dataEndpoint}/files/${fileId}`, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${process.env.PINATA_JWT}`
+          Authorization: `Bearer ${jwt}`
         }
       });
       const fileInfo = await fileInfoReq.json();
       const data2 = fileInfo.data;
+      if (options?.vectorize) {
+        const vectorReq = await fetch(
+          `${endpoint}/vectorize/files/${data2.id}`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${jwt}`
+            }
+          }
+        );
+        if (vectorReq.ok) {
+          data2.vectorized = true;
+          return data2;
+        } else {
+          const errorData = await vectorReq.text();
+          throw new NetworkError(
+            `HTTP error during vectorization: ${errorData}`,
+            vectorReq.status,
+            errorData
+          );
+        }
+      }
       return data2;
     }
   }
@@ -224,6 +246,28 @@ var uploadFile = async (config, file, options) => {
     }
     const res = await request.json();
     const resData = res.data;
+    if (options?.vectorize) {
+      const vectorReq = await fetch(
+        `${endpoint}/vectorize/files/${resData.id}`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${jwt}`
+          }
+        }
+      );
+      if (vectorReq.ok) {
+        resData.vectorized = true;
+        return resData;
+      } else {
+        const errorData = await vectorReq.text();
+        throw new NetworkError(
+          `HTTP error during vectorization: ${errorData}`,
+          vectorReq.status,
+          errorData
+        );
+      }
+    }
     return resData;
   } catch (error) {
     if (error instanceof PinataError) {
@@ -293,6 +337,28 @@ var uploadBase64 = async (config, base64String, options) => {
     }
     const res = await request.json();
     const resData = res.data;
+    if (options?.vectorize) {
+      const vectorReq = await fetch(
+        `${endpoint}/vectorize/files/${resData.id}`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${jwt}`
+          }
+        }
+      );
+      if (vectorReq.ok) {
+        resData.vectorized = true;
+        return resData;
+      } else {
+        const errorData = await vectorReq.text();
+        throw new NetworkError(
+          `HTTP error during vectorization: ${errorData}`,
+          vectorReq.status,
+          errorData
+        );
+      }
+    }
     return resData;
   } catch (error) {
     if (error instanceof PinataError) {
@@ -374,6 +440,28 @@ var uploadUrl = async (config, url, options) => {
     }
     const res = await request.json();
     const resData = res.data;
+    if (options?.vectorize) {
+      const vectorReq = await fetch(
+        `${endpoint}/vectorize/files/${resData.id}`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${jwt}`
+          }
+        }
+      );
+      if (vectorReq.ok) {
+        resData.vectorized = true;
+        return resData;
+      } else {
+        const errorData = await vectorReq.text();
+        throw new NetworkError(
+          `HTTP error during vectorization: ${errorData}`,
+          vectorReq.status,
+          errorData
+        );
+      }
+    }
     return resData;
   } catch (error) {
     if (error instanceof PinataError) {
@@ -443,6 +531,28 @@ var uploadJson = async (config, jsonData, options) => {
     }
     const res = await request.json();
     const resData = res.data;
+    if (options?.vectorize) {
+      const vectorReq = await fetch(
+        `${endpoint}/vectorize/files/${resData.id}`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${jwt}`
+          }
+        }
+      );
+      if (vectorReq.ok) {
+        resData.vectorized = true;
+        return resData;
+      } else {
+        const errorData = await vectorReq.text();
+        throw new NetworkError(
+          `HTTP error during vectorization: ${errorData}`,
+          vectorReq.status,
+          errorData
+        );
+      }
+    }
     return resData;
   } catch (error) {
     if (error instanceof PinataError) {
@@ -1990,6 +2100,191 @@ var createSignedURL = async (config, options, imgOpts) => {
   }
 };
 
+// src/core/files/vectorizeFile.ts
+var vectorizeFile = async (config, fileId) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/vectorizeFile"
+    };
+  }
+  let endpoint = "https://uploads.pinata.cloud/v3";
+  if (config.uploadUrl) {
+    endpoint = config.uploadUrl;
+  }
+  try {
+    const request = await fetch(`${endpoint}/vectorize/files/${fileId}`, {
+      method: "POST",
+      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 vectorize file: ${error.message}`
+      );
+    }
+    throw new PinataError("An unknown error occurred while vectorizing file");
+  }
+};
+
+// src/core/files/vectorizeQuery.ts
+var vectorizeQuery = async (config, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/vectorQuery"
+    };
+  }
+  let endpoint = "https://uploads.pinata.cloud/v3";
+  if (config.uploadUrl) {
+    endpoint = config.uploadUrl;
+  }
+  const body = JSON.stringify({
+    text: options.query
+  });
+  try {
+    const request = await fetch(
+      `${endpoint}/vectorize/groups/${options.groupId}/query`,
+      {
+        method: "POST",
+        headers,
+        body
+      }
+    );
+    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;
+    if (options.returnFile) {
+      if (resData.matches.length === 0) {
+        throw new PinataError(`No files returned in query to fetch`);
+      }
+      console.log(config.pinataGateway);
+      const cid = resData.matches[0].cid;
+      const fileRes = await getCid(config, cid, void 0);
+      return fileRes;
+    }
+    return resData;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing vectorize file: ${error.message}`
+      );
+    }
+    throw new PinataError("An unknown error occurred while vectorizing file");
+  }
+};
+
+// src/core/files/deleteFileVectors.ts
+var deleteFileVectors = async (config, fileId) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/vectorizeFile"
+    };
+  }
+  let endpoint = "https://uploads.pinata.cloud/v3";
+  if (config.uploadUrl) {
+    endpoint = config.uploadUrl;
+  }
+  try {
+    const request = await fetch(`${endpoint}/vectorize/files/${fileId}`, {
+      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
+        );
+      }
+      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 vectorize file: ${error.message}`
+      );
+    }
+    throw new PinataError("An unknown error occurred while vectorizing file");
+  }
+};
+
 // src/core/pinataSDK.ts
 var formatConfig = (config) => {
   let gateway = config?.pinataGateway;
@@ -2065,6 +2360,15 @@ var Files = class {
   deleteSwap(cid) {
     return deleteSwap(this.config, cid);
   }
+  vectorize(fileId) {
+    return vectorizeFile(this.config, fileId);
+  }
+  queryVectors(options) {
+    return vectorizeQuery(this.config, options);
+  }
+  deleteVectors(fileId) {
+    return deleteFileVectors(this.config, fileId);
+  }
 };
 var UploadBuilder = class {
   constructor(config, uploadFunction, ...args) {
@@ -2080,6 +2384,10 @@ var UploadBuilder = class {
     this.keys = jwt;
     return this;
   }
+  vectorize() {
+    this.vector = true;
+    return this;
+  }
   // cidVersion(v: 0 | 1): UploadBuilder<T> {
   // 	this.version = v;
   // 	return this;
@@ -2099,6 +2407,9 @@ var UploadBuilder = class {
     if (this.groupId) {
       options.groupId = this.groupId;
     }
+    if (this.vector) {
+      options.vectorize = this.vector;
+    }
     this.args[this.args.length - 1] = options;
     return this.uploadFunction(this.config, ...this.args).then(
       onfulfilled,
@@ -2239,42 +2550,6 @@ var Gateways = class {
   createSignedURL(options) {
     return new OptimizeImageCreateSignedURL(this.config, options);
   }
-  // topUsageAnalytics(options: {
-  // 	domain: string;
-  // 	start: string;
-  // 	end: string;
-  // 	sortBy: "requests" | "bandwidth";
-  // 	attribute:
-  // 		| "cid"
-  // 		| "country"
-  // 		| "region"
-  // 		| "user_agent"
-  // 		| "referer"
-  // 		| "file_name";
-  // }): TopGatewayAnalyticsBuilder {
-  // 	return new TopGatewayAnalyticsBuilder(
-  // 		this.config,
-  // 		options.domain,
-  // 		options.start,
-  // 		options.end,
-  // 		options.sortBy,
-  // 		options.attribute,
-  // 	);
-  // }
-  // dateIntervalAnalytics(options: {
-  // 	domain: string;
-  // 	start: string;
-  // 	end: string;
-  // 	interval: "day" | "week";
-  // }): TimeIntervalGatewayAnalyticsBuilder {
-  // 	return new TimeIntervalGatewayAnalyticsBuilder(
-  // 		this.config,
-  // 		options.domain,
-  // 		options.start,
-  // 		options.end,
-  // 		options.interval,
-  // 	);
-  // }
 };
 var OptimizeImageGetCid = class {
   constructor(config, cid) {
@@ -2500,28 +2775,6 @@ var Analytics = class {
     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,