@meistrari/vault-sdk 0.0.12 → 0.0.13

package/dist/index.cjs

@@ -0,0 +1,192 @@
+'use strict';
+
+class FetchError extends Error {
+  constructor(message, response) {
+    super(message);
+    this.response = response;
+    this.name = "FetchError";
+  }
+}
+
+async function blobToBase64(blob) {
+  const fileContent = new Uint8Array(await blob.arrayBuffer());
+  let content = "";
+  for (const part of fileContent)
+    content += String.fromCharCode(part);
+  return btoa(content);
+}
+
+async function getFileHash(blob) {
+  const arrayBuffer = await blob.arrayBuffer();
+  const hashBuffer = await crypto.subtle.digest("SHA-256", arrayBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+
+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 VaultFile {
+  constructor(params) {
+    __publicField$1(this, "vaultUrl");
+    __publicField$1(this, "name");
+    __publicField$1(this, "headers");
+    this.name = params.name;
+    this.vaultUrl = params.vaultUrl;
+    this.headers = params.authStrategy.getHeaders();
+  }
+  getVaultUrl() {
+    if (this.name.includes("vault://")) {
+      return this.name;
+    }
+    return `vault://${this.name}`;
+  }
+  removeVaultPrefix(url) {
+    return url.replace("vault://", "");
+  }
+  async getUploadUrl() {
+    const response = await this._fetch({
+      method: "POST",
+      path: `/v2/files/${this.removeVaultPrefix(this.name)}`
+    });
+    return new URL(response.url);
+  }
+  async getDownloadUrl() {
+    const response = await this._fetch({
+      method: "GET",
+      path: `/v2/files/${this.removeVaultPrefix(this.name)}`
+    });
+    return new URL(response.url);
+  }
+  refreshAuth(authStrategy) {
+    this.headers = authStrategy.getHeaders();
+  }
+  async _fetch(params) {
+    const { method, path, body, ignoreHeaders } = params;
+    const url = new URL(this.vaultUrl + path).toString();
+    const response = await fetch(url, {
+      method,
+      body,
+      headers: ignoreHeaders ? void 0 : this.headers
+    });
+    if (!response.ok) {
+      throw new FetchError(`Failed to ${method} ${url}: ${response.status} ${response.statusText}`, response);
+    }
+    const content = await response.json();
+    return content;
+  }
+  /**
+   * Adds a SHA-256 hash of the file content as a prefix to the filename. This ensures uniqueness and prevents
+   * files with identical names but different content from overwriting each other in the vault.
+   *
+   * The resulting filename format is: "{hash}-{originalName}"
+   *
+   * IMPORTANT: The modified filename must be stored and used for all future operations with this file in the vault,
+   * as it becomes the file's unique identifier. The original filename alone will not be sufficient to retrieve
+   * the file later.
+   *
+   * @example
+   * const file = new File(['content'], 'document.txt')
+   * await vaultFile.addHashToName(file)
+   * // vaultFile.name becomes: "a1b2c3...xyz-document.txt"
+   *
+   * @param file - The file to generate a hash for
+   * @returns The new filename with the hash prefix
+   */
+  async addHashToName(file) {
+    const fileHash = await getFileHash(file);
+    if (!this.name.includes(fileHash))
+      this.name = `${fileHash}-${this.name}`;
+    return this.name;
+  }
+  /**
+   * Uploads a file to the vault.
+   *
+   * Files are saved with the given file names, so files with the same name within the same workspace
+   * will overwrite each other. To prevent accidental overwrites and support multiple files with the
+   * same original name, you should call addHashToName() before uploading to add a unique content-based
+   * hash to the filename.
+   *
+   * @example
+   * const file = new File(['content'], 'document.txt')
+   * await vaultFile.addHashToName(file) // Adds hash prefix to filename
+   * await vaultFile.upload(file)
+   *
+   * @param file - The file to upload to the vault
+   * @throws {FetchError} If the upload fails
+   * @returns Promise that resolves when upload is complete
+   */
+  async upload(file) {
+    const uploadUrl = await this.getUploadUrl();
+    const response = await fetch(uploadUrl, {
+      method: "PUT",
+      body: file
+    });
+    if (!response.ok) {
+      throw new FetchError(`Error uploading file ${this.name}: ${response.status} ${response.statusText}`, response);
+    }
+  }
+  async download(responseType = "blob") {
+    const downloadUrl = await this.getDownloadUrl();
+    const response = await fetch(downloadUrl, {
+      method: "GET"
+    });
+    if (!response.ok) {
+      throw new FetchError(`Error downloading file ${this.name}: ${response.status} ${response.statusText}`, response);
+    }
+    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
+    });
+  }
+}
+
+function useVault(vaultUrl, authStrategy) {
+  function createVaultFile(name) {
+    return new VaultFile({
+      name,
+      authStrategy,
+      vaultUrl
+    });
+  }
+  return { createVaultFile };
+}
+
+exports.APIKeyAuthStrategy = APIKeyAuthStrategy;
+exports.DataTokenAuthStrategy = DataTokenAuthStrategy;
+exports.FetchError = FetchError;
+exports.VaultFile = VaultFile;
+exports.useVault = useVault;

package/dist/index.d.cts

@@ -0,0 +1,87 @@
+interface AuthStrategy {
+    getHeaders: () => Headers;
+}
+declare class DataTokenAuthStrategy implements AuthStrategy {
+    dataToken: string;
+    getHeaders(): Headers;
+    constructor(dataToken: string);
+}
+declare class APIKeyAuthStrategy implements AuthStrategy {
+    apiKey: string;
+    getHeaders(): Headers;
+    constructor(apiKey: string);
+}
+
+type FetchParams = {
+    method: 'GET' | 'POST' | 'PUT';
+    path: string;
+    body?: any;
+    ignoreHeaders?: boolean;
+};
+type VaultParams = {
+    name: string;
+    authStrategy: AuthStrategy;
+    vaultUrl: string;
+};
+declare class VaultFile {
+    readonly vaultUrl: string;
+    name: string;
+    headers: Headers;
+    constructor(params: VaultParams);
+    getVaultUrl(): string;
+    removeVaultPrefix(url: string): string;
+    getUploadUrl(): Promise<URL>;
+    getDownloadUrl(): Promise<URL>;
+    refreshAuth(authStrategy: AuthStrategy): void;
+    _fetch(params: FetchParams): Promise<any>;
+    /**
+     * Adds a SHA-256 hash of the file content as a prefix to the filename. This ensures uniqueness and prevents
+     * files with identical names but different content from overwriting each other in the vault.
+     *
+     * The resulting filename format is: "{hash}-{originalName}"
+     *
+     * IMPORTANT: The modified filename must be stored and used for all future operations with this file in the vault,
+     * as it becomes the file's unique identifier. The original filename alone will not be sufficient to retrieve
+     * the file later.
+     *
+     * @example
+     * const file = new File(['content'], 'document.txt')
+     * await vaultFile.addHashToName(file)
+     * // vaultFile.name becomes: "a1b2c3...xyz-document.txt"
+     *
+     * @param file - The file to generate a hash for
+     * @returns The new filename with the hash prefix
+     */
+    addHashToName(file: Blob): Promise<string>;
+    /**
+     * Uploads a file to the vault.
+     *
+     * Files are saved with the given file names, so files with the same name within the same workspace
+     * will overwrite each other. To prevent accidental overwrites and support multiple files with the
+     * same original name, you should call addHashToName() before uploading to add a unique content-based
+     * hash to the filename.
+     *
+     * @example
+     * const file = new File(['content'], 'document.txt')
+     * await vaultFile.addHashToName(file) // Adds hash prefix to filename
+     * await vaultFile.upload(file)
+     *
+     * @param file - The file to upload to the vault
+     * @throws {FetchError} If the upload fails
+     * @returns Promise that resolves when upload is complete
+     */
+    upload(file: Blob): Promise<void>;
+    download(responseType?: 'blob'): Promise<Blob>;
+    download(responseType: 'base64'): Promise<string>;
+}
+
+declare class FetchError extends Error {
+    readonly response: Response;
+    constructor(message: string, response: Response);
+}
+
+declare function useVault(vaultUrl: string, authStrategy: AuthStrategy): {
+    createVaultFile: (name: string) => VaultFile;
+};
+
+export { APIKeyAuthStrategy, type AuthStrategy, DataTokenAuthStrategy, FetchError, VaultFile, useVault };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/vault-sdk",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -9,7 +9,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     }
   },
   "main": "dist/index.mjs",