@arke-institute/sdk 3.6.0 → 3.6.2

package/dist/operations/index.cjs

@@ -43,6 +43,7 @@ __export(operations_exports, {
   isCasConflictError: () => isCasConflictError,
   scanFileList: () => scanFileList,
   scanFileSystemEntries: () => scanFileSystemEntries,
+  uploadToEntity: () => uploadToEntity,
   uploadTree: () => uploadTree,
   verifyCid: () => verifyCid,
   withCasRetry: () => withCasRetry
@@ -859,6 +860,185 @@ function buildUploadTree(items) {
   return { files, folders };
 }
 
+// src/operations/upload/single.ts
+var MAX_CAS_RETRIES = 3;
+async function uploadToEntity(client, entityId, items, options = {}) {
+  if (items.length === 0) {
+    throw new Error("At least one upload item is required");
+  }
+  const { onProgress } = options;
+  let progressState = {
+    phase: "preparing",
+    totalBytes: 0,
+    uploadedBytes: 0,
+    completedFiles: 0,
+    totalFiles: items.length
+  };
+  const reportProgress = (update) => {
+    progressState = { ...progressState, ...update };
+    onProgress?.(progressState);
+  };
+  reportProgress({ phase: "preparing" });
+  const prepared = await Promise.all(
+    items.map((item) => prepareItem(item))
+  );
+  const keys = prepared.map((p) => p.key);
+  const duplicates = keys.filter((key, i) => keys.indexOf(key) !== i);
+  if (duplicates.length > 0) {
+    const uniqueDupes = [...new Set(duplicates)];
+    throw new Error(
+      `Duplicate content keys detected: ${uniqueDupes.map((k) => `"${k}"`).join(", ")}. Each file must have a unique key. Provide explicit keys to resolve.`
+    );
+  }
+  const totalBytes = prepared.reduce((sum, p) => sum + p.size, 0);
+  reportProgress({ totalBytes });
+  const uploadInfos = await Promise.all(
+    prepared.map(async (item) => {
+      const { data: presigned, error } = await client.api.POST(
+        "/entities/{id}/content/upload-url",
+        {
+          params: { path: { id: entityId } },
+          body: {
+            cid: item.cid,
+            content_type: item.contentType,
+            size: item.size
+          }
+        }
+      );
+      if (error || !presigned) {
+        throw new Error(
+          `Failed to get upload URL for ${item.key}: ${JSON.stringify(error)}`
+        );
+      }
+      return {
+        ...item,
+        uploadUrl: presigned.upload_url
+      };
+    })
+  );
+  reportProgress({ phase: "uploading", uploadedBytes: 0 });
+  let uploadedBytes = 0;
+  await Promise.all(
+    uploadInfos.map(async (item) => {
+      const response = await fetch(item.uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": item.contentType },
+        body: item.bytes
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Upload to R2 failed for ${item.key}: ${response.statusText}`
+        );
+      }
+      uploadedBytes += item.size;
+      reportProgress({ uploadedBytes });
+    })
+  );
+  const { data: tipData, error: tipError } = await client.api.GET(
+    "/entities/{id}/tip",
+    { params: { path: { id: entityId } } }
+  );
+  if (tipError || !tipData) {
+    throw new Error(`Failed to get entity tip: ${JSON.stringify(tipError)}`);
+  }
+  const prevCid = tipData.cid;
+  let currentTip = prevCid;
+  reportProgress({ phase: "completing", completedFiles: 0 });
+  const contents = [];
+  let finalCid = currentTip;
+  for (let i = 0; i < uploadInfos.length; i++) {
+    const item = uploadInfos[i];
+    const result = await completeWithRetry(client, entityId, item, currentTip);
+    currentTip = result.cid;
+    finalCid = result.cid;
+    contents.push({
+      key: item.key,
+      cid: result.contentCid,
+      size: item.size,
+      contentType: item.contentType,
+      filename: item.filename
+    });
+    reportProgress({ completedFiles: i + 1 });
+  }
+  return {
+    id: entityId,
+    cid: finalCid,
+    prevCid,
+    contents
+  };
+}
+async function prepareItem(item) {
+  const { data } = item;
+  let bytes;
+  if (data instanceof Blob) {
+    bytes = await data.arrayBuffer();
+  } else if (data instanceof ArrayBuffer) {
+    bytes = data;
+  } else {
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(data);
+    bytes = buffer;
+  }
+  const size = bytes.byteLength;
+  let filename = item.filename;
+  let contentType = item.contentType;
+  if (data instanceof File) {
+    filename = filename ?? data.name;
+    contentType = contentType ?? (data.type || getMimeType(data.name));
+  }
+  contentType = contentType ?? "application/octet-stream";
+  if (contentType === "application/octet-stream" && filename) {
+    contentType = getMimeType(filename);
+  }
+  const cid = await computeCid(new Uint8Array(bytes));
+  let key = item.key;
+  if (!key && filename) {
+    const lastDot = filename.lastIndexOf(".");
+    key = lastDot > 0 ? filename.substring(0, lastDot) : filename;
+  }
+  if (!key) {
+    key = `file_${cid.slice(-8)}`;
+  }
+  return { key, bytes, size, contentType, filename, cid };
+}
+async function completeWithRetry(client, entityId, item, expectTip) {
+  let tip = expectTip;
+  for (let attempt = 0; attempt < MAX_CAS_RETRIES; attempt++) {
+    const { data, error, response } = await client.api.POST(
+      "/entities/{id}/content/complete",
+      {
+        params: { path: { id: entityId } },
+        body: {
+          key: item.key,
+          cid: item.cid,
+          size: item.size,
+          content_type: item.contentType,
+          filename: item.filename,
+          expect_tip: tip
+        }
+      }
+    );
+    if (data) {
+      return { cid: data.cid, contentCid: data.content.cid };
+    }
+    if (response?.status === 409) {
+      const { data: freshTip, error: tipError } = await client.api.GET(
+        "/entities/{id}/tip",
+        { params: { path: { id: entityId } } }
+      );
+      if (tipError || !freshTip) {
+        throw new Error(`Failed to refresh tip: ${JSON.stringify(tipError)}`);
+      }
+      tip = freshTip.cid;
+      continue;
+    }
+    throw new Error(
+      `Failed to complete upload for ${item.key}: ${JSON.stringify(error)}`
+    );
+  }
+  throw new Error(`Max CAS retries exceeded for ${item.key}`);
+}
+
 // src/operations/folders.ts
 var FolderOperations = class {
   constructor(client) {
@@ -1056,6 +1236,7 @@ async function withCasRetry(callbacks, options) {
   isCasConflictError,
   scanFileList,
   scanFileSystemEntries,
+  uploadToEntity,
   uploadTree,
   verifyCid,
   withCasRetry