@meistrari/vault-sdk 1.0.1 → 1.2.0

package/dist/index.cjs

@@ -1,6 +1,37 @@
 'use strict';
 
 const schemas = require('@meistrari/vault-shared/schemas');
+const fileType = require('file-type');
+const mimeTypes = require('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) {
@@ -34,11 +65,30 @@ async function getFileHash(blob) {
   const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
   return hashHex;
 }
+async function detectFileMimeType(blob) {
+  const result = await fileType.fileTypeFromBlob(blob).catch(() => void 0);
+  if (result?.mime) {
+    return result.mime;
+  }
+  if ("name" in blob && typeof blob.name === "string") {
+    const extension = blob.name.split(".").pop()?.toLowerCase();
+    if (extension) {
+      const mimeType = mimeTypes.lookup(`.${extension}`);
+      if (mimeType) {
+        return mimeType;
+      }
+    }
+  }
+  if (blob instanceof Blob && blob.type) {
+    return blob.type;
+  }
+  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";
@@ -67,13 +117,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;
@@ -95,37 +145,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() {
+  async _createFile(metadata = {}, options) {
     const response = await this._fetch({
       method: "POST",
       path: `/v2/files`,
       body: JSON.stringify({
+        ...metadata,
         fileName: this.name,
         sha256sum: this.id ?? this.metadata?.id ?? (this.content ? await getFileHash(this.content) : void 0)
-      })
+      }),
+      signal: options?.signal
     }).then((data) => schemas.GetUploadUrlResponseV2.safeParse(data));
     if (!response.success) {
       throw new Error(`Invalid response from vault service. ${JSON.stringify(response.error)}`);
@@ -142,6 +201,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
@@ -171,13 +233,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) => schemas.GetDownloadUrlResponse.safeParse(data));
     if (!response.success) {
       throw new Error("Invalid response from vault service");
@@ -192,7 +255,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);
   }
@@ -204,6 +267,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
@@ -236,10 +302,12 @@ 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);
+    const mimeType = await detectFileMimeType(content);
+    const size = content.size;
     const file = new VaultFile({
       content,
       config: {
@@ -249,22 +317,27 @@ class VaultFile {
       id: sha256sum,
       name
     });
-    const createdFile = await file._createFile();
+    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;
@@ -286,29 +359,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;
     }
@@ -322,7 +400,8 @@ class VaultFile {
     }
     const response = await this._fetch({
       method: "PUT",
-      path: `/v2/files/${this.id}`
+      path: `/v2/files/${this.id}`,
+      signal: options?.signal
     }).then(schemas.GetUploadUrlResponseV2.safeParse);
     if (!response.success) {
       throw new Error(`Invalid response from vault service. ${JSON.stringify(response.error)}`);
@@ -332,13 +411,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;
     }
@@ -348,7 +429,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;
@@ -359,29 +441,48 @@ class VaultFile {
    * @example
    * ```ts
    * const file = new File(['content'], 'document.txt')
-   * const vaultFile = await VaultFile.fromBlob('document.txt', file, { vaultUrl, authStrategy })
+   * const vaultFile = await VaultFile.fromContent({
+   *     name: 'document.txt',
+   *     content: file,
+   *     config: {
+   *         vaultUrl,
+   *         authStrategy,
+   *     },
+   * })
    * await vaultFile.upload(file)
    * ```
    *
    * @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) {
-    if (!file && !this.content) {
-      throw new Error("Missing file content. Use fromBlob() to create a file with content, or provide a file to upload.");
+  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.");
     }
     const uploadUrl = url ?? await this.getUploadUrl();
+    const mimeType = this.metadata?.mimeType ?? await detectFileMimeType(content);
+    const headers = new Headers();
+    if (mimeType)
+      headers.set("Content-Type", mimeType);
     await wrappedFetch(uploadUrl, {
       method: "PUT",
-      body: file ?? this.content
+      body: content,
+      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")
@@ -390,48 +491,19 @@ class VaultFile {
   }
 }
 
-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
-    });
-  }
-}
-
 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/dist/index.d.cts

@@ -14,6 +14,15 @@ declare class APIKeyAuthStrategy implements AuthStrategy {
     constructor(apiKey: string);
 }
 
+declare class FetchError extends Error {
+    readonly message: string;
+    readonly url: string;
+    readonly method: string;
+    readonly response: Response;
+    constructor(message: string, url: string, method: string, response: Response);
+    static from(url: string, method: string, response: Response): Promise<FetchError>;
+}
+
 type VaultConfig = {
     vaultUrl: string;
     authStrategy: AuthStrategy;
@@ -76,12 +85,18 @@ declare 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
      */
     private _fetch;
     /**
      * 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
@@ -95,6 +110,9 @@ declare 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
@@ -128,6 +146,8 @@ declare class VaultFile {
         reference: string;
         config: VaultConfig;
         download?: boolean;
+    }, options?: {
+        signal?: AbortSignal;
     }): Promise<VaultFile>;
     /**
      * Creates a new VaultFile instance from given content.
@@ -137,6 +157,9 @@ declare 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
@@ -174,15 +197,21 @@ declare class VaultFile {
         content: Blob | File;
         config: VaultConfig;
         upload?: boolean;
+    }, options?: {
+        signal?: AbortSignal;
     }): Promise<VaultFile>;
     /**
      * 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
      */
-    populateMetadata(): Promise<this | undefined>;
+    populateMetadata(options?: {
+        signal?: AbortSignal;
+    }): Promise<this | undefined>;
     /**
      * Gets the vault reference for this file.
      *
@@ -192,49 +221,77 @@ declare class VaultFile {
     getVaultReference(): string;
     /**
      * 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
      */
-    getFileMetadata(): Promise<FileMetadata>;
+    getFileMetadata(options?: {
+        signal?: AbortSignal;
+    }): Promise<FileMetadata>;
     /**
      * 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
      */
-    getUploadUrl(): Promise<URL>;
+    getUploadUrl(options?: {
+        signal?: AbortSignal;
+    }): Promise<URL>;
     /**
      * 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
      */
-    getDownloadUrl(): Promise<URL>;
+    getDownloadUrl(options?: {
+        signal?: AbortSignal;
+    }): Promise<URL>;
     /**
      * Uploads a file to the vault.
      *
      * @example
      * ```ts
      * const file = new File(['content'], 'document.txt')
-     * const vaultFile = await VaultFile.fromBlob('document.txt', file, { vaultUrl, authStrategy })
+     * const vaultFile = await VaultFile.fromContent({
+     *     name: 'document.txt',
+     *     content: file,
+     *     config: {
+     *         vaultUrl,
+     *         authStrategy,
+     *     },
+     * })
      * await vaultFile.upload(file)
      * ```
      *
      * @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
      */
-    upload(file?: Blob, url?: string): Promise<void>;
+    upload(file?: Blob, url?: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
      * Downloads a file from the vault.
      *
      * @param responseType - The type of the response
+     * @param options - The options for the request
+     * @param options.signal - The signal to abort the request
+     *
      * @returns The response from the vault
      *
      * @example
@@ -243,22 +300,22 @@ declare class VaultFile {
      * const content = await vaultFile.download()
      * ```
      */
-    download(responseType?: 'blob'): Promise<Blob>;
-    download(responseType: 'base64'): Promise<string>;
-}
-
-declare class FetchError extends Error {
-    readonly message: string;
-    readonly url: string;
-    readonly method: string;
-    readonly response: Response;
-    constructor(message: string, url: string, method: string, response: Response);
-    static from(url: string, method: string, response: Response): Promise<FetchError>;
+    download(responseType?: 'blob', options?: {
+        signal?: AbortSignal;
+    }): Promise<Blob>;
+    download(responseType: 'base64', options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
 }
 
 declare function vaultClient(config: VaultConfig): {
-    createFromContent: (name: string, content: Blob | File) => Promise<VaultFile>;
-    createFromReference: (reference: string) => Promise<VaultFile>;
+    createFromContent: (name: string, content: Blob | File, options?: {
+        signal?: AbortSignal;
+    }) => Promise<VaultFile>;
+    createFromReference: (reference: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<VaultFile>;
 };
 
-export { APIKeyAuthStrategy, type AuthStrategy, DataTokenAuthStrategy, FetchError, type VaultConfig, VaultFile, vaultClient };
+export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, VaultFile, vaultClient };
+export type { AuthStrategy, VaultConfig };