@intuitionrobotics/thunderstorm/dist/app-backend/modules/FirestoreBackupScheduler.js

Thunderstorm

import { currentTimeMillies, Dispatcher, dispatch_onServerError, filterInstances, ServerErrorSeverity, _logger_logException, __stringify } from "@intuitionrobotics/ts-common";
import { FirebaseScheduledFunction } from "@intuitionrobotics/firebase/app-backend/functions/firebase-function";
import { FirebaseModule } from "@intuitionrobotics/firebase/app-backend/FirebaseModule";
import {} from "./CleanupScheduler.js";
import { FirestoreCollection } from "@intuitionrobotics/firebase/app-backend/firestore/FirestoreCollection";
import {} from "@intuitionrobotics/firebase";
const dispatch_onFirestoreBackupSchedulerAct = new Dispatcher("__onFirestoreBackupSchedulerAct");
export class FirestoreBackupScheduler_Class extends FirebaseScheduledFunction {
    constructor() {
        super("FirestoreBackupScheduler");
        this.setSchedule('every 24 hours');
    }
    onScheduledEvent = async () => {
        const backupStatusCollection = FirebaseModule.createAdminSession().getFirestore().getCollection('firestore-backup-status', ["moduleKey", "timestamp"]);
        const backups = [];
        filterInstances(dispatch_onFirestoreBackupSchedulerAct.dispatchModule()).forEach(backupArray => {
            backups.push(...backupArray);
        });
        const bucket = await FirebaseModule.createAdminSession().getStorage().getOrCreateBucket();
        await Promise.all(backups.map(async (backupItem) => {
            const query = {
                where: { moduleKey: backupItem.moduleKey },
                orderBy: [{ key: "timestamp", order: "asc" }],
                limit: 1
            };
            const docs = await backupStatusCollection.query(query);
            const latestDoc = docs[0];
            if (latestDoc && latestDoc.timestamp + backupItem.interval > currentTimeMillies())
                return;
            const backupPath = `backup/firestore/${backupItem.moduleKey}/${currentTimeMillies()}.json`;
            try {
                const toBackupData = await backupItem.collection.query(backupItem.backupQuery);
                await (await bucket.getFile(backupPath)).write(toBackupData);
                await backupStatusCollection.upsert({ timestamp: currentTimeMillies(), moduleKey: backupItem.moduleKey, backupPath });
                const keepInterval = backupItem.keepInterval;
                if (keepInterval) {
                    const queryOld = { where: { moduleKey: backupItem.moduleKey, timestamp: { $lt: currentTimeMillies() - keepInterval } } };
                    const oldDocs = await backupStatusCollection.query(queryOld);
                    await Promise.all(oldDocs.map(async (oldDoc) => {
                        await (await bucket.getFile(oldDoc.backupPath)).delete();
                    }));
                    await backupStatusCollection.delete(queryOld);
                }
            }
            catch (e) {
                this.logWarning(`backup of ${backupItem.moduleKey} has failed with error`, e);
                const errorMessage = `Error backing up firestore collection config:\n ${__stringify(backupItem, true)}\nError: ${_logger_logException(e)}`;
                await dispatch_onServerError.dispatchModuleAsync(ServerErrorSeverity.Critical, errorMessage);
            }
        }));
    };
}
export const FirestoreBackupScheduler = new FirestoreBackupScheduler_Class();
//# sourceMappingURL=FirestoreBackupScheduler.js.map