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

package/dist/overmap-core.umd.cjs

@@ -4514,8 +4514,9 @@ var __publicField = (obj, key, value) => {
       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,
@@ -4528,6 +4529,7 @@ var __publicField = (obj, key, value) => {
           s3url: presignedUrl
         });
       }
+      return promisesBySha1;
     }
   }
   const AttachmentModelMeta = {
@@ -6913,12 +6915,89 @@ var __publicField = (obj, key, value) => {
         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",