@meistrari/vault-sdk 1.8.3 → 2.0.0

package/dist/index.mjs

@@ -231,7 +231,7 @@ function getFileName(content) {
 }
 
 const name = "@meistrari/vault-sdk";
-const version = "1.8.3";
+const version = "2.0.0";
 const license = "UNLICENSED";
 const repository = {
 	type: "git",
@@ -258,8 +258,8 @@ const scripts = {
 	check: "bun run lint && bun tsc --noEmit"
 };
 const dependencies = {
-	"@meistrari/vault-shared": "workspace:*",
 	"@meistrari/file-type": "22.0.0",
+	"@meistrari/vault-shared": "workspace:*",
 	"mime-types": "3.0.1",
 	ofetch: "1.4.1",
 	zod: "3.23.8"
@@ -320,6 +320,7 @@ async function wrappedFetch(url, requestInit) {
   };
   const request = new Request(url, options);
   request.headers.set("User-Agent", userAgent);
+  request.headers.set("x-compatibility-date", compatibilityDate);
   const response = await fetch(request);
   if (!response.ok) {
     throw await FetchError.from(request.url, request.method, response);
@@ -363,9 +364,7 @@ class VaultFile {
    * @returns The headers for the request
    */
   get headers() {
-    const headers = this.config.authStrategy.getHeaders();
-    headers.set("User-Agent", userAgent);
-    return headers;
+    return this.config.authStrategy.getHeaders();
   }
   /**
    * Performs a request to the vault service and handles the response or errors.
@@ -382,7 +381,6 @@ class VaultFile {
     const { method, path, body, signal, query } = params;
     const url = new URL(path, this.baseUrl);
     const headers = new Headers(this.headers);
-    headers.set("x-compatibility-date", compatibilityDate);
     if (query) {
       Object.entries(query).forEach(([key, value]) => {
         url.searchParams.set(key, value);
@@ -411,6 +409,7 @@ class VaultFile {
    * @param metadata.mimeType - The mime type of the file
    * @param metadata.parentId - The ID of the parent file for hierarchical file relationships
    * @param metadata.onMissingParent - What to do if the parent file does not exist or has been deleted
+   * @param metadata.onParentConflict - What to do if the file already exists as an active child of another file
    * @param options - The options for the request
    * @param options.signal - The signal to abort the request
    *
@@ -427,6 +426,7 @@ class VaultFile {
         mimeType: metadata.mimeType,
         parentId: metadata.parentId,
         onMissingParent: metadata.onMissingParent,
+        onParentConflict: metadata.onParentConflict,
         fileName: this.name,
         sha256sum: this.id ?? this.metadata?.id ?? (this.content ? await getFileHash(this.content) : void 0)
       }),
@@ -518,6 +518,7 @@ class VaultFile {
    * @param params.upload - Whether to upload the file (default: false)
    * @param params.parentId - The ID of the parent file for hierarchical file relationships
    * @param params.onMissingParent - What to do if the parent file does not exist or has been deleted
+   * @param params.onParentConflict - What to do if the file already exists as an active child of another file
    * @param options - The options for the request
    * @param options.signal - The signal to abort the request
    *
@@ -570,7 +571,7 @@ class VaultFile {
    * ```
    */
   static async fromContent(params, options) {
-    const { content, config: vaultConfig, upload = false, parentId, onMissingParent } = params;
+    const { content, config: vaultConfig, upload = false, parentId, onMissingParent, onParentConflict } = params;
     const name = basename(params.name) ?? getFileName(content);
     const config = resolveConfig(vaultConfig);
     const { vaultUrl, authStrategy } = config;
@@ -590,7 +591,8 @@ class VaultFile {
       size,
       mimeType,
       parentId,
-      onMissingParent
+      onMissingParent,
+      onParentConflict
     }, { signal: options?.signal });
     if (upload) {
       await file.upload(file.content, createdFile.uploadUrl, { signal: options?.signal });
@@ -608,6 +610,7 @@ class VaultFile {
    * @param params.contentType - The MIME type of the content (optional)
    * @param params.parentId - The ID of the parent file for hierarchical file relationships
    * @param params.onMissingParent - What to do if the parent file does not exist or has been deleted
+   * @param params.onParentConflict - What to do if the file already exists as an active child of another file
    * @param options - The options for the request
    * @param options.signal - The signal to abort the request
    *
@@ -644,7 +647,14 @@ class VaultFile {
    * ```
    */
   static async fromStream(params, options) {
-    const { contentLength, config: vaultConfig, contentType, parentId, onMissingParent } = params;
+    const {
+      contentLength,
+      config: vaultConfig,
+      contentType,
+      parentId,
+      onMissingParent,
+      onParentConflict
+    } = params;
     const name = basename(params.name);
     const config = resolveConfig(vaultConfig);
     const file = new VaultFile({ config, name });
@@ -652,10 +662,89 @@ class VaultFile {
       size: contentLength,
       mimeType: contentType || "application/octet-stream",
       parentId,
-      onMissingParent
+      onMissingParent,
+      onParentConflict
     }, { signal: options?.signal });
     return file;
   }
+  /**
+   * Creates multiple VaultFile instances from given content in a single request.
+   *
+   * @param params - Parameters for creating VaultFiles from content
+   * @param params.files - Array of file inputs with content and optional metadata
+   * @param params.config - The configuration for the VaultFiles
+   * @param params.upload - Whether to upload all files (default: false)
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
+   *
+   * @returns Array of new VaultFile instances
+   *
+   * @example
+   * ```ts
+   * const files = await VaultFile.fromContentBulk({
+   *     files: [
+   *         { content: blob1, name: 'file1.txt' },
+   *         { content: blob2, name: 'file2.txt', parentId: 'parent-id' },
+   *     ],
+   *     config: { vaultUrl, authStrategy },
+   *     upload: true
+   * })
+   * ```
+   */
+  static async fromContentBulk(params, options) {
+    const { files: fileInputs, config: vaultConfig, upload = false } = params;
+    const config = resolveConfig(vaultConfig);
+    const preparedFiles = await Promise.all(
+      fileInputs.map(async (input) => {
+        const name = basename(input.name) ?? getFileName(input.content);
+        const sha256sum = await getFileHash(input.content);
+        const mimeType = input.mimeType ?? await detectFileMimeType(input.content);
+        const size = input.content.size;
+        return { ...input, name, sha256sum, mimeType, size };
+      })
+    );
+    const url = new URL("files/bulk", config.vaultUrl);
+    const headers = config.authStrategy.getHeaders();
+    headers.set("Content-Type", "application/json");
+    const body = preparedFiles.map((file) => ({
+      fileName: file.name,
+      sha256sum: file.sha256sum,
+      mimeType: file.mimeType,
+      size: file.size,
+      parentId: file.parentId,
+      onMissingParent: file.onMissingParent,
+      onParentConflict: file.onParentConflict
+    }));
+    const response = await wrappedFetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: options?.signal
+    });
+    const data = await response.json();
+    const vaultFiles = data.map((item, index) => {
+      const file = new VaultFile({
+        config,
+        id: item.id,
+        name: item.metadata?.originalFileName ?? preparedFiles[index].name,
+        content: preparedFiles[index].content,
+        metadata: item.metadata
+      });
+      file.lastUploadUrl = {
+        url: new URL(item.uploadUrl),
+        expiresAt: new Date(item.expiresAt)
+      };
+      return file;
+    });
+    if (upload) {
+      await Promise.all(
+        vaultFiles.map(
+          (file) => file.upload(void 0, void 0, { signal: options?.signal })
+        )
+      );
+    }
+    return vaultFiles;
+  }
   /**
    * Fetches and populates the metadata fields for this VaultFile instance.
    *
@@ -1577,8 +1666,80 @@ class VaultFile {
       options
     );
   }
+  /**
+   * Updates the metadata of this file in the vault.
+   *
+   * This method allows you to modify specific metadata properties of the file, such as renaming it.
+   * The instance's metadata property is automatically updated with the response from the server.
+   * Only the provided parameters will be updated; all other metadata remains unchanged.
+   *
+   * @param params - The metadata properties to update
+   * @param params.name - The new name to assign to the file
+   * @param options - Additional options for the request
+   * @param options.signal - AbortSignal to cancel the request
+   *
+   * @returns A Promise that resolves when the update completes successfully
+   * @throws {Error} If the file ID is not set
+   * @throws {FetchError} If the update request fails
+   *
+   * @example
+   * ```ts
+   * // Rename a file
+   * const vaultFile = await VaultFile.fromVaultReference({
+   *     reference: 'vault://file-id',
+   *     config: { vaultUrl, authStrategy }
+   * })
+   * await vaultFile.updateMetadata({ name: 'new-name.txt' })
+   * console.log('File renamed to:', vaultFile.metadata?.originalFileName)
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Rename a file with abort signal
+   * const controller = new AbortController()
+   * await vaultFile.updateMetadata(
+   *     { name: 'document-v2.pdf' },
+   *     { signal: controller.signal }
+   * )
+   * // Later: controller.abort()
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Rename after upload
+   * const file = new File(['content'], 'temp.txt')
+   * const vaultFile = await VaultFile.fromContent({
+   *     name: 'temp.txt',
+   *     content: file,
+   *     config: { vaultUrl, authStrategy },
+   *     upload: true
+   * })
+   * // Later, rename the file
+   * await vaultFile.updateMetadata({ name: 'final-document.txt' })
+   * ```
+   */
+  async updateMetadata(params, options) {
+    if (!this.id) {
+      throw new Error("File ID is not set");
+    }
+    const updatedMetadata = await this._fetch({
+      method: "PATCH",
+      path: `files/${this.id}`,
+      body: JSON.stringify(params),
+      signal: options?.signal
+    });
+    this.metadata = updatedMetadata;
+  }
 }
 
+const VAULT_REFERENCE_UUID_REGEX = /^vault:\/\/[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const VAULT_REFERENCE_SHA256_REGEX = /^vault:\/\/[a-f0-9]{64}$/i;
+function isValidUuidV4(uuid) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid);
+}
+function isValidSha256(sha256) {
+  return /^[a-f0-9]{64}$/i.test(sha256);
+}
 function isS3UrlExpired(url) {
   try {
     const urlObj = new URL(url);
@@ -1602,59 +1763,94 @@ function isS3UrlExpired(url) {
   }
 }
 function isVaultReference(url) {
-  return url.startsWith("vault://") && url.length === 10;
+  return VAULT_REFERENCE_UUID_REGEX.test(url) || VAULT_REFERENCE_SHA256_REGEX.test(url);
 }
-function isVaultFileS3Url(url) {
-  const urlObj = new URL(url);
-  const amzDate = urlObj.searchParams.get("X-Amz-Date");
-  const amzExpires = urlObj.searchParams.get("X-Amz-Expires");
-  return urlObj.hostname.includes("amazonaws.com") && Boolean(amzDate) && Boolean(amzExpires);
+function isPresignedS3Url(url) {
+  try {
+    const urlObj = new URL(url);
+    const amzDate = urlObj.searchParams.get("X-Amz-Date");
+    const amzExpires = urlObj.searchParams.get("X-Amz-Expires");
+    return urlObj.hostname.includes("amazonaws.com") && Boolean(amzDate) && Boolean(amzExpires);
+  } catch {
+    return false;
+  }
 }
 const URL_STRATEGIES = [
-  {
-    separator: "/",
-    extractSegments: ([workspaceId, vaultFileId]) => ({
-      workspaceId,
-      vaultFileId
-    })
-  },
   {
     separator: "_",
     extractSegments: ([vaultFileId, workspaceId]) => ({
       vaultFileId,
       workspaceId
     })
+  },
+  {
+    separator: "/",
+    extractSegments: ([workspaceId, vaultFileId]) => ({
+      workspaceId,
+      vaultFileId
+    })
   }
 ];
-function extractVaultFileIdFromS3Url(url) {
-  if (isVaultReference(url))
-    return vaultUtils.file.getFileIdFromVaultReference(url);
+function extractVaultFileIdFromLegacyS3Url(url) {
   try {
-    if (!isVaultFileS3Url(url))
-      return null;
     const urlObj = new URL(url);
     const strategy = URL_STRATEGIES.find((strategy2) => urlObj.pathname.includes(strategy2.separator));
     if (!strategy)
       return null;
-    const segments = urlObj.pathname.split(strategy.separator).filter((segment) => segment.length > 0);
+    const segments = urlObj.pathname.split(strategy.separator).map((segment) => segment.replace(/^\/+|\/+$/g, "")).filter((segment) => segment.length > 0);
     if (segments.length < 2)
       return null;
     const extractedIds = strategy.extractSegments(segments);
-    if (!extractedIds || !extractedIds.vaultFileId || !extractedIds.workspaceId || extractedIds.vaultFileId.length < 32)
+    if (!extractedIds.vaultFileId || !extractedIds.workspaceId || extractedIds.vaultFileId.length < 32)
       return null;
     return extractedIds.vaultFileId;
   } catch {
     return null;
   }
 }
+function extractVaultFileIdFromS3Url(url) {
+  if (isVaultReference(url))
+    return vaultUtils.file.getFileIdFromVaultReference(url);
+  if (!isPresignedS3Url(url))
+    return null;
+  if (isTaggedVaultPresignedUrl(url))
+    return getVaultParamsFromS3Url(url)?.fileId ?? null;
+  return extractVaultFileIdFromLegacyS3Url(url);
+}
 function convertS3UrlToVaultReference(url) {
   const vaultFileId = extractVaultFileIdFromS3Url(url);
   return vaultFileId ? `vault://${vaultFileId}` : null;
 }
+function isTaggedVaultPresignedUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    const workspaceId = urlObj.searchParams.get("vault-workspace-id");
+    const fileId = urlObj.searchParams.get("vault-file-id");
+    if (!workspaceId || !fileId) {
+      return false;
+    }
+    const hasWorkspaceId = isValidUuidV4(workspaceId);
+    const hasFileId = isValidSha256(fileId) || isValidUuidV4(fileId);
+    const hasAmazonDomain = urlObj.hostname.endsWith("amazonaws.com");
+    return hasWorkspaceId && hasFileId && hasAmazonDomain;
+  } catch {
+    return false;
+  }
+}
+function getVaultParamsFromS3Url(url) {
+  if (!isTaggedVaultPresignedUrl(url))
+    return null;
+  const urlObj = new URL(url);
+  return {
+    fileId: urlObj.searchParams.get("vault-file-id"),
+    workspaceId: urlObj.searchParams.get("vault-workspace-id"),
+    parentId: urlObj.searchParams.get("vault-parent-id")
+  };
+}
 
 function vaultClient(vaultConfig) {
   const config = resolveConfig(vaultConfig);
-  function createFromContent(nameOrContent, contentOrNameOrOptions, options) {
+  async function createFromContent(nameOrContent, contentOrNameOrOptions, options) {
     const isOptionsObject = (value) => {
       return typeof value === "object" && value !== null && !(value instanceof Blob) && !(value instanceof File);
     };
@@ -1665,7 +1861,7 @@ function vaultClient(vaultConfig) {
       const parentId2 = options?.parentId;
       const mimeType2 = options?.mimeType;
       const upload2 = options?.upload;
-      return VaultFile.fromContent({ content: content2, name: name2, config, parentId: parentId2, mimeType: mimeType2, upload: upload2 }, { signal: signal2 });
+      return await VaultFile.fromContent({ content: content2, name: name2, config, parentId: parentId2, mimeType: mimeType2, upload: upload2 }, { signal: signal2 });
     }
     const content = nameOrContent;
     const name = typeof contentOrNameOrOptions === "string" ? contentOrNameOrOptions : void 0;
@@ -1673,16 +1869,16 @@ function vaultClient(vaultConfig) {
     const parentId = isOptionsObject(contentOrNameOrOptions) ? contentOrNameOrOptions.parentId : options?.parentId;
     const mimeType = isOptionsObject(contentOrNameOrOptions) ? contentOrNameOrOptions.mimeType : options?.mimeType;
     const upload = isOptionsObject(contentOrNameOrOptions) ? contentOrNameOrOptions.upload : options?.upload;
-    return VaultFile.fromContent({ content, name, config, parentId, mimeType, upload }, { signal });
+    return await VaultFile.fromContent({ content, name, config, parentId, mimeType, upload }, { signal });
   }
-  function createFromReference(reference, options) {
-    return VaultFile.fromVaultReference({
+  async function createFromReference(reference, options) {
+    return await VaultFile.fromVaultReference({
       reference,
       config
     }, { signal: options?.signal });
   }
   async function createFromStream(name, contentLength, options) {
-    return VaultFile.fromStream({
+    return await VaultFile.fromStream({
       name,
       contentLength,
       config,
@@ -1690,7 +1886,14 @@ function vaultClient(vaultConfig) {
       parentId: options?.parentId
     }, { signal: options?.signal });
   }
-  return { createFromContent, createFromReference, createFromStream };
+  async function createFromContentBulk(files, options) {
+    return await VaultFile.fromContentBulk({
+      files,
+      config,
+      upload: options?.upload
+    }, { signal: options?.signal });
+  }
+  return { createFromContent, createFromReference, createFromStream, createFromContentBulk };
 }
 
-export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, VaultFile, convertS3UrlToVaultReference, extractVaultFileIdFromS3Url, isS3UrlExpired, isVaultFileS3Url, vaultClient };
+export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, VaultFile, convertS3UrlToVaultReference, extractVaultFileIdFromS3Url, getVaultParamsFromS3Url, isS3UrlExpired, isTaggedVaultPresignedUrl, isPresignedS3Url as isVaultFileS3Url, isVaultReference, vaultClient };

package/package.json

@@ -1,49 +1,49 @@
 {
-  "name": "@meistrari/vault-sdk",
-  "version": "1.8.3",
-  "license": "UNLICENSED",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/meistrari/vault.git"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+    "name": "@meistrari/vault-sdk",
+    "version": "2.0.0",
+    "license": "UNLICENSED",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/meistrari/vault.git"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "main": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "test": "vitest --no-watch",
+        "test:watch": "vitest",
+        "build": "unbuild",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "check": "bun run lint && bun tsc --noEmit"
+    },
+    "dependencies": {
+        "@meistrari/file-type": "22.0.0",
+        "@meistrari/vault-shared": "workspace:*",
+        "mime-types": "3.0.1",
+        "ofetch": "1.4.1",
+        "zod": "3.23.8"
+    },
+    "devDependencies": {
+        "@types/bun": "latest",
+        "@types/mime-types": "3.0.1",
+        "msw": "2.6.8",
+        "unbuild": "2.0.0",
+        "vitest": "2.1.9"
+    },
+    "peerDependencies": {
+        "typescript": "^5.0.0"
+    },
+    "publishConfig": {
+        "access": "public"
     }
-  },
-  "main": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "test": "vitest --no-watch",
-    "test:watch": "vitest",
-    "build": "unbuild",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "check": "bun run lint && bun tsc --noEmit"
-  },
-  "dependencies": {
-    "@meistrari/vault-shared": "0.0.7",
-    "@meistrari/file-type": "22.0.0",
-    "mime-types": "3.0.1",
-    "ofetch": "1.4.1",
-    "zod": "3.23.8"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/mime-types": "3.0.1",
-    "msw": "2.6.8",
-    "unbuild": "2.0.0",
-    "vitest": "2.1.9"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+}