tinybase 9.4.0-beta.1 → 9.4.0

package/persisters/persister-sqlite-wasm/with-schemas/index.js

@@ -826,11 +826,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/persisters/persister-sqlite3/index.js

@@ -831,11 +831,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/persisters/persister-sqlite3/with-schemas/index.js

@@ -831,11 +831,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/persisters/persister-yjs/index.js

@@ -615,11 +615,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/persisters/persister-yjs/with-schemas/index.js

@@ -615,11 +615,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/persisters/with-schemas/index.js

@@ -653,11 +653,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) => {
@@ -1566,6 +1590,8 @@ const createTabularPersister = (
 const TABLE_CREATED = 'c';
 const DATA_CHANGED = 'd';
 const EVENT_REGEX = /^([cd]:)(.+)/;
+const SIMPLE_TABLE_NAME = /^[A-Za-z0-9_]+$/;
+const POSTGRES_IDENTIFIER_SIZE = 63;
 const listenerResourcesByThing = mapNew();
 const createCustomPostgreSqlPersister = (
   store,
@@ -1638,17 +1664,30 @@ const createCustomPostgreSqlPersister = (
           );
   const addDataChangedTriggers = (tableName, dataChangedFunction) =>
     promiseAll(
-      arrayMap([INSERT, DELETE, UPDATE], (action, newOrOldOrBoth) =>
-        createTrigger(
+      arrayMap([INSERT, DELETE, UPDATE], (action, newOrOldOrBoth) => {
+        const legacyTriggerId = arrayJoin(
+          [TINYBASE, DATA_CHANGED, configHash, tableName, action],
+          '_',
+        );
+        return createTrigger(
           OR_REPLACE,
-          escapeIds(TINYBASE, DATA_CHANGED, configHash, tableName, action),
+          test(SIMPLE_TABLE_NAME, tableName) &&
+            size(legacyTriggerId) <= POSTGRES_IDENTIFIER_SIZE
+            ? escapeId(legacyTriggerId)
+            : escapeIds(
+                TINYBASE,
+                DATA_CHANGED,
+                configHash,
+                action,
+                EMPTY_STRING + getHash(tableName),
+              ),
           `AFTER ${action} ON${escapeId(tableName)}FOR EACH ROW WHEN(${when(
             tableName,
             newOrOldOrBoth,
           )})`,
           dataChangedFunction,
-        ),
-      ),
+        );
+      }),
     );
   const dropFunctions = async (functionNames) => {
     if (!isEmpty(functionNames)) {

package/queries/index.js

@@ -1,4 +1,5 @@
 const getTypeOf = (thing) => typeof thing;
+const TINYBASE = 'tinybase';
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
@@ -251,6 +252,20 @@ const getCellOrValueType = (cellOrValue) => {
 const encodeIfJson = (value) =>
   isObject(value) || isArray(value) ? JSON_PREFIX + jsonString(value) : value;
 
+const ERROR_QUERY_SELECT_ALL_CYCLE = 16;
+const errorNew = (code, details) =>
+  new Error(
+    TINYBASE +
+      ':' +
+      code +
+      (isUndefined(details)
+        ? EMPTY_STRING
+        : /* istanbul ignore next */
+          ':' + details),
+  );
+const errorThrow = (code, details) => {
+  throw errorNew(code, details);
+};
 const tryCatchSync = (action, onError) => {
   try {
     return action();
@@ -470,7 +485,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,
@@ -544,6 +602,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) => {
@@ -562,7 +644,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;
+              },
+            ),
           ),
         ),
       );
@@ -721,6 +809,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) => {
@@ -794,28 +886,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]) => {
@@ -833,11 +946,7 @@ const createQueries = getCreateFunction((store) => {
                       (cellId) =>
                         arrayPush(selectEntries, [
                           clauseOrMapper(cellId),
-                          (getTableCell) =>
-                            isUndefined(selectedOrJoinedTableId) ||
-                            selectedOrJoinedTableId === tableId
-                              ? getTableCell(cellId)
-                              : getTableCell(selectedOrJoinedTableId, cellId),
+                          getUndefined,
                         ]),
                     );
                   },
@@ -1034,67 +1143,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](
@@ -1224,7 +1340,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(
       () =>
@@ -1246,11 +1369,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) => {
@@ -1301,7 +1430,9 @@ const createQueries = getCreateFunction((store) => {
     resetPreStores(queryId);
     resetSourceStores(queryId);
     syncSelectAllListeners(queryId);
+    clearSelectAllRetryListeners(queryId);
     mapSet(referencedQueryIds, queryId);
+    mapSet(selectAllQuerySources, queryId);
     delDefinition(queryId);
     cleanStores();
     return queries;