@nu-art/firebase-backend 0.400.5

package/firestore/FirestoreCollection.d.ts

@@ -0,0 +1,71 @@
+import { Subset, TS_Object } from '@nu-art/ts-common';
+import { FirestoreType_Collection, FirestoreType_DocumentSnapshot } from './types.js';
+import { Clause_Select, Clause_Where, FilterKeys, FirestoreQuery } from '@nu-art/firebase-shared';
+import { FirestoreWrapperBE } from './FirestoreWrapperBE.js';
+import { FirestoreTransaction } from './FirestoreTransaction.js';
+import { Transaction } from 'firebase-admin/firestore';
+/**
+ * FirestoreCollection is a class for handling Firestore collections. It takes in the name, FirestoreWrapperBE instance, and uniqueKeys as parameters.
+ */
+export declare class FirestoreCollection<Type extends TS_Object> {
+    readonly name: string;
+    readonly wrapper: FirestoreWrapperBE;
+    readonly collection: FirestoreType_Collection;
+    /**
+     * External unique as in there must never ever be two that answer the same query
+     */
+    readonly externalUniqueFilter: ((object: Subset<Type>) => Clause_Where<Type>);
+    /**
+     * @param name
+     * @param wrapper
+     * @param uniqueKeys
+     */
+    constructor(name: string, wrapper: FirestoreWrapperBE, uniqueKeys?: FilterKeys<Type>);
+    /**
+     Executes a Firestore query on the collection.
+     @param ourQuery - The query to execute.
+     @returns A Promise that resolves to an array of FirestoreType_DocumentSnapshot objects.
+     @private
+     */
+    private _query;
+    /**
+
+     Executes a unique Firestore query on the collection.
+     @param ourQuery - The query to execute.
+     @returns A Promise that resolves to a single FirestoreType_DocumentSnapshot object, or undefined if no match is found.
+     @private
+     */
+    private _queryUnique;
+    /**
+     Executes a unique Firestore query on the collection and returns the matching object.
+     @param ourQuery - The query to execute.
+     @returns A Promise that resolves to the matching object, or undefined if no match is found.
+     */
+    queryUnique(ourQuery: FirestoreQuery<Type>): Promise<Type | undefined>;
+    insert(instance: Type, _id?: string): Promise<Type>;
+    insertAll(instances: Type[]): Promise<Awaited<Type>[]>;
+    query(ourQuery: FirestoreQuery<Type>): Promise<Type[]>;
+    upsert(instance: Type): Promise<Type>;
+    upsertAll(instances: Type[]): Promise<Type[]>;
+    patch(instance: Subset<Type>): Promise<Type>;
+    deleteItem(instance: Type): Promise<Type | undefined>;
+    deleteUnique(query: FirestoreQuery<Type>): Promise<Type | undefined>;
+    delete(query: FirestoreQuery<Type>): Promise<Type[]>;
+    private deleteBatch;
+    deleteAll(): Promise<Type[]>;
+    getAll(select?: Clause_Select<Type>): Promise<Type[]>;
+    runInTransaction<ReturnType>(processor: (transaction: FirestoreTransaction) => Promise<ReturnType>): Promise<ReturnType>;
+    createDocumentReference(_id?: string): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
+    getUniqueFilter: () => (object: Subset<Type>) => Clause_Where<Type>;
+    newQueryUnique(ourQuery: FirestoreQuery<Type>): Promise<DocWrapper<Type> | undefined>;
+    newQuery(ourQuery: FirestoreQuery<Type>): Promise<DocWrapper<Type>[]>;
+}
+export declare class DocWrapper<T extends TS_Object> {
+    wrapper: FirestoreWrapperBE;
+    doc: FirestoreType_DocumentSnapshot<T>;
+    constructor(wrapper: FirestoreWrapperBE, doc: FirestoreType_DocumentSnapshot<T>);
+    runInTransaction<R>(processor: (transaction: Transaction) => Promise<R>): Promise<R>;
+    delete: (transaction?: Transaction) => Promise<T>;
+    get: () => T;
+    set: (instance: T, transaction?: Transaction) => Promise<T>;
+}

package/firestore/FirestoreCollection.js

@@ -0,0 +1,184 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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 { BadImplementationException, batchAction, exists, generateHex, StaticLogger } from '@nu-art/ts-common';
+import { FirestoreInterface } from './FirestoreInterface.js';
+import { FirestoreTransaction } from './FirestoreTransaction.js';
+/**
+ * FirestoreCollection is a class for handling Firestore collections. It takes in the name, FirestoreWrapperBE instance, and uniqueKeys as parameters.
+ */
+export class FirestoreCollection {
+    name;
+    wrapper;
+    collection;
+    /**
+     * External unique as in there must never ever be two that answer the same query
+     */
+    externalUniqueFilter;
+    /**
+     * @param name
+     * @param wrapper
+     * @param uniqueKeys
+     */
+    constructor(name, wrapper, uniqueKeys) {
+        this.name = name;
+        this.wrapper = wrapper;
+        if (!/[a-z-]{3,}/.test(name))
+            StaticLogger.logWarning('Please follow name pattern for collections /[a-z-]{3,}/');
+        this.collection = wrapper.firestore.collection(name);
+        this.externalUniqueFilter = (instance) => {
+            if (!uniqueKeys)
+                throw new BadImplementationException('In order to use a unique query your collection MUST have a unique filter');
+            return uniqueKeys.reduce((where, key) => {
+                if (!exists(instance[key]))
+                    throw new BadImplementationException(`No where properties are allowed to be null or undefined.\nWhile querying collection '${this.name}' we found property '${String(key)}' to be '${where[key]}'`);
+                where[key] = instance[key];
+                return where;
+            }, {});
+        };
+    }
+    /**
+     Executes a Firestore query on the collection.
+     @param ourQuery - The query to execute.
+     @returns A Promise that resolves to an array of FirestoreType_DocumentSnapshot objects.
+     @private
+     */
+    async _query(ourQuery) {
+        const myQuery = FirestoreInterface.buildQuery(this, ourQuery);
+        return (await myQuery.get()).docs;
+    }
+    /**
+
+     Executes a unique Firestore query on the collection.
+     @param ourQuery - The query to execute.
+     @returns A Promise that resolves to a single FirestoreType_DocumentSnapshot object, or undefined if no match is found.
+     @private
+     */
+    async _queryUnique(ourQuery) {
+        const results = await this._query(ourQuery);
+        return FirestoreInterface.assertUniqueDocument(results, ourQuery, this.name);
+    }
+    /**
+     Executes a unique Firestore query on the collection and returns the matching object.
+     @param ourQuery - The query to execute.
+     @returns A Promise that resolves to the matching object, or undefined if no match is found.
+     */
+    async queryUnique(ourQuery) {
+        const doc = await this._queryUnique(ourQuery);
+        if (!doc)
+            return;
+        return doc.data();
+    }
+    async insert(instance, _id) {
+        await this.createDocumentReference(_id).set(instance);
+        return instance;
+    }
+    async insertAll(instances) {
+        return await Promise.all(instances.map(instance => this.insert(instance)));
+    }
+    async query(ourQuery) {
+        return (await this._query(ourQuery)).map(result => result.data());
+    }
+    async upsert(instance) {
+        return this.runInTransaction((transaction) => transaction.upsert(this, instance));
+    }
+    async upsertAll(instances) {
+        return batchAction(instances, 500, async (chunked) => this.runInTransaction(transaction => transaction.upsertAll(this, chunked)));
+    }
+    async patch(instance) {
+        return this.runInTransaction(transaction => transaction.patch(this, instance));
+    }
+    async deleteItem(instance) {
+        return this.runInTransaction((transaction) => transaction.deleteItem(this, instance));
+    }
+    async deleteUnique(query) {
+        return this.runInTransaction((transaction) => transaction.deleteUnique(this, query));
+    }
+    async delete(query) {
+        const docRefs = await this._query(query);
+        return this.deleteBatch(docRefs);
+    }
+    async deleteBatch(docRefs) {
+        return await batchAction(docRefs, 200, async (chunk) => {
+            const batch = this.wrapper.firestore.batch();
+            const toRet = [];
+            await chunk.reduce((_batch, val) => {
+                toRet.push(val.data());
+                return _batch.delete(val.ref);
+            }, batch).commit();
+            return toRet;
+        });
+    }
+    async deleteAll() {
+        const docRefs = await this._query();
+        return this.deleteBatch(docRefs);
+    }
+    async getAll(select) {
+        return this.query({ select });
+    }
+    async runInTransaction(processor) {
+        const firestore = this.wrapper.firestore;
+        return firestore.runTransaction(async (transaction) => {
+            return processor(new FirestoreTransaction(transaction));
+        });
+    }
+    createDocumentReference(_id) {
+        const id = _id || generateHex(16);
+        return this.wrapper.firestore.doc(`${this.name}/${id}`);
+    }
+    getUniqueFilter = () => this.externalUniqueFilter;
+    async newQueryUnique(ourQuery) {
+        const doc = await this._queryUnique(ourQuery);
+        if (!doc || !doc.exists)
+            return;
+        return new DocWrapper(this.wrapper, doc);
+    }
+    async newQuery(ourQuery) {
+        const docs = await this._query(ourQuery);
+        return docs.filter(doc => doc.exists).map(doc => new DocWrapper(this.wrapper, doc));
+    }
+}
+export class DocWrapper {
+    wrapper;
+    doc;
+    constructor(wrapper, doc) {
+        this.wrapper = wrapper;
+        this.doc = doc;
+    }
+    async runInTransaction(processor) {
+        const firestore = this.wrapper.firestore;
+        return firestore.runTransaction(processor);
+    }
+    delete = async (transaction) => {
+        if (!transaction) {
+            // const item = this.doc.data();   TODO: TBD do we need a create and run in transaction for each delete??
+            // this.doc.ref.delete();
+            // return item;
+            return this.runInTransaction(this.delete);
+        }
+        const item = this.get();
+        transaction.delete(this.doc.ref);
+        return item;
+    };
+    get = () => this.doc.data();
+    set = async (instance, transaction) => {
+        if (!transaction)
+            return this.runInTransaction((_transaction) => this.set(instance, _transaction));
+        transaction.set(this.doc.ref, instance);
+        return instance;
+    };
+}

package/firestore/FirestoreInterface.d.ts

@@ -0,0 +1,11 @@
+import { FirestoreQuery } from '@nu-art/firebase-shared';
+import { FirestoreType_DocumentSnapshot } from './types.js';
+import { FirestoreCollection } from './FirestoreCollection.js';
+import { TS_Object } from '@nu-art/ts-common';
+import { Query } from 'firebase-admin/firestore';
+export declare class FirestoreInterface {
+    static buildQuery<Type extends TS_Object>(collection: FirestoreCollection<Type>, query?: FirestoreQuery<Type>): Query<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
+    private static isQueryObject;
+    static assertUniqueDocument(results: FirestoreType_DocumentSnapshot[], query: FirestoreQuery<any>, collectionName: string): (FirestoreType_DocumentSnapshot | undefined);
+    static buildUniqueQuery<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Type): FirestoreQuery<Type>;
+}

package/firestore/FirestoreInterface.js

@@ -0,0 +1,111 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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 { ComparatorMap } from '@nu-art/firebase-shared';
+import { __stringify, BadImplementationException, ImplementationMissingException, StaticLogger } from '@nu-art/ts-common';
+export class FirestoreInterface {
+    static buildQuery(collection, query) {
+        try {
+            let myQuery = collection.collection;
+            if (query && query.select)
+                myQuery = myQuery.select ? myQuery.select(...query.select) : myQuery;
+            if (query && query.where) {
+                const whereClause = query.where;
+                myQuery = Object.keys(whereClause).reduce((_query, _whereField) => {
+                    const whereField = _whereField;
+                    const whereValue = whereClause[whereField];
+                    if (whereValue === undefined || whereValue === null)
+                        return _query;
+                    const processObject = (___query, whereKey, _whereValue) => {
+                        const valueType = typeof _whereValue;
+                        if (Array.isArray(_whereValue)) {
+                            if (_whereValue.length === 0 || _whereValue.length > 10)
+                                throw new BadImplementationException('While querying in an array you can only provide one or more values to query by and not more than 10... this ' +
+                                    'is due to Firestore limitation... ');
+                            if (_whereValue.length === 1)
+                                return _query.where(whereKey, 'array-contains', _whereValue[0]);
+                            return _query.where(whereKey, 'array-contains-any', _whereValue);
+                        }
+                        if (this.isQueryObject(_whereValue)) {
+                            const comparatorKey = Object.keys(_whereValue)[0];
+                            const comparator = ComparatorMap[comparatorKey];
+                            if (!comparator)
+                                throw new ImplementationMissingException(`could not find comparator for: ${comparatorKey} in query: ${JSON.stringify(query)}`);
+                            const value = _whereValue[comparatorKey];
+                            if (value === undefined)
+                                throw new ImplementationMissingException(`no value: ${comparatorKey} in query: ${JSON.stringify(query)}`);
+                            return _query.where(whereKey, comparator, value);
+                        }
+                        if (valueType === 'string' || valueType === 'number' || valueType === 'boolean')
+                            return ___query.where(whereKey, '==', _whereValue);
+                        if (valueType === 'object') {
+                            return Object.keys(_whereValue).reduce((__query, key) => {
+                                return processObject(__query, `${whereKey}.${key}`, _whereValue[key]);
+                            }, ___query);
+                        }
+                        throw new ImplementationMissingException(`Could not compose where clause for '${whereKey}' with value type '${valueType}'in query: ${__stringify(___query)}`);
+                    };
+                    return processObject(_query, whereField, whereValue);
+                }, myQuery);
+            }
+            if (query && query.orderBy)
+                myQuery = query.orderBy.reduce((_query, field) => {
+                    return _query.orderBy ? _query.orderBy(field.key, field.order) : _query;
+                }, myQuery);
+            if (query && query.limit)
+                if (typeof query.limit === 'number')
+                    myQuery = myQuery.limit(query.limit);
+                else {
+                    const page = query.limit.page || 0;
+                    // console.log(`limit: ${query.limit.itemsCount} * ${page}`);
+                    if (page > 0)
+                        myQuery = myQuery.offset(query.limit.itemsCount * page + 1);
+                    myQuery = myQuery.limit(query.limit.itemsCount);
+                }
+            return myQuery;
+        }
+        catch (e) {
+            StaticLogger.logError(`Query: ${JSON.stringify(query)}`);
+            StaticLogger.logError(`Error: ${e}`);
+            throw e;
+        }
+    }
+    static isQueryObject(whereValue) {
+        const keys = Object.keys(whereValue);
+        return typeof whereValue === 'object' && keys.length === 1 && (whereValue['$ac'] !== undefined ||
+            whereValue['$aca'] !== undefined ||
+            whereValue['$in'] !== undefined ||
+            whereValue['$nin'] !== undefined ||
+            whereValue['$gt'] !== undefined ||
+            whereValue['$gte'] !== undefined ||
+            whereValue['$lt'] !== undefined ||
+            whereValue['$lte'] !== undefined ||
+            whereValue['$neq'] !== undefined ||
+            whereValue['$eq'] !== undefined);
+    }
+    static assertUniqueDocument(results, query, collectionName) {
+        if (results.length > 1)
+            throw new BadImplementationException(`too many results for query: ${__stringify(query)} in collection: ${collectionName}`);
+        if (results.length === 0)
+            return;
+        return results[0];
+    }
+    static buildUniqueQuery(collection, instance) {
+        const where = collection.externalUniqueFilter(instance);
+        return { where };
+    }
+}

package/firestore/FirestoreTransaction.d.ts

@@ -0,0 +1,30 @@
+import { DocWrapper, FirestoreCollection } from './FirestoreCollection.js';
+import { Subset, TS_Object } from '@nu-art/ts-common';
+import { FirestoreQuery } from '@nu-art/firebase-shared';
+import { Transaction } from 'firebase-admin/firestore';
+export declare class FirestoreTransaction {
+    transaction: Transaction;
+    constructor(transaction: Transaction);
+    private _query;
+    private _queryUnique;
+    private _queryItem;
+    query<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<Type[]>;
+    queryItem<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Type): Promise<Type | undefined>;
+    queryUnique<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<Type | undefined>;
+    insert<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Type, _id?: string): Promise<Type>;
+    insertAll<Type extends TS_Object>(collection: FirestoreCollection<Type>, instances: Type[], _ids?: string[]): Promise<Awaited<Type>[]>;
+    upsert<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Type, _id?: string): Promise<Type>;
+    upsert_Read<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Type, _id?: string): Promise<() => Promise<Type>>;
+    getOrCreateDocument<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Type, _id?: string): Promise<FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>>;
+    upsertAll<Type extends TS_Object>(collection: FirestoreCollection<Type>, instances: Type[], _ids?: string[]): Promise<Type[]>;
+    upsertAll_Read<Type extends TS_Object>(collection: FirestoreCollection<Type>, instances: Type[], _ids?: string[]): Promise<() => Promise<Type[]>>;
+    patch<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Subset<Type>): Promise<any>;
+    patch_Read<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Subset<Type>): Promise<() => Promise<any>>;
+    delete<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<Type[]>;
+    delete_Read<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<() => Promise<Type[]>>;
+    deleteItem<Type extends TS_Object>(collection: FirestoreCollection<Type>, instance: Type): Promise<Type | undefined>;
+    deleteUnique<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<Type | undefined>;
+    deleteUnique_Read<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<undefined | (() => Promise<Type>)>;
+    newQueryUnique<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<DocWrapper<Type> | undefined>;
+    newQuery<Type extends TS_Object>(collection: FirestoreCollection<Type>, ourQuery: FirestoreQuery<Type>): Promise<DocWrapper<Type>[]>;
+}

package/firestore/FirestoreTransaction.js

@@ -0,0 +1,153 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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 { DocWrapper, } from './FirestoreCollection.js';
+import { BadImplementationException, merge } from '@nu-art/ts-common';
+import { FirestoreInterface } from './FirestoreInterface.js';
+export class FirestoreTransaction {
+    transaction;
+    constructor(transaction) {
+        this.transaction = transaction;
+    }
+    async _query(collection, ourQuery) {
+        const query = FirestoreInterface.buildQuery(collection, ourQuery);
+        return (await this.transaction.get(query)).docs;
+    }
+    async _queryUnique(collection, ourQuery) {
+        const results = await this._query(collection, ourQuery);
+        return FirestoreInterface.assertUniqueDocument(results, ourQuery, collection.name);
+    }
+    async _queryItem(collection, instance) {
+        const ourQuery = FirestoreInterface.buildUniqueQuery(collection, instance);
+        const results = await this._query(collection, ourQuery);
+        return FirestoreInterface.assertUniqueDocument(results, ourQuery, collection.name);
+    }
+    async query(collection, ourQuery) {
+        return (await this._query(collection, ourQuery)).map(result => result.data());
+    }
+    async queryItem(collection, instance) {
+        const ourQuery = FirestoreInterface.buildUniqueQuery(collection, instance);
+        return this.queryUnique(collection, ourQuery);
+    }
+    async queryUnique(collection, ourQuery) {
+        const doc = await this._queryUnique(collection, ourQuery);
+        if (!doc)
+            return;
+        return doc.data();
+    }
+    async insert(collection, instance, _id) {
+        const doc = collection.createDocumentReference(_id);
+        try {
+            await this.transaction.create(doc, instance);
+        }
+        catch (e) {
+            console.error('Failed creating object: ', instance, e);
+            throw e;
+        }
+        return instance;
+    }
+    async insertAll(collection, instances, _ids) {
+        return await Promise.all(instances.map((instance, i) => this.insert(collection, instance, _ids?.[i])));
+    }
+    //------------------------
+    async upsert(collection, instance, _id) {
+        return (await this.upsert_Read(collection, instance, _id))();
+    }
+    async upsert_Read(collection, instance, _id) {
+        const ref = await this.getOrCreateDocument(collection, instance, _id);
+        return async () => {
+            try {
+                await this.transaction.set(ref, instance);
+            }
+            catch (e) {
+                console.error('Failed creating object: ', instance, e);
+                throw e;
+            }
+            return instance;
+        };
+    }
+    async getOrCreateDocument(collection, instance, _id) {
+        let ref = (await this._queryItem(collection, instance))?.ref;
+        if (!ref)
+            ref = collection.createDocumentReference(_id);
+        return ref;
+    }
+    async upsertAll(collection, instances, _ids) {
+        if (instances.length > 500)
+            throw new BadImplementationException('Firestore transaction supports maximum 500 at a time');
+        return (await this.upsertAll_Read(collection, instances, _ids))();
+    }
+    async upsertAll_Read(collection, instances, _ids) {
+        const writes = await Promise.all(instances.map(async (instance, i) => this.upsert_Read(collection, instance, _ids?.[i])));
+        return async () => Promise.all(writes.map(async (_write) => _write()));
+    }
+    async patch(collection, instance) {
+        return (await this.patch_Read(collection, instance))();
+    }
+    async patch_Read(collection, instance) {
+        const doc = await this._queryItem(collection, instance);
+        if (!doc)
+            throw new BadImplementationException(`Patching a non existent doc for query ${FirestoreInterface.buildUniqueQuery(collection, instance)}`);
+        return async () => {
+            const patchedInstance = merge(await doc.data(), instance);
+            this.transaction.set(doc.ref, patchedInstance);
+            return patchedInstance;
+        };
+    }
+    async delete(collection, ourQuery) {
+        return await (await this.delete_Read(collection, ourQuery))();
+    }
+    async delete_Read(collection, ourQuery) {
+        const docs = await this._query(collection, ourQuery);
+        if (docs.length > 500)
+            throw new BadImplementationException(`Trying to delete ${docs.length} documents. Not allowed more then 5oo in a single transaction`);
+        return async () => {
+            const toReturn = docs.map(doc => doc.data());
+            await Promise.all(docs.map(async (doc) => this.transaction.delete(doc.ref)));
+            return toReturn;
+        };
+    }
+    async deleteItem(collection, instance) {
+        return this.deleteUnique(collection, FirestoreInterface.buildUniqueQuery(collection, instance));
+    }
+    async deleteUnique(collection, ourQuery) {
+        const write = await this.deleteUnique_Read(collection, ourQuery);
+        if (!write)
+            return;
+        return write();
+    }
+    async deleteUnique_Read(collection, ourQuery) {
+        const doc = (await this._queryUnique(collection, ourQuery));
+        if (!doc)
+            return;
+        return async () => {
+            const result = doc.data();
+            await this.transaction.delete(doc.ref);
+            return result;
+        };
+    }
+    async newQueryUnique(collection, ourQuery) {
+        const doc = await this._queryUnique(collection, ourQuery);
+        if (!doc || !doc.exists)
+            return;
+        return new DocWrapper(collection.wrapper, doc);
+    }
+    async newQuery(collection, ourQuery) {
+        const docs = await this._query(collection, ourQuery);
+        return docs.filter(doc => doc.exists).map(doc => new DocWrapper(collection.wrapper, doc));
+    }
+}

package/firestore/FirestoreWrapperBE.d.ts

@@ -0,0 +1,16 @@
+import { FirestoreCollection } from './FirestoreCollection.js';
+import { FirestoreType, FirestoreType_Collection } from './types.js';
+import { FilterKeys } from '@nu-art/firebase-shared';
+import { FirebaseSession } from '../auth/firebase-session.js';
+import { FirebaseBaseWrapper } from '../auth/FirebaseBaseWrapper.js';
+import { DB_Object, TS_Object } from '@nu-art/ts-common';
+export declare class FirestoreWrapperBE extends FirebaseBaseWrapper {
+    readonly firestore: FirestoreType;
+    private readonly collections;
+    constructor(firebaseSession: FirebaseSession<any>, dbName?: string);
+    getCollection<Type extends TS_Object>(name: string, uniqueKeys?: FilterKeys<Type>): FirestoreCollection<Type>;
+    listen<Type extends DB_Object>(collection: FirestoreCollection<Type>, doc: string): void;
+    deleteCollection(name: string): Promise<TS_Object[]>;
+    listCollections(): Promise<FirestoreType_Collection[]>;
+    isEmulator(): boolean;
+}

package/firestore/FirestoreWrapperBE.js

@@ -0,0 +1,53 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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 { FirestoreCollection, } from './FirestoreCollection.js';
+import { FirebaseBaseWrapper } from '../auth/FirebaseBaseWrapper.js';
+import { getFirestore } from 'firebase-admin/firestore';
+export class FirestoreWrapperBE extends FirebaseBaseWrapper {
+    firestore;
+    collections = {};
+    constructor(firebaseSession, dbName) {
+        super(firebaseSession);
+        if (dbName)
+            this.firestore = getFirestore(firebaseSession.app, dbName);
+        else
+            this.firestore = getFirestore(firebaseSession.app);
+    }
+    getCollection(name, uniqueKeys) {
+        const collection = this.collections[name];
+        if (collection)
+            return collection;
+        return this.collections[name] = new FirestoreCollection(name, this, uniqueKeys);
+    }
+    listen(collection, doc) {
+        collection.wrapper.firestore.doc(`${collection.name}/${doc}`).onSnapshot(() => {
+            this.logInfo('recieved snapshot!');
+        });
+    }
+    async deleteCollection(name) {
+        return this.getCollection(name).deleteAll();
+    }
+    async listCollections() {
+        if (!this.firestore.listCollections)
+            return [];
+        return this.firestore.listCollections();
+    }
+    isEmulator() {
+        return !!process.env.FIRESTORE_EMULATOR_HOST || false;
+    }
+}

package/firestore/types.d.ts

@@ -0,0 +1,6 @@
+import { CollectionReference, QueryDocumentSnapshot, Query, DocumentReference, Firestore, DocumentData } from 'firebase-admin/firestore';
+export type FirestoreType_Collection = CollectionReference;
+export type FirestoreType_DocumentSnapshot<T = DocumentData> = QueryDocumentSnapshot<T>;
+export type FirestoreType_Query = Query;
+export type FirestoreType_DocumentReference<T> = DocumentReference<T>;
+export type FirestoreType = Firestore;

package/firestore/types.js

@@ -0,0 +1,25 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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.
+ */
+export {};
+// export type FirestoreType_Collection = admin.CollectionReference | firebase.firestore.CollectionReference;
+// export type FirestoreType_DocumentSnapshot = admin.firestore.QueryDocumentSnapshot | firebase.firestore.QueryDocumentSnapshot;
+// export type FirestoreType_Query = (admin.firestore.Query | firebase.firestore.Query) & { select?: (...field: string[]) => FirestoreType_Query };
+// export type FirestoreType_DocumentReference = admin.firestore.DocumentReference | firebase.firestore.DocumentReference;
+// export type FirestoreType = (admin.firestore.Firestore | firebase.firestore.Firestore) & ({ listCollections?: () => Promise<FirestoreType_Collection[]> });
+// export type FirestoreType_Transaction = admin.firestore.Transaction | firebase.firestore.Transaction;
+//