@overmap-ai/core 1.0.58-asset-description.8 → 1.0.58-asset-description.10

package/dist/overmap-core.umd.cjs

@@ -5399,7 +5399,6 @@ var __publicField = (obj, key, value) => {
     }
     return chunks;
   }
-  const BULK_ADD_ASSET_BATCH_SIZE = 1e3;
   class AssetService extends BaseApiService {
     // Basic CRUD functions
     add(asset, workspaceId) {
@@ -5476,45 +5475,53 @@ var __publicField = (obj, key, value) => {
         throw err;
       });
     }
-    addBulk(assetsToCreate, workspaceId, assetTypeId) {
+    // TODO: payload does not require asset_type
+    bulkAdd(assetsToCreate, workspaceId, assetTypeId, batchSize) {
       const { store } = this.client;
-      const fullAssets = assetsToCreate.map((asset) => {
-        return { ...offline(asset), submitted_at: (/* @__PURE__ */ new Date()).toISOString() };
-      });
-      const assetBatches = chunkArray(fullAssets, BULK_ADD_ASSET_BATCH_SIZE).map((assetBatch) => {
+      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const assetBatches = chunkArray(assetsToCreate, batchSize).map((assetBatch) => {
+        const assetPayloads = assetBatch.map((assetPayload) => {
+          return offline({
+            ...assetPayload,
+            submitted_at: submittedAt
+          });
+        });
         return {
           batchId: uuid.v4(),
           payload: {
-            assets: assetBatch
+            assets: assetPayloads
           }
         };
       });
-      store.dispatch(addAssetsInBatches(fullAssets));
+      const batchPromises = [];
       let prevBatchId = null;
-      const batchPromises = Promise.all(
-        assetBatches.map((assetBatch) => {
-          const { batchId, payload } = assetBatch;
-          const promise = this.client.enqueueRequest({
-            description: "Batch create assets",
-            method: HttpMethod.POST,
-            url: `/assets/types/${assetTypeId}/add-assets/`,
-            queryParams: {
-              workspace_id: workspaceId.toString()
-            },
-            payload,
-            blockers: prevBatchId ? [assetTypeId, prevBatchId] : [assetTypeId],
-            blocks: assetBatch.payload.assets.map((c) => c.offline_id).concat([batchId])
-          });
-          promise.then((result) => {
-            store.dispatch(updateAssets(Object.values(result)));
-          }).catch(() => {
-            store.dispatch(removeAssets(assetBatch.payload.assets.map((c) => c.offline_id)));
-          });
-          prevBatchId = assetBatch.batchId;
-          return promise;
-        })
-      );
-      return [fullAssets, batchPromises.then((result) => result)];
+      for (const assetBatch of assetBatches) {
+        const { batchId, payload } = assetBatch;
+        const batchAssetOfflineIds = payload.assets.map((c) => c.offline_id);
+        const blockers = [assetTypeId];
+        if (prevBatchId)
+          blockers.push(prevBatchId);
+        const blocks2 = batchAssetOfflineIds;
+        blocks2.push(batchId);
+        const promise = this.client.enqueueRequest({
+          description: "Batch create assets",
+          method: HttpMethod.POST,
+          url: `/assets/types/${assetTypeId}/add-assets/`,
+          queryParams: {
+            workspace_id: workspaceId.toString()
+          },
+          payload,
+          blockers,
+          blocks: blocks2
+        });
+        prevBatchId = assetBatch.batchId;
+        batchPromises.push(promise);
+      }
+      void Promise.all(batchPromises).then((result) => {
+        const allCreatedAssets = result.flat();
+        store.dispatch(addAssetsInBatches(allCreatedAssets));
+      });
+      return batchPromises;
     }
     async refreshStore() {
       const { store } = this.client;
@@ -7300,7 +7307,6 @@ var __publicField = (obj, key, value) => {
     }
     return { values: newValues, files };
   };
-  const MAX_BULK_ADD_SUBMISSIONS = 1e3;
   class UserFormSubmissionService extends BaseApiService {
     constructor() {
       super(...arguments);
@@ -7381,63 +7387,38 @@ var __publicField = (obj, key, value) => {
     }
     // Note currently the bulkAdd method is specific to form submissions for assets
     // TODO: adapt the support bulk adding to any model type
-    async bulkAdd(args) {
-      const { formRevision, commonFieldValues, fieldValuesByAsset } = args;
+    async bulkAdd(args, batchSize) {
       const { store } = this.client;
-      const offlineSubmissions = [];
-      const offlineAttachments = [];
-      const submissionOfflineIds = [];
+      const { formRevision, commonFieldValues, fieldValuesByAsset } = args;
       const allFilesRecord = {};
       const { values: fileSeperatedCommonFieldValues, files: commonFiles } = separateFilesFromValues(commonFieldValues);
       const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = store.getState().userReducer.currentUser.id;
-      const assetIdBatches = chunkArray(Object.keys(fieldValuesByAsset), MAX_BULK_ADD_SUBMISSIONS);
+      const assetIdBatches = chunkArray(Object.keys(fieldValuesByAsset), batchSize);
       const bulkAddBatches = await Promise.all(
         assetIdBatches.map(async (assetIdBatch) => {
           const batchId = uuid.v4();
-          const submissionsPayload = [];
-          const attachmentsPayload = [];
-          let files = { ...commonFiles };
+          const submissionPayloads = [];
+          const attachmentPayloads = [];
+          const files = { ...commonFiles };
           for (const assetId of assetIdBatch) {
             const { values: fileSeperatedSubmissionSpecificValues, files: submissionSpecificFiles } = separateFilesFromValues(fieldValuesByAsset[assetId] ?? {});
-            files = Object.assign(files, submissionSpecificFiles);
-            const submissionValues = {
-              ...fileSeperatedCommonFieldValues,
-              ...fileSeperatedSubmissionSpecificValues
-            };
-            const submission = offline({
-              form_revision: formRevision,
-              values: submissionValues,
-              created_by: createdBy,
-              submitted_at: submittedAt,
-              asset: assetId
-            });
-            submissionOfflineIds.push(submission.offline_id);
-            submissionsPayload.push({
-              offline_id: submission.offline_id,
+            Object.assign(files, submissionSpecificFiles);
+            const submissionPayload = offline({
               asset_id: assetId,
               form_data: fileSeperatedSubmissionSpecificValues
             });
-            offlineSubmissions.push(submission);
+            submissionPayloads.push(submissionPayload);
             for (const [fieldIdentifier, fileArray] of Object.entries(files)) {
               for (const file of fileArray) {
                 const sha1 = await hashFile(file);
                 await this.client.files.addCache(file, sha1);
-                const offlineAttachment = offline({
-                  file_name: file.name,
-                  file_sha1: sha1,
-                  file: URL.createObjectURL(file),
-                  submission: submission.offline_id,
-                  field_identifier: fieldIdentifier
-                });
-                offlineAttachments.push(offlineAttachment);
-                attachmentsPayload.push({
-                  offline_id: offlineAttachment.offline_id,
-                  submission_id: submission.offline_id,
+                const attachmentPayload = offline({
+                  submission_id: submissionPayload.offline_id,
                   sha1,
                   name: file.name,
                   field_identifier: fieldIdentifier
                 });
+                attachmentPayloads.push(attachmentPayload);
               }
             }
           }
@@ -7458,58 +7439,66 @@ var __publicField = (obj, key, value) => {
             payload: {
               form_data: fileSeperatedCommonFieldValues,
               submitted_at: submittedAt,
-              submissions: submissionsPayload,
-              attachments: attachmentsPayload,
+              submissions: submissionPayloads,
+              attachments: attachmentPayloads,
               files: filePaylods
             }
           };
         })
       );
-      store.dispatch(addFormSubmissions(offlineSubmissions));
-      store.dispatch(addFormSubmissionAttachments(offlineAttachments));
+      const batchPromises = [];
       let prevBatchId = null;
-      const batchPromises = Promise.all(
-        bulkAddBatches.map((batch) => {
-          const { payload, batchId } = batch;
-          const batchAssetIds = payload.submissions.map((x) => x.asset_id);
-          const batchSubmissionOfflineIds = payload.submissions.map((x) => x.offline_id);
-          const batchAttachmentsOfflineIds = payload.attachments.map((x) => x.offline_id);
-          const promise = this.client.enqueueRequest({
-            description: "Bulk add form submissions",
-            method: HttpMethod.POST,
-            url: `/forms/revisions/${formRevision}/bulk-respond/`,
-            payload,
-            blockers: prevBatchId ? batchAssetIds.concat([prevBatchId]) : batchAssetIds,
-            blocks: batchSubmissionOfflineIds.concat([batchId])
-          });
-          promise.then(({ submissions, attachments, presigned_urls }) => {
-            store.dispatch(updateFormSubmissions(submissions));
-            store.dispatch(updateFormSubmissionAttachments(attachments));
-            for (const [sha1, presigned_url] of Object.entries(presigned_urls)) {
-              const file = allFilesRecord[sha1];
-              if (!file)
-                continue;
-              void this.client.enqueueRequest({
-                url: presigned_url.url,
-                description: "Upload file",
-                method: HttpMethod.POST,
-                isExternalUrl: true,
-                isAuthNeeded: false,
-                attachmentHash: sha1,
-                blockers: [`s3-${file.sha1}.${file.extension}`],
-                blocks: [sha1],
-                s3url: presigned_url
-              });
-            }
-          }).catch(() => {
-            store.dispatch(deleteFormSubmissions(batchSubmissionOfflineIds));
-            store.dispatch(deleteFormSubmissionAttachments(batchAttachmentsOfflineIds));
-          });
-          prevBatchId = batchId;
-          return promise;
-        })
-      );
-      return [offlineSubmissions, batchPromises.then((results) => results.map(({ submissions }) => submissions))];
+      for (const batch of bulkAddBatches) {
+        const { payload, batchId } = batch;
+        const batchAssetIds = payload.submissions.map((x) => x.asset_id);
+        const batchSubmissionOfflineIds = payload.submissions.map((x) => x.offline_id);
+        const batchAttachmentsOfflineIds = payload.attachments.map((x) => x.offline_id);
+        const blockers = batchAssetIds;
+        if (prevBatchId)
+          blockers.push(prevBatchId);
+        const blocks2 = [...batchSubmissionOfflineIds, ...batchAttachmentsOfflineIds, batchId];
+        const promise = this.client.enqueueRequest({
+          description: "Bulk add form submissions",
+          method: HttpMethod.POST,
+          url: `/forms/revisions/${formRevision}/bulk-respond/`,
+          payload,
+          blockers,
+          blocks: blocks2
+        });
+        void promise.then(({ presigned_urls }) => {
+          for (const [sha1, presignedUrl] of Object.entries(presigned_urls)) {
+            const file = allFilesRecord[sha1];
+            if (!file)
+              continue;
+            void this.client.enqueueRequest({
+              url: presignedUrl.url,
+              description: "Upload file",
+              method: HttpMethod.POST,
+              isExternalUrl: true,
+              isAuthNeeded: false,
+              attachmentHash: sha1,
+              blockers: [`s3-${file.sha1}.${file.extension}`],
+              blocks: [sha1],
+              s3url: presignedUrl
+            });
+          }
+        });
+        prevBatchId = batchId;
+        batchPromises.push(promise);
+      }
+      void Promise.all(batchPromises).then((results) => {
+        const createdSubmissions = [];
+        const createdAttachments = [];
+        for (const result of results) {
+          for (const createdSubmission of result.submissions)
+            createdSubmissions.push(createdSubmission);
+          for (const createdAttachment of result.attachments)
+            createdAttachments.push(createdAttachment);
+        }
+        store.dispatch(addFormSubmissions(createdSubmissions));
+        store.dispatch(addFormSubmissionAttachments(createdAttachments));
+      });
+      return batchPromises;
     }
     update(submission) {
       const { store } = this.client;
@@ -13123,10 +13112,7 @@ var __publicField = (obj, key, value) => {
     helpText = showInputOnly ? null : helpText;
     label = showInputOnly ? "" : label;
     const color = blocks.useSeverityColor(severity);
-    const value = React.useMemo(
-      () => Array.isArray(fieldProps.value) ? fieldProps.value : [],
-      [fieldProps.value]
-    );
+    const value = React.useMemo(() => Array.isArray(fieldProps.value) ? fieldProps.value : [], [fieldProps.value]);
     const { onChange, onBlur } = fieldProps;
     const droppableId = `${inputId}-droppable`;
     const { disabled } = rest;
@@ -14942,39 +14928,37 @@ var __publicField = (obj, key, value) => {
       meta: { readonly }
     };
   }
-  function decodeFormValues(schema, values) {
-    let allFields = [];
+  function flattenFields(schema) {
+    const allFields = [];
     for (const field of schema.fields) {
       if (field instanceof FieldSection) {
-        allFields = allFields.concat(field.fields);
+        for (const subField of field.fields) {
+          allFields.push(subField);
+        }
       } else {
         if (!(field instanceof BaseField)) {
-          throw new Error("Invalid field type");
+          throw new Error(`Invalid field type: ${field.type}`);
         }
         allFields.push(field);
       }
     }
+    return allFields;
+  }
+  function decodeFormValues(schema, values) {
+    const allFields = flattenFields(schema);
     const result = {};
     for (const field of allFields) {
-      if (!(field.identifier in values))
-        ;
-      const value = values[field.identifier];
-      result[field.identifier] = field.decodeJsonToValue(value);
+      const value = values[field.identifier] ?? null;
+      if (value !== null) {
+        result[field.identifier] = field.decodeJsonToValue(value);
+      } else {
+        result[field.identifier] = value;
+      }
     }
     return result;
   }
   function encodeFormValues(schema, values) {
-    let allFields = [];
-    for (const field of schema.fields) {
-      if (field instanceof FieldSection) {
-        allFields = allFields.concat(field.fields);
-      } else {
-        if (!(field instanceof BaseField)) {
-          throw new Error("Invalid field type");
-        }
-        allFields.push(field);
-      }
-    }
+    const allFields = flattenFields(schema);
     const result = {};
     for (const field of allFields) {
       const value = values[field.identifier];
@@ -16777,6 +16761,7 @@ var __publicField = (obj, key, value) => {
     emptyStringField,
     emptyTextField,
     encodeFormValues,
+    flattenFields,
     formRevisionToSchema,
     initialFormValues,
     isConditionMet,
@@ -17018,6 +17003,7 @@ var __publicField = (obj, key, value) => {
   exports2.fileReducer = fileReducer;
   exports2.fileSlice = fileSlice;
   exports2.fileToBlob = fileToBlob;
+  exports2.flattenFields = flattenFields;
   exports2.flipCoordinates = flipCoordinates;
   exports2.formReducer = formReducer;
   exports2.formRevisionReducer = formRevisionReducer;