diff --git a/web/database/utils/store.js b/web/database/utils/store.js
index aa6cf2712..32f1b0a5b 100644
--- a/web/database/utils/store.js
+++ b/web/database/utils/store.js
@@ -1,102 +1,102 @@
 // @flow
 
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { canUseDatabaseOnWeb } from 'lib/shared/web-database.js';
 import type {
   ClientStore,
   StoreOperations,
 } from 'lib/types/store-ops-types.js';
 
 import { workerRequestMessageTypes } from '../../types/worker-types.js';
 import { getDatabaseModule } from '../database-module-provider.js';
 
-async function getClientStore(): Promise<ClientStore> {
+async function getClientDBStore(): Promise<ClientStore> {
   const databaseModule = await getDatabaseModule();
   let result: ClientStore = {
     currentUserID: null,
     drafts: [],
     messages: null,
     threadStore: null,
     messageStoreThreads: null,
     reports: null,
     users: null,
   };
   const data = await databaseModule.schedule({
     type: workerRequestMessageTypes.GET_CLIENT_STORE,
   });
   if (data?.store?.drafts) {
     result = {
       ...result,
       drafts: data.store.drafts,
     };
   }
   if (data?.store?.reports) {
     result = {
       ...result,
       reports: reportStoreOpsHandlers.translateClientDBData(data.store.reports),
     };
   }
   if (data?.store?.threads && data.store.threads.length > 0) {
     result = {
       ...result,
       threadStore: {
         threadInfos: threadStoreOpsHandlers.translateClientDBData(
           data.store.threads,
         ),
       },
     };
   }
   return result;
 }
 
 async function processDBStoreOperations(
   storeOperations: StoreOperations,
   userID: null | string,
 ): Promise<void> {
   const { draftStoreOperations, threadStoreOperations, reportStoreOperations } =
     storeOperations;
 
   const canUseDatabase = canUseDatabaseOnWeb(userID);
 
   const convertedThreadStoreOperations = canUseDatabase
     ? threadStoreOpsHandlers.convertOpsToClientDBOps(threadStoreOperations)
     : [];
   const convertedReportStoreOperations =
     reportStoreOpsHandlers.convertOpsToClientDBOps(reportStoreOperations);
 
   if (
     convertedThreadStoreOperations.length === 0 &&
     convertedReportStoreOperations.length === 0 &&
     draftStoreOperations.length === 0
   ) {
     return;
   }
 
   const databaseModule = await getDatabaseModule();
   const isSupported = await databaseModule.isDatabaseSupported();
   if (!isSupported) {
     return;
   }
   try {
     await databaseModule.schedule({
       type: workerRequestMessageTypes.PROCESS_STORE_OPERATIONS,
       storeOperations: {
         draftStoreOperations,
         reportStoreOperations: convertedReportStoreOperations,
         threadStoreOperations: convertedThreadStoreOperations,
       },
     });
   } catch (e) {
     console.log(e);
     if (canUseDatabase) {
       window.alert(e.message);
       if (threadStoreOperations.length > 0) {
         await databaseModule.init({ clearDatabase: true });
         location.reload();
       }
     }
   }
 }
 
-export { getClientStore, processDBStoreOperations };
+export { getClientDBStore, processDBStoreOperations };
diff --git a/web/database/worker/db-worker.js b/web/database/worker/db-worker.js
index de512f5d4..14341d01f 100644
--- a/web/database/worker/db-worker.js
+++ b/web/database/worker/db-worker.js
@@ -1,265 +1,265 @@
 // @flow
 
 import localforage from 'localforage';
 
 import {
-  getClientStore,
+  getClientStoreFromQueryExecutor,
   processDBStoreOperations,
 } from './process-operations.js';
 import {
   decryptData,
   encryptData,
   generateCryptoKey,
   importJWKKey,
   type EncryptedData,
 } from '../../crypto/aes-gcm-crypto-utils.js';
 import {
   type SharedWorkerMessageEvent,
   type WorkerRequestMessage,
   type WorkerResponseMessage,
   workerRequestMessageTypes,
   workerResponseMessageTypes,
   type WorkerRequestProxyMessage,
   workerWriteRequests,
 } from '../../types/worker-types.js';
 import { getDatabaseModule } from '../db-module.js';
 import { type EmscriptenModule } from '../types/module.js';
 import { type SQLiteQueryExecutor } from '../types/sqlite-query-executor.js';
 import {
   COMM_SQLITE_DATABASE_PATH,
   CURRENT_USER_ID_KEY,
   localforageConfig,
   SQLITE_CONTENT,
   SQLITE_ENCRYPTION_KEY,
 } from '../utils/constants.js';
 import {
   clearSensitiveData,
   exportDatabaseContent,
   importDatabaseContent,
 } from '../utils/db-utils.js';
 
 localforage.config(localforageConfig);
 
 let encryptionKey: ?CryptoKey = null;
 
 let sqliteQueryExecutor: ?SQLiteQueryExecutor = null;
 let dbModule: ?EmscriptenModule = null;
 
 let persistNeeded: boolean = false;
 let persistInProgress: boolean = false;
 
 async function initDatabase(
   databaseModuleFilePath: string,
   commQueryExecutorFilename: ?string,
   encryptionKeyJWK?: ?SubtleCrypto$JsonWebKey,
 ) {
   if (!!dbModule && !!sqliteQueryExecutor) {
     console.log('Database already initialized');
     return;
   }
 
   const newModule = dbModule
     ? dbModule
     : getDatabaseModule(commQueryExecutorFilename, databaseModuleFilePath);
   if (!dbModule) {
     dbModule = newModule;
   }
 
   if (encryptionKeyJWK) {
     encryptionKey = await importJWKKey(encryptionKeyJWK);
   } else {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
     if (!encryptionKey) {
       const cryptoKey = await generateCryptoKey({ extractable: false });
       await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     }
   }
 
   const encryptedContent =
     await localforage.getItem<EncryptedData>(SQLITE_CONTENT);
 
   let dbContent = null;
   try {
     if (encryptionKey && encryptedContent) {
       dbContent = await decryptData(encryptedContent, encryptionKey);
     }
   } catch (e) {
     console.error('Error while decrypting content, clearing database content');
     await localforage.removeItem(SQLITE_CONTENT);
   }
 
   if (dbContent) {
     importDatabaseContent(dbContent, newModule, COMM_SQLITE_DATABASE_PATH);
 
     console.info(
       'Database exists and is properly encrypted, using persisted data',
     );
   } else {
     console.info('Creating fresh database');
   }
   sqliteQueryExecutor = new newModule.SQLiteQueryExecutor(
     COMM_SQLITE_DATABASE_PATH,
   );
 }
 
 async function persist() {
   persistInProgress = true;
   const module = dbModule;
   if (!sqliteQueryExecutor || !module) {
     persistInProgress = false;
     throw new Error(
       'Database not initialized while persisting database content',
     );
   }
 
   if (!encryptionKey) {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
   }
 
   while (persistNeeded) {
     persistNeeded = false;
     const dbData = exportDatabaseContent(module, COMM_SQLITE_DATABASE_PATH);
     if (!encryptionKey) {
       persistInProgress = false;
       throw new Error('Encryption key is missing');
     }
     const encryptedData = await encryptData(dbData, encryptionKey);
     await localforage.setItem(SQLITE_CONTENT, encryptedData);
   }
   persistInProgress = false;
 }
 
 async function processAppRequest(
   message: WorkerRequestMessage,
 ): Promise<?WorkerResponseMessage> {
   // non-database operations
   if (message.type === workerRequestMessageTypes.PING) {
     return {
       type: workerResponseMessageTypes.PONG,
       text: 'PONG',
     };
   } else if (
     message.type === workerRequestMessageTypes.GENERATE_DATABASE_ENCRYPTION_KEY
   ) {
     const cryptoKey = await generateCryptoKey({ extractable: false });
     await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     return undefined;
   }
 
   // database operations
   if (message.type === workerRequestMessageTypes.INIT) {
     await initDatabase(
       message.databaseModuleFilePath,
       message.commQueryExecutorFilename,
       message.encryptionKey,
     );
     return undefined;
   } else if (message.type === workerRequestMessageTypes.CLEAR_SENSITIVE_DATA) {
     encryptionKey = null;
     await localforage.clear();
     if (dbModule && sqliteQueryExecutor) {
       clearSensitiveData(
         dbModule,
         COMM_SQLITE_DATABASE_PATH,
         sqliteQueryExecutor,
       );
     }
     sqliteQueryExecutor = null;
     return undefined;
   }
 
   if (!sqliteQueryExecutor) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   // read-only operations
   if (message.type === workerRequestMessageTypes.GET_CLIENT_STORE) {
     return {
       type: workerResponseMessageTypes.CLIENT_STORE,
-      store: getClientStore(sqliteQueryExecutor),
+      store: getClientStoreFromQueryExecutor(sqliteQueryExecutor),
     };
   } else if (message.type === workerRequestMessageTypes.GET_CURRENT_USER_ID) {
     return {
       type: workerResponseMessageTypes.GET_CURRENT_USER_ID,
       userID: sqliteQueryExecutor.getMetadata(CURRENT_USER_ID_KEY),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_PERSIST_STORAGE_ITEM
   ) {
     return {
       type: workerResponseMessageTypes.GET_PERSIST_STORAGE_ITEM,
       item: sqliteQueryExecutor.getPersistStorageItem(message.key),
     };
   }
 
   // write operations
   if (!workerWriteRequests.includes(message.type)) {
     throw new Error('Request type not supported');
   }
   if (!sqliteQueryExecutor || !dbModule) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   if (message.type === workerRequestMessageTypes.PROCESS_STORE_OPERATIONS) {
     processDBStoreOperations(
       sqliteQueryExecutor,
       message.storeOperations,
       dbModule,
     );
   } else if (message.type === workerRequestMessageTypes.SET_CURRENT_USER_ID) {
     sqliteQueryExecutor.setMetadata(CURRENT_USER_ID_KEY, message.userID);
   } else if (
     message.type === workerRequestMessageTypes.SET_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.setPersistStorageItem(message.key, message.item);
   } else if (
     message.type === workerRequestMessageTypes.REMOVE_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.removePersistStorageItem(message.key);
   }
 
   persistNeeded = true;
   if (!persistInProgress) {
     void persist();
   }
 
   return undefined;
 }
 
 function connectHandler(event: SharedWorkerMessageEvent) {
   if (!event.ports.length) {
     return;
   }
   const port: MessagePort = event.ports[0];
   console.log('Web database worker alive!');
 
   port.onmessage = async function (messageEvent: MessageEvent) {
     const data: WorkerRequestProxyMessage = (messageEvent.data: any);
     const { id, message } = data;
 
     if (!id) {
       port.postMessage({
         error: 'Request without identifier',
       });
     }
 
     try {
       const result = await processAppRequest(message);
       port.postMessage({
         id,
         message: result,
       });
     } catch (e) {
       port.postMessage({
         id,
         error: e.message,
       });
     }
   };
 }
 
 self.addEventListener('connect', connectHandler);
diff --git a/web/database/worker/process-operations.js b/web/database/worker/process-operations.js
index d4a33e98c..0992d17c5 100644
--- a/web/database/worker/process-operations.js
+++ b/web/database/worker/process-operations.js
@@ -1,180 +1,180 @@
 // @flow
 
 import type { ClientDBReportStoreOperation } from 'lib/ops/report-store-ops.js';
 import type { ClientDBThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import type {
   ClientDBDraftStoreOperation,
   DraftStoreOperation,
 } from 'lib/types/draft-types.js';
 import type {
   ClientDBStore,
   ClientDBStoreOperations,
 } from 'lib/types/store-ops-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 
 import {
   clientDBThreadInfoToWebThread,
   webThreadToClientDBThreadInfo,
 } from '../types/entities.js';
 import type { EmscriptenModule } from '../types/module.js';
 import type { SQLiteQueryExecutor } from '../types/sqlite-query-executor.js';
 
 function getProcessingStoreOpsExceptionMessage(
   e: mixed,
   module: EmscriptenModule,
 ): string {
   if (typeof e === 'number') {
     return module.getExceptionMessage(e);
   }
   return getMessageForException(e) ?? 'unknown error';
 }
 function processDraftStoreOperations(
   sqliteQueryExecutor: SQLiteQueryExecutor,
   operations: $ReadOnlyArray<ClientDBDraftStoreOperation>,
   module: EmscriptenModule,
 ) {
   for (const operation: DraftStoreOperation of operations) {
     try {
       if (operation.type === 'remove_all') {
         sqliteQueryExecutor.removeAllDrafts();
       } else if (operation.type === 'remove') {
         const { ids } = operation.payload;
         sqliteQueryExecutor.removeDrafts(ids);
       } else if (operation.type === 'update') {
         const { key, text } = operation.payload;
         sqliteQueryExecutor.updateDraft(key, text);
       } else if (operation.type === 'move') {
         const { oldKey, newKey } = operation.payload;
         sqliteQueryExecutor.moveDraft(oldKey, newKey);
       } else {
         throw new Error('Unsupported draft operation');
       }
     } catch (e) {
       throw new Error(
         `Error while processing ${
           operation.type
         } draft operation: ${getProcessingStoreOpsExceptionMessage(e, module)}`,
       );
     }
   }
 }
 
 function processReportStoreOperations(
   sqliteQueryExecutor: SQLiteQueryExecutor,
   operations: $ReadOnlyArray<ClientDBReportStoreOperation>,
   module: EmscriptenModule,
 ) {
   for (const operation: ClientDBReportStoreOperation of operations) {
     try {
       if (operation.type === 'remove_all_reports') {
         sqliteQueryExecutor.removeAllReports();
       } else if (operation.type === 'remove_reports') {
         const { ids } = operation.payload;
         sqliteQueryExecutor.removeReports(ids);
       } else if (operation.type === 'replace_report') {
         const { id, report } = operation.payload;
         sqliteQueryExecutor.replaceReport({ id, report });
       } else {
         throw new Error('Unsupported report operation');
       }
     } catch (e) {
       throw new Error(
         `Error while processing ${
           operation.type
         } report operation: ${getProcessingStoreOpsExceptionMessage(
           e,
           module,
         )}`,
       );
     }
   }
 }
 
 function processThreadStoreOperations(
   sqliteQueryExecutor: SQLiteQueryExecutor,
   operations: $ReadOnlyArray<ClientDBThreadStoreOperation>,
   module: EmscriptenModule,
 ) {
   for (const operation: ClientDBThreadStoreOperation of operations) {
     try {
       if (operation.type === 'remove_all') {
         sqliteQueryExecutor.removeAllThreads();
       } else if (operation.type === 'remove') {
         const { ids } = operation.payload;
         sqliteQueryExecutor.removeThreads(ids);
       } else if (operation.type === 'replace') {
         sqliteQueryExecutor.replaceThreadWeb(
           clientDBThreadInfoToWebThread(operation.payload),
         );
       } else {
         throw new Error('Unsupported thread operation');
       }
     } catch (e) {
       throw new Error(
         `Error while processing ${
           operation.type
         } thread operation: ${getProcessingStoreOpsExceptionMessage(
           e,
           module,
         )}`,
       );
     }
   }
 }
 
 function processDBStoreOperations(
   sqliteQueryExecutor: SQLiteQueryExecutor,
   storeOperations: ClientDBStoreOperations,
   module: EmscriptenModule,
 ) {
   const { draftStoreOperations, reportStoreOperations, threadStoreOperations } =
     storeOperations;
 
   try {
     sqliteQueryExecutor.beginTransaction();
     if (draftStoreOperations && draftStoreOperations.length > 0) {
       processDraftStoreOperations(
         sqliteQueryExecutor,
         draftStoreOperations,
         module,
       );
     }
     if (reportStoreOperations && reportStoreOperations.length > 0) {
       processReportStoreOperations(
         sqliteQueryExecutor,
         reportStoreOperations,
         module,
       );
     }
     if (threadStoreOperations && threadStoreOperations.length > 0) {
       processThreadStoreOperations(
         sqliteQueryExecutor,
         threadStoreOperations,
         module,
       );
     }
     sqliteQueryExecutor.commitTransaction();
   } catch (e) {
     sqliteQueryExecutor.rollbackTransaction();
     console.log('Error while processing store ops: ', e);
     throw e;
   }
 }
 
-function getClientStore(
+function getClientStoreFromQueryExecutor(
   sqliteQueryExecutor: SQLiteQueryExecutor,
 ): ClientDBStore {
   return {
     drafts: sqliteQueryExecutor.getAllDrafts(),
     messages: [],
     threads: sqliteQueryExecutor
       .getAllThreadsWeb()
       .map(t => webThreadToClientDBThreadInfo(t)),
     messageStoreThreads: [],
     reports: sqliteQueryExecutor.getAllReports(),
     users: [],
     keyservers: [],
   };
 }
 
-export { processDBStoreOperations, getClientStore };
+export { processDBStoreOperations, getClientStoreFromQueryExecutor };
diff --git a/web/redux/initial-state-gate.js b/web/redux/initial-state-gate.js
index 014f7f2c5..101ef06f9 100644
--- a/web/redux/initial-state-gate.js
+++ b/web/redux/initial-state-gate.js
@@ -1,152 +1,152 @@
 // @flow
 
 import * as React from 'react';
 import { PersistGate } from 'redux-persist/es/integration/react.js';
 import type { Persistor } from 'redux-persist/es/types';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import type { ThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { allUpdatesCurrentAsOfSelector } from 'lib/selectors/keyserver-selectors.js';
 import { canUseDatabaseOnWeb } from 'lib/shared/web-database.js';
 import type { RawThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import type { LegacyRawThreadInfo } from 'lib/types/thread-types.js';
 import { convertIDToNewSchema } from 'lib/utils/migration-utils.js';
 import { entries } from 'lib/utils/objects.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { infoFromURL } from 'lib/utils/url-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   setInitialReduxState,
   useGetInitialReduxState,
 } from './action-types.js';
 import { useSelector } from './redux-utils.js';
 import {
-  getClientStore,
+  getClientDBStore,
   processDBStoreOperations,
 } from '../database/utils/store.js';
 import Loading from '../loading.react.js';
 
 type Props = {
   +persistor: Persistor,
   +children: React.Node,
 };
 function InitialReduxStateGate(props: Props): React.Node {
   const { children, persistor } = props;
   const callGetInitialReduxState = useGetInitialReduxState();
   const dispatch = useDispatch();
 
   const [initError, setInitError] = React.useState<?Error>(null);
   React.useEffect(() => {
     if (initError) {
       throw initError;
     }
   }, [initError]);
 
   const isRehydrated = useSelector(state => !!state._persist?.rehydrated);
   const allUpdatesCurrentAsOf = useSelector(allUpdatesCurrentAsOfSelector);
 
   const prevIsRehydrated = React.useRef(false);
   React.useEffect(() => {
     if (prevIsRehydrated.current || !isRehydrated) {
       return;
     }
     prevIsRehydrated.current = isRehydrated;
     void (async () => {
       try {
         let urlInfo = infoFromURL(decodeURI(window.location.href));
         // Handle older links
         if (urlInfo.thread) {
           urlInfo = {
             ...urlInfo,
             thread: convertIDToNewSchema(urlInfo.thread, ashoatKeyserverID),
           };
         }
-        const clientDBStore = await getClientStore();
+        const clientDBStore = await getClientDBStore();
         dispatch({
           type: setClientDBStoreActionType,
           payload: clientDBStore,
         });
 
         const payload = await callGetInitialReduxState({
           urlInfo,
           excludedData: {
             threadStore: !!clientDBStore.threadStore,
           },
           allUpdatesCurrentAsOf,
         });
 
         const currentLoggedInUserID = payload.currentUserInfo?.anonymous
           ? null
           : payload.currentUserInfo?.id;
         const useDatabase = canUseDatabaseOnWeb(currentLoggedInUserID);
 
         if (!currentLoggedInUserID || !useDatabase) {
           dispatch({ type: setInitialReduxState, payload });
           return;
         }
 
         if (clientDBStore.threadStore) {
           const { threadStore, ...rest } = payload;
           dispatch({ type: setInitialReduxState, payload: rest });
           return;
         }
 
         // When there is no data in the DB, it's necessary to migrate data
         // from the keyserver payload to the DB
         const {
           threadStore: { threadInfos },
         } = payload;
 
         const threadStoreOperations: ThreadStoreOperation[] = entries(
           threadInfos,
         ).map(
           ([id, threadInfo]: [
             string,
             LegacyRawThreadInfo | RawThreadInfo,
           ]) => ({
             type: 'replace',
             payload: {
               id,
               threadInfo,
             },
           }),
         );
 
         await processDBStoreOperations(
           {
             threadStoreOperations,
             draftStoreOperations: [],
             messageStoreOperations: [],
             reportStoreOperations: [],
             userStoreOperations: [],
           },
           currentLoggedInUserID,
         );
 
         dispatch({ type: setInitialReduxState, payload });
       } catch (err) {
         setInitError(err);
       }
     })();
   }, [callGetInitialReduxState, dispatch, isRehydrated, allUpdatesCurrentAsOf]);
 
   const initialStateLoaded = useSelector(state => state.initialStateLoaded);
 
   const childFunction = React.useCallback(
     // This argument is passed from `PersistGate`. It means that the state is
     // rehydrated and we can start fetching the initial info.
     (bootstrapped: boolean) => {
       if (bootstrapped && initialStateLoaded) {
         return children;
       } else {
         return <Loading />;
       }
     },
     [children, initialStateLoaded],
   );
 
   return <PersistGate persistor={persistor}>{childFunction}</PersistGate>;
 }
 
 export default InitialReduxStateGate;