@meistrari/vault-sdk 1.0.1 → 1.2.0

package/dist/index.mjs

@@ -1,4 +1,35 @@
 import { GetUploadUrlResponseV2, GetDownloadUrlResponse } from '@meistrari/vault-shared/schemas';
+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) {
@@ -32,11 +63,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 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 = 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";
@@ -65,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;
@@ -93,37 +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() {
+  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) => GetUploadUrlResponseV2.safeParse(data));
     if (!response.success) {
       throw new Error(`Invalid response from vault service. ${JSON.stringify(response.error)}`);
@@ -140,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
@@ -169,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");
@@ -190,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);
   }
@@ -202,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
@@ -234,10 +300,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: {
@@ -247,22 +315,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;
@@ -284,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;
     }
@@ -320,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)}`);
@@ -330,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;
     }
@@ -346,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;
@@ -357,29 +439,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")
@@ -388,48 +489,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/vault-sdk",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -18,20 +18,16 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "test": "vitest",
-    "build": "unbuild",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "check": "bun run lint && bun tsc --noEmit"
-  },
   "dependencies": {
-    "@meistrari/vault-shared": "0.0.2",
+    "file-type": "21.0.0",
+    "mime-types": "3.0.1",
     "ofetch": "1.4.1",
-    "zod": "3.23.8"
+    "zod": "3.23.8",
+    "@meistrari/vault-shared": "0.0.3"
   },
   "devDependencies": {
     "@types/bun": "latest",
+    "@types/mime-types": "3.0.1",
     "msw": "2.6.8",
     "unbuild": "2.0.0",
     "vitest": "2.1.9"
@@ -41,5 +37,12 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "vitest",
+    "build": "unbuild",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "check": "bun run lint && bun tsc --noEmit"
   }
-}
+}