@nu-art/thunderstorm-frontend 0.400.5

package/modules/sync-manager/ModuleFE_SyncManager.js

@@ -0,0 +1,378 @@
+/*
+ * Database API Generator is a utility library for Thunderstorm.
+ *
+ * Given proper configurations it will dynamically generate APIs to your Firestore
+ * collections, will assert uniqueness and restrict deletion... and more
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { _keys, BadImplementationException, debounce, exists, filterDuplicates, flatArray, generateHex, Module, MUSTNeverHappenException, reduceToMap, removeFromArrayByIndex, removeItemFromArray, resolveContent, RuntimeModules, Second } from '@nu-art/ts-common';
+import { apiWithBody } from '../../core/typed-api.js';
+import { SmartSync_DeltaSync, SmartSync_FullSync, SmartSync_UpToDateSync } from '@nu-art/thunderstorm-shared/sync-manager/types';
+import { ThunderDispatcher } from '../../core/thunder-dispatcher.js';
+import { DataStatus, EventType_Query } from '../../core/db-api-gen/consts.js';
+import { QueueV2 } from '@nu-art/ts-common/utils/queue-v2';
+import { dispatch_QueryAwaitedModules } from '../../components/AwaitModules/AwaitModules.js';
+import { ModuleFE_ConnectivityModule } from '../ModuleFE_ConnectivityModule.js';
+import { ModuleSyncType } from '../db-api-gen/types.js';
+import { ApiDef_SyncManager } from '@nu-art/thunderstorm-shared/sync-manager/apis';
+import { ModuleFE_FirebaseListener } from '@nu-art/firebase-frontend/ModuleFE_FirebaseListener/ModuleFE_FirebaseListener';
+export const Default_SyncManagerNodePath = '/state/ModuleBE_SyncManager/syncData'; // Hardcoded path for now per Adam's request, should be const somewhere.
+const dispatch_OnPermissibleModulesUpdated = new ThunderDispatcher('__onPermissibleModulesUpdated');
+export class ModuleFE_SyncManager_Class extends Module {
+    async __onConnectivityChange() {
+        if (ModuleFE_ConnectivityModule.isConnected()) {
+            this.logInfo(`Browser gained network connectivity- initiating smartSync.`);
+            await this.debounceSyncImpl();
+        }
+        else {
+            this.logWarningBold(`Browser lost network connectivity!`);
+        }
+    }
+    // ######################### Class Properties #########################
+    // All the modules that a user has permissions to view and with the last updated timestamp of each collection
+    syncedModules = [];
+    currentlySyncingModules = [];
+    syncFirebaseListener;
+    outOfSyncCollections = new Set();
+    syncing;
+    pendingSync;
+    cancelledSyncs = [];
+    cleanIDBOnFullSync = true;
+    syncManagerNodePath = Default_SyncManagerNodePath;
+    smartSyncApiUrl;
+    currentSyncData;
+    _smartSyncCompleted;
+    _onSyncDataChanged;
+    _debounceTimeout = 2 * Second;
+    _debounceMaxTimeout = 10 * Second;
+    syncDebouncer;
+    syncQueue;
+    constructor() {
+        super();
+        this.syncQueue = new QueueV2('Sync Queue', this.performSync)
+            .setParallelCount(4)
+            .setSorter(data => {
+            if (data.sync === SmartSync_UpToDateSync)
+                return 0;
+            if (data.sync === SmartSync_DeltaSync)
+                return 1;
+            //Is full sync
+            const priorityModuleKeys = filterDuplicates(flatArray(dispatch_QueryAwaitedModules.dispatchUI())).map(module => module.dbDef.dbKey);
+            return priorityModuleKeys.includes(data.dbKey) ? 2 : 3;
+        })
+            .setOnQueueEmpty(this.clearSyncingStatus);
+        // this.setMinLevel(LogLevel.Debug);
+    }
+    // ######################### Public Methods #########################
+    setShouldCleanIDBOnFullSync = (cleanIDBOnFullSync) => {
+        this.cleanIDBOnFullSync = cleanIDBOnFullSync;
+    };
+    getPermissibleModuleNames = () => this.syncedModules.map(moduleSyncData => moduleSyncData.dbKey);
+    getCurrentlySyncingModules = () => this.currentlySyncingModules.map(module => module.module);
+    cancelSync = () => {
+        this.cancelledSyncs = this.currentlySyncingModules.map(module => {
+            module.request?.abort();
+            return module.syncId;
+        });
+        this.currentlySyncingModules.splice(0, this.currentlySyncingModules.length);
+        this.syncing = false;
+        this.pendingSync = false;
+        this.syncQueue.cancelAll();
+    };
+    // ######################### Smart Sync #########################
+    getModulesToSync = () => RuntimeModules().filter((module) => module.syncType === ModuleSyncType.APISync);
+    getLocalSyncData = () => {
+        const existingDBModules = this.getModulesToSync();
+        return existingDBModules.map(module => {
+            const lastSync = module.IDB.getLastSync();
+            return ({
+                dbKey: module.dbDef.dbKey,
+                lastUpdated: lastSync
+            });
+        });
+    };
+    smartSync = async () => {
+        //If syncing currently, flag pending sync and return
+        if (this.syncing) {
+            this.pendingSync = true;
+            return;
+        }
+        this.syncing = true;
+        const request = {
+            modules: this.getLocalSyncData()
+        };
+        // if the module have a custom base url for this api apply it to the api def keeping the original path
+        const customBase = resolveContent(this.smartSyncApiUrl);
+        if (customBase)
+            ApiDef_SyncManager.v1.smartSync.fullUrl = customBase;
+        // implement the smart sync call internal so no one will initiate it from the anywhere in the code, except this module
+        try {
+            await apiWithBody(ApiDef_SyncManager.v1.smartSync, this.onSmartSyncCompleted)(request).executeSync();
+        }
+        catch (e) {
+            this.logError(e);
+            this.syncing = false;
+            this.pendingSync = false;
+            return;
+        }
+        // //If queue is empty
+        // if (!this.syncQueue.getLength())
+        // 	await this.clearSyncingStatus();
+    };
+    clearSyncingStatus = async () => {
+        //Un-flag currently syncing
+        this.syncing = false;
+        //If a sync is pending
+        if (this.pendingSync) {
+            delete this.pendingSync;
+            await this.debounceSyncImpl();
+        }
+    };
+    async debounceSyncImpl() {
+        // Everytime after the first, we'll have the debounceSync const ready, amd debounce the call.
+        if (exists(this.syncDebouncer))
+            return this.syncDebouncer();
+        // Since RTDB event arrives upon start listening we would like to perform a first sync immediately,
+        // therefore we call sync directly for the first event and create the debounce function right after for all the consecutive events
+        this.syncDebouncer = debounce(async () => {
+            if (!this.syncFirebaseListener)
+                return this.logWarning('Ignoring sync data state, listener is undefined');
+            this.logDebug(`Collections out of sync:`, this.outOfSyncCollections);
+            this.outOfSyncCollections.clear();
+            await this.smartSync();
+        }, this._debounceTimeout, this._debounceMaxTimeout);
+        this.logInfo('Performing Immediate Sync', '');
+        await this.smartSync();
+    }
+    // ######################### onSmartSyncCompleted #########################
+    /**
+     * Perform no sync, delta sync and full sync on modules. Intention is to get all modules to DataStatus "ContainsData".
+     */
+    onSmartSyncCompleted = async (response) => {
+        this.logInfo(`onSmartSyncCompleted (${response.modules.length})`, response);
+        this._smartSyncCompleted?.(this.currentSyncData);
+        const currentSyncedModulesLength = this.syncedModules.length;
+        this.syncedModules = response.modules.map(item => ({ dbKey: item.dbKey, lastUpdated: item.lastUpdated }));
+        response.modules.forEach(module => this.syncQueue.addItem(module));
+        //Start off the syncing
+        this.syncQueue.executeSync();
+        if (currentSyncedModulesLength !== response.modules.length)
+            dispatch_OnPermissibleModulesUpdated.dispatchUI();
+    };
+    // ######################### Sync operations #########################
+    performSync = (data) => {
+        const rtModule = RuntimeModules().find(rtModule => rtModule.dbDef?.dbKey === data.dbKey);
+        if (!rtModule)
+            throw new MUSTNeverHappenException(`Trying to queue a module to sync without an existing rtModule: ${data.dbKey}`);
+        switch (data.sync) {
+            case SmartSync_UpToDateSync:
+                return this.performNoSync(data);
+            case SmartSync_DeltaSync:
+                return this.performDeltaSync(data);
+            case SmartSync_FullSync:
+                return this.performFullSync(data);
+            default:
+                // @ts-ignore
+                throw new BadImplementationException(`No handling for sync key ${data.sync}`);
+        }
+    };
+    performNoSync = async (data) => {
+        const rtModule = RuntimeModules().find(rtModule => rtModule.dbDef?.dbKey === data.dbKey);
+        if (!rtModule)
+            throw new MUSTNeverHappenException(`Trying perform NoSync without an existing rtModule: ${data.dbKey}`);
+        //If the cache is already loaded no need to reload
+        if (rtModule.getDataStatus() === DataStatus.ContainsData)
+            return;
+        this.currentlySyncingModules.push({ module: rtModule, syncId: this.generateSyncRequestId() });
+        this.logVerbose(`Performing NoSyncOperation for module ${rtModule.getName()}`);
+        this.logVerbose(`No sync for: ${rtModule.dbDef.dbKey}, Already UpToDate.`);
+        try {
+            rtModule.logVerbose(`Updating Cache: ${rtModule.dbDef.dbKey}`);
+            await rtModule.cache.load();
+            rtModule.logVerbose(`Firing event (DataStatus.ContainsData): ${rtModule.dbDef.dbKey}`);
+            rtModule.setDataStatus(DataStatus.ContainsData);
+        }
+        catch (e) {
+            this.logError(e);
+        }
+        finally {
+            const indexOfModuleToRemove = this.currentlySyncingModules.findIndex(module => module.module.dbDef?.dbKey === data.dbKey);
+            removeFromArrayByIndex(this.currentlySyncingModules, indexOfModuleToRemove);
+        }
+    };
+    performDeltaSync = async (data) => {
+        const rtModule = RuntimeModules().find(rtModule => rtModule.dbDef?.dbKey === data.dbKey);
+        if (!rtModule)
+            throw new MUSTNeverHappenException(`Trying perform DeltaSync without an existing rtModule: ${data.dbKey}`);
+        this.logDebug(`Performing DeltaSyncOperation for module ${rtModule.getName()}`);
+        try {
+            this.currentlySyncingModules.push({ module: rtModule, syncId: this.generateSyncRequestId() });
+            rtModule.logVerbose(`Firing event (DataStatus.UpdatingData): ${rtModule.dbDef.dbKey}`);
+            rtModule.setDataStatus(DataStatus.UpdatingData);
+            if (data.items.toUpdate.length)
+                await rtModule.onEntriesUpdated(data.items.toUpdate);
+            if (data.items.toDelete.length)
+                await rtModule.onEntriesDeleted((data.items.toDelete));
+            rtModule.IDB.setLastUpdated(data.lastUpdated);
+            this.logDebug(`Delta Sync Completed: ${rtModule.dbDef.dbKey}`);
+            await rtModule.cache.load();
+            rtModule.setDataStatus(DataStatus.ContainsData);
+        }
+        catch (e) {
+            this.logError(e);
+        }
+        finally {
+            const indexOfModuleToRemove = this.currentlySyncingModules.findIndex(module => module.module.dbDef?.dbKey === data.dbKey);
+            removeFromArrayByIndex(this.currentlySyncingModules, indexOfModuleToRemove);
+        }
+    };
+    performFullSync = async (data) => {
+        const rtModule = RuntimeModules().find(rtModule => rtModule.dbDef?.dbKey === data.dbKey);
+        if (!rtModule)
+            throw new MUSTNeverHappenException(`Trying perform DeltaSync without an existing rtModule: ${data.dbKey}`);
+        this.logDebug(`Performing FullSyncOperation for module ${rtModule.getName()}`);
+        const syncId = this.generateSyncRequestId();
+        this.currentlySyncingModules.push({ module: rtModule, syncId: syncId });
+        try {
+            // if the backend have decided module collection needs a full sync, we need to clean local idb and cache
+            if (this.cleanIDBOnFullSync) {
+                rtModule.logVerbose(`Cleaning IDB: ${rtModule.dbDef.dbKey}`);
+                await rtModule.IDB.clear(); // Also sets the module's data status to NoData.
+            }
+            rtModule.logVerbose(`Cleaning Cache: ${rtModule.dbDef.dbKey}`);
+            rtModule.cache.clear();
+            // for full sync go fetch all db items
+            rtModule.logVerbose(`Syncing: ${rtModule.dbDef.dbKey}`);
+            let allItems;
+            try {
+                if (this.cancelledSyncs.includes(syncId)) {
+                    this.removeFromCancelledSyncs(syncId);
+                    return;
+                }
+                const baseHttpRequest = rtModule.v1.query({ where: {} });
+                const indexOfModuleToUpdate = this.currentlySyncingModules.findIndex(module => module.module.dbDef?.dbKey === data.dbKey);
+                this.currentlySyncingModules[indexOfModuleToUpdate].request = baseHttpRequest;
+                allItems = await baseHttpRequest.executeSync();
+            }
+            catch (e) {
+                if (this.cancelledSyncs.includes(syncId)) {
+                    this.removeFromCancelledSyncs(syncId);
+                    return;
+                }
+                throw e;
+            }
+            rtModule.logVerbose(`Updating IDB: ${rtModule.dbDef.dbKey}`);
+            if (this.cancelledSyncs.includes(syncId)) {
+                this.removeFromCancelledSyncs(syncId);
+                return;
+            }
+            await rtModule.IDB.syncIndexDb(allItems);
+            rtModule.IDB.setLastUpdated(data.lastUpdated);
+            rtModule.logVerbose(`Updating Cache: ${rtModule.dbDef.dbKey}`);
+            rtModule.logVerbose(`allItems length ${allItems.length}`);
+            await rtModule.cache.load();
+            rtModule.logVerbose(`IDB items length ${(await rtModule.IDB.query()).length}`);
+            rtModule.logVerbose(`cache items length ${rtModule.cache.all().length}`);
+            rtModule.logVerbose(`Firing event (DataStatus.ContainsData): ${rtModule.dbDef.dbKey}`);
+            rtModule.setDataStatus(DataStatus.ContainsData);
+            rtModule.logVerbose(`Firing event (EventType_Query): ${rtModule.dbDef.dbKey}`);
+            this.logDebug(`Full Sync Completed: ${rtModule.dbDef.dbKey}`);
+            if (allItems.length === 0)
+                return;
+            rtModule.dispatchMulti(EventType_Query, allItems);
+        }
+        catch (e) {
+            this.logError(`Error while syncing collection '${rtModule.dbDef.dbKey}'`, e);
+            throw e;
+        }
+        finally {
+            const indexOfModuleToRemove = this.currentlySyncingModules.findIndex(module => module.module.dbDef?.dbKey === data.dbKey);
+            removeFromArrayByIndex(this.currentlySyncingModules, indexOfModuleToRemove);
+        }
+    };
+    generateSyncRequestId = () => {
+        return generateHex(12);
+    };
+    removeFromCancelledSyncs = (syncId) => {
+        if (!syncId) {
+            this.logError(`ID ${syncId} doesn't exist in cancelledSyncs, redundant attempt to remove it.`);
+            return;
+        }
+        removeItemFromArray(this.cancelledSyncs, syncId);
+    };
+    // ######################### Listening #########################
+    startListening() {
+        const nodePath = resolveContent(this.syncManagerNodePath);
+        if (this.syncFirebaseListener) {
+            this.logWarning(`Trying to start listening on --- ${nodePath} --- but the listener already exists.`);
+            return;
+        }
+        this.syncFirebaseListener = ModuleFE_FirebaseListener
+            .createListener(nodePath)
+            .startListening(this.onSyncDataChanged);
+    }
+    stopListening() {
+        this.logDebug(`Stop listening on ${resolveContent(this.syncManagerNodePath)}`);
+        this.syncFirebaseListener?.stopListening();
+        this.syncFirebaseListener = undefined;
+        delete this.syncDebouncer;
+    }
+    onSyncDataChanged = async (snapshot) => {
+        this.logDebug('Received firebase state data');
+        // remoteSyncData is the data we received from the firebase listener, that just detected a change.
+        const rtdbSyncData = snapshot.val();
+        // if exists trigger the external callback
+        this._onSyncDataChanged?.(rtdbSyncData);
+        if (!rtdbSyncData)
+            return await this.debounceSyncImpl();
+        this.currentSyncData = rtdbSyncData;
+        // localSyncData is the data we just collected from the IDB regarding all existing modules.
+        const localSyncData = reduceToMap(this.getLocalSyncData(), data => data.dbKey, data => ({ lastUpdated: data.lastUpdated }));
+        _keys(rtdbSyncData).forEach((dbKey) => {
+            // this Should be taken care of by the below condition because both local and remote will return last updated 0
+            // if (!exists(this.remoteSyncData[dbKey]))
+            // 	return;
+            if (!localSyncData[dbKey])
+                return;
+            if (rtdbSyncData[dbKey].lastUpdated <= localSyncData[dbKey].lastUpdated)
+                return;
+            this.outOfSyncCollections.add(dbKey);
+        });
+        //todo This fixed the issue when we received delta sync and not up-to-date, see if this code can go
+        // // If there are no changes, just set all modules' data status to ContainsData
+        // if (this.outOfSyncCollections.size === 0) {
+        // 	// on sync completed
+        // 	const allModulesAreUpToDate: NoNeedToSyncModule[] = (_keys(localSyncData) as string[]).map(dbKey =>
+        // 		({
+        // 			dbKey: dbKey,
+        // 			lastUpdated: localSyncData[dbKey]?.lastUpdated ?? 0,
+        // 			sync: SmartSync_UpToDateSync
+        // 		}));
+        // 	const setAllModulesAsContainData: Response_SmartSync = {modules: allModulesAreUpToDate};
+        // 	await this.onSmartSyncCompleted(setAllModulesAsContainData);
+        // }
+        // If there are changes, call sync
+        return await this.debounceSyncImpl();
+    };
+    // ######################### setNodeContext #########################
+    setNodeContext = (nodeContextResolver) => this.syncManagerNodePath = nodeContextResolver;
+    setSmartSyncUrl = (baseUrlResolver) => this.smartSyncApiUrl = baseUrlResolver;
+    setOnSyncCompleted = (smartSyncCompleted) => this._smartSyncCompleted = smartSyncCompleted;
+    setOnSyncDataChanged = (onSyncDataChanged) => this._onSyncDataChanged = onSyncDataChanged;
+    setDebounceTimeout = (debounceTimeout) => this._debounceTimeout = debounceTimeout;
+    setDebounceMaxTimeout = (debounceTimeout) => this._debounceMaxTimeout = debounceTimeout;
+}
+export const ModuleFE_SyncManager = new ModuleFE_SyncManager_Class();

package/modules/sync-manager/ModuleFE_SyncManager_CSV.d.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nu-art/ts-common';
+import { Readable } from 'stream';
+import { PapaparseConfig } from '../ModuleFE_CSVParser.js';
+export declare class ModuleFE_SyncManager_CSV_Class extends Module {
+    constructor();
+    private getModulesToSync;
+    syncFromCSVUrl: (url: string, config?: PapaparseConfig) => Promise<void>;
+    readyAllModules: () => Promise<void>;
+    syncFromBackupStream: (stream: Readable) => Promise<void>;
+}
+export declare const ModuleFE_SyncManager_CSV: ModuleFE_SyncManager_CSV_Class;

package/modules/sync-manager/ModuleFE_SyncManager_CSV.js

@@ -0,0 +1,121 @@
+import { _keys, arrayToMap, mergeObject, Module, RuntimeModules } from '@nu-art/ts-common';
+import { Writable } from 'stream';
+import { DataStatus } from '../../core/db-api-gen/consts.js';
+import { ModuleFE_CSVParser } from '../ModuleFE_CSVParser.js';
+import { ModuleSyncType } from '../db-api-gen/types.js';
+import { Thunder } from '../../core/Thunder.js';
+import { HeaderKey_ContentType } from '../../shared.js';
+export class ModuleFE_SyncManager_CSV_Class extends Module {
+    constructor() {
+        super();
+    }
+    getModulesToSync = () => RuntimeModules().filter((module) => module.syncType === ModuleSyncType.CSVSync);
+    syncFromCSVUrl = async (url, config) => {
+        const modules = arrayToMap(this.getModulesToSync(), i => i.dbDef.dbKey);
+        const start = performance.now();
+        const itemsToSync = [];
+        const errors = [];
+        await new Promise(resolve => {
+            const isEmulator = Thunder.getInstance().getConfig().label?.toLowerCase() === 'local';
+            const downloadRequestHeaders = isEmulator ? undefined : { [HeaderKey_ContentType]: 'text/csv' };
+            const finalConfig = config ? mergeObject({ downloadRequestHeaders }, config) : { downloadRequestHeaders };
+            ModuleFE_CSVParser.fromURL(url, {
+                transform: (value, field) => field === 'document' ? JSON.parse(value) : value,
+                step: async (results) => {
+                    if (results.errors?.length)
+                        return errors.push(...results.errors);
+                    const item = results.data;
+                    const module = modules[item.dbKey];
+                    if (!module)
+                        return;
+                    itemsToSync.push(item);
+                },
+                complete: async () => {
+                    for (const moduleKey of _keys(modules)) {
+                        const items = itemsToSync.filter(item => item.dbKey === moduleKey);
+                        const module = modules[moduleKey];
+                        // Get all docs to upsert
+                        const documents = items.map(i => i.document);
+                        // Run upgrade processors on them from the module
+                        await module.upgradeInstances(documents);
+                        // Upsert items to the idb
+                        await module.IDB.syncIndexDb(documents);
+                        await module.cache.load();
+                        module.setDataStatus(DataStatus.ContainsData);
+                    }
+                    const end = performance.now();
+                    this.logInfo(`sync took ${((end - start) / 1000).toFixed(3)} seconds`);
+                    if (errors.length)
+                        this.logError('Parsed with errors', ...errors);
+                    resolve();
+                },
+                ...finalConfig,
+                error: (error) => {
+                    this.logError(`CSV Parsing failed`, error);
+                }
+            });
+        });
+    };
+    readyAllModules = async () => {
+        const modules = this.getModulesToSync();
+        this.logDebug('Readying modules', modules);
+        for (const module of modules) {
+            await module.cache.load();
+            module.setDataStatus(DataStatus.ContainsData);
+        }
+    };
+    syncFromBackupStream = async (stream) => {
+        const modules = this.getModulesToSync();
+        this.logInfo('Modules', modules);
+        const writer = new ModuleIDBWriter(modules);
+        await new Promise((resolve, reject) => {
+            stream.pipe(writer)
+                .on('error', err => reject(err))
+                .on('close', () => {
+                modules.forEach(module => {
+                    module.setDataStatus(DataStatus.ContainsData);
+                });
+                resolve();
+            });
+        });
+    };
+}
+export const ModuleFE_SyncManager_CSV = new ModuleFE_SyncManager_CSV_Class();
+class ModuleIDBWriter extends Writable {
+    modules;
+    moduleNameMap;
+    paginationSize;
+    itemsToUpsert = [];
+    constructor(modules, paginationSize = 1000) {
+        super();
+        this.modules = modules;
+        this.paginationSize = paginationSize;
+        this.moduleNameMap = modules.reduce((acc, curr) => {
+            acc[curr.dbDef.backend.name] = curr;
+            return acc;
+        }, {});
+    }
+    async _write(chunk, encoding, callback) {
+        console.log('WRITE');
+        this.itemsToUpsert.push(chunk);
+        await this.upsertItems();
+        callback();
+    }
+    async _final(callback) {
+        await this.upsertItems(true);
+        callback();
+    }
+    upsertItems = async (force = false) => {
+        const itemCount = this.itemsToUpsert.length;
+        if ((itemCount < this.paginationSize) && !force)
+            return;
+        for (const item of this.itemsToUpsert) {
+            const module = this.moduleNameMap[item.dbKey];
+            if (!module)
+                continue;
+            const document = JSON.parse(item.document);
+            await module.IDB.storeWrapper.upsert(document);
+        }
+        this.itemsToUpsert = [];
+    };
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@nu-art/thunderstorm-frontend",
+  "version": "0.400.5",
+  "description": "Thunderstorm Frontend",
+  "keywords": [
+    "TacB0sS",
+    "express",
+    "infra",
+    "nu-art",
+    "thunderstorm",
+    "typescript"
+  ],
+  "homepage": "https://github.com/nu-art-js/thunderstorm",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/thunderstorm/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git"
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "scripts": {
+    "build": "tsc"
+  },
+  "contributors": [
+    {
+      "name": "TacB0sS"
+    },
+    {
+      "name": "Cipher",
+      "url": "https://www.linkedin.com/in/itay-leybovich-470b87229/"
+    }
+  ],
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "dependencies": {
+    "@nu-art/thunderstorm-shared": "0.400.5",
+    "@nu-art/firebase-frontend": "0.400.5",
+    "@nu-art/firebase-shared": "0.400.5",
+    "@nu-art/ts-common": "0.400.5",
+    "@nu-art/ts-styles": "0.400.5",
+    "abort-controller": "^3.0.0",
+    "axios": "^1.13.1",
+    "body-parser": "^1.19.0",
+    "browserify-zlib": "^0.2.0",
+    "buffer": "^6.0.3",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "crypto-browserify": "^3.12.0",
+    "csstype": "^3.0.0",
+    "express": "^4.18.2",
+    "firebase": "^11.9.0",
+    "firebase-admin": "13.4.0",
+    "firebase-functions": "6.3.2",
+    "history": "^4.9.0",
+    "moment": "^2.29.4",
+    "pako": "^2.1.0",
+    "papaparse": "^5.4.1",
+    "qs": "^6.6.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-router-dom": "^6.9.0",
+    "react-virtualized-auto-sizer": "^1.0.12",
+    "react-window": "^1.8.8",
+    "request": "^2.88.0",
+    "stream-browserify": "^3.0.0",
+    "util": "^0.12.4"
+  },
+  "devDependencies": {
+    "@types/papaparse": "^5.3.14",
+    "@types/pako": "^2.0.0",
+    "@types/cors": "^2.8.17",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "@types/react-router": "^5.1.20",
+    "@types/react-router-dom": "^5.3.3",
+    "@types/compression": "^1.7.0",
+    "@types/express": "^4.17.17",
+    "@types/history": "^4.7.2",
+    "@types/request": "^2.48.1",
+    "@types/chrome": "^0.0.202",
+    "@types/react-window": "^1.8.5",
+    "@types/react-virtualized-auto-sizer": "^1.0.1"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./editable-item": {
+      "types": "./editable-item.d.ts",
+      "import": "./editable-item.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    },
+    "./styles": "./styles.scss"
+  }
+}

package/server-info/Button_VersionUpdate.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { ComponentSync } from '../core/ComponentSync.js';
+import { OnServerInfoUpdatedListener } from './ModuleFE_ServerInfo.js';
+import './Button_VersionUpdate.scss';
+export type Props = {
+    updateVersion?: () => void;
+    buttonContent?: React.JSX.Element;
+};
+export declare class Button_VersionUpdate extends ComponentSync<Props> implements OnServerInfoUpdatedListener {
+    __onServerInfoUpdated: () => void;
+    protected updateVersion: () => Promise<void>;
+    protected getLatestVersion(): string;
+    protected getButtonToRender(): import("react/jsx-runtime").JSX.Element;
+    render(): React.JSX.Element;
+}

package/server-info/Button_VersionUpdate.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { ComponentSync } from '../core/ComponentSync.js';
+import { ModuleFE_ServerInfo } from './ModuleFE_ServerInfo.js';
+import './Button_VersionUpdate.scss';
+export class Button_VersionUpdate extends ComponentSync {
+    __onServerInfoUpdated = () => {
+        this.forceUpdate();
+    };
+    updateVersion = async () => {
+        if (this.props.updateVersion) {
+            this.props.updateVersion();
+            return;
+        }
+        ModuleFE_ServerInfo.Update.updateAndRefreshPage();
+    };
+    getLatestVersion() {
+        return ModuleFE_ServerInfo.Version.getLatestVersion();
+    }
+    getButtonToRender() {
+        const ButtonContent = this.props.buttonContent ? this.props.buttonContent : `Version ${this.getLatestVersion()} available. Click to update`;
+        return _jsx("div", { className: 'version-update-message', onClick: () => this.updateVersion(), children: ButtonContent });
+    }
+    render() {
+        const shouldUpdateVersion = ModuleFE_ServerInfo.Version.shouldUpdateVersion();
+        if (!shouldUpdateVersion)
+            return _jsx(_Fragment, {});
+        return this.getButtonToRender();
+    }
+}