pinata 1.9.1 → 1.10.1

package/dist/index.mjs

@@ -124,7 +124,11 @@ var uploadFile = async (config, file, options) => {
     if (options?.metadata?.keyvalues) {
       metadata + `,keyvalues ${btoa(JSON.stringify(options.metadata.keyvalues))}`;
     }
-    const urlReq = await fetch(`${endpoint}/files`, {
+    let updatedEndpoint = `${endpoint}/files`;
+    if (options?.url) {
+      updatedEndpoint = options.url;
+    }
+    const urlReq = await fetch(updatedEndpoint, {
       method: "POST",
       headers: {
         "Upload-Length": `${file.size}`,
@@ -216,6 +220,43 @@ var uploadFile = async (config, file, options) => {
   }
   const data = new FormData();
   data.append("file", file, file.name);
+  if (options?.url) {
+    try {
+      const request = await fetch(options.url, {
+        method: "POST",
+        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
+          );
+        }
+        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 base64: ${error.message}`);
+      }
+      throw new PinataError(
+        "An unknown error occurred while trying to upload base64"
+      );
+    }
+  }
   data.append("name", options?.metadata?.name || file.name || "File from SDK");
   if (options?.groupId) {
     data.append("group_id", options.groupId);
@@ -314,6 +355,42 @@ var uploadBase64 = async (config, base64String, options) => {
   if (config.uploadUrl) {
     endpoint = config.uploadUrl;
   }
+  if (options?.url) {
+    try {
+      const request = await fetch(options.url, {
+        method: "POST",
+        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
+          );
+        }
+        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 base64: ${error.message}`);
+      }
+      throw new PinataError(
+        "An unknown error occurred while trying to upload base64"
+      );
+    }
+  }
   try {
     const request = await fetch(`${endpoint}/files`, {
       method: "POST",
@@ -417,6 +494,42 @@ var uploadUrl = async (config, url, options) => {
   if (config.uploadUrl) {
     endpoint = config.uploadUrl;
   }
+  if (options?.url) {
+    try {
+      const request = await fetch(options.url, {
+        method: "POST",
+        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
+          );
+        }
+        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 base64: ${error.message}`);
+      }
+      throw new PinataError(
+        "An unknown error occurred while trying to upload base64"
+      );
+    }
+  }
   try {
     const request = await fetch(`${endpoint}/files`, {
       method: "POST",
@@ -508,6 +621,42 @@ var uploadJson = async (config, jsonData, options) => {
   if (config.uploadUrl) {
     endpoint = config.uploadUrl;
   }
+  if (options?.url) {
+    try {
+      const request = await fetch(options.url, {
+        method: "POST",
+        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
+          );
+        }
+        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 base64: ${error.message}`);
+      }
+      throw new PinataError(
+        "An unknown error occurred while trying to upload base64"
+      );
+    }
+  }
   try {
     const request = await fetch(`${endpoint}/files`, {
       method: "POST",
@@ -2284,6 +2433,79 @@ var deleteFileVectors = async (config, fileId) => {
   }
 };
 
+// src/core/uploads/createSignedUploadURL.ts
+var createSignedUploadURL = async (config, options) => {
+  if (!config) {
+    throw new ValidationError("Pinata configuration is missing");
+  }
+  const date = options?.date || Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+  const payload = {
+    date,
+    expires: options.expires
+  };
+  if (options.groupId) {
+    payload.group_id = options.groupId;
+  }
+  if (options.name) {
+    payload.filename = options.name;
+  }
+  if (options.keyvalues) {
+    payload.keyvalues = options.keyvalues;
+  }
+  let endpoint = "https://uploads.pinata.cloud/v3";
+  if (config.uploadUrl) {
+    endpoint = config.uploadUrl;
+  }
+  let headers;
+  if (config.customHeaders && Object.keys(config.customHeaders).length > 0) {
+    headers = {
+      Authorization: `Bearer ${config.pinataJwt}`,
+      "Content-Type": "application/json",
+      ...config.customHeaders
+    };
+  } else {
+    headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.pinataJwt}`,
+      Source: "sdk/createSignURL"
+    };
+  }
+  try {
+    const request = await fetch(`${endpoint}/files/sign`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    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.data;
+  } catch (error) {
+    if (error instanceof PinataError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new PinataError(
+        `Error processing createSignedURL: ${error.message}`
+      );
+    }
+    throw new PinataError("An unknown error occurred while getting signed url");
+  }
+};
+
 // src/core/pinataSDK.ts
 var formatConfig = (config) => {
   let gateway = config?.pinataGateway;
@@ -2387,6 +2609,10 @@ var UploadBuilder = class {
     this.vector = true;
     return this;
   }
+  url(url) {
+    this.uploadUrl = url;
+    return this;
+  }
   // cidVersion(v: 0 | 1): UploadBuilder<T> {
   // 	this.version = v;
   // 	return this;
@@ -2409,6 +2635,9 @@ var UploadBuilder = class {
     if (this.vector) {
       options.vectorize = this.vector;
     }
+    if (this.uploadUrl) {
+      options.url = this.uploadUrl;
+    }
     this.args[this.args.length - 1] = options;
     return this.uploadFunction(this.config, ...this.args).then(
       onfulfilled,
@@ -2441,6 +2670,9 @@ var Upload = class {
   json(data, options) {
     return new UploadBuilder(this.config, uploadJson, data, options);
   }
+  createSignedURL(options) {
+    return createSignedUploadURL(this.config, options);
+  }
 };
 var FilterFiles = class {
   // rate limit vars