tinybase 9.4.0-beta.1 → 9.4.0

package/ui-svelte-inspector/with-schemas/index.js

@@ -1245,11 +1245,35 @@ const createCustomPersister = (
     initialContent,
     startSaveFirst = false,
   ) => {
-    const [call1, call2] = startSaveFirst
-      ? [startAutoSave, startAutoLoad]
-      : [startAutoLoad, startAutoSave];
-    await call1(initialContent);
-    await call2(initialContent);
+    const [call1, call2, stop1, stop2] = startSaveFirst
+      ? [startAutoSave, startAutoLoad, stopAutoSave, stopAutoLoad]
+      : [startAutoLoad, startAutoSave, stopAutoLoad, stopAutoSave];
+    const start1 = call1(initialContent);
+    const generation1 = startSaveFirst
+      ? autoSaveGeneration
+      : autoLoadGeneration;
+    await start1;
+    const start2 = call2(initialContent);
+    const generation2 = startSaveFirst
+      ? autoLoadGeneration
+      : autoSaveGeneration;
+    try {
+      await start2;
+    } catch (error) {
+      if (
+        generation2 ==
+        (startSaveFirst ? autoLoadGeneration : autoSaveGeneration)
+      ) {
+        await tryCatchIgnore(stop2);
+      }
+      if (
+        generation1 ==
+        (startSaveFirst ? autoSaveGeneration : autoLoadGeneration)
+      ) {
+        await tryCatchIgnore(stop1);
+      }
+      throw error;
+    }
     return persister;
   };
   const stopAutoPersisting = async (stopSaveFirst = false) => {

package/with-schemas/index.js

@@ -261,6 +261,7 @@ const collForEach = (coll, cb) => coll?.forEach(cb);
 const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
 const ERROR_HLC = 13;
+const ERROR_QUERY_SELECT_ALL_CYCLE = 16;
 const errorNew = (code, details) =>
   new Error(
     TINYBASE +
@@ -4477,7 +4478,50 @@ const createQueries = getCreateFunction((store) => {
   const preStoreListenerIds = mapNew();
   const sourceStoreListenerIds = mapNew();
   const selectAllListenerIds = mapNew();
+  const selectAllRetryListenerIds = mapNew();
+  const selectAllQuerySources = mapNew();
   const referencedQueryIds = mapNew();
+  const assertNoMappedSelectAllCycle = (queryId, nextQuerySources) => {
+    const getQuerySources = (sourceQueryId) =>
+      sourceQueryId === queryId
+        ? nextQuerySources
+        : mapGet(selectAllQuerySources, sourceQueryId);
+    const reachesQuery = (
+      sourceQueryId,
+      targetQueryId,
+      visitedQueryIds = setNew(),
+    ) => {
+      if (sourceQueryId === targetQueryId) {
+        return true;
+      }
+      if (collHas(visitedQueryIds, sourceQueryId)) {
+        return false;
+      }
+      setAdd(visitedQueryIds, sourceQueryId);
+      return !collEvery(
+        getQuerySources(sourceQueryId),
+        (_changesCellId, nextQueryId) =>
+          !reachesQuery(nextQueryId, targetQueryId, visitedQueryIds),
+      );
+    };
+    const hasMappedCycle = (sourceQueryId, querySources) =>
+      !collEvery(
+        querySources,
+        (changesCellId, nextQueryId) =>
+          !changesCellId || !reachesQuery(nextQueryId, sourceQueryId),
+      );
+    if (
+      hasMappedCycle(queryId, nextQuerySources) ||
+      !collEvery(
+        selectAllQuerySources,
+        (querySources, sourceQueryId) =>
+          sourceQueryId === queryId ||
+          !hasMappedCycle(sourceQueryId, querySources),
+      )
+    ) {
+      errorThrow(ERROR_QUERY_SELECT_ALL_CYCLE);
+    }
+  };
   const {
     _: [, addListener, callListeners],
     delListener: delListenerImpl,
@@ -4551,6 +4595,30 @@ const createQueries = getCreateFunction((store) => {
     resetStoreListeners(mapGet(sourceStoreListenerIds, queryId));
     mapSet(sourceStoreListenerIds, queryId);
   };
+  const clearSelectAllRetryListeners = (queryId) =>
+    ifNotUndefined(
+      mapGet(selectAllRetryListenerIds, queryId),
+      (listenerIds) => {
+        mapForEach(listenerIds, (sourceStore, listenerIdsByTableId) =>
+          mapForEach(listenerIdsByTableId, (_sourceTableId, listenerId) =>
+            sourceStore.delListener(listenerId),
+          ),
+        );
+        mapSet(selectAllRetryListenerIds, queryId);
+      },
+    );
+  const addSelectAllRetryListener = (queryId, sourceStore, sourceTableId) => {
+    const listenerIdsByTableId = mapEnsure(
+      mapEnsure(selectAllRetryListenerIds, queryId, mapNew),
+      sourceStore,
+      mapNew,
+    );
+    mapEnsure(listenerIdsByTableId, sourceTableId, () =>
+      sourceStore.addTableListener(sourceTableId, () =>
+        setQueryDefinitionImpl(queryId),
+      ),
+    );
+  };
   const syncSelectAllListeners = (queryId, nextSources = mapNew()) => {
     const listenerIds = mapEnsure(selectAllListenerIds, queryId, mapNew);
     mapForEach(listenerIds, (sourceStore, listenerIdsByTableId) => {
@@ -4569,7 +4637,13 @@ const createQueries = getCreateFunction((store) => {
       collForEach(tableIds, (sourceTableId) =>
         mapEnsure(listenerIdsByTableId, sourceTableId, () =>
           sourceStore.addTableCellIdsListener(sourceTableId, () =>
-            setQueryDefinitionImpl(queryId),
+            tryCatchSync(
+              () => setQueryDefinitionImpl(queryId),
+              (error) => {
+                addSelectAllRetryListener(queryId, sourceStore, sourceTableId);
+                throw error;
+              },
+            ),
           ),
         ),
       );
@@ -4728,6 +4802,10 @@ const createQueries = getCreateFunction((store) => {
             isFunction(prefixOrMapper)
               ? prefixOrMapper
               : (cellId) => (prefixOrMapper ?? EMPTY_STRING) + cellId,
+            isFunction(prefixOrMapper) ||
+            (!isUndefined(prefixOrMapper) && prefixOrMapper !== EMPTY_STRING)
+              ? 1
+              : 0,
           ]);
         };
         const join = (arg1, arg2, arg3, arg4) => {
@@ -4801,28 +4879,49 @@ const createQueries = getCreateFunction((store) => {
                   getSelectedOrGroupedCell(arg1) === arg2,
           );
         build({select, selectAll, join, where, group, having, param});
-        resultStore2.delTable(queryId);
-        if (isEmpty(selectionEntries)) {
-          commit?.();
-          return queries;
-        }
         const joins = mapNew(joinEntries);
         mapForEach(joins, (joinAlias, [, fromJoinAlias]) =>
           ifNotUndefined(mapGet(joins, fromJoinAlias), ({3: toJoinAliases2}) =>
             isUndefined(joinAlias) ? 0 : arrayPush(toJoinAliases2, joinAlias),
           ),
         );
-        const groups = mapNew(groupEntries);
-        const hasGroupsOrHavings = !collIsEmpty(groups) || !isEmpty(havings);
-        const selectEntries = [];
-        const selectAllSources = stagedDefinition[3];
+        const isRootSelectAll = (joinedTableId) => isUndefined(joinedTableId);
         const getSelectAllJoin = (joinedTableId) =>
           mapGet(
             joins,
-            isUndefined(joinedTableId) || joinedTableId === tableId
-              ? void 0
-              : joinedTableId,
+            isRootSelectAll(joinedTableId) ? void 0 : joinedTableId,
           );
+        const nextSelectAllQuerySources = stagedDefinition[5];
+        arrayForEach(
+          selectionEntries,
+          ([selectAll2, selectedOrJoinedTableId, , changesCellId = 0]) =>
+            selectAll2
+              ? ifNotUndefined(
+                  getSelectAllJoin(selectedOrJoinedTableId),
+                  ([sourceQueryId, , , , , sourceStore]) =>
+                    sourceStore === store
+                      ? 0
+                      : mapSet(
+                          nextSelectAllQuerySources,
+                          sourceQueryId,
+                          mapGet(nextSelectAllQuerySources, sourceQueryId) ||
+                            changesCellId
+                            ? 1
+                            : 0,
+                        ),
+                )
+              : 0,
+        );
+        assertNoMappedSelectAllCycle(queryId, nextSelectAllQuerySources);
+        resultStore2.delTable(queryId);
+        if (isEmpty(selectionEntries)) {
+          commit?.();
+          return queries;
+        }
+        const groups = mapNew(groupEntries);
+        const hasGroupsOrHavings = !collIsEmpty(groups) || !isEmpty(havings);
+        const selectEntries = [];
+        const selectAllSources = stagedDefinition[3];
         arrayForEach(
           selectionEntries,
           ([selectAll2, selectedOrJoinedTableId, clauseOrMapper]) => {
@@ -4840,11 +4939,7 @@ const createQueries = getCreateFunction((store) => {
                       (cellId) =>
                         arrayPush(selectEntries, [
                           clauseOrMapper(cellId),
-                          (getTableCell) =>
-                            isUndefined(selectedOrJoinedTableId) ||
-                            selectedOrJoinedTableId === tableId
-                              ? getTableCell(cellId)
-                              : getTableCell(selectedOrJoinedTableId, cellId),
+                          getUndefined,
                         ]),
                     );
                   },
@@ -5041,67 +5136,74 @@ const createQueries = getCreateFunction((store) => {
                   joinedCellId,
                 );
           };
+          const writeSelectAllRow = () => {
+            const resultRow = objNew();
+            arrayForEach(
+              selectionEntries,
+              ([selectAll2, selectedOrJoinedTableId, clauseOrMapper]) => {
+                if (selectAll2) {
+                  ifNotUndefined(
+                    getSelectAllJoin(selectedOrJoinedTableId),
+                    ([realTableId, , , , remoteIdPairs, sourceStore]) => {
+                      const sourceRowId = isRootSelectAll(
+                        selectedOrJoinedTableId,
+                      )
+                        ? rootRowId
+                        : mapGet(remoteIdPairs, rootRowId)?.[0];
+                      ifNotUndefined(sourceRowId, (sourceRowId2) =>
+                        arrayForEach(
+                          arraySort(
+                            sourceStore.getCellIds(realTableId, sourceRowId2),
+                          ),
+                          (cellId) =>
+                            objSet(
+                              resultRow,
+                              clauseOrMapper(cellId),
+                              sourceStore.getCell(
+                                realTableId,
+                                sourceRowId2,
+                                cellId,
+                              ),
+                            ),
+                        ),
+                      );
+                    },
+                  );
+                } else {
+                  const selectedCell = clauseOrMapper(getJoinCell, rootRowId);
+                  const selectedCellId = selectedOrJoinedTableId;
+                  if (isUndefined(selectedCell)) {
+                    objDel(resultRow, selectedCellId);
+                  } else {
+                    objSet(resultRow, selectedCellId, selectedCell);
+                  }
+                }
+              },
+            );
+            if (objIsEmpty(resultRow)) {
+              selectJoinWhereStore.delRow(queryId, rootRowId);
+            } else {
+              selectJoinWhereStore.setRow(queryId, rootRowId, resultRow);
+            }
+          };
           selectJoinWhereStore.transaction(() => {
             if (!arrayEvery(wheres, (where2) => where2(getJoinCell))) {
               selectJoinWhereStore.delRow(queryId, rootRowId);
             } else if (hasGroupsOrHavings) {
-              mapForEach(selects, (asCellId, tableCellGetter) =>
-                selectJoinWhereStore._[5](
-                  queryId,
-                  rootRowId,
-                  asCellId,
-                  tableCellGetter(getJoinCell, rootRowId),
-                ),
-              );
-            } else if (hasSelectAll) {
-              const resultRow = objNew();
-              arrayForEach(
-                selectionEntries,
-                ([selectAll2, selectedOrJoinedTableId, clauseOrMapper]) => {
-                  if (selectAll2) {
-                    ifNotUndefined(
-                      getSelectAllJoin(selectedOrJoinedTableId),
-                      ([realTableId, , , , remoteIdPairs, sourceStore]) => {
-                        const sourceRowId =
-                          isUndefined(selectedOrJoinedTableId) ||
-                          selectedOrJoinedTableId === tableId
-                            ? rootRowId
-                            : mapGet(remoteIdPairs, rootRowId)?.[0];
-                        ifNotUndefined(sourceRowId, (sourceRowId2) =>
-                          arrayForEach(
-                            arraySort(
-                              sourceStore.getCellIds(realTableId, sourceRowId2),
-                            ),
-                            (cellId) =>
-                              objSet(
-                                resultRow,
-                                clauseOrMapper(cellId),
-                                sourceStore.getCell(
-                                  realTableId,
-                                  sourceRowId2,
-                                  cellId,
-                                ),
-                              ),
-                          ),
-                        );
-                      },
-                    );
-                  } else {
-                    const selectedCell = clauseOrMapper(getJoinCell, rootRowId);
-                    const selectedCellId = selectedOrJoinedTableId;
-                    if (isUndefined(selectedCell)) {
-                      objDel(resultRow, selectedCellId);
-                    } else {
-                      objSet(resultRow, selectedCellId, selectedCell);
-                    }
-                  }
-                },
-              );
-              if (objIsEmpty(resultRow)) {
-                selectJoinWhereStore.delRow(queryId, rootRowId);
+              if (hasSelectAll) {
+                writeSelectAllRow();
               } else {
-                selectJoinWhereStore.setRow(queryId, rootRowId, resultRow);
+                mapForEach(selects, (asCellId, tableCellGetter) =>
+                  selectJoinWhereStore._[5](
+                    queryId,
+                    rootRowId,
+                    asCellId,
+                    tableCellGetter(getJoinCell, rootRowId),
+                  ),
+                );
               }
+            } else if (hasSelectAll) {
+              writeSelectAllRow();
             } else {
               mapForEach(selects, (asCellId, tableCellGetter) =>
                 selectJoinWhereStore._[5](
@@ -5231,7 +5333,14 @@ const createQueries = getCreateFunction((store) => {
       }),
     );
   const setQueryDefinitionImpl = (queryId, definition) => {
-    const stagedDefinition = [mapNew(), mapNew(), void 0, mapNew(), setNew()];
+    const stagedDefinition = [
+      mapNew(),
+      mapNew(),
+      void 0,
+      mapNew(),
+      setNew(),
+      mapNew(),
+    ];
     let committed = false;
     tryCatchSync(
       () =>
@@ -5253,11 +5362,17 @@ const createQueries = getCreateFunction((store) => {
           );
           mapSet(preStores, queryId, stagedDefinition[2]);
           syncSelectAllListeners(queryId, stagedDefinition[3]);
+          clearSelectAllRetryListeners(queryId);
           mapSet(
             referencedQueryIds,
             queryId,
             collIsEmpty(stagedDefinition[4]) ? void 0 : stagedDefinition[4],
           );
+          mapSet(
+            selectAllQuerySources,
+            queryId,
+            collIsEmpty(stagedDefinition[5]) ? void 0 : stagedDefinition[5],
+          );
           committed = true;
         }),
       (error) => {
@@ -5308,7 +5423,9 @@ const createQueries = getCreateFunction((store) => {
     resetPreStores(queryId);
     resetSourceStores(queryId);
     syncSelectAllListeners(queryId);
+    clearSelectAllRetryListeners(queryId);
     mapSet(referencedQueryIds, queryId);
+    mapSet(selectAllQuerySources, queryId);
     delDefinition(queryId);
     cleanStores();
     return queries;