@legendapp/state 3.0.0-alpha.8 → 3.0.0-beta.0

package/sync-plugins/crud.js

@@ -5,33 +5,25 @@ var sync = require('@legendapp/state/sync');
 
 // src/sync-plugins/crud.ts
 var { clone } = state.internal;
+var { waitForSet } = sync.internal;
 function transformOut(data, transform) {
   return transform ? transform(clone(data)) : data;
 }
-function ensureId(obj, generateId) {
-  if (!obj.id) {
-    obj.id = generateId();
+function ensureId(obj, fieldId, generateId) {
+  if (!obj[fieldId]) {
+    obj[fieldId] = generateId();
   }
-  return obj.id;
+  return obj[fieldId];
 }
-function onSavedCreatedUpdatedAt(mode, { saved, currentValue, isCreate, props }) {
-  const savedOut = {};
-  if (isCreate) {
-    Object.keys(saved).forEach((key) => {
-      if (state.isNullOrUndefined(currentValue[key])) {
-        savedOut[key] = saved[key];
-      }
-    });
-  } else if (mode === "createdUpdatedAt") {
-    Object.keys(saved).forEach((key) => {
-      const k = key;
-      const keyLower = key.toLowerCase();
-      if ((key === props.fieldCreatedAt || key === props.fieldUpdatedAt || keyLower.endsWith("createdat") || keyLower.endsWith("updatedat") || keyLower.endsWith("created_at") || keyLower.endsWith("updated_at")) && saved[k] instanceof Date) {
-        savedOut[k] = saved[k];
-      }
-    });
+function computeLastSync(data, fieldUpdatedAt, fieldCreatedAt) {
+  let newLastSync = 0;
+  for (let i = 0; i < data.length; i++) {
+    const updated = (fieldUpdatedAt ? data[i][fieldUpdatedAt] : 0) || (fieldCreatedAt ? data[i][fieldCreatedAt] : 0);
+    if (updated) {
+      newLastSync = Math.max(newLastSync, +new Date(updated));
+    }
   }
-  return savedOut;
+  return newLastSync;
 }
 function syncedCrud(props) {
   const {
@@ -41,168 +33,233 @@ function syncedCrud(props) {
     update: updateFn,
     delete: deleteFn,
     transform,
+    fieldId: fieldIdProp,
     fieldCreatedAt,
     fieldUpdatedAt,
     fieldDeleted,
+    fieldDeletedList,
     updatePartial,
+    subscribe: subscribeProp,
     onSaved,
-    onSavedUpdate,
     mode: modeParam,
     changesSince,
     generateId,
+    waitForSet: waitForSetParam,
     ...rest
   } = props;
+  const fieldId = fieldIdProp || "id";
+  const pendingCreates = /* @__PURE__ */ new Set();
   let asType = props.as;
   if (!asType) {
     asType = getFn ? "value" : "object";
   }
   const asMap = asType === "Map";
   const asArray = asType === "array";
-  const get = getFn || listFn ? async (getParams) => {
+  const resultsToOutType = (results) => {
+    if (asType === "value") {
+      return results[0];
+    }
+    const out = asType === "array" ? [] : asMap ? /* @__PURE__ */ new Map() : {};
+    for (let i = 0; i < results.length; i++) {
+      let result = results[i];
+      const value = result;
+      if (value) {
+        result = fieldDeleted && result[fieldDeleted] || fieldDeletedList && result[fieldDeletedList] || result[state.symbolDelete] ? state.internal.symbolDelete : result;
+        if (asArray) {
+          out.push(result);
+        } else if (asMap) {
+          out.set(value[fieldId], result);
+        } else {
+          out[value[fieldId]] = result;
+        }
+      }
+    }
+    return out;
+  };
+  const transformRows = (data) => {
+    return Promise.all(
+      data.map(
+        (value) => (
+          // Skip transforming any children with symbolDelete or fieldDeleted because they'll get deleted by resultsToOutType
+          value[state.symbolDelete] || fieldDeleted && value[fieldDeleted] || fieldDeletedList && value[fieldDeletedList] ? value : transform.load(value, "get")
+        )
+      )
+    );
+  };
+  const get = getFn || listFn ? (getParams) => {
     const { updateLastSync, lastSync, value } = getParams;
     if (listFn) {
       const isLastSyncMode = changesSince === "last-sync";
       if (isLastSyncMode && lastSync) {
         getParams.mode = modeParam || (asType === "array" ? "append" : asType === "value" ? "set" : "assign");
       }
-      const data = await listFn(getParams) || [];
-      let newLastSync = 0;
-      for (let i = 0; i < data.length; i++) {
-        const updated = data[i][fieldUpdatedAt] || data[i][fieldCreatedAt];
-        if (updated) {
-          newLastSync = Math.max(newLastSync, +new Date(updated));
+      const listPromise = listFn(getParams);
+      const toOut = (transformed) => {
+        var _a;
+        if (asType === "value") {
+          return transformed.length > 0 ? transformed[0] : (_a = (isLastSyncMode && lastSync || fieldDeleted) && value) != null ? _a : null;
+        } else {
+          return resultsToOutType(transformed);
         }
-      }
-      if (newLastSync && newLastSync !== lastSync) {
-        updateLastSync(newLastSync);
-      }
-      let transformed = data;
-      if (transform == null ? void 0 : transform.load) {
-        transformed = await Promise.all(data.map((value2) => transform.load(value2, "get")));
-      }
-      if (asType === "value") {
-        return transformed.length > 0 ? transformed[0] : isLastSyncMode && lastSync && value || null;
-      } else {
-        const results = transformed.map(
-          (result) => result[fieldDeleted] || result.__deleted ? state.internal.symbolDelete : result
-        );
-        const out = asType === "array" ? [] : asMap ? /* @__PURE__ */ new Map() : {};
-        for (let i = 0; i < results.length; i++) {
-          let result = results[i];
-          result = result[fieldDeleted] || result.__deleted ? state.internal.symbolDelete : result;
-          if (asArray) {
-            out.push(result);
-          } else if (asMap) {
-            out.set(result.id, result);
-          } else {
-            out[result.id] = result;
+      };
+      const processResults = (data) => {
+        data || (data = []);
+        if (fieldUpdatedAt) {
+          const newLastSync = computeLastSync(data, fieldUpdatedAt, fieldCreatedAt);
+          if (newLastSync && newLastSync !== lastSync) {
+            updateLastSync(newLastSync);
           }
         }
-        return out;
-      }
-    } else if (getFn) {
-      const data = await getFn(getParams);
-      let transformed = data;
-      if (data) {
-        const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
-        if (newLastSync && newLastSync !== lastSync) {
-          updateLastSync(newLastSync);
-        }
+        let transformed = data;
         if (transform == null ? void 0 : transform.load) {
-          transformed = await transform.load(data, "get");
+          transformed = transformRows(data);
         }
-      }
-      return transformed;
+        return state.isPromise(transformed) ? transformed.then(toOut) : toOut(transformed);
+      };
+      return state.isPromise(listPromise) ? listPromise.then(processResults) : processResults(listPromise);
+    } else if (getFn) {
+      const dataPromise = getFn(getParams);
+      const processData = (data) => {
+        let transformed = data;
+        if (data) {
+          const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
+          if (newLastSync && newLastSync !== lastSync) {
+            updateLastSync(newLastSync);
+          }
+          if (transform == null ? void 0 : transform.load) {
+            transformed = transform.load(data, "get");
+          }
+        }
+        return transformed;
+      };
+      return state.isPromise(dataPromise) ? dataPromise.then(processData) : processData(dataPromise);
     }
   } : void 0;
   const set = createFn || updateFn || deleteFn ? async (params) => {
-    const { value, changes, update, retryAsCreate, valuePrevious, node } = params;
+    const { value, changes, update, retryAsCreate, node } = params;
     const creates = /* @__PURE__ */ new Map();
     const updates = /* @__PURE__ */ new Map();
     const deletes = /* @__PURE__ */ new Set();
-    changes.forEach(({ path, prevAtPath, valueAtPath }) => {
+    const getUpdateValue = (itemValue, prev) => {
+      return updatePartial ? Object.assign(
+        sync.diffObjects(
+          prev,
+          itemValue,
+          /*deep*/
+          true
+        ),
+        itemValue[fieldId] ? { [fieldId]: itemValue[fieldId] } : {}
+      ) : itemValue;
+    };
+    changes.forEach((change) => {
+      const { path, prevAtPath, valueAtPath, pathTypes } = change;
       if (asType === "value") {
         if (value) {
-          let id = value == null ? void 0 : value.id;
-          const isCreate = fieldCreatedAt ? !value[fieldCreatedAt] : !prevAtPath;
+          let id = value == null ? void 0 : value[fieldId];
+          let isCreate = fieldCreatedAt ? !value[fieldCreatedAt] : !prevAtPath;
           if (!id && generateId) {
-            id = ensureId(value, generateId);
+            id = ensureId(value, fieldId, generateId);
           }
           if (id) {
+            if (pendingCreates.has(id)) {
+              isCreate = false;
+            }
             if (isCreate || retryAsCreate) {
-              creates.set(id, value);
+              if (createFn) {
+                creates.set(id, value);
+              } else {
+                console.warn("[legend-state] missing create function");
+              }
             } else if (path.length === 0) {
               if (valueAtPath) {
-                updates.set(id, valueAtPath);
+                updates.set(id, getUpdateValue(valueAtPath, prevAtPath));
               } else if (prevAtPath) {
-                deletes.add(prevAtPath == null ? void 0 : prevAtPath.id);
+                deletes.add(prevAtPath);
               }
-            } else {
-              updates.set(id, Object.assign(updates.get(id) || { id }, value));
+            } else if (!updates.has(id)) {
+              const previous = state.applyChanges(
+                clone(value),
+                changes,
+                /*applyPrevious*/
+                true
+              );
+              updates.set(id, getUpdateValue(value, previous));
             }
           } else {
             console.error("[legend-state]: added synced item without an id");
           }
         } else if (path.length === 0) {
-          const id = prevAtPath == null ? void 0 : prevAtPath.id;
-          if (id) {
-            deletes.add(id);
-          }
+          deletes.add(prevAtPath);
         }
       } else {
-        let itemsChanged = void 0;
+        let itemsChanged = [];
         if (path.length === 0) {
-          itemsChanged = (asMap ? Array.from(valueAtPath.entries()) : Object.entries(valueAtPath)).filter(([key, value2]) => {
+          const changed = asMap ? Array.from(valueAtPath.entries()) : Object.entries(valueAtPath);
+          for (let i = 0; i < changed.length; i++) {
+            const [key, value2] = changed[i];
             const prev = asMap ? prevAtPath.get(key) : prevAtPath[key];
-            const isDiff = !prevAtPath || !sync.deepEqual(value2, prev);
-            return isDiff;
-          });
+            if (state.isNullOrUndefined(value2) && !state.isNullOrUndefined(prev)) {
+              deletes.add(prev);
+              return false;
+            } else {
+              const isDiff = !prevAtPath || !sync.deepEqual(value2, prev);
+              if (isDiff) {
+                itemsChanged.push([getUpdateValue(value2, prev), prev]);
+              }
+            }
+          }
         } else {
           const itemKey = path[0];
           const itemValue = asMap ? value.get(itemKey) : value[itemKey];
           if (!itemValue) {
             if (path.length === 1 && prevAtPath) {
-              deletes.add(itemKey);
+              deletes.add(prevAtPath);
             }
           } else {
-            itemsChanged = [[itemKey, itemValue]];
+            const previous = state.setAtPath(
+              clone(itemValue),
+              path.slice(1),
+              pathTypes.slice(1),
+              prevAtPath
+            );
+            itemsChanged = [[getUpdateValue(itemValue, previous), previous]];
           }
         }
-        itemsChanged == null ? void 0 : itemsChanged.forEach(([itemKey, item]) => {
-          if (state.isNullOrUndefined(item)) {
-            deletes.add(itemKey);
+        itemsChanged == null ? void 0 : itemsChanged.forEach(([item, prev]) => {
+          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));
+          if (isCreate) {
+            if (generateId) {
+              ensureId(item, fieldId, generateId);
+            }
+            if (!item[fieldId]) {
+              console.error("[legend-state]: added item without an id");
+            }
+            if (createFn) {
+              pendingCreates.add(item[fieldId]);
+              creates.set(item[fieldId], item);
+            } else {
+              console.warn("[legend-state] missing create function");
+            }
           } else {
-            const prev = asMap ? valuePrevious.get(itemKey) : valuePrevious[itemKey];
-            const isCreate = fieldCreatedAt ? !item[fieldCreatedAt] : fieldUpdatedAt ? !item[fieldUpdatedAt] : state.isNullOrUndefined(prev);
-            if (isCreate) {
-              if (generateId) {
-                ensureId(item, generateId);
-              }
-              if (!item.id) {
-                console.error("[legend-state]: added item without an id");
-              }
-              if (createFn) {
-                creates.set(item.id, item);
-              } else {
-                console.log("[legend-state] missing create function");
-              }
+            if (updateFn) {
+              updates.set(
+                item[fieldId],
+                updates.has(item[fieldId]) ? Object.assign(updates.get(item[fieldId]), item) : item
+              );
             } else {
-              if (updateFn) {
-                updates.set(item.id, item);
-              } else {
-                console.log("[legend-state] missing update function");
-              }
+              console.warn("[legend-state] missing update function");
             }
           }
         });
       }
     });
     const saveResult = async (itemKey, input, data, isCreate) => {
-      if (data && (onSaved || onSavedUpdate)) {
-        const saved = (transform == null ? void 0 : transform.load) ? transform.load(data, "set") : data;
+      var _a;
+      if (data) {
+        const saved = (transform == null ? void 0 : transform.load) ? await transform.load(data, "set") : data;
         const isChild = itemKey !== "undefined" && asType !== "value";
         const currentPeeked = state.getNodeValue(node);
-        const currentValue = isChild ? currentPeeked == null ? void 0 : currentPeeked[itemKey] : currentPeeked;
+        const currentValue = isChild ? (_a = asType === "array" && state.isArray(currentPeeked) ? currentPeeked.find((v) => v[fieldId] === itemKey) : void 0) != null ? _a : currentPeeked[itemKey] : currentPeeked;
         const dataOnSaved = {
           saved,
           input,
@@ -210,17 +267,26 @@ function syncedCrud(props) {
           isCreate,
           props
         };
-        let savedOut = void 0;
-        if (onSavedUpdate) {
-          savedOut = onSavedCreatedUpdatedAt(onSavedUpdate, dataOnSaved);
-        }
-        if (onSaved) {
-          const ret = onSaved(dataOnSaved);
-          if (ret) {
-            savedOut = ret;
+        let savedOut = saved;
+        if (savedOut && !state.isNullOrUndefined(currentValue)) {
+          savedOut = clone(savedOut);
+          Object.keys(savedOut).forEach((key) => {
+            const i = input[key];
+            const c = currentValue[key];
+            if (
+              // value is already the new value, can ignore
+              savedOut[key] === c || // user has changed local value
+              key !== "id" && i !== c
+            ) {
+              delete savedOut[key];
+            }
+          });
+          if (onSaved) {
+            const ret = onSaved(dataOnSaved);
+            if (ret) {
+              savedOut = ret;
+            }
           }
-        }
-        if (savedOut) {
           const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt] : void 0;
           const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt] : void 0;
           const value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: savedOut } : savedOut;
@@ -233,38 +299,73 @@ function syncedCrud(props) {
       }
     };
     return Promise.all([
-      ...Array.from(creates).map(([itemKey, itemValue]) => {
-        const createObj = transformOut(itemValue, transform == null ? void 0 : transform.save);
-        return createFn(createObj, params).then(
-          (result) => saveResult(itemKey, createObj, result, true)
-        );
+      ...Array.from(creates).map(async ([itemKey, itemValue]) => {
+        if (waitForSetParam) {
+          await waitForSet(waitForSetParam, changes, itemValue, { type: "create" });
+        }
+        const createObj = await transformOut(itemValue, transform == null ? void 0 : transform.save);
+        return createFn(createObj, params).then((result) => {
+          return saveResult(itemKey, createObj, result, true);
+        }).finally(() => {
+          pendingCreates.delete(itemKey);
+        });
       }),
-      ...Array.from(updates).map(([itemKey, itemValue]) => {
-        const toSave = updatePartial ? Object.assign(
-          sync.diffObjects(asType === "value" ? valuePrevious : valuePrevious[itemKey], itemValue),
-          { id: itemValue.id }
-        ) : itemValue;
-        const changed = transformOut(toSave, transform == null ? void 0 : transform.save);
+      ...Array.from(updates).map(async ([itemKey, itemValue]) => {
+        if (waitForSetParam) {
+          await waitForSet(waitForSetParam, changes, itemValue, { type: "update" });
+        }
+        const toSave = itemValue;
+        const changed = await transformOut(toSave, transform == null ? void 0 : transform.save);
         if (Object.keys(changed).length > 0) {
           return updateFn(changed, params).then(
             (result) => result && saveResult(itemKey, changed, result, false)
           );
         }
       }),
-      ...Array.from(deletes).map((id) => {
-        if (deleteFn) {
-          deleteFn({ id }, params);
-        } else if (fieldDeleted && updateFn) {
-          updateFn({ id, [fieldDeleted]: true }, params);
-        } else {
-          console.log("[legend-state] missing delete function");
+      ...Array.from(deletes).map(async (valuePrevious) => {
+        if (valuePrevious !== state.symbolDelete) {
+          if (waitForSetParam) {
+            await waitForSet(waitForSetParam, changes, valuePrevious, { type: "delete" });
+          }
+          if (deleteFn) {
+            deleteFn(valuePrevious, params);
+          } else if (fieldDeleted && updateFn) {
+            const valueId = valuePrevious[fieldId];
+            if (valueId) {
+              updateFn({ ...{ [fieldId]: valueId }, [fieldDeleted]: true }, params);
+            } else {
+              console.error("[legend-state]: deleting item without an id");
+            }
+          } else {
+            console.warn("[legend-state] missing delete function");
+          }
         }
       })
     ]);
   } : void 0;
+  const subscribe = subscribeProp ? (params) => subscribeProp({
+    ...params,
+    update: async (paramsUpdate) => {
+      const paramsForUpdate = paramsUpdate;
+      const rows = paramsUpdate.value;
+      if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+        if (!state.isArray(rows)) {
+          console.error("[legend-state] subscribe:update expects an array of changed items");
+        }
+      }
+      const newLastSync = computeLastSync(rows, fieldUpdatedAt, fieldCreatedAt);
+      if (newLastSync) {
+        paramsForUpdate.lastSync = newLastSync;
+      }
+      const rowsTransformed = (transform == null ? void 0 : transform.load) ? await transformRows(rows) : rows;
+      paramsForUpdate.value = resultsToOutType(rowsTransformed);
+      params.update(paramsForUpdate);
+    }
+  }) : void 0;
   return sync.synced({
     set,
     get,
+    subscribe,
     mode: modeParam,
     ...rest
   });