tinybase 9.4.0-beta.0 → 9.4.0-beta.2

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 +
@@ -4476,6 +4477,51 @@ 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,
@@ -4549,11 +4595,72 @@ const createQueries = getCreateFunction((store) => {
     resetStoreListeners(mapGet(sourceStoreListenerIds, queryId));
     mapSet(sourceStoreListenerIds, queryId);
   };
-  const isResultStoreReferenced = (resultStore2) =>
+  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) => {
+      mapForEach(listenerIdsByTableId, (sourceTableId, listenerId) =>
+        collHas(mapGet(nextSources, sourceStore), sourceTableId)
+          ? 0
+          : (sourceStore.delListener(listenerId),
+            mapSet(listenerIdsByTableId, sourceTableId)),
+      );
+      if (collIsEmpty(listenerIdsByTableId)) {
+        mapSet(listenerIds, sourceStore);
+      }
+    });
+    mapForEach(nextSources, (sourceStore, tableIds) => {
+      const listenerIdsByTableId = mapEnsure(listenerIds, sourceStore, mapNew);
+      collForEach(tableIds, (sourceTableId) =>
+        mapEnsure(listenerIdsByTableId, sourceTableId, () =>
+          sourceStore.addTableCellIdsListener(sourceTableId, () =>
+            tryCatchSync(
+              () => setQueryDefinitionImpl(queryId),
+              (error) => {
+                addSelectAllRetryListener(queryId, sourceStore, sourceTableId);
+                throw error;
+              },
+            ),
+          ),
+        ),
+      );
+    });
+    if (collIsEmpty(listenerIds)) {
+      mapSet(selectAllListenerIds, queryId);
+    }
+  };
+  const isResultStoreReferenced = (queryId, resultStore2) =>
     !(
       collEvery(routedResultListeners, ([, storeListenerIds]) =>
         collEvery(storeListenerIds, ([store2]) => store2 !== resultStore2),
       ) &&
+      collEvery(
+        referencedQueryIds,
+        (queryIds) => !collHas(queryIds, queryId),
+      ) &&
       arrayEvery(
         [preStoreListenerIds, sourceStoreListenerIds],
         (storeListenerIds) =>
@@ -4568,7 +4675,7 @@ const createQueries = getCreateFunction((store) => {
       hasQuery(queryId) ? 0 : mapSet(preStores, queryId),
     );
     mapForEach(resultStores, (queryId, resultStore2) =>
-      hasQuery(queryId) || isResultStoreReferenced(resultStore2)
+      hasQuery(queryId) || isResultStoreReferenced(queryId, resultStore2)
         ? 0
         : mapSet(resultStores, queryId),
     );
@@ -4650,7 +4757,13 @@ const createQueries = getCreateFunction((store) => {
         const rootStore = asQuery ? getResultStore(tableId) : store;
         const resultStore2 = getResultStore(queryId);
         const paramValues = definition?.[3] ?? getParamValues(queryId);
-        const selectEntries = [];
+        const nextReferencedQueryIds = stagedDefinition[4];
+        if (asQuery) {
+          setAdd(nextReferencedQueryIds, tableId);
+        }
+        const selectionEntries = [];
+        let hasSelectAll = false;
+        let selectCount = 0;
         const joinEntries = [
           [void 0, [tableId, void 0, void 0, [], mapNew(), rootStore]],
         ];
@@ -4662,21 +4775,39 @@ const createQueries = getCreateFunction((store) => {
           const joinedTableId = isTrue(arg1) ? arg2 : arg1;
           const joinedCellId = isTrue(arg1) ? arg3 : arg2;
           const selectEntry = isFunction(arg1)
-            ? [size(selectEntries) + EMPTY_STRING, arg1]
+            ? [0, selectCount + EMPTY_STRING, arg1]
             : isUndefined(joinedCellId)
-              ? [arg1, (getTableCell) => getTableCell(arg1)]
+              ? [0, arg1, (getTableCell) => getTableCell(arg1)]
               : [
+                  0,
                   joinedCellId,
                   (getTableCell) =>
                     isTrue(arg1)
                       ? getTableCell(true, joinedTableId, joinedCellId)
                       : getTableCell(joinedTableId, joinedCellId),
                 ];
-          arrayPush(selectEntries, selectEntry);
+          selectCount++;
+          arrayPush(selectionEntries, selectEntry);
           return {
-            as: (selectedCellId) => (selectEntry[0] = selectedCellId),
+            as: (selectedCellId) => (selectEntry[1] = selectedCellId),
           };
         };
+        const selectAll = (arg1, arg2, arg3) => {
+          hasSelectAll = true;
+          const joinedTableId = isTrue(arg1) ? arg2 : arg1;
+          const prefixOrMapper = isTrue(arg1) ? arg3 : arg2;
+          arrayPush(selectionEntries, [
+            1,
+            joinedTableId,
+            isFunction(prefixOrMapper)
+              ? prefixOrMapper
+              : (cellId) => (prefixOrMapper ?? EMPTY_STRING) + cellId,
+            isFunction(prefixOrMapper) ||
+            (!isUndefined(prefixOrMapper) && prefixOrMapper !== EMPTY_STRING)
+              ? 1
+              : 0,
+          ]);
+        };
         const join = (arg1, arg2, arg3, arg4) => {
           const joinedTableId = isTrue(arg1) ? arg2 : arg1;
           const [fromJoinAlias, onArg] = isTrue(arg1)
@@ -4686,6 +4817,13 @@ const createQueries = getCreateFunction((store) => {
             : isUndefined(arg3) || isFunction(arg2)
               ? [void 0, arg2]
               : [arg2, arg3];
+          const sourceIsQuery = isTrue(arg1);
+          const sourceStore = sourceIsQuery
+            ? getResultStore(joinedTableId)
+            : store;
+          if (sourceIsQuery) {
+            setAdd(nextReferencedQueryIds, joinedTableId);
+          }
           const joinEntry = [
             joinedTableId,
             [
@@ -4694,7 +4832,7 @@ const createQueries = getCreateFunction((store) => {
               isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
               [],
               mapNew(),
-              isTrue(arg1) ? getResultStore(joinedTableId) : store,
+              sourceStore,
             ],
           ];
           arrayPush(joinEntries, joinEntry);
@@ -4740,21 +4878,86 @@ const createQueries = getCreateFunction((store) => {
               : (getSelectedOrGroupedCell) =>
                   getSelectedOrGroupedCell(arg1) === arg2,
           );
-        build({select, join, where, group, having, param});
-        resultStore2.delTable(queryId);
-        const selects = mapNew(selectEntries);
-        if (collIsEmpty(selects)) {
-          commit?.();
-          return queries;
-        }
+        build({select, selectAll, join, where, group, having, param});
         const joins = mapNew(joinEntries);
         mapForEach(joins, (joinAlias, [, fromJoinAlias]) =>
           ifNotUndefined(mapGet(joins, fromJoinAlias), ({3: toJoinAliases2}) =>
             isUndefined(joinAlias) ? 0 : arrayPush(toJoinAliases2, joinAlias),
           ),
         );
+        const isRootSelectAll = (joinedTableId) => isUndefined(joinedTableId);
+        const getSelectAllJoin = (joinedTableId) =>
+          mapGet(
+            joins,
+            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]) => {
+            if (selectAll2) {
+              if (hasGroupsOrHavings) {
+                ifNotUndefined(
+                  getSelectAllJoin(selectedOrJoinedTableId),
+                  ([realTableId, , , , , sourceStore]) => {
+                    setAdd(
+                      mapEnsure(selectAllSources, sourceStore, setNew),
+                      realTableId,
+                    );
+                    arrayForEach(
+                      arraySort(sourceStore.getTableCellIds(realTableId)),
+                      (cellId) =>
+                        arrayPush(selectEntries, [
+                          clauseOrMapper(cellId),
+                          getUndefined,
+                        ]),
+                    );
+                  },
+                );
+              }
+            } else {
+              arrayPush(selectEntries, [
+                selectedOrJoinedTableId,
+                clauseOrMapper,
+              ]);
+            }
+          },
+        );
+        const selects = mapNew(selectEntries);
+        if (hasGroupsOrHavings && collIsEmpty(selects)) {
+          commit?.();
+          return queries;
+        }
         const selectJoinWhereStore = hasGroupsOrHavings
           ? (stagedDefinition[2] = createStore())
           : resultStore2;
@@ -4933,18 +5136,85 @@ const createQueries = getCreateFunction((store) => {
                   joinedCellId,
                 );
           };
-          selectJoinWhereStore.transaction(() =>
-            arrayEvery(wheres, (where2) => where2(getJoinCell))
-              ? mapForEach(selects, (asCellId, tableCellGetter) =>
+          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) {
+              if (hasSelectAll) {
+                writeSelectAllRow();
+              } else {
+                mapForEach(selects, (asCellId, tableCellGetter) =>
                   selectJoinWhereStore._[5](
                     queryId,
                     rootRowId,
                     asCellId,
                     tableCellGetter(getJoinCell, rootRowId),
                   ),
-                )
-              : selectJoinWhereStore.delRow(queryId, rootRowId),
-          );
+                );
+              }
+            } else if (hasSelectAll) {
+              writeSelectAllRow();
+            } else {
+              mapForEach(selects, (asCellId, tableCellGetter) =>
+                selectJoinWhereStore._[5](
+                  queryId,
+                  rootRowId,
+                  asCellId,
+                  tableCellGetter(getJoinCell, rootRowId),
+                ),
+              );
+            }
+          });
         };
         const listenToTable = (
           rootRowId,
@@ -5063,7 +5333,14 @@ const createQueries = getCreateFunction((store) => {
       }),
     );
   const setQueryDefinitionImpl = (queryId, definition) => {
-    const stagedDefinition = [mapNew(), mapNew()];
+    const stagedDefinition = [
+      mapNew(),
+      mapNew(),
+      void 0,
+      mapNew(),
+      setNew(),
+      mapNew(),
+    ];
     let committed = false;
     tryCatchSync(
       () =>
@@ -5084,6 +5361,18 @@ const createQueries = getCreateFunction((store) => {
             collIsEmpty(stagedDefinition[1]) ? void 0 : stagedDefinition[1],
           );
           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) => {
@@ -5133,6 +5422,10 @@ const createQueries = getCreateFunction((store) => {
     paramStore.delRow(PARAMS_TABLE, queryId);
     resetPreStores(queryId);
     resetSourceStores(queryId);
+    syncSelectAllListeners(queryId);
+    clearSelectAllRetryListeners(queryId);
+    mapSet(referencedQueryIds, queryId);
+    mapSet(selectAllQuerySources, queryId);
     delDefinition(queryId);
     cleanStores();
     return queries;