@legendapp/state 3.0.0-beta.46 → 3.0.0-beta.48

package/sync-plugins/crud.js

@@ -9,6 +9,11 @@ var { waitForSet, runWithRetry } = sync.internal;
 function transformOut(data, transform) {
   return transform ? transform(clone(data)) : data;
 }
+function warnMissingId(value) {
+  if (process.env.NODE_ENV === "development") {
+    console.warn("[legend-state] syncedCrud received an item without an id", value);
+  }
+}
 function ensureId(obj, fieldId, generateId, node) {
   if (!obj[fieldId]) {
     obj[fieldId] = generateId();
@@ -43,40 +48,89 @@ function arrayToRecord(arr, keyField) {
     for (let i = 0; i < arr.length; i++) {
       const v = arr[i];
       const key = v[keyField];
-      record[key] = v;
+      if (state.isNullOrUndefined(key)) {
+        warnMissingId(v);
+      } else {
+        record[key] = v;
+      }
     }
   }
   return record;
 }
-function retrySet(params, retry, action, itemKey, itemValue, change, queuedRetries, itemValueFull, actionFn, saveResult) {
-  if (action === "delete") {
-    if (queuedRetries.create.has(itemKey)) {
-      queuedRetries.create.delete(itemKey);
-    }
-    if (queuedRetries.update.has(itemKey)) {
-      queuedRetries.update.delete(itemKey);
-    }
-  } else {
-    if (queuedRetries.delete.has(itemKey)) {
-      queuedRetries.delete.delete(itemKey);
-    }
+function mergeQueuedRetryValue(currentValue, nextValue) {
+  if (currentValue && nextValue && typeof currentValue === "object" && typeof nextValue === "object") {
+    Object.assign(currentValue, nextValue);
+    return currentValue;
+  }
+  return nextValue;
+}
+function queueRetryValue(queuedRetries, itemKey, itemValue, itemValueFull) {
+  const queuedRetry = queuedRetries.get(itemKey);
+  if (queuedRetry) {
+    queuedRetry.value = mergeQueuedRetryValue(queuedRetry.value, itemValue);
+    queuedRetry.fullValue = mergeQueuedRetryValue(queuedRetry.fullValue, itemValueFull);
+    return queuedRetry;
   }
-  const queuedRetry = queuedRetries[action].get(itemKey);
+  const nextQueuedRetry = {
+    value: itemValue,
+    fullValue: itemValueFull
+  };
+  queuedRetries.set(itemKey, nextQueuedRetry);
+  return nextQueuedRetry;
+}
+function cancelQueuedRetry(queuedRetries, itemKey) {
+  const queuedRetry = queuedRetries.get(itemKey);
   if (queuedRetry) {
-    itemValue = Object.assign(queuedRetry, itemValue);
+    queuedRetry.cancelled = true;
+    queuedRetries.delete(itemKey);
+  }
+}
+function retrySet(params, retry, action, itemKey, itemValue, change, queuedRetries, itemValueFull, actionFn, saveResult, options) {
+  if (action === "delete") {
+    cancelQueuedRetry(queuedRetries.create, itemKey);
+    cancelQueuedRetry(queuedRetries.update, itemKey);
+  } else {
+    cancelQueuedRetry(queuedRetries.delete, itemKey);
   }
-  queuedRetries[action].set(itemKey, itemValue);
-  const clonedValue = clone(itemValueFull);
+  const queuedRetry = queueRetryValue(queuedRetries[action], itemKey, itemValue, itemValueFull);
   const paramsWithChanges = { ...params, changes: [change] };
-  return runWithRetry(
-    paramsWithChanges,
-    retry,
-    "create_" + itemKey,
-    () => actionFn(itemValue, paramsWithChanges).then((result) => {
-      queuedRetries[action].delete(itemKey);
-      return saveResult(itemKey, clonedValue, result, true, change);
-    })
-  );
+  const runAttempt = () => {
+    var _a;
+    if (queuedRetry.cancelled) {
+      return Promise.resolve(void 0);
+    }
+    const refreshed = (_a = options == null ? void 0 : options.refreshValue) == null ? void 0 : _a.call(options);
+    const runWithRefreshedValue = (retryValue) => {
+      if (retryValue === false || queuedRetry.cancelled) {
+        queuedRetry.cancelled = true;
+        queuedRetries[action].delete(itemKey);
+        return Promise.resolve(void 0);
+      }
+      if (retryValue) {
+        queuedRetry.value = retryValue.value;
+        queuedRetry.fullValue = retryValue.fullValue;
+      }
+      const attemptValue = queuedRetry.value;
+      const attemptFullValue = clone(queuedRetry.fullValue);
+      return actionFn(attemptValue, paramsWithChanges).catch((error) => {
+        var _a2;
+        (_a2 = options == null ? void 0 : options.onAttemptFailure) == null ? void 0 : _a2.call(options);
+        throw error;
+      }).then(async (result) => {
+        queuedRetries[action].delete(itemKey);
+        if (queuedRetry.cancelled) {
+          return result;
+        }
+        await saveResult(itemKey, attemptFullValue, result, true, change);
+        return result;
+      });
+    };
+    return state.isPromise(refreshed) ? refreshed.then(runWithRefreshedValue) : runWithRefreshedValue(refreshed);
+  };
+  return runWithRetry(paramsWithChanges, retry, action + "_" + itemKey, runAttempt).catch((error) => {
+    params.update({ value: {}, failedChanges: [change] });
+    throw error;
+  });
 }
 function syncedCrud(props) {
   const {
@@ -102,12 +156,53 @@ function syncedCrud(props) {
     ...rest
   } = props;
   const fieldId = fieldIdProp || "id";
-  const pendingCreates = /* @__PURE__ */ new Set();
+  const pendingCreates = /* @__PURE__ */ new Map();
   const queuedRetries = {
     create: /* @__PURE__ */ new Map(),
     update: /* @__PURE__ */ new Map(),
     delete: /* @__PURE__ */ new Map()
   };
+  const beginPendingCreate = (id, change) => {
+    const pendingCreate = pendingCreates.get(id) || { hasFailed: false };
+    pendingCreate.hasFailed = false;
+    pendingCreate.change || (pendingCreate.change = change);
+    pendingCreates.set(id, pendingCreate);
+    return pendingCreate;
+  };
+  const clearPendingCreate = (id) => {
+    if (!state.isNullOrUndefined(id)) {
+      pendingCreates.delete(id);
+      cancelQueuedRetry(queuedRetries.create, id);
+    }
+  };
+  const cancelFailedPendingCreate = (id) => {
+    var _a;
+    if (!state.isNullOrUndefined(id) && ((_a = pendingCreates.get(id)) == null ? void 0 : _a.hasFailed)) {
+      clearPendingCreate(id);
+      return true;
+    }
+    return false;
+  };
+  const clearPendingCreateForValue = (value) => {
+    if (value && typeof value === "object") {
+      clearPendingCreate(value[fieldId]);
+    }
+  };
+  const clearPendingCreatesForValues = (values) => {
+    if (values == null ? void 0 : values.length) {
+      for (let i = 0; i < values.length; i++) {
+        clearPendingCreateForValue(values[i]);
+      }
+    }
+  };
+  const markPendingCreateFailed = (itemKey) => {
+    const pendingCreate = pendingCreates.get(itemKey);
+    if (pendingCreate && !pendingCreate.hasFailed) {
+      pendingCreate.hasFailed = true;
+      cancelQueuedRetry(queuedRetries.update, itemKey);
+      cancelQueuedRetry(queuedRetries.delete, itemKey);
+    }
+  };
   let asType = props.as;
   if (!asType) {
     asType = getFn ? "value" : "object";
@@ -127,9 +222,19 @@ function syncedCrud(props) {
         if (asArray) {
           out.push(result);
         } else if (asMap) {
-          out.set(value[fieldId], result);
+          const key = value[fieldId];
+          if (state.isNullOrUndefined(key)) {
+            warnMissingId(value);
+          } else {
+            out.set(key, result);
+          }
         } else {
-          out[value[fieldId]] = result;
+          const key = value[fieldId];
+          if (state.isNullOrUndefined(key)) {
+            warnMissingId(value);
+          } else {
+            out[key] = result;
+          }
         }
       }
     }
@@ -167,6 +272,7 @@ function syncedCrud(props) {
         };
         const processResults = (data) => {
           data || (data = []);
+          clearPendingCreatesForValues(data);
           if (fieldUpdatedAt) {
             const newLastSync = computeLastSync(data, fieldUpdatedAt, fieldCreatedAt);
             if (newLastSync && newLastSync !== lastSync) {
@@ -183,6 +289,7 @@ function syncedCrud(props) {
       } else if (getFn) {
         const dataPromise = getFn(getParams);
         const processData = (data) => {
+          clearPendingCreateForValue(data);
           let transformed = data;
           if (data) {
             const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
@@ -217,6 +324,32 @@ function syncedCrud(props) {
         !state.isNullOrUndefined(itemValue[fieldId]) ? { [fieldId]: itemValue[fieldId] } : {}
       ) : itemValue;
     };
+    const getCurrentValueAtKey = (itemKey) => {
+      const currentPeeked = state.getNodeValue(node);
+      if (asType === "value") {
+        return currentPeeked;
+      }
+      if (asType === "array") {
+        return state.isArray(currentPeeked) ? currentPeeked.find((value2) => (value2 == null ? void 0 : value2[fieldId]) === itemKey) : void 0;
+      }
+      if (asType === "Map") {
+        return currentPeeked == null ? void 0 : currentPeeked.get(itemKey);
+      }
+      return currentPeeked == null ? void 0 : currentPeeked[itemKey];
+    };
+    const isFailedCreateReadyToRetry = (itemKey) => {
+      const pendingCreate = pendingCreates.get(itemKey);
+      return !!(pendingCreate == null ? void 0 : pendingCreate.hasFailed) && !pendingCreate.promise;
+    };
+    const addCreate = (id, itemValue, change) => {
+      const existingPendingCreate = pendingCreates.get(id);
+      if ((existingPendingCreate == null ? void 0 : existingPendingCreate.hasFailed) && !existingPendingCreate.promise && change.path.length === 0) {
+        existingPendingCreate.change = change;
+      }
+      const pendingCreate = beginPendingCreate(id, change);
+      changesById.set(id, pendingCreate.change);
+      creates.set(id, itemValue);
+    };
     changes.forEach((change) => {
       var _a, _b;
       const { path, prevAtPath, valueAtPath, pathTypes } = change;
@@ -229,12 +362,14 @@ function syncedCrud(props) {
           const id = value[fieldId];
           if (!state.isNullOrUndefined(id)) {
             changesById.set(id, change);
-            if (pendingCreates.has(id)) {
+            if (isFailedCreateReadyToRetry(id)) {
+              isCreate = true;
+            } else if (pendingCreates.has(id)) {
               isCreate = false;
             }
             if (isCreate || retryAsCreate) {
               if (createFn) {
-                creates.set(id, value);
+                addCreate(id, value, change);
               } else {
                 console.warn("[legend-state] missing create function");
               }
@@ -259,8 +394,11 @@ function syncedCrud(props) {
             console.error("[legend-state]: added synced item without an id");
           }
         } else if (path.length === 0) {
-          deletes.add(prevAtPath);
-          changesById.set(prevAtPath[fieldId], change);
+          const id = prevAtPath == null ? void 0 : prevAtPath[fieldId];
+          if (!cancelFailedPendingCreate(id)) {
+            deletes.add(prevAtPath);
+            changesById.set(prevAtPath[fieldId], change);
+          }
         }
       } else {
         let itemsChanged = [];
@@ -283,7 +421,11 @@ function syncedCrud(props) {
           for (let i = 0; i < lengthPrev; i++) {
             const key = keysPrev[i];
             if (!keysSet.has(key)) {
-              deletes.add(prevAsObject[key]);
+              const prevValue = prevAsObject[key];
+              const id = prevValue == null ? void 0 : prevValue[fieldId];
+              if (!cancelFailedPendingCreate(id)) {
+                deletes.add(prevValue);
+              }
             }
           }
           for (let i = 0; i < length; i++) {
@@ -295,7 +437,8 @@ function syncedCrud(props) {
               return false;
             } else {
               const isDiff = !prevAsObject || !sync.deepEqual(value2, prev);
-              if (isDiff) {
+              const isFailedCreateRetry = isFailedCreateReadyToRetry(value2 == null ? void 0 : value2[fieldId]);
+              if (isDiff || isFailedCreateRetry) {
                 itemsChanged.push([getUpdateValue(value2, prev), prev, value2]);
               }
             }
@@ -305,8 +448,11 @@ function syncedCrud(props) {
           const itemValue = asMap ? value.get(itemKey) : value[itemKey];
           if (!itemValue) {
             if (path.length === 1 && prevAtPath) {
-              deletes.add(prevAtPath);
-              changesById.set(prevAtPath[fieldId], change);
+              const id = prevAtPath[fieldId];
+              if (!cancelFailedPendingCreate(id)) {
+                deletes.add(prevAtPath);
+                changesById.set(id, change);
+              }
             }
           } else {
             if (generateId) {
@@ -322,27 +468,26 @@ function syncedCrud(props) {
           }
         }
         itemsChanged == null ? void 0 : itemsChanged.forEach(([item, prev, fullValue]) => {
-          const isCreate = !pendingCreates.has(item[fieldId]) && (fieldCreatedAt ? !item[fieldCreatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : fieldUpdatedAt ? !item[fieldUpdatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : state.isNullOrUndefined(prev));
+          const id = item[fieldId];
+          const isFailedCreateRetry = isFailedCreateReadyToRetry(id);
+          const isCreate = isFailedCreateRetry || !pendingCreates.has(id) && (fieldCreatedAt ? !item[fieldCreatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : fieldUpdatedAt ? !item[fieldUpdatedAt] && !(prev == null ? void 0 : prev[fieldCreatedAt]) : state.isNullOrUndefined(prev));
           if (isCreate) {
-            if (!item[fieldId]) {
+            if (!id) {
               console.error("[legend-state]: added item without an id");
             }
             if (createFn) {
-              const id = item[fieldId];
-              changesById.set(id, change);
-              pendingCreates.add(id);
-              creates.set(id, item);
+              addCreate(id, isFailedCreateRetry ? fullValue : item, change);
             } else {
               console.warn("[legend-state] missing create function");
             }
           } else {
             if (updateFn) {
-              const id = item[fieldId];
-              changesById.set(id, change);
-              updates.set(id, updates.has(id) ? Object.assign(updates.get(id), item) : item);
+              const id2 = item[fieldId];
+              changesById.set(id2, change);
+              updates.set(id2, updates.has(id2) ? Object.assign(updates.get(id2), item) : item);
               updateFullValues.set(
-                id,
-                updateFullValues.has(id) ? Object.assign(updateFullValues.get(id), fullValue) : fullValue
+                id2,
+                updateFullValues.has(id2) ? Object.assign(updateFullValues.get(id2), fullValue) : fullValue
               );
             } else {
               console.warn("[legend-state] missing update function");
@@ -413,7 +558,28 @@ function syncedCrud(props) {
           await waitForSet(waitForSetParam, changes, itemValue, { type: "create" });
         }
         const createObj = await transformOut(itemValue, transform == null ? void 0 : transform.save);
-        return retrySet(
+        const pendingCreate = pendingCreates.get(itemKey) || { hasFailed: false };
+        pendingCreates.set(itemKey, pendingCreate);
+        const refreshCreateValue = async () => {
+          const currentPendingCreate = pendingCreates.get(itemKey);
+          if (!currentPendingCreate) {
+            return false;
+          }
+          if (!currentPendingCreate.hasFailed) {
+            return void 0;
+          }
+          const currentValue = getCurrentValueAtKey(itemKey);
+          if (state.isNullOrUndefined(currentValue)) {
+            clearPendingCreate(itemKey);
+            return false;
+          }
+          const nextCreateObj = await transformOut(
+            clone(currentValue),
+            transform == null ? void 0 : transform.save
+          );
+          return { value: nextCreateObj, fullValue: nextCreateObj };
+        };
+        const createPromise = retrySet(
           params,
           retry,
           "create",
@@ -423,13 +589,31 @@ function syncedCrud(props) {
           queuedRetries,
           createObj,
           createFn,
-          saveResult
-        ).then(() => {
-          pendingCreates.delete(itemKey);
+          saveResult,
+          {
+            onAttemptFailure: () => markPendingCreateFailed(itemKey),
+            refreshValue: refreshCreateValue
+          }
+        );
+        pendingCreate.promise = createPromise;
+        return createPromise.then((result) => {
+          if (pendingCreates.get(itemKey) === pendingCreate) {
+            pendingCreates.delete(itemKey);
+          }
+          return result;
+        }).catch((error) => {
+          if (pendingCreates.get(itemKey) === pendingCreate) {
+            pendingCreate.promise = void 0;
+          }
+          throw error;
         });
       }),
       // Handle updates
       ...Array.from(updates).map(async ([itemKey, itemValue]) => {
+        const pendingCreate = pendingCreates.get(itemKey);
+        if ((pendingCreate == null ? void 0 : pendingCreate.hasFailed) && pendingCreate.promise) {
+          await pendingCreate.promise;
+        }
         const fullValue = updateFullValues.get(itemKey);
         if (waitForSetParam) {
           await waitForSet(waitForSetParam, changes, fullValue, { type: "update" });
@@ -512,6 +696,7 @@ function syncedCrud(props) {
         paramsForUpdate.lastSync = newLastSync;
       }
       const rowsTransformed = (transform == null ? void 0 : transform.load) ? await transformRows(rows) : rows;
+      clearPendingCreatesForValues(rows);
       paramsForUpdate.value = resultsToOutType(rowsTransformed);
       params.update(paramsForUpdate);
     }