@nu-art/thunderstorm-backend 0.400.5

package/modules/archiving/ModuleBE_Archiving.js

@@ -0,0 +1,236 @@
+import { BadImplementationException, batchActionParallel, currentTimeMillis, Day, dbIdLength, deepClone, generateHex, Hour, removeDBObjectKeys, RuntimeModules } from '@nu-art/ts-common';
+import { ModuleBE_FirestoreListener } from '@nu-art/firebase-backend';
+import { addRoutes } from '../ModuleBE_APIs.js';
+import { createBodyServerApi, createQueryServerApi } from '../../core/typed-api.js';
+import { ApiDef_Archiving } from '@nu-art/thunderstorm-shared';
+import { _EmptyQuery } from '@nu-art/firebase-shared';
+export const Const_ArchivedCollectionPath = '/_archived';
+/**
+ * This class extends FirestoreFunctionModule and handles Firestore database operations
+ * with custom logic for archiving and Time-To-Live (TTL) functionality.
+ */
+export class ModuleBE_ArchiveModule_Class extends ModuleBE_FirestoreListener {
+    TTL; // Time to live for each instance
+    lastUpdatedTTL; // Time to live after last update
+    moduleMapper; // Module mapper, mapping collection name to module
+    /**
+     * Constructor initializes TTL, lastUpdatedTTL moduleMapper and sets api routes for the module.
+     */
+    constructor() {
+        super('{collectionName}');
+        this.moduleMapper = {};
+        this.lastUpdatedTTL = Day; // Default TTL for last updated is one day
+        this.TTL = Hour * 2; // Default TTL is two hours
+    }
+    /**
+     * Initializes the `moduleMapper` by populating it with Firestore collections.
+     * Iterates through all modules obtained from the Storm instance and adds modules
+     * which are Firestore DB modules to the `moduleMapper`.
+     */
+    init() {
+        super.init();
+        // Add all DB modules to the mapper
+        RuntimeModules()
+            .filter((module) => !!module.dbDef)
+            .forEach(_module => this.moduleMapper[_module.collection.collection.path] = _module);
+        addRoutes([
+            createBodyServerApi(ApiDef_Archiving.vv1.hardDeleteUnique, this.hardDeleteUnique),
+            createQueryServerApi(ApiDef_Archiving.vv1.hardDeleteAll, this.hardDeleteAll),
+            createQueryServerApi(ApiDef_Archiving.vv1.getDocumentHistory, this.getDocumentHistory)
+        ]);
+    }
+    /**
+     * Deletes a unique document by its ID in a Firestore transaction.
+     * This method first retrieves the document with the given ID.
+     * If the document is found, it is marked for deletion and an upsert operation is performed.
+     * The upsert operation triggers a Firestore OnUpdate event, which will delete the document and its '_archived' sub-collection.
+     *
+     * @param body - An object of type `RequestBody_HardDeleteUnique` containing the following fields:
+     *    - _id: The ID of the document to be deleted.
+     *    - collectionName: The name of the collection the document belongs to.
+     *    - dbInstance: (optional) The instance of the document. If not provided, the method will attempt to retrieve it using the given ID.
+     * @returns - A promise that performs the deletion operation.
+     * @throws - A `BadImplementationException` if no module is found for the given collection or if no document with the provided ID is found.
+     */
+    hardDeleteUnique = async (body) => {
+        const { _id, collectionName, dbInstance } = body;
+        const dbModule = this.moduleMapper[collectionName];
+        if (!dbModule)
+            throw new BadImplementationException('no module found');
+        return dbModule.runTransaction(async (transaction) => {
+            const instance = dbInstance ?? await dbModule.query.unique(_id, transaction);
+            // queryUnique(dbModule.collection, {where: {_id} as Clause_Where<DBType>});
+            if (!instance)
+                throw new BadImplementationException(`couldn't find doc with id ${_id}`);
+            //make sure trigger will delete object, and it's _archived collection
+            instance.__hardDelete = true;
+            await dbModule.set.item(instance, transaction);
+        });
+    };
+    /**
+     * Deletes all documents in the specified collection.
+     * This function first retrieves all documents in the collection.
+     * It then deletes each document in the collection in parallel chunks for efficiency.
+     *
+     * @param queryParams - Params includes the name of the collection in which the documents will be deleted.
+     * @returns - A promise that performs the deletion operation.
+     * @throws - A BadImplementationException if no corresponding module is found for the given collection.
+     */
+    hardDeleteAll = async (queryParams) => {
+        const dbModule = this.moduleMapper[queryParams.collectionName];
+        if (!dbModule)
+            throw new BadImplementationException('no module found');
+        const collectionItems = await dbModule.query.custom(_EmptyQuery);
+        await batchActionParallel(collectionItems, 10, (chunk) => Promise.all(chunk.map(item => this.hardDeleteUnique({
+            _id: item._id,
+            collectionName: dbModule.collection.collection.path,
+            dbInstance: item
+        }))));
+    };
+    /**
+     * Asynchronously retrieves the document history from the '_archived' collection group.
+     *
+     * This function takes a RequestQuery_GetHistory object as a parameter, which contains the name of the collection
+     * and the ID of the document for which the history should be retrieved.
+     * It then finds the respective Firestore DB module for the provided collection.
+     *
+     * If no module is found for the given collection, a BadImplementationException is thrown.
+     *
+     * The function queries the '_archived' collection group where the '_originDocId' field matches the provided
+     * document ID, and orders the results by the '__created' timestamp in descending order.
+     * It then maps the document snapshots to their respective data, creating an array of DBType documents, which is returned.
+     *
+     * @param queryParams - The request query parameters containing the collection name and the document ID.
+     * @returns - An array of DBType documents representing the history of the specified document.
+     * @throws - A BadImplementationException if no module is found for the given collection.
+     */
+    getDocumentHistory = async (queryParams) => {
+        const { collectionName, _id } = queryParams;
+        const dbModule = this.moduleMapper[collectionName];
+        if (!dbModule)
+            throw new BadImplementationException('no db module found');
+        const collectionGroup = dbModule.collection.collection.firestore.collectionGroup('_archived');
+        const query = collectionGroup.where('_originDocId', '==', _id).orderBy('__created', 'desc');
+        const snapshot = await query.get();
+        const docs = snapshot.docs.map(doc => doc.data());
+        return docs.filter((doc) => !doc.__collectionName);
+    };
+    /**
+     * Checks if the Time-To-Live (TTL) for a document instance has been exceeded.
+     *
+     * @param instance - The document instance to check.
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @returns - A boolean indicating whether the TTL has been exceeded (true) or not (false).
+     */
+    checkTTL(instance, dbModule) {
+        const timestamp = currentTimeMillis();
+        const TTL = dbModule.dbDef.TTL || this.TTL;
+        // If TTL is not set or the document is not updated, return false
+        if (TTL === -1 || !instance.__updated)
+            return false;
+        // Check if the current time is past the document's TTL
+        return timestamp > (instance.__updated + TTL);
+    }
+    /**
+     * Checks if the `lastUpdatedTTL` for a document instance has been exceeded.
+     * This represents a secondary TTL which is based on the last update time of the document.
+     *
+     * @param instance - The document instance to check.
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @returns - A boolean indicating whether the `lastUpdatedTTL` has been exceeded (true) or not (false).
+     */
+    checkLastUpdatedTTL(instance, dbModule) {
+        const timestamp = currentTimeMillis();
+        const lastUpdatedTTL = dbModule.dbDef.lastUpdatedTTL || this.lastUpdatedTTL;
+        // If lastUpdatedTTL is not set or the document is not updated, return false
+        if (lastUpdatedTTL === -1 || !instance.__updated)
+            return false;
+        // Check if the current time is past the document's lastUpdatedTTL
+        return timestamp > (instance.__updated + lastUpdatedTTL);
+    }
+    /**
+     * Inserts a document into the '_archived' sub-collection.
+     * This function is used for archiving the previous state of the document before it was changed.
+     *
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @param before - The state of the document before changes.
+     * @returns - A promise that performs the archiving operation or undefined in case of an error.
+     */
+    async insertToArchive(dbModule, before) {
+        if (before.__hardDelete)
+            return;
+        // Reference to the original collection
+        const collectionRef = dbModule.collection.collection;
+        const timestamp = currentTimeMillis();
+        // Deep clone the document before mutation
+        let dbInstance = deepClone(before);
+        // Reference to the _archived sub-collection
+        const subCollection = collectionRef.doc(dbInstance._id).collection(Const_ArchivedCollectionPath);
+        // Remove the keys from the original object that shouldn't be in the archive
+        dbInstance = removeDBObjectKeys(dbInstance);
+        // Record the original document ID
+        dbInstance._originDocId = before._id;
+        // Generate a new ID for the archived document
+        dbInstance._id = generateHex(dbIdLength);
+        dbInstance.__updated = timestamp;
+        dbInstance.__created = timestamp;
+        // Insert the archived document into the _archived sub-collection
+        await subCollection.doc(dbInstance._id).set(dbInstance);
+    }
+    /**
+     * Hard deletes a document and its associated archived documents.
+     *
+     * @param instance - The instance of the document to delete.
+     * @param dbModule - The Firestore database module the document belongs to.
+     * @returns - A promise to perform the deletion operation.
+     */
+    async hardDeleteDoc(instance, dbModule) {
+        // Get reference to the collection the document belongs to
+        const collectionRef = dbModule.collection.collection;
+        // Get reference to the document instance to delete
+        const instanceRef = collectionRef.doc(instance._id);
+        // Get reference to the archived documents collection associated with the document instance
+        const archivedCollectionRef = instanceRef.collection(Const_ArchivedCollectionPath);
+        // Get all archived documents
+        const archivedDocs = await archivedCollectionRef.listDocuments();
+        // Delete the document instance
+        await instanceRef.delete();
+        // Delete all archived documents associated with the document instance, performing the delete operation in chunks of 10
+        return batchActionParallel(archivedDocs, 10, (docChunk) => Promise.all(docChunk.map(async (doc) => {
+            await doc.set({ __hardDelete: true }, { merge: true });
+            return doc.delete();
+        })));
+    }
+    /**
+     * Processes changes in the Firestore collection.
+     * Depending on the state of the documents, it either archives the documents,
+     * checks the Time-To-Live (TTL) or performs a hard delete operation.
+     *
+     * @param params - An object containing the collectionName and the document ID.
+     * @param before - The state of the document before changes.
+     * @param after - The state of the document after changes.
+     * @returns - A promise that performs the necessary operation based on the document states.
+     */
+    async processChanges(params, before, after) {
+        // Get the relevant module
+        const dbModule = this.moduleMapper[params.collectionName];
+        if (!dbModule)
+            throw new BadImplementationException('no db module found');
+        // If there's no previous document state, or it's marked for hard deletion, exit the function
+        if (!before)
+            return;
+        // If the document was deleted, archive the original document
+        if (!after)
+            return this.insertToArchive(dbModule, before);
+        // If the document is marked for hard deletion, delete the document
+        if (after.__hardDelete)
+            return this.hardDeleteDoc(before, dbModule);
+        // If the document's TTL has been exceeded, archive the original document
+        if (this.checkTTL(before, dbModule))
+            return this.insertToArchive(dbModule, before);
+        // If the document's lastUpdatedTTL has been exceeded, archive the original document
+        if (this.checkLastUpdatedTTL(before, dbModule))
+            return this.insertToArchive(dbModule, before);
+    }
+}
+export const ModuleBE_Archiving = new ModuleBE_ArchiveModule_Class();

package/modules/collection-actions/ModuleBE_CollectionActions.d.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nu-art/ts-common';
+import { CollectionActions_Check, CollectionActions_Upgrade } from '../../shared.js';
+declare class ModuleBE_CollectionActions_Class extends Module {
+    constructor();
+    protected init(): void;
+    private getUpgradableModules;
+    upgrade_Collections: (req: CollectionActions_Upgrade["collections"]["request"]) => Promise<CollectionActions_Upgrade["collections"]["response"]>;
+    upgrade_All: (req: CollectionActions_Upgrade["all"]["request"]) => Promise<CollectionActions_Upgrade["all"]["response"]>;
+    check_Usage: (req: CollectionActions_Check["usage"]["request"]) => Promise<CollectionActions_Check["usage"]["response"]>;
+}
+export declare const ModuleBE_CollectionActions: ModuleBE_CollectionActions_Class;
+export {};

package/modules/collection-actions/ModuleBE_CollectionActions.js

@@ -0,0 +1,69 @@
+import { _keys, filterInstances, LogLevel, merge, Module, Promise_all_sequentially, RuntimeModules } from '@nu-art/ts-common';
+import { addRoutes } from '../ModuleBE_APIs.js';
+import { createBodyServerApi } from '../../core/typed-api.js';
+import { ApiDef_CollectionActions } from '../../shared.js';
+import { dispatch_CollectEntityDependencies } from './dispatcher.js';
+class ModuleBE_CollectionActions_Class extends Module {
+    constructor() {
+        super();
+        this.setMinLevel(LogLevel.Verbose);
+    }
+    init() {
+        super.init();
+        addRoutes([
+            //Add upgrade routes
+            createBodyServerApi(ApiDef_CollectionActions.upgrade.collections, this.upgrade_Collections),
+            createBodyServerApi(ApiDef_CollectionActions.upgrade.all, this.upgrade_All),
+            //Add check routes
+            createBodyServerApi(ApiDef_CollectionActions.check.usage, this.check_Usage),
+        ]);
+    }
+    // ##################### Internal Logic #####################
+    getUpgradableModules = async (limitKeys, forceUpgrade) => {
+        const filterModule = async (_module) => {
+            const module = _module;
+            const dbKey = module?.dbDef?.dbKey;
+            //Assert dbKey exists
+            if (!dbKey)
+                return undefined;
+            //Assert not an advisor collection module
+            if (module.advisorCollectionModule)
+                return undefined;
+            //Assert in the user given keys
+            if (limitKeys.length > 0 && !limitKeys.includes(dbKey))
+                return undefined;
+            const isUpToDate = await module.isCollectionUpToDate();
+            return (!isUpToDate || forceUpgrade) ? module : undefined;
+        };
+        const allModules = RuntimeModules().all;
+        return filterInstances(await Promise.all(allModules.map(filterModule)));
+    };
+    // ##################### API Callbacks - Upgrade #####################
+    upgrade_Collections = async (req) => {
+        this.logInfo(`Upgrade - Collections${req.force ? ', Forcefully' : ''}`);
+        if (req.dbKeys.length)
+            this.logInfo(`Limited to ${req.dbKeys.length} collections:`, req.dbKeys.join(', '));
+        else
+            this.logInfo('No collection limit');
+        const modules = await this.getUpgradableModules(req.dbKeys, req.force);
+        this.logInfo(`Will upgrade ${modules.length} modules`);
+        await Promise_all_sequentially(modules.map(module => () => module.upgradeCollection(req.force)));
+    };
+    upgrade_All = async (req) => {
+        this.logInfo('Upgrade - All');
+        //Call upgrade collections with no dbKey limit
+        await this.upgrade_Collections({ dbKeys: [], force: req.force });
+    };
+    // ##################### API Callbacks - Check #####################
+    check_Usage = async (req) => {
+        this.logInfo(`Checking usage for ${req.itemIds.length} items under the "${req.dbKey}" collection`);
+        const dependencies = await dispatch_CollectEntityDependencies.dispatchModuleAsync(req.dbKey, req.itemIds);
+        const filtered = filterInstances(dependencies);
+        if (!filtered.length)
+            return { dependencies: undefined };
+        const merged = filtered.reduce((acc, dependency) => merge(acc, dependency));
+        const dependenciesAmount = _keys(merged.dependencyMap).length;
+        return { dependencies: dependenciesAmount ? merged : undefined };
+    };
+}
+export const ModuleBE_CollectionActions = new ModuleBE_CollectionActions_Class();

package/modules/collection-actions/dispatcher.d.ts

@@ -0,0 +1,7 @@
+import { DBProto, Dispatcher } from '@nu-art/ts-common';
+import { Transaction } from 'firebase-admin/firestore';
+import { DBEntityDependencies } from '../../shared.js';
+export interface EntityDependencyCollection {
+    __collectEntityDependencies: <T extends DBProto<any>>(type: T['dbKey'], itemIds: string[], transaction?: Transaction) => Promise<DBEntityDependencies | undefined>;
+}
+export declare const dispatch_CollectEntityDependencies: Dispatcher<EntityDependencyCollection, "__collectEntityDependencies", [type: any, itemIds: string[], transaction?: Transaction | undefined], DBEntityDependencies | undefined>;

package/modules/collection-actions/dispatcher.js

@@ -0,0 +1,2 @@
+import { Dispatcher } from '@nu-art/ts-common';
+export const dispatch_CollectEntityDependencies = new Dispatcher('__collectEntityDependencies');

package/modules/db-api-gen/ModuleBE_BaseApi.d.ts

@@ -0,0 +1,16 @@
+import { DBProto, Module } from '@nu-art/ts-common';
+import { ModuleBE_BaseDB } from './ModuleBE_BaseDB.js';
+/**
+ * A base class used for implementing CRUD operations on a db module collection.
+ *
+ * By default, it exposes API endpoints for creating, deleting, updating, querying and querying for unique document.
+ */
+export declare class ModuleBE_BaseApi_Class<Proto extends DBProto<any>> extends Module {
+    readonly dbModule: ModuleBE_BaseDB<Proto>;
+    readonly apiDef: import("@nu-art/thunderstorm-shared").ApiDefRouter<import("@nu-art/thunderstorm-shared").ApiStruct_DBApiGenIDBV3<Proto>>;
+    constructor(dbModule: ModuleBE_BaseDB<Proto, any>, version?: string);
+    init(): void;
+    private _metadata;
+    private _deleteQuery;
+}
+export declare const createApisForDBModuleV3: <Proto extends DBProto<any>>(dbModule: ModuleBE_BaseDB<Proto>, version?: string) => ModuleBE_BaseApi_Class<Proto>;

package/modules/db-api-gen/ModuleBE_BaseApi.js

@@ -0,0 +1,74 @@
+/*
+ * 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 { __stringify, _values, ApiException, Module } from '@nu-art/ts-common';
+import { _EmptyQuery } from '@nu-art/firebase-shared';
+import { DBApiDefGeneratorIDBV3 } from '@nu-art/thunderstorm-shared';
+import { addRoutes } from '../ModuleBE_APIs.js';
+import { createBodyServerApi, createQueryServerApi } from '../../core/typed-api.js';
+/**
+ * A base class used for implementing CRUD operations on a db module collection.
+ *
+ * By default, it exposes API endpoints for creating, deleting, updating, querying and querying for unique document.
+ */
+export class ModuleBE_BaseApi_Class extends Module {
+    dbModule;
+    apiDef;
+    constructor(dbModule, version) {
+        super(`GenApiV3(${dbModule.getName()})`);
+        this.dbModule = dbModule;
+        this.apiDef = DBApiDefGeneratorIDBV3(this.dbModule.dbDef, version);
+    }
+    init() {
+        this.logDebug(`Adding routes : ${this.apiDef.v1.query.path}`);
+        addRoutes([
+            createBodyServerApi(this.apiDef.v1.query, async (queryBody) => {
+                const items = await this.dbModule.query.where(queryBody);
+                await this.dbModule.upgradeInstances(items);
+                return items;
+            }),
+            createQueryServerApi(this.apiDef.v1.queryUnique, async (queryObject) => {
+                const toReturnItem = await this.dbModule.query.unique(queryObject._id);
+                if (!toReturnItem)
+                    throw new ApiException(404, `Could not find ${this.dbModule.collection.dbDef.entityName} with _id: ${queryObject._id}`);
+                return toReturnItem;
+            }),
+            createBodyServerApi(this.apiDef.v1.upsert, this.dbModule.set.item),
+            createBodyServerApi(this.apiDef.v1.upsertAll, (body) => this.dbModule.set.all(body)),
+            createQueryServerApi(this.apiDef.v1.delete, (toDeleteObject) => this.dbModule.delete.unique(toDeleteObject._id)),
+            createBodyServerApi(this.apiDef.v1.deleteQuery, this._deleteQuery),
+            createQueryServerApi(this.apiDef.v1.deleteAll, () => this.dbModule.delete.query(_EmptyQuery)),
+            createQueryServerApi(this.apiDef.v1.metadata, this._metadata)
+        ]);
+    }
+    _metadata = async () => {
+        return { ...this.dbModule.dbDef.metadata };
+    };
+    _deleteQuery = async (query) => {
+        if (!query.where)
+            throw new ApiException(400, `Cannot delete without a where clause, using query: ${__stringify(query)}`);
+        if (_values(query.where).filter(v => v === undefined || v === null).length > 0)
+            throw new ApiException(400, `Cannot delete with property value undefined or null, using query: ${__stringify(query)}`);
+        return this.dbModule.delete.query(query);
+    };
+}
+export const createApisForDBModuleV3 = (dbModule, version) => {
+    return new ModuleBE_BaseApi_Class(dbModule, version);
+};

package/modules/db-api-gen/ModuleBE_BaseDB.d.ts

@@ -0,0 +1,78 @@
+import { FirestoreQuery } from '@nu-art/firebase-shared';
+import { DBDef_V3, DBProto, Module } from '@nu-art/ts-common';
+import { CollectionActionType, FirestoreCollectionV3, PostWriteProcessingData } from '@nu-art/firebase-backend/firestore-v3/FirestoreCollectionV3';
+import { DBApiBEConfig } from '../../core/db-def.js';
+import { Response_DBSync } from '@nu-art/thunderstorm-shared/sync-manager/types';
+import { Transaction } from 'firebase-admin/firestore';
+import { EntityDependencyCollection } from '../collection-actions/dispatcher.js';
+import { DBEntityDependencies } from '../../shared.js';
+export type BaseDBApiConfigV3 = {
+    projectId?: string;
+    chunksSize: number;
+};
+export type DBApiConfigV3<Proto extends DBProto<any>> = BaseDBApiConfigV3 & DBApiBEConfig<Proto>;
+/**
+ * An abstract base class used for implementing CRUD operations on a specific collection.
+ *
+ * By default, it exposes API endpoints for creating, deleting, updating, querying and querying for unique document.
+ */
+export declare abstract class ModuleBE_BaseDB<Proto extends DBProto<any>, ConfigType = any, Config extends ConfigType & DBApiConfigV3<Proto> = ConfigType & DBApiConfigV3<Proto>> extends Module<Config> implements EntityDependencyCollection {
+    private readonly ModuleBE_BaseDBV2;
+    collection: FirestoreCollectionV3<Proto>;
+    dbDef: DBDef_V3<Proto>;
+    query: FirestoreCollectionV3<Proto>['query'];
+    create: FirestoreCollectionV3<Proto>['create'];
+    set: FirestoreCollectionV3<Proto>['set'];
+    delete: FirestoreCollectionV3<Proto>['delete'];
+    doc: FirestoreCollectionV3<Proto>['doc'];
+    runTransaction: FirestoreCollectionV3<Proto>['runTransaction'];
+    protected constructor(dbDef: DBDef_V3<Proto>, appConfig?: BaseDBApiConfigV3);
+    __collectEntityDependencies: <T extends DBProto<any>>(type: T["dbKey"], itemIds: string[], transaction?: Transaction) => Promise<DBEntityDependencies | undefined>;
+    private mapConflicts;
+    /**
+     * Executed during the initialization of the module.
+     * The collection reference is set in this method.
+     */
+    init(): void;
+    querySync: (syncQuery: FirestoreQuery<Proto["dbType"]>) => Promise<Response_DBSync<Proto["dbType"]>>;
+    private _preWriteProcessing;
+    /**
+     * Override this method to customize the processing that should be done before create, set or update.
+     *
+     * @param transaction - The transaction object.
+     * @param dbInstance - The DB entry for which the uniqueness is being asserted.
+     * @param originalDbInstance - The DB instance fetched from remote firestore.
+     */
+    protected preWriteProcessing(dbInstance: Proto['uiType'], originalDbInstance: Proto['dbType'], transaction?: Transaction): Promise<void>;
+    private _postWriteProcessing;
+    /**
+     * Override this method to customize processing that should be done after create, set, update or delete.
+     * @param data
+     * @param actionType create/set/update/delete
+     * @param transaction
+     */
+    protected postWriteProcessing(data: PostWriteProcessingData<Proto>, actionType: CollectionActionType, transaction?: Transaction): Promise<void>;
+    manipulateQuery(query: FirestoreQuery<Proto['dbType']>): FirestoreQuery<Proto['dbType']>;
+    preUpsertProcessing: never;
+    /**
+     * Override this method to provide actions or assertions to be executed before the deletion happens.
+     * @param transaction - The transaction object
+     * @param dbItems - The DB entry that is going to be deleted.
+     */
+    canDeleteItems(dbItems: Proto['dbType'][], transaction?: Transaction): Promise<void>;
+    collectDependencies(dbInstances: Proto['dbType'][], transaction?: Transaction): Promise<DBEntityDependencies | undefined>;
+    private versionUpgrades;
+    /**
+     * Upgrades the entity from the given version to the next one (to the same version if the given version is the latest)
+     * @param version - The version we start from
+     * @param processor
+     */
+    registerVersionUpgradeProcessor<K extends Proto['versions']['versions'][number]>(version: K, processor: (items: Proto['versions']['types'][K][]) => Promise<void>): void;
+    /**
+     * Check if the collection has at least one item without the latest version. Version[0] is the latest version.
+     */
+    isCollectionUpToDate: () => Promise<boolean>;
+    upgradeCollection: (force?: boolean) => Promise<void>;
+    processCollection: (processInstances: (instances: Proto["dbType"][]) => Promise<void>) => Promise<void>;
+    upgradeInstances(instances: Proto['dbType'][], force?: boolean): Promise<Proto["dbType"][]>;
+}