tinybase 9.4.0-beta.1 → 9.4.0-beta.2

package/@types/persisters/index.d.ts

@@ -1340,6 +1340,10 @@ export interface Persister<Persist extends Persists = Persists.StoreOnly> {
    * This simply runs the startAutoLoad and startAutoSave methods in sequence,
    * and returns a Promise that resolves when both have completed.
    *
+   * If the second method fails after either half has partially started, both
+   * halves are stopped again before this method rejects. The original startup
+   * error is preserved if that cleanup also fails.
+   *
    * This method can take `initialContent` to pass to the startAutoLoad method.
    * See its documentation for more details.
    *

package/@types/persisters/persister-durable-object-sql-storage/index.d.ts

@@ -78,8 +78,15 @@ export type DpcFragmented = {
    * This is useful when you have multiple stores or applications sharing the
    * same Durable Object SQL storage and want to avoid table name conflicts.
    *
-   * The prefix will be sanitized to only include alphanumeric characters and
-   * underscores. For example, a prefix of 'my-app!' becomes 'my_app_'.
+   * Empty prefixes and those containing only lower-case ASCII letters, digits,
+   * and underscores are used as-is. Other prefixes are encoded so that distinct
+   * prefixes cannot resolve to the same tables, including under SQLite's
+   * case-insensitive identifier rules.
+   *
+   * Tables created for prefixes that are now encoded, including uppercase
+   * prefixes and those previously changed by lossy sanitization, are not copied
+   * automatically because their names may legitimately belong to another
+   * prefix. Migrate those tables explicitly before using the new prefix.
    * @example
    * This example shows a configuration using the storagePrefix setting. With a
    * `storagePrefix` of 'user_data_', it creates `user_data_tinybase_tables` and

package/@types/persisters/persister-durable-object-sql-storage/with-schemas/index.d.ts

@@ -86,8 +86,15 @@ export type DpcFragmented = {
    * This is useful when you have multiple stores or applications sharing the
    * same Durable Object SQL storage and want to avoid table name conflicts.
    *
-   * The prefix will be sanitized to only include alphanumeric characters and
-   * underscores. For example, a prefix of 'my-app!' becomes 'my_app_'.
+   * Empty prefixes and those containing only lower-case ASCII letters, digits,
+   * and underscores are used as-is. Other prefixes are encoded so that distinct
+   * prefixes cannot resolve to the same tables, including under SQLite's
+   * case-insensitive identifier rules.
+   *
+   * Tables created for prefixes that are now encoded, including uppercase
+   * prefixes and those previously changed by lossy sanitization, are not copied
+   * automatically because their names may legitimately belong to another
+   * prefix. Migrate those tables explicitly before using the new prefix.
    * @example
    * This example shows a configuration using the storagePrefix setting. With a
    * `storagePrefix` of 'user_data_', it creates `user_data_tinybase_tables` and

package/@types/persisters/with-schemas/index.d.ts

@@ -1461,6 +1461,10 @@ export interface Persister<
    * This simply runs the startAutoLoad and startAutoSave methods in sequence,
    * and returns a Promise that resolves when both have completed.
    *
+   * If the second method fails after either half has partially started, both
+   * halves are stopped again before this method rejects. The original startup
+   * error is preserved if that cleanup also fails.
+   *
    * This method can take `initialContent` to pass to the startAutoLoad method.
    * See its documentation for more details.
    *

package/@types/queries/index.d.ts

@@ -1039,6 +1039,10 @@ export type CellIdMapper = (cellId: Id) => Id;
  * is expanded into individual selections. The query is rebuilt if this union
  * changes, and any selected Cell that is not grouped becomes a grouping
  * dimension as usual.
+ *
+ * A cycle between query results is allowed when every SelectAll clause retains
+ * its source Cell Ids. A prefix or CellIdMapper callback in such a cycle is
+ * rejected because it could expand Cell Ids indefinitely.
  * @category Definition
  * @since v9.4.0
  */

package/@types/queries/with-schemas/index.d.ts

@@ -1186,6 +1186,10 @@ export type CellIdMapper<CellId extends Id = Id> = (cellId: CellId) => Id;
  * is expanded into individual selections. The query is rebuilt if this union
  * changes, and any selected Cell that is not grouped becomes a grouping
  * dimension as usual.
+ *
+ * A cycle between query results is allowed when every SelectAll clause retains
+ * its source Cell Ids. A prefix or CellIdMapper callback in such a cycle is
+ * rejected because it could expand Cell Ids indefinitely.
  * @category Definition
  * @since v9.4.0
  */

package/@types/synchronizers/synchronizer-ws-client/index.d.ts

@@ -177,7 +177,9 @@ export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(
    * Construct the WebSocket with the `tinybase` subprotocol and provide a
    * channel Id as the third argument. The channel Id is appended to the
    * WebSocket URL path to form the server path; it is not taken from the
-   * MergeableStore Id.
+   * MergeableStore Id. It can contain at most 1,024 UTF-8 bytes, and one shared
+   * WebSocket can have at most 100 channels. Creating a 101st channel is
+   * rejected without closing the existing shared WebSocket.
    *
    * Destroying the WsSynchronizer unsubscribes its channel. The shared
    * WebSocket is closed only when the last WsSynchronizer using it is
@@ -188,8 +190,10 @@ export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(
    * later. It is not supported by WsServerDurableObject.
    * @param store The MergeableStore to synchronize.
    * @param webSocket The shared WebSocket to send synchronization messages
-   * over, constructed with the `tinybase` subprotocol.
-   * @param channelId The channel Id to append to the WebSocket URL path.
+   * over, constructed with the `tinybase` subprotocol and shared by at most 100
+   * channels.
+   * @param channelId The channel Id to append to the WebSocket URL path, with
+   * at most 1,024 UTF-8 bytes.
    * @param requestTimeoutSeconds An optional time in seconds that the
    * Synchronizer will wait for responses to request messages, defaulting to 1.
    * @param onSend An optional handler for the messages that this Synchronizer

package/@types/synchronizers/synchronizer-ws-client/with-schemas/index.d.ts

@@ -211,7 +211,9 @@ export function createWsSynchronizer<
    * Construct the WebSocket with the `tinybase` subprotocol and provide a
    * channel Id as the third argument. The channel Id is appended to the
    * WebSocket URL path to form the server path; it is not taken from the
-   * MergeableStore Id.
+   * MergeableStore Id. It can contain at most 1,024 UTF-8 bytes, and one shared
+   * WebSocket can have at most 100 channels. Creating a 101st channel is
+   * rejected without closing the existing shared WebSocket.
    *
    * Destroying the WsSynchronizer unsubscribes its channel. The shared
    * WebSocket is closed only when the last WsSynchronizer using it is
@@ -222,8 +224,10 @@ export function createWsSynchronizer<
    * later. It is not supported by WsServerDurableObject.
    * @param store The MergeableStore to synchronize.
    * @param webSocket The shared WebSocket to send synchronization messages
-   * over, constructed with the `tinybase` subprotocol.
-   * @param channelId The channel Id to append to the WebSocket URL path.
+   * over, constructed with the `tinybase` subprotocol and shared by at most 100
+   * channels.
+   * @param channelId The channel Id to append to the WebSocket URL path, with
+   * at most 1,024 UTF-8 bytes.
    * @param requestTimeoutSeconds An optional time in seconds that the
    * Synchronizer will wait for responses to request messages, defaulting to 1.
    * @param onSend An optional handler for the messages that this Synchronizer

package/@types/synchronizers/synchronizer-ws-server/index.d.ts

@@ -519,7 +519,11 @@ export interface WsServer {
  * Since v9.3, multiple WsSynchronizer instances can share one WebSocket by
  * using channel Ids. Each channel Id is appended to the WebSocket URL path and
  * treated as an ordinary server path. This means a multiplexed channel can
- * interoperate with legacy clients connected directly to that full path.
+ * interoperate with legacy clients connected directly to that full path. A
+ * channel Id can contain at most 1,024 UTF-8 bytes, and each multiplexed
+ * WebSocket can have at most 100 subscribed channels. Pending setup and
+ * teardown resources are also bounded. Fragment reassembly and traffic
+ * buffered while paths start share limits across the physical WebSocket.
  *
  * The WsServer does not authenticate or authorize URL paths or channel Ids.
  * Once a client WebSocket is accepted on a base path, it can subscribe to any
@@ -608,7 +612,7 @@ export interface WsServer {
  * client connects, it picks up the data the previous two were using.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -616,6 +620,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) =>
@@ -679,7 +684,7 @@ export interface WsServer {
  * data once synchronization has started.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -687,6 +692,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) => [

package/@types/synchronizers/synchronizer-ws-server/with-schemas/index.d.ts

@@ -548,7 +548,11 @@ export interface WsServer {
  * Since v9.3, multiple WsSynchronizer instances can share one WebSocket by
  * using channel Ids. Each channel Id is appended to the WebSocket URL path and
  * treated as an ordinary server path. This means a multiplexed channel can
- * interoperate with legacy clients connected directly to that full path.
+ * interoperate with legacy clients connected directly to that full path. A
+ * channel Id can contain at most 1,024 UTF-8 bytes, and each multiplexed
+ * WebSocket can have at most 100 subscribed channels. Pending setup and
+ * teardown resources are also bounded. Fragment reassembly and traffic
+ * buffered while paths start share limits across the physical WebSocket.
  *
  * The WsServer does not authenticate or authorize URL paths or channel Ids.
  * Once a client WebSocket is accepted on a base path, it can subscribe to any
@@ -637,7 +641,7 @@ export interface WsServer {
  * client connects, it picks up the data the previous two were using.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -645,6 +649,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) =>
@@ -708,7 +713,7 @@ export interface WsServer {
  * data once synchronization has started.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -716,6 +721,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) => [

package/@types/synchronizers/synchronizer-ws-server-simple/index.d.ts

@@ -96,9 +96,12 @@ export interface WsServerSimple {
  * Since v9.3, it also supports multiple channel-based WsSynchronizer instances
  * sharing one WebSocket. Once a client WebSocket is accepted on a base path,
  * it can subscribe to any valid channel beneath that path: WsServerSimple does
- * not authenticate or authorize channel Ids. For untrusted clients, use a
- * separate authenticated WebSocket for each authorized path unless access to
- * all descendants is acceptable.
+ * not authenticate or authorize channel Ids. A channel Id can contain at most
+ * 1,024 UTF-8 bytes, and each multiplexed WebSocket can have at most 100
+ * subscribed channels. Pending channel cleanup is also bounded, and fragment
+ * reassembly limits are shared across the physical WebSocket. For untrusted
+ * clients, use a separate authenticated WebSocket for each authorized path
+ * unless access to all descendants is acceptable.
  * @param webSocketServer A WebSocketServer object from your server environment.
  * @returns A reference to the new WsServerSimple object.
  * @example

package/@types/synchronizers/synchronizer-ws-server-simple/with-schemas/index.d.ts

@@ -96,9 +96,12 @@ export interface WsServerSimple {
  * Since v9.3, it also supports multiple channel-based WsSynchronizer instances
  * sharing one WebSocket. Once a client WebSocket is accepted on a base path,
  * it can subscribe to any valid channel beneath that path: WsServerSimple does
- * not authenticate or authorize channel Ids. For untrusted clients, use a
- * separate authenticated WebSocket for each authorized path unless access to
- * all descendants is acceptable.
+ * not authenticate or authorize channel Ids. A channel Id can contain at most
+ * 1,024 UTF-8 bytes, and each multiplexed WebSocket can have at most 100
+ * subscribed channels. Pending channel cleanup is also bounded, and fragment
+ * reassembly limits are shared across the physical WebSocket. For untrusted
+ * clients, use a separate authenticated WebSocket for each authorized path
+ * unless access to all descendants is acceptable.
  * @param webSocketServer A WebSocketServer object from your server environment.
  * @returns A reference to the new WsServerSimple object.
  * @example

package/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;