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

package/dist/forms/fields/utils.d.ts

@@ -10,6 +10,7 @@ export declare const deserializeField: (serializedField: ISerializedOnlyField) =
 export declare const deserialize: (serialized: ISerializedField) => AnyField | FieldSection;
 export type PartialFormRevision = Pick<UserFormRevision, "title" | "fields" | "description"> & Partial<UserFormRevision>;
 export declare function formRevisionToSchema(formRevision: PartialFormRevision, meta?: Partial<SchemaMeta>): ISchema;
+export declare function flattenFields(schema: ISchema): AnyField[];
 export declare function decodeFormValues(schema: ISchema, values: Record<string, string>): Record<string, FieldValue>;
 export declare function encodeFormValues(schema: ISchema, values: Record<string, FieldValue>): Record<string, string>;
 export declare function valueIsFile(v: FieldValue | Promise<File>[] | undefined): v is File[] | Promise<File>[];

package/dist/overmap-core.js

@@ -5409,7 +5409,6 @@ function chunkArray(arr, chunkSize) {
   }
   return chunks;
 }
-const BULK_ADD_ASSET_BATCH_SIZE = 1e3;
 class AssetService extends BaseApiService {
   // Basic CRUD functions
   add(asset, workspaceId) {
@@ -5486,45 +5485,53 @@ class AssetService extends BaseApiService {
       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: 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 blocks = batchAssetOfflineIds;
+      blocks.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
+      });
+      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;
@@ -7310,7 +7317,6 @@ const separateFilesFromValues = (values) => {
   }
   return { values: newValues, files };
 };
-const MAX_BULK_ADD_SUBMISSIONS = 1e3;
 class UserFormSubmissionService extends BaseApiService {
   constructor() {
     super(...arguments);
@@ -7391,63 +7397,38 @@ class UserFormSubmissionService extends BaseApiService {
   }
   // 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 = 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);
             }
           }
         }
@@ -7468,58 +7449,66 @@ class UserFormSubmissionService extends BaseApiService {
           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 blocks = [...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
+      });
+      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;
@@ -13133,10 +13122,7 @@ const MultiStringInput = memo((props) => {
   helpText = showInputOnly ? null : helpText;
   label = showInputOnly ? "" : label;
   const color = useSeverityColor(severity);
-  const value = useMemo(
-    () => Array.isArray(fieldProps.value) ? fieldProps.value : [],
-    [fieldProps.value]
-  );
+  const value = useMemo(() => Array.isArray(fieldProps.value) ? fieldProps.value : [], [fieldProps.value]);
   const { onChange, onBlur } = fieldProps;
   const droppableId = `${inputId}-droppable`;
   const { disabled } = rest;
@@ -14952,39 +14938,37 @@ function formRevisionToSchema(formRevision, meta = {}) {
     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];
@@ -16787,6 +16771,7 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   emptyStringField,
   emptyTextField,
   encodeFormValues,
+  flattenFields,
   formRevisionToSchema,
   initialFormValues,
   isConditionMet,
@@ -17029,6 +17014,7 @@ export {
   fileReducer,
   fileSlice,
   fileToBlob,
+  flattenFields,
   flipCoordinates,
   formReducer,
   formRevisionReducer,