tinybase 9.4.0-beta.0 → 9.4.0-beta.1

package/queries/with-schemas/index.js

@@ -53,6 +53,7 @@ const arrayEvery = (array, cb) => array.every(cb);
 const arrayIsEqual = (array1, array2) =>
   size(array1) === size(array2) &&
   arrayEvery(array1, (value1, index) => array2[index] === value1);
+const arraySort = (array, sorter) => array.sort(sorter);
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
 const arrayMax = (array) =>
@@ -111,6 +112,10 @@ const objNew = (entries = []) => {
   arrayForEach(entries, ([id, value]) => objSet(obj, id, value));
   return obj;
 };
+const objDel = (obj, id) => {
+  delete obj[id];
+  return obj;
+};
 const objForEach = (obj, cb) =>
   arrayForEach(objIds(obj), (id) => cb(obj[id], id));
 const objSize = (obj) => size(objIds(obj));
@@ -464,6 +469,8 @@ const createQueries = getCreateFunction((store) => {
   };
   const preStoreListenerIds = mapNew();
   const sourceStoreListenerIds = mapNew();
+  const selectAllListenerIds = mapNew();
+  const referencedQueryIds = mapNew();
   const {
     _: [, addListener, callListeners],
     delListener: delListenerImpl,
@@ -537,11 +544,42 @@ const createQueries = getCreateFunction((store) => {
     resetStoreListeners(mapGet(sourceStoreListenerIds, queryId));
     mapSet(sourceStoreListenerIds, queryId);
   };
-  const isResultStoreReferenced = (resultStore2) =>
+  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, () =>
+            setQueryDefinitionImpl(queryId),
+          ),
+        ),
+      );
+    });
+    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) =>
@@ -556,7 +594,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),
     );
@@ -638,7 +676,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]],
         ];
@@ -650,21 +694,35 @@ 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,
+          ]);
+        };
         const join = (arg1, arg2, arg3, arg4) => {
           const joinedTableId = isTrue(arg1) ? arg2 : arg1;
           const [fromJoinAlias, onArg] = isTrue(arg1)
@@ -674,6 +732,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,
             [
@@ -682,7 +747,7 @@ const createQueries = getCreateFunction((store) => {
               isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
               [],
               mapNew(),
-              isTrue(arg1) ? getResultStore(joinedTableId) : store,
+              sourceStore,
             ],
           ];
           arrayPush(joinEntries, joinEntry);
@@ -728,10 +793,9 @@ const createQueries = getCreateFunction((store) => {
               : (getSelectedOrGroupedCell) =>
                   getSelectedOrGroupedCell(arg1) === arg2,
           );
-        build({select, join, where, group, having, param});
+        build({select, selectAll, join, where, group, having, param});
         resultStore2.delTable(queryId);
-        const selects = mapNew(selectEntries);
-        if (collIsEmpty(selects)) {
+        if (isEmpty(selectionEntries)) {
           commit?.();
           return queries;
         }
@@ -743,6 +807,55 @@ const createQueries = getCreateFunction((store) => {
         );
         const groups = mapNew(groupEntries);
         const hasGroupsOrHavings = !collIsEmpty(groups) || !isEmpty(havings);
+        const selectEntries = [];
+        const selectAllSources = stagedDefinition[3];
+        const getSelectAllJoin = (joinedTableId) =>
+          mapGet(
+            joins,
+            isUndefined(joinedTableId) || joinedTableId === tableId
+              ? void 0
+              : joinedTableId,
+          );
+        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),
+                          (getTableCell) =>
+                            isUndefined(selectedOrJoinedTableId) ||
+                            selectedOrJoinedTableId === tableId
+                              ? getTableCell(cellId)
+                              : getTableCell(selectedOrJoinedTableId, cellId),
+                        ]),
+                    );
+                  },
+                );
+              }
+            } else {
+              arrayPush(selectEntries, [
+                selectedOrJoinedTableId,
+                clauseOrMapper,
+              ]);
+            }
+          },
+        );
+        const selects = mapNew(selectEntries);
+        if (hasGroupsOrHavings && collIsEmpty(selects)) {
+          commit?.();
+          return queries;
+        }
         const selectJoinWhereStore = hasGroupsOrHavings
           ? (stagedDefinition[2] = createStore())
           : resultStore2;
@@ -921,18 +1034,78 @@ const createQueries = getCreateFunction((store) => {
                   joinedCellId,
                 );
           };
-          selectJoinWhereStore.transaction(() =>
-            arrayEvery(wheres, (where2) => where2(getJoinCell))
-              ? mapForEach(selects, (asCellId, tableCellGetter) =>
-                  selectJoinWhereStore._[5](
-                    queryId,
-                    rootRowId,
-                    asCellId,
-                    tableCellGetter(getJoinCell, rootRowId),
-                  ),
-                )
-              : selectJoinWhereStore.delRow(queryId, rootRowId),
-          );
+          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);
+              } else {
+                selectJoinWhereStore.setRow(queryId, rootRowId, resultRow);
+              }
+            } else {
+              mapForEach(selects, (asCellId, tableCellGetter) =>
+                selectJoinWhereStore._[5](
+                  queryId,
+                  rootRowId,
+                  asCellId,
+                  tableCellGetter(getJoinCell, rootRowId),
+                ),
+              );
+            }
+          });
         };
         const listenToTable = (
           rootRowId,
@@ -1051,7 +1224,7 @@ const createQueries = getCreateFunction((store) => {
       }),
     );
   const setQueryDefinitionImpl = (queryId, definition) => {
-    const stagedDefinition = [mapNew(), mapNew()];
+    const stagedDefinition = [mapNew(), mapNew(), void 0, mapNew(), setNew()];
     let committed = false;
     tryCatchSync(
       () =>
@@ -1072,6 +1245,12 @@ const createQueries = getCreateFunction((store) => {
             collIsEmpty(stagedDefinition[1]) ? void 0 : stagedDefinition[1],
           );
           mapSet(preStores, queryId, stagedDefinition[2]);
+          syncSelectAllListeners(queryId, stagedDefinition[3]);
+          mapSet(
+            referencedQueryIds,
+            queryId,
+            collIsEmpty(stagedDefinition[4]) ? void 0 : stagedDefinition[4],
+          );
           committed = true;
         }),
       (error) => {
@@ -1121,6 +1300,8 @@ const createQueries = getCreateFunction((store) => {
     paramStore.delRow(PARAMS_TABLE, queryId);
     resetPreStores(queryId);
     resetSourceStores(queryId);
+    syncSelectAllListeners(queryId);
+    mapSet(referencedQueryIds, queryId);
     delDefinition(queryId);
     cleanStores();
     return queries;