@meistrari/vault-sdk 1.8.3 → 2.0.0

package/dist/index.cjs

@@ -237,7 +237,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",
@@ -264,8 +264,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"
@@ -326,6 +326,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);
@@ -369,9 +370,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.
@@ -388,7 +387,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);
@@ -417,6 +415,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
    *
@@ -433,6 +432,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)
       }),
@@ -524,6 +524,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
    *
@@ -576,7 +577,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;
@@ -596,7 +597,8 @@ class VaultFile {
       size,
       mimeType,
       parentId,
-      onMissingParent
+      onMissingParent,
+      onParentConflict
     }, { signal: options?.signal });
     if (upload) {
       await file.upload(file.content, createdFile.uploadUrl, { signal: options?.signal });
@@ -614,6 +616,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
    *
@@ -650,7 +653,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 });
@@ -658,10 +668,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.
    *
@@ -1583,8 +1672,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);
@@ -1608,59 +1769,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__default.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__default.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);
     };
@@ -1671,7 +1867,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;
@@ -1679,16 +1875,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,
@@ -1696,7 +1892,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 };
 }
 
 exports.APIKeyAuthStrategy = APIKeyAuthStrategy;
@@ -1705,6 +1908,9 @@ exports.FetchError = FetchError;
 exports.VaultFile = VaultFile;
 exports.convertS3UrlToVaultReference = convertS3UrlToVaultReference;
 exports.extractVaultFileIdFromS3Url = extractVaultFileIdFromS3Url;
+exports.getVaultParamsFromS3Url = getVaultParamsFromS3Url;
 exports.isS3UrlExpired = isS3UrlExpired;
-exports.isVaultFileS3Url = isVaultFileS3Url;
+exports.isTaggedVaultPresignedUrl = isTaggedVaultPresignedUrl;
+exports.isVaultFileS3Url = isPresignedS3Url;
+exports.isVaultReference = isVaultReference;
 exports.vaultClient = vaultClient;