@overmap-ai/core 1.0.63-selector-standardization.9 → 1.0.63

package/dist/overmap-core.js

@@ -4526,8 +4526,9 @@ class BaseUploadService extends BaseApiService {
     return objectsWithSha1.filter((object) => object.file_sha1 === sha1).length;
   }
   processPresignedUrls(presignedUrls) {
+    const promisesBySha1 = {};
     for (const [sha1, presignedUrl] of Object.entries(presignedUrls)) {
-      void this.enqueueRequest({
+      promisesBySha1[sha1] = this.enqueueRequest({
         url: presignedUrl.url,
         description: "Upload file to S3",
         method: HttpMethod.POST,
@@ -4540,6 +4541,7 @@ class BaseUploadService extends BaseApiService {
         s3url: presignedUrl
       });
     }
+    return promisesBySha1;
   }
 }
 const AttachmentModelMeta = {
@@ -6925,12 +6927,89 @@ class DocumentAttachmentService extends BaseAttachmentService {
       document: data.modelId
     });
   }
+  // NOTE: overriding the method from BaseAttachmentService since document attachments get vectorized
   async attachFilesToDocument(files, documentId) {
-    return this.attachFiles(files, documentId, this.buildOfflineAttachment.bind(this));
+    const { store } = this.client;
+    const currentUser = store.getState().userReducer.currentUser;
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const offlineAttachments = [];
+    const attachmentPayloads = [];
+    const filePayloads = {};
+    const sha1ToAttachmentIds = {};
+    for (const file of files) {
+      const sha1 = await hashFile(file);
+      if (!(sha1 in filePayloads)) {
+        filePayloads[sha1] = {
+          sha1,
+          file_type: file.type,
+          extension: file.name.split(".").pop(),
+          size: file.size
+        };
+        sha1ToAttachmentIds[sha1] = [];
+        await this.client.files.addCache(file, sha1);
+      }
+      const offlineAttachment = this.buildOfflineAttachment({
+        file,
+        sha1,
+        submittedAt,
+        createdBy: currentUser.id,
+        description: "",
+        modelId: documentId
+      });
+      offlineAttachments.push(offlineAttachment);
+      attachmentPayloads.push({
+        offline_id: offlineAttachment.offline_id,
+        name: offlineAttachment.file_name,
+        sha1: offlineAttachment.file_sha1,
+        description: offlineAttachment.description
+      });
+      sha1ToAttachmentIds[sha1].push(offlineAttachment.offline_id);
+    }
+    this.dispatch(this.addAttachments(offlineAttachments));
+    const promise = this.enqueueRequest({
+      description: "Attach files to document",
+      method: HttpMethod.POST,
+      url: `/documents/${documentId}/attach/`,
+      payload: {
+        submitted_at: submittedAt,
+        attachments: attachmentPayloads,
+        files: Object.values(filePayloads)
+      },
+      blocks: offlineAttachments.map((attachment) => attachment.offline_id),
+      blockers: offlineAttachments.map((attachment) => attachment.file_sha1)
+    });
+    promise.then(({ attachments, presigned_urls }) => {
+      this.dispatch(this.updateAttachments(attachments));
+      const promisesBySha1 = this.processPresignedUrls(presigned_urls);
+      for (const [sha1, promise2] of Object.entries(promisesBySha1)) {
+        void promise2.then(() => {
+          const attachmentIds = sha1ToAttachmentIds[sha1];
+          for (const attachmentId of attachmentIds) {
+            this.makeReadable(attachmentId);
+          }
+        });
+      }
+    }).catch(() => {
+      this.dispatch(this.removeAttachments(offlineAttachments.map((attachment) => attachment.offline_id)));
+    });
+    return [offlineAttachments, promise.then(({ attachments }) => attachments)];
   }
   async deleteDocumentAttachment(attachmentId) {
     return this.deleteAttachment(attachmentId);
   }
+  makeReadable(attachmnentId) {
+    void this.enqueueRequest({
+      description: "Add attachment to AI assistant",
+      method: HttpMethod.PATCH,
+      url: `/document-attachments/${attachmnentId}/`,
+      payload: {
+        readable_to_assistant: true
+      },
+      // passing through "index-document-attachment" so at most one document attachment being indexed at a time
+      blockers: ["index-document-attachment", attachmnentId],
+      blocks: ["index-document-attachment"]
+    });
+  }
   async refreshStore(projectId, organizationId) {
     const projectDocumentAttachments = await this.enqueueRequest({
       description: "Get document attachments",