akita-ng-fire/bundles/akita-ng-fire.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/fire/firestore'), require('@datorama/akita'), require('rxjs'), require('rxjs/operators'), require('@angular/router'), require('@angular/fire/auth'), require('firebase/app')) :
    typeof define === 'function' && define.amd ? define('akita-ng-fire', ['exports', '@angular/core', '@angular/fire/firestore', '@datorama/akita', 'rxjs', 'rxjs/operators', '@angular/router', '@angular/fire/auth', 'firebase/app'], factory) :
    (global = global || self, factory(global['akita-ng-fire'] = {}, global.ng.core, global.ng.fire.firestore, global.akita, global.rxjs, global.rxjs.operators, global.ng.router, global.ng.fire.auth, global.firebase));
}(this, (function (exports, core, firestore, akita, rxjs, operators, router, auth, firebase) { 'use strict';

    firebase = firebase && Object.prototype.hasOwnProperty.call(firebase, 'default') ? firebase['default'] : firebase;

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
    /* global Reflect, Promise */
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b)
                if (Object.prototype.hasOwnProperty.call(b, p))
                    d[p] = b[p]; };
        return extendStatics(d, b);
    };
    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }
    var __assign = function () {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s)
                    if (Object.prototype.hasOwnProperty.call(s, p))
                        t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };
    function __rest(s, e) {
        var t = {};
        for (var p in s)
            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
                t[p] = s[p];
        if (s != null && typeof Object.getOwnPropertySymbols === "function")
            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                    t[p[i]] = s[p[i]];
            }
        return t;
    }
    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
            r = Reflect.decorate(decorators, target, key, desc);
        else
            for (var i = decorators.length - 1; i >= 0; i--)
                if (d = decorators[i])
                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }
    function __param(paramIndex, decorator) {
        return function (target, key) { decorator(target, key, paramIndex); };
    }
    function __metadata(metadataKey, metadataValue) {
        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
            return Reflect.metadata(metadataKey, metadataValue);
    }
    function __awaiter(thisArg, _arguments, P, generator) {
        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try {
                step(generator.next(value));
            }
            catch (e) {
                reject(e);
            } }
            function rejected(value) { try {
                step(generator["throw"](value));
            }
            catch (e) {
                reject(e);
            } }
            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    }
    function __generator(thisArg, body) {
        var _ = { label: 0, sent: function () { if (t[0] & 1)
                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f)
                throw new TypeError("Generator is already executing.");
            while (_)
                try {
                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
                        return t;
                    if (y = 0, t)
                        op = [op[0] & 2, t.value];
                    switch (op[0]) {
                        case 0:
                        case 1:
                            t = op;
                            break;
                        case 4:
                            _.label++;
                            return { value: op[1], done: false };
                        case 5:
                            _.label++;
                            y = op[1];
                            op = [0];
                            continue;
                        case 7:
                            op = _.ops.pop();
                            _.trys.pop();
                            continue;
                        default:
                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                                _ = 0;
                                continue;
                            }
                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
                                _.label = op[1];
                                break;
                            }
                            if (op[0] === 6 && _.label < t[1]) {
                                _.label = t[1];
                                t = op;
                                break;
                            }
                            if (t && _.label < t[2]) {
                                _.label = t[2];
                                _.ops.push(op);
                                break;
                            }
                            if (t[2])
                                _.ops.pop();
                            _.trys.pop();
                            continue;
                    }
                    op = body.call(thisArg, _);
                }
                catch (e) {
                    op = [6, e];
                    y = 0;
                }
                finally {
                    f = t = 0;
                }
            if (op[0] & 5)
                throw op[1];
            return { value: op[0] ? op[1] : void 0, done: true };
        }
    }
    var __createBinding = Object.create ? (function (o, m, k, k2) {
        if (k2 === undefined)
            k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
    }) : (function (o, m, k, k2) {
        if (k2 === undefined)
            k2 = k;
        o[k2] = m[k];
    });
    function __exportStar(m, o) {
        for (var p in m)
            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
                __createBinding(o, m, p);
    }
    function __values(o) {
        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
        if (m)
            return m.call(o);
        if (o && typeof o.length === "number")
            return {
                next: function () {
                    if (o && i >= o.length)
                        o = void 0;
                    return { value: o && o[i++], done: !o };
                }
            };
        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
    }
    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m)
            return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
                ar.push(r.value);
        }
        catch (error) {
            e = { error: error };
        }
        finally {
            try {
                if (r && !r.done && (m = i["return"]))
                    m.call(i);
            }
            finally {
                if (e)
                    throw e.error;
            }
        }
        return ar;
    }
    function __spread() {
        for (var ar = [], i = 0; i < arguments.length; i++)
            ar = ar.concat(__read(arguments[i]));
        return ar;
    }
    function __spreadArrays() {
        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
            s += arguments[i].length;
        for (var r = Array(s), k = 0, i = 0; i < il; i++)
            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
                r[k] = a[j];
        return r;
    }
    ;
    function __await(v) {
        return this instanceof __await ? (this.v = v, this) : new __await(v);
    }
    function __asyncGenerator(thisArg, _arguments, generator) {
        if (!Symbol.asyncIterator)
            throw new TypeError("Symbol.asyncIterator is not defined.");
        var g = generator.apply(thisArg, _arguments || []), i, q = [];
        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
        function verb(n) { if (g[n])
            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
        function resume(n, v) { try {
            step(g[n](v));
        }
        catch (e) {
            settle(q[0][3], e);
        } }
        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
        function fulfill(value) { resume("next", value); }
        function reject(value) { resume("throw", value); }
        function settle(f, v) { if (f(v), q.shift(), q.length)
            resume(q[0][0], q[0][1]); }
    }
    function __asyncDelegator(o) {
        var i, p;
        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
    }
    function __asyncValues(o) {
        if (!Symbol.asyncIterator)
            throw new TypeError("Symbol.asyncIterator is not defined.");
        var m = o[Symbol.asyncIterator], i;
        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
    }
    function __makeTemplateObject(cooked, raw) {
        if (Object.defineProperty) {
            Object.defineProperty(cooked, "raw", { value: raw });
        }
        else {
            cooked.raw = raw;
        }
        return cooked;
    }
    ;
    var __setModuleDefault = Object.create ? (function (o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function (o, v) {
        o["default"] = v;
    };
    function __importStar(mod) {
        if (mod && mod.__esModule)
            return mod;
        var result = {};
        if (mod != null)
            for (var k in mod)
                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
                    __createBinding(result, mod, k);
        __setModuleDefault(result, mod);
        return result;
    }
    function __importDefault(mod) {
        return (mod && mod.__esModule) ? mod : { default: mod };
    }
    function __classPrivateFieldGet(receiver, privateMap) {
        if (!privateMap.has(receiver)) {
            throw new TypeError("attempted to get private field on non-instance");
        }
        return privateMap.get(receiver);
    }
    function __classPrivateFieldSet(receiver, privateMap, value) {
        if (!privateMap.has(receiver)) {
            throw new TypeError("attempted to set private field on non-instance");
        }
        privateMap.set(receiver, value);
        return value;
    }

    // Helper to retrieve the id and path of a document in the collection
    function getIdAndPath(options, collectionPath) {
        var path = '';
        var id = '';
        if (options['id']) {
            if (!collectionPath) {
                throw new Error('You should provide the colletion path with the id');
            }
            id = options['id'];
            path = collectionPath + "/" + id;
        }
        else if (options['path']) {
            path = options['path'];
            var part = path.split('/');
            if (part.length % 2 !== 0) {
                throw new Error("Path " + path + " doesn't look like a Firestore's document path");
            }
            id = part[part.length - 1];
        }
        else {
            throw new Error("You should provide either an \"id\" OR a \"path\".");
        }
        return { id: id, path: path };
    }

    /** Set the loading parameter of a specific store */
    function setLoading(storeName, loading) {
        akita.runStoreAction(storeName, akita.StoreAction.Update, function (update) { return update({ loading: loading }); });
    }
    ;
    /** Reset the store to an empty array */
    function resetStore(storeName) {
        akita.runStoreAction(storeName, akita.StoreAction.Update, function (update) { return update([]); });
    }
    ;
    /** Set a entity as active */
    function setActive(storeName, active) {
        akita.runStoreAction(storeName, akita.StoreAction.Update, function (update) { return update({ active: active }); });
    }
    ;
    /** Create or update one or several entities in the store */
    function upsertStoreEntity(storeName, data, id) {
        akita.runEntityStoreAction(storeName, akita.EntityStoreAction.UpsertEntities, function (upsert) { return upsert(id, data); });
    }
    /** Remove one or several entities in the store */
    function removeStoreEntity(storeName, entityIds) {
        akita.runEntityStoreAction(storeName, akita.EntityStoreAction.RemoveEntities, function (remove) { return remove(entityIds); });
    }
    /** Update one or several entities in the store */
    function updateStoreEntity(removeAndAdd, storeName, entityIds, data) {
        if (removeAndAdd) {
            akita.applyTransaction(function () {
                removeStoreEntity(storeName, entityIds);
                upsertStoreEntity(storeName, data, entityIds);
            });
        }
        else {
            akita.runEntityStoreAction(storeName, akita.EntityStoreAction.UpdateEntities, function (update) { return update(entityIds, data); });
        }
    }
    /** Sync a specific store with actions from Firestore */
    function syncStoreFromDocAction(storeName, actions, idKey, removeAndAdd, formatFromFirestore) {
        var e_1, _a, _b;
        if (idKey === void 0) { idKey = 'id'; }
        setLoading(storeName, false);
        if (actions.length === 0) {
            return;
        }
        try {
            for (var actions_1 = __values(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
                var action = actions_1_1.value;
                var id = action.payload.doc.id;
                var entity = formatFromFirestore(action.payload.doc.data());
                switch (action.type) {
                    case 'added': {
                        upsertStoreEntity(storeName, Object.assign((_b = {}, _b[idKey] = id, _b), entity), id);
                        break;
                    }
                    case 'removed': {
                        removeStoreEntity(storeName, id);
                        break;
                    }
                    case 'modified': {
                        updateStoreEntity(removeAndAdd, storeName, id, entity);
                        break;
                    }
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
    }
    /** Sync a specific store with actions from Firestore */
    function syncStoreFromDocActionSnapshot(storeName, action, idKey, formatFromFirestore) {
        var _a;
        if (idKey === void 0) { idKey = 'id'; }
        setLoading(storeName, false);
        var id = action.payload.id;
        var entity = formatFromFirestore(action.payload.data());
        if (!action.payload.exists) {
            removeStoreEntity(storeName, id);
        }
        else {
            upsertStoreEntity(storeName, Object.assign((_a = {}, _a[idKey] = id, _a), entity), id);
        }
    }

    /**
     * Get the store name of a store to be synced
     */
    function getStoreName(store, storeOptions) {
        if (storeOptions === void 0) { storeOptions = {}; }
        if (!store && !storeOptions.storeName) {
            throw new Error('You should either provide a store name or inject a store instance in constructor');
        }
        return storeOptions.storeName || store.storeName;
    }

    /** Get the params from a path */
    function getPathParams(path) {
        return path.split('/')
            .filter(function (segment) { return segment.charAt(0) === ':'; })
            .map(function (segment) { return segment.substr(1); });
    }
    /**
     * Transform a path based on the params
     * @param path The path with params starting with "/:"
     * @param params A map of id params
     * @example pathWithParams('movies/:movieId/stakeholder/:shId', { movieId, shId })
     */
    function pathWithParams(path, params) {
        return path.split('/').map(function (segment) {
            if (segment.charAt(0) === ':') {
                var key = segment.substr(1);
                if (!params[key]) {
                    throw new Error("Required parameter " + key + " from " + path + " doesn't exist in params " + JSON.stringify(params));
                }
                return params[key];
            }
            else {
                return segment;
            }
        }).join('/');
    }

    /**
     * Same as Object.getOwnPropertyDescriptor, but recursively checks prototype chain excluding passed currentClass
     * @param instance Instance to check on
     * @param params Property name to check
     * @param currentClass Checks prototype chain until this class
     * @example getPropertyDescriptor(this, 'path', CollectionService)
     */
    function getPropertyDescriptor(instance, property, currentClass) {
        if (currentClass === void 0) { currentClass = Object; }
        var prototype = Object.getPrototypeOf(instance);
        if (!prototype || !(prototype instanceof currentClass))
            return;
        return Object.getOwnPropertyDescriptor(prototype, property) || getPropertyDescriptor(prototype, property, currentClass);
    }
    /**
     * Check prototype chain for a specific getter function, excluding parent class
     * @param instance Instance of the class to check on
     * @param parentClass Parent class of the instance
     * @param property Property name to check
     * @example hasChildGetter(this, CollectionService, 'path')
     */
    function hasChildGetter(instance, parentClass, property) {
        var descriptor = getPropertyDescriptor(instance, property, parentClass);
        return descriptor && descriptor.get && true;
    }

    function isArray(entityOrArray) {
        return Array.isArray(entityOrArray);
    }
    /** check is an Atomic write is a transaction */
    function isTransaction(write) {
        return write && !!write['get'];
    }
    var CollectionService = /** @class */ (function () {
        function CollectionService(store, collectionPath, db) {
            this.store = store;
            this.collectionPath = collectionPath;
            // keep memory of the current ids to listen to (for syncManyDocs)
            this.idsToListen = {};
            if (!hasChildGetter(this, CollectionService, 'path') && !this.constructor['path'] && !this.collectionPath) {
                throw new Error('You should provide a path to the collection');
            }
            try {
                this.db = db || core.inject(firestore.AngularFirestore);
            }
            catch (err) {
                throw new Error('CollectionService requires AngularFirestore.');
            }
        }
        CollectionService.prototype.getPath = function (options) {
            return (options && options.params)
                ? pathWithParams(this.path, options.params)
                : this.currentPath;
        };
        Object.defineProperty(CollectionService.prototype, "idKey", {
            get: function () {
                return this.constructor['idKey']
                    || this.store ? this.store.idKey : 'id';
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(CollectionService.prototype, "path", {
            /** The path to the collection in Firestore */
            get: function () {
                return this.constructor['path'] || this.collectionPath;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(CollectionService.prototype, "currentPath", {
            /** A snapshot of the path */
            get: function () {
                if (rxjs.isObservable(this.path)) {
                    throw new Error('Cannot get a snapshot of the path if it is an Observable');
                }
                return this.path;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(CollectionService.prototype, "resetOnUpdate", {
            get: function () {
                return this.constructor['resetOnUpdate'] || false;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(CollectionService.prototype, "collection", {
            /**
             * The Angular Fire collection
             * @notice If path is an observable, it becomes an observable.
             */
            get: function () {
                return this.db.collection(this.currentPath);
            },
            enumerable: false,
            configurable: true
        });
        /**
         * Function triggered when adding/updating data to firestore
         * @note should be overridden
         */
        CollectionService.prototype.formatToFirestore = function (entity) {
            return entity;
        };
        /**
         * Function triggered when getting data from firestore
         * @note should be overridden
         */
        CollectionService.prototype.formatFromFirestore = function (entity) {
            return entity;
        };
        CollectionService.prototype.syncCollection = function (pathOrQuery, queryOrOptions, syncOptions) {
            var _this = this;
            if (pathOrQuery === void 0) { pathOrQuery = this.currentPath; }
            if (syncOptions === void 0) { syncOptions = { loading: true }; }
            var path;
            var queryFn;
            // check type of pathOrQuery
            if (typeof pathOrQuery === 'function') {
                queryFn = pathOrQuery;
                path = this.getPath(queryOrOptions);
            }
            else if (typeof pathOrQuery === 'object') {
                syncOptions = pathOrQuery;
                path = this.getPath(syncOptions);
            }
            else if (typeof pathOrQuery === 'string') {
                path = pathOrQuery;
            }
            else {
                path = this.getPath(syncOptions);
            }
            // check type of queryOrOptions
            if (typeof queryOrOptions === 'function') {
                queryFn = queryOrOptions;
            }
            else if (typeof queryOrOptions === 'object') {
                syncOptions = queryOrOptions;
            }
            var storeName = getStoreName(this.store, syncOptions);
            // reset has to happen before setLoading, otherwise it will also reset the loading state
            if (syncOptions.reset) {
                resetStore(storeName);
            }
            if (syncOptions.loading) {
                setLoading(storeName, true);
            }
            // Start Listening
            return this.db.collection(path, queryFn).stateChanges().pipe(akita.withTransaction(function (actions) { return syncStoreFromDocAction(storeName, actions, _this.idKey, _this.resetOnUpdate, function (entity) { return _this.formatFromFirestore(entity); }); }));
        };
        CollectionService.prototype.syncCollectionGroup = function (idOrQuery, queryOrOption, syncOptions) {
            var _this = this;
            if (idOrQuery === void 0) { idOrQuery = this.currentPath; }
            if (syncOptions === void 0) { syncOptions = { loading: true }; }
            var path;
            var query;
            if (typeof idOrQuery === 'string') {
                path = idOrQuery;
            }
            else if (typeof idOrQuery === 'function') {
                path = this.currentPath;
                query = idOrQuery;
            }
            else if (typeof idOrQuery === 'object') {
                path = this.currentPath;
                syncOptions = idOrQuery;
            }
            else {
                throw new Error('1ier parameter if either a string, a queryFn or a StoreOption');
            }
            if (typeof queryOrOption === 'function') {
                query = queryOrOption;
            }
            else if (typeof queryOrOption === 'object') {
                syncOptions = queryOrOption;
            }
            var storeName = getStoreName(this.store, syncOptions);
            // reset has to happen before setLoading, otherwise it will also reset the loading state
            if (syncOptions.reset) {
                resetStore(storeName);
            }
            if (syncOptions.loading) {
                setLoading(storeName, true);
            }
            var collectionId = path.split('/').pop();
            return this.db.collectionGroup(collectionId, query).stateChanges().pipe(akita.withTransaction(function (actions) { return syncStoreFromDocAction(storeName, actions, _this.idKey, _this.resetOnUpdate, function (entity) { return _this.formatFromFirestore(entity); }); }));
        };
        CollectionService.prototype.syncManyDocs = function (ids$, syncOptions) {
            var _this = this;
            if (syncOptions === void 0) { syncOptions = { loading: true }; }
            if (!rxjs.isObservable(ids$)) {
                ids$ = rxjs.of(ids$);
            }
            var storeName = getStoreName(this.store, syncOptions);
            // reset has to happen before setLoading, otherwise it will also reset the loading state
            if (syncOptions.reset) {
                resetStore(storeName);
            }
            if (syncOptions.loading) {
                setLoading(storeName, true);
            }
            return ids$.pipe(operators.switchMap((function (ids) {
                // Remove previous ids that have changed
                var previousIds = _this.idsToListen[storeName];
                if (previousIds) {
                    var idsToRemove = previousIds.filter(function (id) { return !ids.includes(id); });
                    removeStoreEntity(storeName, idsToRemove);
                }
                _this.idsToListen[storeName] = ids;
                // Return empty array if no ids are provided
                if (!ids.length) {
                    return rxjs.of([]);
                }
                // Sync all docs
                var syncs = ids.map(function (id) {
                    var path = _this.getPath(syncOptions) + "/" + id;
                    return _this.db.doc(path).snapshotChanges();
                });
                return rxjs.combineLatest(syncs).pipe(operators.tap(function (actions) { return actions.map(function (action) {
                    syncStoreFromDocActionSnapshot(storeName, action, _this.idKey, function (entity) { return _this.formatFromFirestore(entity); });
                }); }));
            })));
        };
        /**
         * Stay in sync with one document
         * @param docOptions An object with EITHER `id` OR `path`.
         * @note We need to use id and path because there is no way to differentiate them.
         * @param syncOptions Options on the store to sync to
         */
        CollectionService.prototype.syncDoc = function (docOptions, syncOptions) {
            var _this = this;
            if (syncOptions === void 0) { syncOptions = { loading: false }; }
            var storeName = getStoreName(this.store, syncOptions);
            var collectionPath = this.getPath(syncOptions);
            var _a = getIdAndPath(docOptions, collectionPath), id = _a.id, path = _a.path;
            // reset has to happen before setLoading, otherwise it will also reset the loading state
            if (syncOptions.reset) {
                resetStore(storeName);
            }
            if (syncOptions.loading) {
                setLoading(storeName, true);
            }
            return this.db.doc(path).valueChanges().pipe(operators.map(function (entity) {
                var _a;
                if (!entity) {
                    setLoading(storeName, false);
                    // note: We don't removeEntity as it would result in weird behavior
                    return undefined;
                }
                var data = _this.formatFromFirestore(Object.assign((_a = {}, _a[_this.idKey] = id, _a), entity));
                upsertStoreEntity(storeName, data, id);
                setLoading(storeName, false);
                return data;
            }));
        };
        CollectionService.prototype.syncActive = function (options, syncOptions) {
            var _this = this;
            var storeName = getStoreName(this.store, syncOptions);
            if (Array.isArray(options)) {
                return this.syncManyDocs(options, syncOptions).pipe(operators.tap(function (_) { return setActive(storeName, options); }));
            }
            else {
                return this.syncDoc(options, syncOptions).pipe(operators.tap(function (entity) { return entity ? setActive(storeName, entity[_this.idKey]) : null; }));
            }
        };
        CollectionService.prototype.getRef = function (idOrQuery, options) {
            var _this = this;
            if (options === void 0) { options = {}; }
            var path = this.getPath(options);
            // If path targets a collection ( odd number of segments after the split )
            if (typeof idOrQuery === 'string') {
                return this.db.doc(path + "/" + idOrQuery).ref;
            }
            if (Array.isArray(idOrQuery)) {
                return idOrQuery.map(function (id) { return _this.db.doc(path + "/" + id).ref; });
            }
            else if (typeof idOrQuery === 'object') {
                var subpath = this.getPath(idOrQuery);
                return this.db.collection(subpath).ref;
            }
            else {
                return this.db.collection(path, idOrQuery).ref;
            }
        };
        CollectionService.prototype.getValue = function (idOrQuery, options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var path, snapshot, docs, ref, snaphot, subpath, snapshot, snapshot;
                var _a;
                var _this = this;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            path = this.getPath(options);
                            if (!(typeof idOrQuery === 'string')) return [3 /*break*/, 2];
                            return [4 /*yield*/, this.db.doc(path + "/" + idOrQuery).ref.get()];
                        case 1:
                            snapshot = _b.sent();
                            return [2 /*return*/, snapshot.exists
                                    ? this.formatFromFirestore(Object.assign(Object.assign({}, snapshot.data()), (_a = {}, _a[this.idKey] = snapshot.id, _a)))
                                    : null];
                        case 2:
                            if (!Array.isArray(idOrQuery)) return [3 /*break*/, 4];
                            return [4 /*yield*/, Promise.all(idOrQuery.map(function (id) {
                                    return _this.db.doc(path + "/" + id).ref.get();
                                }))];
                        case 3:
                            docs = _b.sent();
                            return [3 /*break*/, 10];
                        case 4:
                            if (!(typeof idOrQuery === 'function')) return [3 /*break*/, 6];
                            ref = this.db.collection(path).ref;
                            return [4 /*yield*/, idOrQuery(ref).get()];
                        case 5:
                            snaphot = _b.sent();
                            docs = snaphot.docs;
                            return [3 /*break*/, 10];
                        case 6:
                            if (!(typeof idOrQuery === 'object')) return [3 /*break*/, 8];
                            subpath = this.getPath(idOrQuery);
                            return [4 /*yield*/, this.db.collection(subpath).ref.get()];
                        case 7:
                            snapshot = _b.sent();
                            docs = snapshot.docs;
                            return [3 /*break*/, 10];
                        case 8: return [4 /*yield*/, this.db.collection(path, idOrQuery).ref.get()];
                        case 9:
                            snapshot = _b.sent();
                            docs = snapshot.docs;
                            _b.label = 10;
                        case 10: return [2 /*return*/, docs.filter(function (doc) { return doc.exists; })
                                .map(function (doc) {
                                var _a;
                                return Object.assign(Object.assign({}, doc.data()), (_a = {}, _a[_this.idKey] = doc.id, _a));
                            })
                                .map(function (doc) { return _this.formatFromFirestore(doc); })];
                    }
                });
            });
        };
        CollectionService.prototype.valueChanges = function (idOrQuery, options) {
            var _this = this;
            if (options === void 0) { options = {}; }
            var path = this.getPath(options);
            // If path targets a collection ( odd number of segments after the split )
            if (typeof idOrQuery === 'string') {
                return this.db.doc(path + "/" + idOrQuery).valueChanges().pipe(operators.map(function (doc) { return _this.formatFromFirestore(doc); }));
            }
            var docs$;
            if (Array.isArray(idOrQuery)) {
                docs$ = idOrQuery.length
                    ? rxjs.combineLatest(idOrQuery.map(function (id) { return _this.db.doc(path + "/" + id).valueChanges(); }))
                    : rxjs.of([]);
            }
            else if (typeof idOrQuery === 'function') {
                docs$ = this.db.collection(path, idOrQuery).valueChanges();
            }
            else if (typeof idOrQuery === 'object') {
                var subpath = this.getPath(idOrQuery);
                docs$ = this.db.collection(subpath).valueChanges();
            }
            else {
                docs$ = this.db.collection(path, idOrQuery).valueChanges();
            }
            return docs$.pipe(operators.map(function (docs) { return docs.map(function (doc) { return _this.formatFromFirestore(doc); }); }));
        };
        ///////////
        // WRITE //
        ///////////
        /**
         * Create a batch object.
         * @note alias for `angularFirestore.firestore.batch()`
         */
        CollectionService.prototype.batch = function () {
            return this.db.firestore.batch();
        };
        /**
         * Run a transaction
         * @note alias for `angularFirestore.firestore.runTransaction()`
         */
        CollectionService.prototype.runTransaction = function (cb) {
            return this.db.firestore.runTransaction(function (tx) { return cb(tx); });
        };
        /**
         * Create or update documents
         * @param documents One or many documents
         * @param options options to write the document on firestore
         */
        CollectionService.prototype.upsert = function (documents, options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var doesExist, toAdd, toUpdate, documents_1, documents_1_1, doc, e_1_1;
                var e_1, _a;
                var _this = this;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            doesExist = function (doc) { return __awaiter(_this, void 0, void 0, function () {
                                var ref, exists;
                                return __generator(this, function (_a) {
                                    switch (_a.label) {
                                        case 0:
                                            ref = this.getRef(doc[this.idKey]);
                                            return [4 /*yield*/, (isTransaction(options.write) ? options.write.get(ref) : ref.get())];
                                        case 1:
                                            exists = (_a.sent()).exists;
                                            return [2 /*return*/, exists];
                                    }
                                });
                            }); };
                            if (!!isArray(documents)) return [3 /*break*/, 2];
                            return [4 /*yield*/, doesExist(documents)];
                        case 1: return [2 /*return*/, (_b.sent())
                                ? this.update(documents, options).then(function (_) { return documents[_this.idKey]; })
                                : this.add(documents, options)];
                        case 2:
                            toAdd = [];
                            toUpdate = [];
                            _b.label = 3;
                        case 3:
                            _b.trys.push([3, 8, 9, 10]);
                            documents_1 = __values(documents), documents_1_1 = documents_1.next();
                            _b.label = 4;
                        case 4:
                            if (!!documents_1_1.done) return [3 /*break*/, 7];
                            doc = documents_1_1.value;
                            return [4 /*yield*/, doesExist(doc)];
                        case 5:
                            (_b.sent())
                                ? toUpdate.push(doc)
                                : toAdd.push(doc);
                            _b.label = 6;
                        case 6:
                            documents_1_1 = documents_1.next();
                            return [3 /*break*/, 4];
                        case 7: return [3 /*break*/, 10];
                        case 8:
                            e_1_1 = _b.sent();
                            e_1 = { error: e_1_1 };
                            return [3 /*break*/, 10];
                        case 9:
                            try {
                                if (documents_1_1 && !documents_1_1.done && (_a = documents_1.return)) _a.call(documents_1);
                            }
                            finally { if (e_1) throw e_1.error; }
                            return [7 /*endfinally*/];
                        case 10: return [2 /*return*/, Promise.all([
                                this.add(toAdd, options),
                                this.update(toUpdate, options).then(function (_) { return toUpdate.map(function (doc) { return doc[_this.idKey]; }); })
                            ]).then(function (_a) {
                                var _b = __read(_a, 2), added = _b[0], updated = _b[1];
                                return added.concat(updated);
                            })];
                    }
                });
            });
        };
        /**
         * Add a document or a list of document to Firestore
         * @param docs A document or a list of document
         * @param options options to write the document on firestore
         */
        CollectionService.prototype.add = function (documents, options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var docs, _a, write, ctx, path, operations, ids;
                var _this = this;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            docs = (Array.isArray(documents) ? documents : [documents]);
                            _a = options.write, write = _a === void 0 ? this.batch() : _a, ctx = options.ctx;
                            path = this.getPath(options);
                            operations = docs.map(function (doc) { return __awaiter(_this, void 0, void 0, function () {
                                var id, data, ref;
                                var _a;
                                return __generator(this, function (_b) {
                                    switch (_b.label) {
                                        case 0:
                                            id = doc[this.idKey] || this.db.createId();
                                            data = this.formatToFirestore(Object.assign(Object.assign({}, doc), (_a = {}, _a[this.idKey] = id, _a)));
                                            ref = this.db.doc(path + "/" + id).ref;
                                            write.set(ref, (data));
                                            if (!this.onCreate) return [3 /*break*/, 2];
                                            return [4 /*yield*/, this.onCreate(data, { write: write, ctx: ctx })];
                                        case 1:
                                            _b.sent();
                                            _b.label = 2;
                                        case 2: return [2 /*return*/, id];
                                    }
                                });
                            }); });
                            return [4 /*yield*/, Promise.all(operations)];
                        case 1:
                            ids = _b.sent();
                            if (!!options.write) return [3 /*break*/, 3];
                            return [4 /*yield*/, write.commit()];
                        case 2:
                            _b.sent();
                            _b.label = 3;
                        case 3: return [2 /*return*/, Array.isArray(documents) ? ids : ids[0]];
                    }
                });
            });
        };
        /**
         * Remove one or several document from Firestore
         * @param id A unique or list of id representing the document
         * @param options options to write the document on firestore
         */
        CollectionService.prototype.remove = function (id, options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var _a, write, ctx, path, ids, operations;
                var _this = this;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            _a = options.write, write = _a === void 0 ? this.batch() : _a, ctx = options.ctx;
                            path = this.getPath(options);
                            ids = Array.isArray(id) ? id : [id];
                            operations = ids.map(function (docId) { return __awaiter(_this, void 0, void 0, function () {
                                var ref;
                                return __generator(this, function (_a) {
                                    switch (_a.label) {
                                        case 0:
                                            ref = this.db.doc(path + "/" + docId).ref;
                                            write.delete(ref);
                                            if (!this.onDelete) return [3 /*break*/, 2];
                                            return [4 /*yield*/, this.onDelete(docId, { write: write, ctx: ctx })];
                                        case 1:
                                            _a.sent();
                                            _a.label = 2;
                                        case 2: return [2 /*return*/];
                                    }
                                });
                            }); });
                            return [4 /*yield*/, Promise.all(operations)];
                        case 1:
                            _b.sent();
                            // If there is no atomic write provided
                            if (!options.write) {
                                return [2 /*return*/, write.commit()];
                            }
                            return [2 /*return*/];
                    }
                });
            });
        };
        /** Remove all document of the collection */
        CollectionService.prototype.removeAll = function (options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var path, snapshot, ids;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            path = this.getPath(options);
                            return [4 /*yield*/, this.db.collection(path).ref.get()];
                        case 1:
                            snapshot = _a.sent();
                            ids = snapshot.docs.map(function (doc) { return doc.id; });
                            return [2 /*return*/, this.remove(ids, options)];
                    }
                });
            });
        };
        CollectionService.prototype.update = function (idsOrEntity, stateFnOrWrite, options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var ids, stateFunction, getData, isEntity, isEntityArray, entityMap_1, ctx, path, _a, write_1, operations;
                var _this = this;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            ids = [];
                            isEntity = function (value) {
                                return typeof value === 'object' && value[_this.idKey];
                            };
                            isEntityArray = function (values) {
                                return Array.isArray(values) && values.every(function (value) { return isEntity(value); });
                            };
                            if (isEntity(idsOrEntity)) {
                                ids = [idsOrEntity[this.idKey]];
                                getData = function () { return idsOrEntity; };
                                options = stateFnOrWrite || {};
                            }
                            else if (isEntityArray(idsOrEntity)) {
                                entityMap_1 = new Map(idsOrEntity.map(function (entity) { return [entity[_this.idKey], entity]; }));
                                ids = Array.from(entityMap_1.keys());
                                getData = function (docId) { return entityMap_1.get(docId); };
                                options = stateFnOrWrite || {};
                            }
                            else if (typeof stateFnOrWrite === 'function') {
                                ids = Array.isArray(idsOrEntity) ? idsOrEntity : [idsOrEntity];
                                stateFunction = stateFnOrWrite;
                            }
                            else if (typeof stateFnOrWrite === 'object') {
                                ids = Array.isArray(idsOrEntity) ? idsOrEntity : [idsOrEntity];
                                getData = function () { return stateFnOrWrite; };
                            }
                            else {
                                throw new Error('Passed parameters match none of the function signatures.');
                            }
                            ctx = options.ctx;
                            path = this.getPath(options);
                            if (!Array.isArray(ids) || !ids.length) {
                                return [2 /*return*/];
                            }
                            if (!stateFunction) return [3 /*break*/, 1];
                            return [2 /*return*/, this.db.firestore.runTransaction(function (tx) { return __awaiter(_this, void 0, void 0, function () {
                                    var operations;
                                    var _this = this;
                                    return __generator(this, function (_a) {
                                        operations = ids.map(function (id) { return __awaiter(_this, void 0, void 0, function () {
                                            var ref, snapshot, doc, data;
                                            var _a;
                                            return __generator(this, function (_b) {
                                                switch (_b.label) {
                                                    case 0:
                                                        ref = this.db.doc(path + "/" + id).ref;
                                                        return [4 /*yield*/, tx.get(ref)];
                                                    case 1:
                                                        snapshot = _b.sent();
                                                        doc = Object.freeze(Object.assign(Object.assign({}, snapshot.data()), (_a = {}, _a[this.idKey] = id, _a)));
                                                        data = stateFunction(doc, tx);
                                                        tx.update(ref, this.formatToFirestore(data));
                                                        if (!this.onUpdate) return [3 /*break*/, 3];
                                                        return [4 /*yield*/, this.onUpdate(data, { write: tx, ctx: ctx })];
                                                    case 2:
                                                        _b.sent();
                                                        _b.label = 3;
                                                    case 3: return [2 /*return*/, tx];
                                                }
                                            });
                                        }); });
                                        return [2 /*return*/, Promise.all(operations)];
                                    });
                                }); })];
                        case 1:
                            _a = options.write, write_1 = _a === void 0 ? this.batch() : _a;
                            operations = ids.map(function (docId) { return __awaiter(_this, void 0, void 0, function () {
                                var doc, ref;
                                return __generator(this, function (_a) {
                                    switch (_a.label) {
                                        case 0:
                                            doc = Object.freeze(getData(docId));
                                            if (!docId) {
                                                throw new Error("Document should have an unique id to be updated, but none was found in " + doc);
                                            }
                                            ref = this.db.doc(path + "/" + docId).ref;
                                            write_1.update(ref, this.formatToFirestore(doc));
                                            if (!this.onUpdate) return [3 /*break*/, 2];
                                            return [4 /*yield*/, this.onUpdate(doc, { write: write_1, ctx: ctx })];
                                        case 1:
                                            _a.sent();
                                            _a.label = 2;
                                        case 2: return [2 /*return*/];
                                    }
                                });
                            }); });
                            return [4 /*yield*/, Promise.all(operations)];
                        case 2:
                            _b.sent();
                            // If there is no atomic write provided
                            if (!options.write) {
                                return [2 /*return*/, write_1.commit()];
                            }
                            return [2 /*return*/];
                    }
                });
            });
        };
        return CollectionService;
    }());

    /** Set the configuration for the collection service */
    function CollectionConfig(options) {
        if (options === void 0) { options = {}; }
        return function (constructor) {
            Object.keys(options).forEach(function (key) { return constructor[key] = options[key]; });
        };
    }

    var initialAuthState = {
        uid: null,
        emailVerified: undefined,
        profile: null,
        loading: false
    };

    var authProviders = ['github', 'google', 'microsoft', 'facebook', 'twitter', 'email', 'apple'];
    /** Verify if provider is part of the list of Authentication provider provided by Firebase Auth */
    function isFireAuthProvider(provider) {
        return typeof provider === 'string' && authProviders.includes(provider);
    }
    /**
     * Get the custom claims of a user. If no key is provided, return the whole claims object
     * @param user The user object returned by Firebase Auth
     * @param roles Keys of the custom claims inside the claim objet
     */
    function getCustomClaims(user, roles) {
        return __awaiter(this, void 0, void 0, function () {
            var claims, keys;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, user.getIdTokenResult()];
                    case 1:
                        claims = (_a.sent()).claims;
                        if (!roles) {
                            return [2 /*return*/, claims];
                        }
                        keys = Array.isArray(roles) ? roles : [roles];
                        return [2 /*return*/, Object.keys(claims)
                                .filter(function (key) { return keys.includes(key); })
                                .reduce(function (acc, key) {
                                acc[key] = claims[key];
                                return acc;
                            }, {})];
                }
            });
        });
    }
    /**
     * Get the Authentication Provider based on its name
     * @param provider string literal representing the name of the provider
     */
    function getAuthProvider(provider) {
        switch (provider) {
            case 'email': return new firebase.auth.EmailAuthProvider();
            case 'facebook': return new firebase.auth.FacebookAuthProvider();
            case 'github': return new firebase.auth.GithubAuthProvider();
            case 'google': return new firebase.auth.GoogleAuthProvider();
            case 'microsoft': return new firebase.auth.OAuthProvider('microsoft.com');
            case 'twitter': return new firebase.auth.TwitterAuthProvider();
            case 'apple': return new firebase.auth.OAuthProvider('apple');
        }
    }
    var FireAuthService = /** @class */ (function () {
        function FireAuthService(store, db, auth$1) {
            this.store = store;
            this.collectionPath = 'users';
            this.db = db || core.inject(firestore.AngularFirestore);
            this.auth = auth$1 || core.inject(auth.AngularFireAuth);
            this.collection = this.db.collection(this.path);
        }
        /**
         * Select the profile in the Firestore
         * @note can be override to point to a different place
         */
        FireAuthService.prototype.selectProfile = function (user) {
            return this.collection.doc(user.uid).valueChanges();
        };
        /**
         * Select the roles for this user. Can be in custom claims or in a Firestore collection
         * @param user The user given by FireAuth
         * @see getCustomClaims to get the custom claims out of the user
         * @note Can be overwritten
         */
        FireAuthService.prototype.selectRoles = function (user) {
            return rxjs.of(null);
        };
        /**
         * Function triggered when getting data from firestore
         * @note should be overwritten
         */
        FireAuthService.prototype.formatFromFirestore = function (user) {
            return user;
        };
        /**
         * Function triggered when adding/updating data to firestore
         * @note should be overwritten
         */
        FireAuthService.prototype.formatToFirestore = function (user) {
            return user;
        };
        /**
         * Function triggered when transforming a user into a profile
         * @param user The user object from FireAuth
         * @param ctx The context given on signup
         * @note Should be override
         */
        FireAuthService.prototype.createProfile = function (user, ctx) {
            return {
                photoURL: user.photoURL,
                displayName: user.displayName,
            };
        };
        Object.defineProperty(FireAuthService.prototype, "user", {
            /**
             * The current sign-in user (or null)
             * @returns a Promise in v6.*.* & a snapshot in v5.*.*
             */
            get: function () {
                return this.auth.currentUser;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(FireAuthService.prototype, "idKey", {
            get: function () {
                return this.constructor['idKey'] || 'id';
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(FireAuthService.prototype, "path", {
            /** The path to the profile in firestore */
            get: function () {
                return this.constructor['path'] || this.collectionPath;
            },
            enumerable: false,
            configurable: true
        });
        /** Start listening on User */
        FireAuthService.prototype.sync = function () {
            var _this = this;
            return this.auth.authState.pipe(operators.switchMap(function (user) { return user ? rxjs.combineLatest([
                rxjs.of(user),
                _this.selectProfile(user),
                _this.selectRoles(user),
            ]) : rxjs.of([undefined, undefined, undefined]); }), operators.tap(function (_a) {
                var _b = __read(_a, 3), _c = _b[0], user = _c === void 0 ? {} : _c, userProfile = _b[1], roles = _b[2];
                var profile = _this.formatFromFirestore(userProfile);
                var uid = user.uid, emailVerified = user.emailVerified;
                _this.store.update({ uid: uid, emailVerified: emailVerified, profile: profile, roles: roles });
            }), operators.map(function (_a) {
                var _b = __read(_a, 3), user = _b[0], userProfile = _b[1], roles = _b[2];
                return user ? [user, _this.formatFromFirestore(userProfile), roles] : null;
            }));
        };
        /**
         * @description Delete user from authentication service and database
         * WARNING This is security sensitive operation
         */
        FireAuthService.prototype.delete = function (options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var user, _a, write, ctx, ref;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0: return [4 /*yield*/, this.user];
                        case 1:
                            user = _b.sent();
                            if (!user) {
                                throw new Error('No user connected');
                            }
                            _a = options.write, write = _a === void 0 ? this.db.firestore.batch() : _a, ctx = options.ctx;
                            ref = this.collection.doc(user.uid).ref;
                            write.delete(ref);
                            if (!this.onDelete) return [3 /*break*/, 3];
                            return [4 /*yield*/, this.onDelete({ write: write, ctx: ctx })];
                        case 2:
                            _b.sent();
                            _b.label = 3;
                        case 3:
                            if (!!options.write) return [3 /*break*/, 5];
                            return [4 /*yield*/, write.commit()];
                        case 4:
                            _b.sent();
                            _b.label = 5;
                        case 5: return [2 /*return*/, user.delete()];
                    }
                });
            });
        };
        /** Update the current profile of the authenticated user */
        FireAuthService.prototype.update = function (profile, options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var user, ref, _a, write, ctx;
                var _this = this;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0: return [4 /*yield*/, this.user];
                        case 1:
                            user = _b.sent();
                            if (!user.uid) {
                                throw new Error('No user connected.');
                            }
                            ref = this.collection.doc(user.uid).ref;
                            if (!(typeof profile === 'function')) return [3 /*break*/, 2];
                            return [2 /*return*/, this.db.firestore.runTransaction(function (tx) { return __awaiter(_this, void 0, void 0, function () {
                                    var snapshot, doc, data;
                                    var _a;
                                    return __generator(this, function (_b) {
                                        switch (_b.label) {
                                            case 0: return [4 /*yield*/, tx.get(ref)];
                                            case 1:
                                                snapshot = _b.sent();
                                                doc = Object.freeze(Object.assign(Object.assign({}, snapshot.data()), (_a = {}, _a[this.idKey] = snapshot.id, _a)));
                                                data = profile(this.formatToFirestore(doc), tx);
                                                tx.update(ref, data);
                                                if (!this.onUpdate) return [3 /*break*/, 3];
                                                return [4 /*yield*/, this.onUpdate(data, { write: tx, ctx: options.ctx })];
                                            case 2:
                                                _b.sent();
                                                _b.label = 3;
                                            case 3: return [2 /*return*/, tx];
                                        }
                                    });
                                }); })];
                        case 2:
                            if (!(typeof profile === 'object')) return [3 /*break*/, 5];
                            _a = options.write, write = _a === void 0 ? this.db.firestore.batch() : _a, ctx = options.ctx;
                            write.update(ref, this.formatToFirestore(profile));
                            if (!this.onUpdate) return [3 /*break*/, 4];
                            return [4 /*yield*/, this.onUpdate(profile, { write: write, ctx: ctx })];
                        case 3:
                            _b.sent();
                            _b.label = 4;
                        case 4:
                            // If there is no atomic write provided
                            if (!options.write) {
                                return [2 /*return*/, write.commit()];
                            }
                            _b.label = 5;
                        case 5: return [2 /*return*/];
                    }
                });
            });
        };
        /** Create a user based on email and password */
        FireAuthService.prototype.signup = function (email, password, options) {
            if (options === void 0) { options = {}; }
            return __awaiter(this, void 0, void 0, function () {
                var cred, _a, write, ctx, profile, ref;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0: return [4 /*yield*/, this.auth.createUserWithEmailAndPassword(email, password)];
                        case 1:
                            cred = _b.sent();
                            _a = options.write, write = _a === void 0 ? this.db.firestore.batch() : _a, ctx = options.ctx;
                            if (!this.onSignup) return [3 /*break*/, 3];
                            return [4 /*yield*/, this.onSignup(cred, { write: write, ctx: ctx })];
                        case 2:
                            _b.sent();
                            _b.label = 3;
                        case 3: return [4 /*yield*/, this.createProfile(cred.user, ctx)];
                        case 4:
                            profile = _b.sent();
                            ref = this.collection.doc(cred.user.uid).ref;
                            write.set(ref, this.formatToFirestore(profile));
                            if (!this.onCreate) return [3 /*break*/, 6];
                            return [4 /*yield*/, this.onCreate(profile, { write: write, ctx: ctx })];
                        case 5:
                            _b.sent();
                            _b.label = 6;
                        case 6:
                            if (!!options.write) return [3 /*break*/, 8];
                            return [4 /*yield*/, write.commit()];
                        case 7:
                            _b.sent();
                            _b.label = 8;
                        case 8: return [2 /*return*/, cred];
                    }
                });
            });
        };
        FireAuthService.prototype.signin = function (provider, passwordOrOptions) {
            return __awaiter(this, void 0, void 0, function () {
                var profile, cred, write, authProvider, ref, collection, document, _a, uid, emailVerified, error_1, err_1;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            this.store.setLoading(true);
                            _b.label = 1;
                        case 1:
                            _b.trys.push([1, 29, , 30]);
                            cred = void 0;
                            write = this.db.firestore.batch();
                            if (!!provider) return [3 /*break*/, 3];
                            return [4 /*yield*/, this.auth.signInAnonymously()];
                        case 2:
                            cred = _b.sent();
                            return [3 /*break*/, 11];
                        case 3:
                            if (!(passwordOrOptions && typeof provider === 'string' && typeof passwordOrOptions === 'string')) return [3 /*break*/, 5];
                            return [4 /*yield*/, this.auth.signInWithEmailAndPassword(provider, passwordOrOptions)];
                        case 4:
                            cred = _b.sent();
                            return [3 /*break*/, 11];
                        case 5:
                            if (!(typeof provider === 'object')) return [3 /*break*/, 7];
                            return [4 /*yield*/, this.auth.signInWithPopup(provider)];
                        case 6:
                            cred = _b.sent();
                            return [3 /*break*/, 11];
                        case 7:
                            if (!isFireAuthProvider(provider)) return [3 /*break*/, 9];
                            authProvider = getAuthProvider(provider);
                            return [4 /*yield*/, this.auth.signInWithPopup(authProvider)];
                        case 8:
                            cred = _b.sent();
                            return [3 /*break*/, 11];
                        case 9: return [4 /*yield*/, this.auth.signInWithCustomToken(provider)];
                        case 10:
                            cred = _b.sent();
                            _b.label = 11;
                        case 11:
                            if (!cred.additionalUserInfo.isNewUser) return [3 /*break*/, 20];
                            if (!this.onSignup) return [3 /*break*/, 13];
                            return [4 /*yield*/, this.onSignup(cred, {})];
                        case 12:
                            _b.sent();
                            _b.label = 13;
                        case 13: return [4 /*yield*/, this.createProfile(cred.user)];
                        case 14:
                            profile = _b.sent();
                            this.store.update({ profile: profile });
                            ref = this.collection.doc(cred.user.uid).ref;
                            write.set(ref, this.formatToFirestore(profile));
                            if (!this.onCreate) return [3 /*break*/, 18];
                            if (!(typeof passwordOrOptions === 'object')) return [3 /*break*/, 16];
                            return [4 /*yield*/, this.onCreate(profile, { write: write, ctx: passwordOrOptions.ctx })];
                        case 15:
                            _b.sent();
                            return [3 /*break*/, 18];
                        case 16: return [4 /*yield*/, this.onCreate(profile, { write: write, ctx: {} })];
                        case 17:
                            _b.sent();
                            _b.label = 18;
                        case 18: return [4 /*yield*/, write.commit()];
                        case 19:
                            _b.sent();
                            return [3 /*break*/, 26];
                        case 20:
                            _b.trys.push([20, 25, , 26]);
                            collection = this.collection.doc(cred.user.uid);
                            return [4 /*yield*/, collection.get().toPromise()];
                        case 21:
                            document = _b.sent();
                            _a = cred.user, uid = _a.uid, emailVerified = _a.emailVerified;
                            if (!document.exists) return [3 /*break*/, 22];
                            profile = this.formatFromFirestore(document.data());
                            return [3 /*break*/, 24];
                        case 22: return [4 /*yield*/, this.createProfile(cred.user)];
                        case 23:
                            profile = _b.sent();
                            write.set(collection.ref, this.formatToFirestore(profile));
                            write.commit();
                            _b.label = 24;
                        case 24:
                            this.store.update({ profile: profile, uid: uid, emailVerified: emailVerified });
                            return [3 /*break*/, 26];
                        case 25:
                            error_1 = _b.sent();
                            console.error(error_1);
                            return [3 /*break*/, 26];
                        case 26:
                            if (!this.onSignin) return [3 /*break*/, 28];
                            return [4 /*yield*/, this.onSignin(cred)];
                        case 27:
                            _b.sent();
                            _b.label = 28;
                        case 28:
                            this.store.setLoading(false);
                            return [2 /*return*/, cred];
                        case 29:
                            err_1 = _b.sent();
                            this.store.setLoading(false);
                            if (err_1.code === 'auth/operation-not-allowed') {
                                console.warn('You tried to connect with a disabled auth provider. Enable it in Firebase console');
                            }
                            throw err_1;
                        case 30: return [2 /*return*/];
                    }
                });
            });
        };
        /** Signs out the current user and clear the store */
        FireAuthService.prototype.signOut = function () {
            return __awaiter(this, void 0, void 0, function () {
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0: return [4 /*yield*/, this.auth.signOut()];
                        case 1:
                            _a.sent();
                            this.store.update(initialAuthState);
                            if (!this.onSignout) return [3 /*break*/, 3];
                            return [4 /*yield*/, this.onSignout()];
                        case 2:
                            _a.sent();
                            _a.label = 3;
                        case 3: return [2 /*return*/];
                    }
                });
            });
        };
        return FireAuthService;
    }());

    function CollectionGuardConfig(data) {
        return function (constructor) {
            Object.keys(data).forEach(function (key) { return (constructor[key] = data[key]); });
        };
    }
    var CollectionGuard = /** @class */ (function () {
        function CollectionGuard(service) {
            this.service = service;
            try {
                this.router = core.inject(router.Router);
            }
            catch (err) {
                throw new Error('CollectionGuard requires RouterModule to be imported');
            }
        }
        Object.defineProperty(CollectionGuard.prototype, "awaitSync", {
            // Can be override by the extended class
            /** Should the guard wait for connection to Firestore to complete */
            get: function () {
                return this.constructor['awaitSync'] || false;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(CollectionGuard.prototype, "queryFn", {
            // Can be override by the extended class
            /** A queryFn to execute for sync */
            get: function () {
                return this.constructor['queryFn'];
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(CollectionGuard.prototype, "redirect", {
            // Can be override by the extended class
            /** The route to redirect to if you sync failed */
            get: function () {
                return this.constructor['redirect'];
            },
            enumerable: false,
            configurable: true
        });
        // Can be override by the extended class
        /** The method to subscribe to while route is active */
        CollectionGuard.prototype.sync = function (next, state) {
            var _a = next.data.queryFn, queryFn = _a === void 0 ? this.queryFn : _a;
            if (this.service instanceof FireAuthService) {
                return this.service.sync();
            }
            else if (this.service instanceof CollectionService) {
                return this.service.syncCollection(queryFn);
            }
        };
        CollectionGuard.prototype.canActivate = function (next, state) {
            var _this = this;
            var _a = next.data, _b = _a.redirect, redirect = _b === void 0 ? this.redirect : _b, _c = _a.awaitSync, awaitSync = _c === void 0 ? this.awaitSync : _c;
            return new Promise(function (res, rej) {
                if (awaitSync) {
                    var unsubscribe_1 = new rxjs.Subject();
                    _this.subscription = _this.sync(next, state).pipe(operators.takeUntil(unsubscribe_1)).subscribe({
                        next: function (result) {
                            if (result instanceof router.UrlTree) {
                                return res(result);
                            }
                            switch (typeof result) {
                                case 'string':
                                    unsubscribe_1.next();
                                    unsubscribe_1.complete();
                                    return res(_this.router.parseUrl(result));
                                case 'boolean':
                                    return res(result);
                                default:
                                    return res(true);
                            }
                        },
                        error: function (err) {
                            res(_this.router.parseUrl(redirect || ''));
                            throw new Error(err);
                        }
                    });
                }
                else {
                    _this.subscription = _this.sync(next, state).subscribe();
                    res(true);
                }
            });
        };
        CollectionGuard.prototype.canDeactivate = function () {
            if (this.subscription) {
                this.subscription.unsubscribe();
            }
            return true;
        };
        return CollectionGuard;
    }());

    /** @deprecated Use CollectionService instead */
    var CollectionGroupService = /** @class */ (function () {
        function CollectionGroupService(store) {
            this.store = store;
            try {
                this.db = core.inject(firestore.AngularFirestore);
            }
            catch (err) {
                throw new Error('CollectionGroupService requires AngularFirestore.');
            }
        }
        /**
        * Function triggered when getting data from firestore
        * @note should be overrided
        */
        CollectionGroupService.prototype.formatFromFirestore = function (entity) {
            return entity;
        };
        Object.defineProperty(CollectionGroupService.prototype, "idKey", {
            get: function () {
                if (this.store) {
                    return this.store.idKey;
                }
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(CollectionGroupService.prototype, "resetOnUpdate", {
            get: function () {
                return this.constructor['resetOnUpdate'] || false;
            },
            enumerable: false,
            configurable: true
        });
        CollectionGroupService.prototype.syncCollection = function (queryOrOptions, storeOptions) {
            var _this = this;
            if (storeOptions === void 0) { storeOptions = { loading: true }; }
            var query;
            if (typeof queryOrOptions === 'function') {
                query = queryOrOptions;
            }
            else if (typeof queryOrOptions === 'object') {
                storeOptions = queryOrOptions;
            }
            var storeName = getStoreName(this.store, storeOptions);
            // reset has to happen before setLoading, otherwise it will also reset the loading state
            if (storeOptions.reset) {
                resetStore(storeName);
            }
            if (storeOptions.loading) {
                setLoading(storeName, true);
            }
            return this.db.collectionGroup(this.collectionId, query).stateChanges().pipe(akita.withTransaction(function (actions) { return syncStoreFromDocAction(storeName, actions, _this.idKey, _this.resetOnUpdate, function (entity) { return _this.formatFromFirestore(entity); }); }));
        };
        /** Return a snapshot of the collection group */
        CollectionGroupService.prototype.getValue = function (queryGroupFn) {
            return __awaiter(this, void 0, void 0, function () {
                var snapshot;
                var _this = this;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0: return [4 /*yield*/, this.db.collectionGroup(this.collectionId, queryGroupFn).get().toPromise()];
                        case 1:
                            snapshot = _a.sent();
                            return [2 /*return*/, snapshot.docs.map(function (doc) {
                                    var entity = doc.data();
                                    return _this.formatFromFirestore(entity);
                                })];
                    }
                });
            });
        };
        return CollectionGroupService;
    }());

    function canWrite(write, roles) {
        return roles.some(function (role) { return role === write || role === 'write'; });
    }
    function canRead(read, roles) {
        return roles.some(function (role) { return role === read || role === 'write'; });
    }
    function hasRole(role, roles) {
        switch (role) {
            case 'write': return roles.includes('write');
            case 'create': return canWrite('create', roles);
            case 'delete': return canWrite('delete', roles);
            case 'update': return canWrite('update', roles);
            case 'read': return roles.includes('read');
            case 'get': return canRead('get', roles);
            case 'list': return canRead('list', roles);
            default: return false;
        }
    }

    function shouldCancel(_a) {
        var validate = _a.validate, cancel = _a.cancel;
        return rxjs.race([validate.pipe(operators.map(function (_) { return false; })), cancel.pipe(operators.map(function (_) { return true; }))]);
    }
    function waitForCancel(_a) {
        var startWith = _a.startWith, endWith = _a.endWith, shouldValidate = _a.shouldValidate, shouldCancel = _a.shouldCancel;
        return __awaiter(this, void 0, void 0, function () {
            var cancelled;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        startWith();
                        return [4 /*yield*/, rxjs.race([
                                shouldValidate.pipe(operators.map(function (_) { return false; })),
                                shouldCancel.pipe(operators.map(function (_) { return true; }))
                            ]).toPromise()];
                    case 1:
                        cancelled = _a.sent();
                        endWith(cancelled);
                        return [2 /*return*/];
                }
            });
        });
    }

    /**
     * @description Custom RxJs operator
     * @param redirectTo Route path to redirecto if collection is empty
     */
    function redirectIfEmpty(redirectTo) {
        return operators.map(function (actions) { return actions.length === 0 ? redirectTo : true; });
    }

    function syncWithRouter(routerQuery) {
        var _this = this;
        if (!this['store'].resettable) {
            throw new Error("Store " + this['store'].storeName + " is required to be resettable for syncWithRouter to work.");
        }
        var pathParams = getPathParams(this.path);
        return routerQuery.selectParams().pipe(
        // Don't trigger change if params needed (and only them) haven't changed
        operators.distinctUntilChanged(function (old, next) {
            var paramsHaveChanged = !!pathParams.find(function (param) { return old[param] !== next[param]; });
            // reset store on every parameter change
            if (paramsHaveChanged) {
                _this['store'].reset();
            }
            return !paramsHaveChanged;
        }), 
        // Need to filter because changes in params comes before canDeactivate
        operators.filter(function (params) { return pathParams.every(function (param) { return !!params[param]; }); }), operators.switchMap(function (params) { return _this.syncCollection({ params: params }); }), operators.share());
    }

    var queryKeys = ['path', 'queryFn'];
    function getSubQueryKeys(query) {
        var keys = Object.keys(query);
        return keys.filter(function (key) { return !queryKeys.includes(key); });
    }
    function hasSubQueries(query) {
        return getSubQueryKeys(query).length > 0;
    }
    function getSubQuery(query, parent) {
        if (typeof query !== 'function') {
            return query;
        }
        return query(parent);
    }
    function isDocPath(path) {
        return path.split('/').length % 2 === 0;
    }
    /** Transform a path into a collection Query */
    function collection(path, queryFn) {
        return { path: path, queryFn: queryFn };
    }
    /** Transform a path into a doc query */
    function doc(path) {
        return { path: path };
    }
    /** Check if a value is a query */
    function isQuery(query) {
        if (typeof query === 'object' && query !== null) {
            return !!query['path'];
        }
        return false;
    }

    /**
     * Sync the collection
     * @param this Uses this function with bind on a Collection Service
     * @param query The query to trigger
     */
    function syncQuery(query) {
        var _this = this;
        // If single query
        if (typeof query === 'string') {
            return isDocPath(query)
                ? this.syncDoc({ path: query })
                : this.syncCollection(query);
        }
        if (Array.isArray(query)) {
            return rxjs.combineLatest(query.map(function (oneQuery) { return syncQuery.call(_this, oneQuery); }));
        }
        if (!isQuery(query)) {
            throw new Error('Query should be either a path, a Query object or an array of Queries');
        }
        ////////////////
        // SUBQUERIES //
        ////////////////
        /** Listen on Child actions */
        var fromChildAction = function (actions, child) {
            var e_1, _a;
            var idKey = 'id'; // TODO: Improve how to
            var parentId = child.parentId, key = child.key;
            var _loop_1 = function (action) {
                var id = action.payload.doc.id;
                var data = action.payload.doc.data();
                switch (action.type) {
                    case 'added': {
                        _this['store'].update(parentId, function (entity) {
                            var _a;
                            return (_a = {},
                                _a[key] = akita.arrayUpsert(entity[key] || [], id, data, idKey),
                                _a);
                        });
                        break;
                    }
                    case 'removed': {
                        _this['store'].update(parentId, function (entity) {
                            var _a;
                            return (_a = {},
                                _a[key] = akita.arrayRemove(entity[key], id, idKey),
                                _a);
                        });
                        break;
                    }
                    case 'modified': {
                        _this['store'].update(parentId, function (entity) {
                            var _a;
                            return (_a = {},
                                _a[key] = akita.arrayUpdate(entity[key], id, data, idKey),
                                _a);
                        });
                    }
                }
            };
            try {
                for (var actions_1 = __values(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
                    var action = actions_1_1.value;
                    _loop_1(action);
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
                }
                finally { if (e_1) throw e_1.error; }
            }
        };
        /**
         * Stay in sync a subquery of the collection
         * @param subQuery The sub query based on the entity
         * @param child An object that describe the parent
         */
        var syncSubQuery = function (subQuery, child) {
            var _a;
            var parentId = child.parentId, key = child.key;
            // If it's a static value
            // TODO : Check if subQuery is a string ???
            if (!isQuery(subQuery)) {
                var update = _this['store'].update(parentId, (_a = {}, _a[key] = subQuery, _a));
                return rxjs.of(update);
            }
            if (Array.isArray(subQuery)) {
                var syncQueries = subQuery.map(function (oneQuery) {
                    if (isQuery(subQuery)) {
                        var id_1 = getIdAndPath({ path: subQuery.path });
                        return _this['db'].doc(subQuery.path).valueChanges().pipe(operators.tap(function (childDoc) {
                            _this['store'].update(parentId, function (entity) {
                                var _a;
                                return (_a = {},
                                    _a[key] = akita.arrayAdd(entity[key], id_1, childDoc),
                                    _a);
                            });
                        }));
                    }
                    return syncSubQuery(oneQuery, child);
                });
                return rxjs.combineLatest(syncQueries);
            }
            if (typeof subQuery !== 'object') {
                throw new Error('Query should be either a path, a Query object or an array of Queries');
            }
            // Sync subquery
            if (isDocPath(subQuery.path)) {
                return _this['db'].doc(subQuery.path).valueChanges().pipe(operators.tap(function (children) {
                    var _a;
                    return _this['store'].update(parentId, (_a = {}, _a[key] = children, _a));
                }));
            }
            else {
                return _this['db'].collection(subQuery.path, subQuery.queryFn)
                    .stateChanges()
                    .pipe(akita.withTransaction(function (actions) { return fromChildAction(actions, child); }));
            }
        };
        /**
         * Get in sync with all the subqueries
         * @param subQueries A map of all the subqueries
         * @param parent The parent entity to attach the children to
         */
        var syncAllSubQueries = function (subQueries, parent) {
            var obs = Object.keys(subQueries)
                .filter(function (key) { return key !== 'path' && key !== 'queryFn'; })
                .map(function (key) {
                var queryLike = getSubQuery(subQueries[key], parent);
                var child = { key: key, parentId: parent[_this.idKey] };
                return syncSubQuery(queryLike, child);
            });
            return rxjs.combineLatest(obs);
        };
        ////////////////
        // MAIN QUERY //
        ////////////////
        /** Listen on action with child queries */
        var fromActionWithChild = function (actions, mainQuery, subscriptions) {
            var e_2, _a, _b;
            try {
                for (var actions_2 = __values(actions), actions_2_1 = actions_2.next(); !actions_2_1.done; actions_2_1 = actions_2.next()) {
                    var action = actions_2_1.value;
                    var id = action.payload.doc.id;
                    var data = action.payload.doc.data();
                    switch (action.type) {
                        case 'added': {
                            var entity = _this.formatFromFirestore(Object.assign((_b = {}, _b[_this.idKey] = id, _b), data));
                            _this['store'].upsert(id, entity);
                            subscriptions[id] = syncAllSubQueries(mainQuery, entity).subscribe();
                            break;
                        }
                        case 'removed': {
                            _this['store'].remove(id);
                            subscriptions[id].unsubscribe();
                            delete subscriptions[id];
                            break;
                        }
                        case 'modified': {
                            _this['store'].update(id, data);
                        }
                    }
                }
            }
            catch (e_2_1) { e_2 = { error: e_2_1 }; }
            finally {
                try {
                    if (actions_2_1 && !actions_2_1.done && (_a = actions_2.return)) _a.call(actions_2);
                }
                finally { if (e_2) throw e_2.error; }
            }
        };
        var path = query.path, queryFn = query.queryFn;
        if (isDocPath(path)) {
            var id_2 = getIdAndPath({ path: path }).id;
            var subscription_1;
            return this['db'].doc(path).valueChanges().pipe(operators.tap(function (entity) {
                _this['store'].upsert(id_2, _this.formatFromFirestore(Object.assign({ id: id_2 }, entity)));
                if (!subscription_1) { // Subscribe only the first time
                    subscription_1 = syncAllSubQueries(query, entity).subscribe();
                }
            }), 
            // Stop subscription
            operators.finalize(function () { return subscription_1.unsubscribe(); }));
        }
        else {
            var subscriptions_1 = {};
            return this['db'].collection(path, queryFn)
                .stateChanges()
                .pipe(akita.withTransaction(function (actions) { return fromActionWithChild(actions, query, subscriptions_1); }), 
            // Stop all subscriptions
            operators.finalize(function () { return Object.keys(subscriptions_1).forEach(function (id) {
                subscriptions_1[id].unsubscribe();
                delete subscriptions_1[id];
            }); }));
        }
    }

    function awaitSyncQuery(query) {
        var _this = this;
        return queryChanges.call(this, query).pipe(operators.tap(function (entities) {
            Array.isArray(entities)
                ? _this['store'].upsertMany(entities)
                : _this['store'].upsert(entities[_this.idKey], entities);
        }));
    }
    /**
     * Listen on the changes of the documents in the query
     * @param query A query object to listen to
     */
    function queryChanges(query) {
        var _this = this;
        return awaitQuery.call(this, query).pipe(operators.map(function (entities) {
            return Array.isArray(entities)
                ? entities.map(function (e) { return _this.formatFromFirestore(e); })
                : _this.formatFromFirestore(entities);
        }));
    }
    function awaitQuery(query) {
        var _this = this;
        // If single query
        if (typeof query === 'string') {
            return isDocPath(query)
                ? this['db'].doc(query).valueChanges()
                : this['db'].collection(query).valueChanges({ idField: this.idKey });
        }
        if (Array.isArray(query)) {
            return !!query.length
                ? rxjs.combineLatest(query.map(function (oneQuery) { return awaitSyncQuery.call(_this, oneQuery); }))
                : rxjs.of(query);
        }
        if (!isQuery(query)) {
            return rxjs.of(query);
        }
        /**
         * Get the entity of one subquery
         * @param subQuery The subquery function or value
         * @param entity The parent entity
         */
        var syncSubQuery = function (subQueryFn, entity) {
            if (!subQueryFn) {
                return rxjs.throwError("Query failed");
            }
            if (typeof subQueryFn !== 'function') {
                return rxjs.of(subQueryFn);
            }
            return awaitQuery.call(_this, subQueryFn(entity));
        };
        /**
         * Get all the Entities of all subqueries
         * @param parentQuery The parent Query
         * @param entity The parent Entity
         */
        var getAllSubQueries = function (parentQuery, entity) {
            if (!entity) {
                return rxjs.throwError("Nothing found at path : " + parentQuery.path);
            }
            // There is no subqueries return the entity
            if (!hasSubQueries(parentQuery)) {
                return rxjs.of(entity);
            }
            // Get all subquery keys
            var subQueryKeys = getSubQueryKeys(query);
            // For each key get the subquery
            var subQueries$ = subQueryKeys.map(function (key) {
                return syncSubQuery(parentQuery[key], entity).pipe(operators.tap(function (subentity) { return entity[key] = subentity; }));
            });
            return !!subQueries$.length
                ? rxjs.combineLatest(subQueries$).pipe(operators.map(function () { return entity; }))
                : rxjs.of(entity);
        };
        // IF DOCUMENT
        var path = query.path, queryFn = query.queryFn;
        if (isDocPath(path)) {
            var id_1 = getIdAndPath({ path: path }).id;
            return this['db'].doc(path).valueChanges().pipe(operators.switchMap(function (entity) { return getAllSubQueries(query, entity); }), operators.map(function (entity) { return (Object.assign({ id: id_1 }, entity)); }));
        }
        // IF COLLECTION
        return this['db'].collection(path, queryFn)
            .valueChanges({ idField: this.idKey })
            .pipe(operators.switchMap(function (entities) {
            var entities$ = entities.map(function (entity) { return getAllSubQueries(query, entity); });
            return entities$.length ? rxjs.combineLatest(entities$) : rxjs.of([]);
        }));
    }

    /**
     * @description calls cloud function
     * @param functions you want to make callable
     * @param name of the cloud function
     * @param params you want to set
     */
    function callFunction(functions, name, params) {
        return __awaiter(this, void 0, void 0, function () {
            var callable;
            return __generator(this, function (_a) {
                callable = functions.httpsCallable(name);
                return [2 /*return*/, callable(params).toPromise()];
            });
        });
    }

    /*
     * Public API Surface of akita-ng-fire
     */

    /**
     * Generated bundle index. Do not edit.
     */

    exports.CollectionConfig = CollectionConfig;
    exports.CollectionGroupService = CollectionGroupService;
    exports.CollectionGuard = CollectionGuard;
    exports.CollectionGuardConfig = CollectionGuardConfig;
    exports.CollectionService = CollectionService;
    exports.FireAuthService = FireAuthService;
    exports.authProviders = authProviders;
    exports.awaitQuery = awaitQuery;
    exports.awaitSyncQuery = awaitSyncQuery;
    exports.callFunction = callFunction;
    exports.canRead = canRead;
    exports.canWrite = canWrite;
    exports.collection = collection;
    exports.doc = doc;
    exports.getAuthProvider = getAuthProvider;
    exports.getCustomClaims = getCustomClaims;
    exports.getIdAndPath = getIdAndPath;
    exports.getPathParams = getPathParams;
    exports.getSubQuery = getSubQuery;
    exports.getSubQueryKeys = getSubQueryKeys;
    exports.hasRole = hasRole;
    exports.hasSubQueries = hasSubQueries;
    exports.initialAuthState = initialAuthState;
    exports.isDocPath = isDocPath;
    exports.isFireAuthProvider = isFireAuthProvider;
    exports.isQuery = isQuery;
    exports.isTransaction = isTransaction;
    exports.pathWithParams = pathWithParams;
    exports.queryChanges = queryChanges;
    exports.queryKeys = queryKeys;
    exports.redirectIfEmpty = redirectIfEmpty;
    exports.removeStoreEntity = removeStoreEntity;
    exports.resetStore = resetStore;
    exports.setActive = setActive;
    exports.setLoading = setLoading;
    exports.shouldCancel = shouldCancel;
    exports.syncQuery = syncQuery;
    exports.syncStoreFromDocAction = syncStoreFromDocAction;
    exports.syncStoreFromDocActionSnapshot = syncStoreFromDocActionSnapshot;
    exports.syncWithRouter = syncWithRouter;
    exports.updateStoreEntity = updateStoreEntity;
    exports.upsertStoreEntity = upsertStoreEntity;
    exports.waitForCancel = waitForCancel;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=akita-ng-fire.umd.js.map