@meistrari/vault-sdk 1.1.0 → 1.3.0

package/dist/index.mjs

@@ -2,6 +2,35 @@ import { GetUploadUrlResponseV2, GetDownloadUrlResponse } from '@meistrari/vault
 import { fileTypeFromBlob } from 'file-type';
 import { lookup } from 'mime-types';
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class DataTokenAuthStrategy {
+  constructor(dataToken) {
+    __publicField$1(this, "dataToken");
+    this.dataToken = dataToken;
+  }
+  getHeaders() {
+    return new Headers({
+      "x-data-token": this.dataToken
+    });
+  }
+}
+class APIKeyAuthStrategy {
+  constructor(apiKey) {
+    __publicField$1(this, "apiKey");
+    this.apiKey = apiKey;
+  }
+  getHeaders() {
+    return new Headers({
+      Authorization: this.apiKey
+    });
+  }
+}
+
 class FetchError extends Error {
   constructor(message, url, method, response) {
     super(message);
@@ -54,10 +83,10 @@ async function detectFileMimeType(blob) {
   return void 0;
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 const compatibilityDate = "2025-05-19";
@@ -86,13 +115,13 @@ class VaultFile {
    * @param params.metadata - The metadata of the file
    */
   constructor({ config, content, id, name, metadata }) {
-    __publicField$1(this, "id");
-    __publicField$1(this, "name");
-    __publicField$1(this, "metadata");
-    __publicField$1(this, "config");
-    __publicField$1(this, "content");
-    __publicField$1(this, "lastDownloadUrl");
-    __publicField$1(this, "lastUploadUrl");
+    __publicField(this, "id");
+    __publicField(this, "name");
+    __publicField(this, "metadata");
+    __publicField(this, "config");
+    __publicField(this, "content");
+    __publicField(this, "lastDownloadUrl");
+    __publicField(this, "lastUploadUrl");
     this.config = config;
     this.content = content;
     this.id = id;
@@ -114,38 +143,46 @@ class VaultFile {
    * @param params.method - The method to use for the fetch
    * @param params.path - The path to fetch
    * @param params.body - The body of the request
+   * @param params.signal - The signal to abort the request
    * @returns The response from the vault
    * @throws {FetchError} If the fetch fails
    */
   async _fetch(params) {
-    const { method, path, body } = params;
+    const { method, path, body, signal } = params;
     const url = new URL(this.config.vaultUrl + path).toString();
     const headers = new Headers(this.headers);
     headers.set("x-compatibility-date", compatibilityDate);
     const response = await wrappedFetch(url, {
       method,
       body,
-      headers
+      headers,
+      signal
     });
     const content = await response.json();
     return content;
   }
   /**
    * Creates a new file in the vault.
+   * @param metadata - The metadata for creating a file
+   * @param metadata.size - The size of the file
+   * @param metadata.mimeType - The mime type of the file
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
    *
    * @returns The metadata of the file
    * @throws {Error} If the file ID is not set
    * @throws {FetchError} If the metadata fetch fails
    */
-  async _createFile(params = {}) {
+  async _createFile(metadata = {}, options) {
     const response = await this._fetch({
       method: "POST",
       path: `/v2/files`,
       body: JSON.stringify({
-        ...params,
+        ...metadata,
         fileName: this.name,
         sha256sum: this.id ?? this.metadata?.id ?? (this.content ? await getFileHash(this.content) : void 0)
-      })
+      }),
+      signal: options?.signal
     }).then((data) => GetUploadUrlResponseV2.safeParse(data));
     if (!response.success) {
       throw new Error(`Invalid response from vault service. ${JSON.stringify(response.error)}`);
@@ -162,6 +199,9 @@ class VaultFile {
    * @param params.reference - The reference to the file in the vault
    * @param params.config - The configuration for the VaultFile
    * @param params.download - Whether to download the file content (default: false)
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
+   *
    * @returns A new VaultFile instance
    *
    * @example
@@ -191,13 +231,14 @@ class VaultFile {
    * const content = vaultFile.content
    * ```
    */
-  static async fromVaultReference(params) {
+  static async fromVaultReference(params, options) {
     const { reference, config, download = false } = params;
     const { vaultUrl, authStrategy } = config;
     const id = removeVaultPrefix(reference);
     const response = await wrappedFetch(`${vaultUrl}/v2/files/${id}`, {
       method: "GET",
-      headers: authStrategy.getHeaders()
+      headers: authStrategy.getHeaders(),
+      signal: options?.signal
     }).then((response2) => response2.json()).then((data) => GetDownloadUrlResponse.safeParse(data));
     if (!response.success) {
       throw new Error("Invalid response from vault service");
@@ -212,7 +253,7 @@ class VaultFile {
       name: response.data.metadata?.originalFileName
     };
     if (download) {
-      await wrappedFetch(response.data.url, { method: "GET" }).then((response2) => response2.blob()).then((blob) => fileParams.content = blob);
+      await wrappedFetch(response.data.url, { method: "GET", signal: options?.signal }).then((response2) => response2.blob()).then((blob) => fileParams.content = blob);
     }
     return new VaultFile(fileParams);
   }
@@ -224,6 +265,9 @@ class VaultFile {
    * @param params.content - The content of the file
    * @param params.config - The configuration for the VaultFile
    * @param params.upload - Whether to upload the file (default: false)
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
+   *
    * @returns A new VaultFile instance
    *
    * @example
@@ -256,7 +300,7 @@ class VaultFile {
    * })
    * ```
    */
-  static async fromContent(params) {
+  static async fromContent(params, options) {
     const { name, content, config, upload = false } = params;
     const { vaultUrl, authStrategy } = config;
     const sha256sum = await getFileHash(content);
@@ -274,22 +318,24 @@ class VaultFile {
     const createdFile = await file._createFile({
       size,
       mimeType
-    });
+    }, { signal: options?.signal });
     if (upload) {
-      await file.upload(file.content, createdFile.uploadUrl);
+      await file.upload(file.content, createdFile.uploadUrl, { signal: options?.signal });
     }
     return file;
   }
   /**
    * Populates the metadata of the file instance.
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
    *
    * @returns The file instance
    * @throws {Error} If the file ID is not set
    * @throws {FetchError} If the metadata fetch fails
    */
-  async populateMetadata() {
+  async populateMetadata(options) {
     try {
-      this.metadata = await this.getFileMetadata();
+      this.metadata = await this.getFileMetadata({ signal: options?.signal });
       this.name = this.metadata.originalFileName;
       this.id = this.metadata.id;
       return this;
@@ -311,29 +357,34 @@ class VaultFile {
   }
   /**
    * Fetches the metadata of the file.
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
    *
    * @returns The metadata of the file
    * @throws {Error} If the file ID is not set
    * @throws {FetchError} If the metadata fetch fails
    */
-  async getFileMetadata() {
+  async getFileMetadata(options) {
     if (!this.id) {
       throw new Error("File ID is not set");
     }
     const response = await this._fetch({
       method: "GET",
-      path: `/v2/files/${this.id}/metadata`
+      path: `/v2/files/${this.id}/metadata`,
+      signal: options?.signal
     });
     return response;
   }
   /**
    * Fetches a upload URL for the file.
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
    *
    * @returns The upload URL for the file
    * @throws {Error} If the vault service returns an invalid response
    * @throws {FetchError} If the upload URL fetch fails
    */
-  async getUploadUrl() {
+  async getUploadUrl(options) {
     if (this.lastUploadUrl && this.lastUploadUrl.expiresAt > /* @__PURE__ */ new Date()) {
       return this.lastUploadUrl.url;
     }
@@ -347,7 +398,8 @@ class VaultFile {
     }
     const response = await this._fetch({
       method: "PUT",
-      path: `/v2/files/${this.id}`
+      path: `/v2/files/${this.id}`,
+      signal: options?.signal
     }).then(GetUploadUrlResponseV2.safeParse);
     if (!response.success) {
       throw new Error(`Invalid response from vault service. ${JSON.stringify(response.error)}`);
@@ -357,13 +409,15 @@ class VaultFile {
   }
   /**
    * Fetches a download URL for the file.
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
    *
    * @returns The download URL for the file
    * @throws {Error} If the vault service returns an invalid response
    * @throws {Error} If not file ID, name or content is set
    * @throws {FetchError} If the download URL fetch fails
    */
-  async getDownloadUrl() {
+  async getDownloadUrl(options) {
     if (this.lastDownloadUrl && this.lastDownloadUrl.expiresAt > /* @__PURE__ */ new Date()) {
       return this.lastDownloadUrl.url;
     }
@@ -373,7 +427,8 @@ class VaultFile {
     const id = this.id ?? this.metadata?.id ?? (this.content ? await getFileHash(this.content) : this.name);
     const response = await this._fetch({
       method: "GET",
-      path: `/v2/files/${id}`
+      path: `/v2/files/${id}`,
+      signal: options?.signal
     });
     this.lastDownloadUrl = { url: new URL(response.url), expiresAt: new Date(response.expiresAt) };
     return this.lastDownloadUrl.url;
@@ -396,11 +451,15 @@ class VaultFile {
    * ```
    *
    * @param file - The file to upload to the vault. If not provided, the file content will be taken from the `content` property.
+   * @param url - The URL to upload the file to. If not provided, the upload URL will be fetched from the vault.
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
+   *
    * @throws {FetchError} If the upload fails
    * @throws {Error} If the file content is not set and no file is provided
    * @returns Promise that resolves when upload is complete
    */
-  async upload(file, url) {
+  async upload(file, url, options) {
     const content = file ?? this.content;
     if (!content) {
       throw new Error("Missing file content. Use fromContent() to create a file with content, or provide a file to upload.");
@@ -413,63 +472,52 @@ class VaultFile {
     await wrappedFetch(uploadUrl, {
       method: "PUT",
       body: content,
-      headers
+      headers,
+      signal: options?.signal
     });
   }
-  async download(responseType = "blob") {
-    const downloadUrl = await this.getDownloadUrl();
+  async download(responseType = "blob", options) {
+    const downloadUrl = await this.getDownloadUrl({ signal: options?.signal });
     const response = await wrappedFetch(downloadUrl, {
-      method: "GET"
+      method: "GET",
+      signal: options?.signal
     });
     const blob = await response.blob();
     if (responseType === "blob")
       return blob;
     return await blobToBase64(blob);
   }
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class DataTokenAuthStrategy {
-  constructor(dataToken) {
-    __publicField(this, "dataToken");
-    this.dataToken = dataToken;
-  }
-  getHeaders() {
-    return new Headers({
-      "x-data-token": this.dataToken
-    });
-  }
-}
-class APIKeyAuthStrategy {
-  constructor(apiKey) {
-    __publicField(this, "apiKey");
-    this.apiKey = apiKey;
-  }
-  getHeaders() {
-    return new Headers({
-      Authorization: this.apiKey
+  /**
+   * Deletes the file from the vault.
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
+   *
+   */
+  async delete(options) {
+    if (!this.id) {
+      throw new Error("File ID is not set");
+    }
+    await this._fetch({
+      method: "DELETE",
+      path: `/v2/files/${this.id}`,
+      signal: options?.signal
     });
   }
 }
 
 function vaultClient(config) {
-  function createFromContent(name, content) {
+  function createFromContent(name, content, options) {
     return VaultFile.fromContent({
       name,
       content,
       config
-    });
+    }, { signal: options?.signal });
   }
-  function createFromReference(reference) {
+  function createFromReference(reference, options) {
     return VaultFile.fromVaultReference({
       reference,
       config
-    });
+    }, { signal: options?.signal });
   }
   return { createFromContent, createFromReference };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/vault-sdk",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",