owservable 0.8.40 → 0.8.42

package/lib/store/collection.store.js

@@ -1,112 +1,112 @@
-'use strict';
-var __awaiter = (this && this.__awaiter) || function (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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const sift_1 = require("sift");
-const _ = require("lodash");
-const a_store_1 = require("./a.store");
-const store_type_enum_1 = require("../_enums/store.type.enum");
-class CollectionStore extends a_store_1.default {
-    constructor(model, target) {
-        super(model, target);
-        this._type = store_type_enum_1.default.COLLECTION;
-        Object.setPrototypeOf(this, CollectionStore.prototype);
-    }
-    shouldReload(change) {
-        if (this.isInitialSubscription(change))
-            return true;
-        const { operationType: type, updateDescription: description, fullDocument: document } = change;
-        const test = (0, sift_1.default)(_.omit(this._query, ['createdAt', 'updatedAt']));
-        switch (type) {
-            case 'delete':
-            case 'insert':
-                return true;
-            case 'replace':
-            case 'update':
-                if (!description)
-                    return true;
-                if (!this.shouldConsiderFields())
-                    return test(document);
-                const { updatedFields, removedFields } = description;
-                const us = _.concat(removedFields, _.keys(updatedFields));
-                const qs = _.keys(this._fields);
-                return !_.isEmpty(_.intersection(qs, us));
-        }
-        return false;
-    }
-    load(change) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isEmpty(this._config))
-                return this.emitMany();
-            if (!this.shouldReload(change))
-                return;
-            try {
-                const { operationType: type, documentKey, fullDocument: document } = change;
-                const key = _.get(documentKey, '_id', '').toString();
-                if (document && this._incremental) {
-                    if ('delete' === type)
-                        return this.emitDelete(key);
-                    for (const populate of this._populates) {
-                        yield this._model.populate(document, populate);
-                    }
-                    if (_.isEmpty(this._virtuals))
-                        return this.emitMany({ data: document });
-                    const replacement = _.cloneDeep(_.omit(document.toJSON(), this._virtuals));
-                    for (const virtual of this._virtuals) {
-                        replacement[virtual] = yield Promise.resolve(document[virtual]);
-                    }
-                    return this.emitMany({ data: replacement });
-                }
-                else {
-                    let data = [];
-                    const total = yield this._model.countDocuments(this._query);
-                    if (total > 0) {
-                        data = yield this._model
-                            .find(this._query, this._fields, this._paging)
-                            .sort(this._sort)
-                            .setOptions({ allowDiskUse: true });
-                        for (const populate of this._populates) {
-                            yield this._model.populate(data, populate);
-                        }
-                        if (!_.isEmpty(this._virtuals)) {
-                            const replacements = [];
-                            for (const item of data) {
-                                const replacement = _.cloneDeep(_.omit(item.toJSON(), this._virtuals));
-                                for (const virtual of this._virtuals) {
-                                    replacement[virtual] = yield Promise.resolve(item[virtual]);
-                                }
-                                replacements.push(replacement);
-                            }
-                            data = replacements;
-                        }
-                    }
-                    return this.emitMany({ total, data });
-                }
-            }
-            catch (error) {
-                this.emitError(error);
-            }
-        });
-    }
-    extractFromConfig() {
-        super.extractFromConfig();
-        const { incremental = false, page = 1, pageSize } = this._config;
-        this._incremental = incremental;
-        this._paging = {};
-        if (pageSize) {
-            this._paging = {
-                skip: (page - 1) * pageSize,
-                limit: pageSize
-            };
-        }
-    }
-}
-exports.default = CollectionStore;
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sift_1 = require("sift");
+const _ = require("lodash");
+const a_store_1 = require("./a.store");
+const store_type_enum_1 = require("../_enums/store.type.enum");
+class CollectionStore extends a_store_1.default {
+    constructor(model, target) {
+        super(model, target);
+        this._type = store_type_enum_1.default.COLLECTION;
+        Object.setPrototypeOf(this, CollectionStore.prototype);
+    }
+    shouldReload(change) {
+        if (this.isInitialSubscription(change))
+            return true;
+        const { operationType: type, updateDescription: description, fullDocument: document } = change;
+        const test = (0, sift_1.default)(_.omit(this._query, ['createdAt', 'updatedAt']));
+        switch (type) {
+            case 'delete':
+            case 'insert':
+                return true;
+            case 'replace':
+            case 'update':
+                if (!description)
+                    return true;
+                if (!this.shouldConsiderFields())
+                    return test(document);
+                const { updatedFields, removedFields } = description;
+                const us = _.concat(removedFields, _.keys(updatedFields));
+                const qs = _.keys(this._fields);
+                return !_.isEmpty(_.intersection(qs, us));
+        }
+        return false;
+    }
+    load(change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_.isEmpty(this._config))
+                return this.emitMany();
+            if (!this.shouldReload(change))
+                return;
+            try {
+                const { operationType: type, documentKey, fullDocument: document } = change;
+                const key = _.get(documentKey, '_id', '').toString();
+                if (document && this._incremental) {
+                    if ('delete' === type)
+                        return this.emitDelete(key);
+                    for (const populate of this._populates) {
+                        yield this._model.populate(document, populate);
+                    }
+                    if (_.isEmpty(this._virtuals))
+                        return this.emitMany({ data: document });
+                    const replacement = _.cloneDeep(_.omit(document.toJSON(), this._virtuals));
+                    for (const virtual of this._virtuals) {
+                        replacement[virtual] = yield Promise.resolve(document[virtual]);
+                    }
+                    return this.emitMany({ data: replacement });
+                }
+                else {
+                    let data = [];
+                    const total = yield this._model.countDocuments(this._query);
+                    if (total > 0) {
+                        data = yield this._model
+                            .find(this._query, this._fields, this._paging)
+                            .sort(this._sort)
+                            .setOptions({ allowDiskUse: true });
+                        for (const populate of this._populates) {
+                            yield this._model.populate(data, populate);
+                        }
+                        if (!_.isEmpty(this._virtuals)) {
+                            const replacements = [];
+                            for (const item of data) {
+                                const replacement = _.cloneDeep(_.omit(item.toJSON(), this._virtuals));
+                                for (const virtual of this._virtuals) {
+                                    replacement[virtual] = yield Promise.resolve(item[virtual]);
+                                }
+                                replacements.push(replacement);
+                            }
+                            data = replacements;
+                        }
+                    }
+                    return this.emitMany({ total, data });
+                }
+            }
+            catch (error) {
+                this.emitError(error);
+            }
+        });
+    }
+    extractFromConfig() {
+        super.extractFromConfig();
+        const { incremental = false, page = 1, pageSize } = this._config;
+        this._incremental = incremental;
+        this._paging = {};
+        if (pageSize) {
+            this._paging = {
+                skip: (page - 1) * pageSize,
+                limit: pageSize
+            };
+        }
+    }
+}
+exports.default = CollectionStore;
 //# sourceMappingURL=collection.store.js.map

package/lib/store/count.store.d.ts

@@ -1,7 +1,7 @@
-import { Model } from 'mongoose';
-import AStore from './a.store';
-export default class CountStore extends AStore {
-    constructor(model: Model<any>, target: string);
-    protected shouldReload(change: any): boolean;
-    protected load(change: any): Promise<void>;
-}
+import { Model } from 'mongoose';
+import AStore from './a.store';
+export default class CountStore extends AStore {
+    constructor(model: Model<any>, target: string);
+    protected shouldReload(change: any): boolean;
+    protected load(change: any): Promise<void>;
+}

package/lib/store/count.store.js

@@ -1,47 +1,47 @@
-'use strict';
-var __awaiter = (this && this.__awaiter) || function (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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
-const a_store_1 = require("./a.store");
-const store_type_enum_1 = require("../_enums/store.type.enum");
-class CountStore extends a_store_1.default {
-    constructor(model, target) {
-        super(model, target);
-        this._type = store_type_enum_1.default.COUNT;
-        Object.setPrototypeOf(this, CountStore.prototype);
-    }
-    shouldReload(change) {
-        if (this.isInitialSubscription(change))
-            return true;
-        const { operationType: type } = change;
-        switch (type) {
-            case 'delete':
-            case 'insert':
-                return true;
-            case 'replace':
-            case 'update':
-            default:
-                return false;
-        }
-    }
-    load(change) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((0, lodash_1.isEmpty)(this._config))
-                return this.emitOne();
-            if (!this.shouldReload(change))
-                return;
-            const count = yield this._model.countDocuments(this._query);
-            this.emitOne(count);
-        });
-    }
-}
-exports.default = CountStore;
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const a_store_1 = require("./a.store");
+const store_type_enum_1 = require("../_enums/store.type.enum");
+class CountStore extends a_store_1.default {
+    constructor(model, target) {
+        super(model, target);
+        this._type = store_type_enum_1.default.COUNT;
+        Object.setPrototypeOf(this, CountStore.prototype);
+    }
+    shouldReload(change) {
+        if (this.isInitialSubscription(change))
+            return true;
+        const { operationType: type } = change;
+        switch (type) {
+            case 'delete':
+            case 'insert':
+                return true;
+            case 'replace':
+            case 'update':
+            default:
+                return false;
+        }
+    }
+    load(change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((0, lodash_1.isEmpty)(this._config))
+                return this.emitOne();
+            if (!this.shouldReload(change))
+                return;
+            const count = yield this._model.countDocuments(this._query);
+            this.emitOne(count);
+        });
+    }
+}
+exports.default = CountStore;
 //# sourceMappingURL=count.store.js.map

package/lib/store/document.store.d.ts

@@ -1,12 +1,12 @@
-import AStore from './a.store';
-export default class DocumentStore extends AStore {
-    constructor(model: any, target: string);
-    protected extractFromConfig(): void;
-    restartSubscription(): void;
-    protected shouldReload(change: any): boolean;
-    protected load(change: any): Promise<void>;
-    private _pipeFilter;
-    private _loadDocumentById;
-    private _loadSortedFirstDocument;
-    private _loadDocument;
-}
+import AStore from './a.store';
+export default class DocumentStore extends AStore {
+    constructor(model: any, target: string);
+    protected extractFromConfig(): void;
+    restartSubscription(): void;
+    protected shouldReload(change: any): boolean;
+    protected load(change: any): Promise<void>;
+    private _pipeFilter;
+    private _loadDocumentById;
+    private _loadSortedFirstDocument;
+    private _loadDocument;
+}

package/lib/store/document.store.js

@@ -1,135 +1,135 @@
-'use strict';
-var __awaiter = (this && this.__awaiter) || function (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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const sift_1 = require("sift");
-const _ = require("lodash");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const a_store_1 = require("./a.store");
-const store_type_enum_1 = require("../_enums/store.type.enum");
-const observable_model_1 = require("../mongodb/functions/observable.model");
-const _getIdFromQuery = (query) => (_.isString(query) ? query : _.get(query, '_id', '').toString());
-class DocumentStore extends a_store_1.default {
-    constructor(model, target) {
-        super(model, target);
-        this._type = store_type_enum_1.default.DOCUMENT;
-        Object.setPrototypeOf(this, DocumentStore.prototype);
-    }
-    extractFromConfig() {
-        super.extractFromConfig();
-        const { skip = 0 } = this._config;
-        this._paging = skip ? {} : { skip, limit: 1 };
-    }
-    restartSubscription() {
-        this.subscription = (0, observable_model_1.default)(this.model)
-            .pipe((0, operators_1.throttleTime)(this._delay, rxjs_1.asyncScheduler, { leading: true, trailing: true }))
-            .pipe((0, operators_1.filter)((change) => this._pipeFilter(change)))
-            .subscribe({
-            next: (change) => this.load(change)
-        });
-    }
-    shouldReload(change) {
-        if (this.isInitialSubscription(change))
-            return true;
-        const id = _getIdFromQuery(this._query);
-        const { operationType: type, documentKey, updateDescription: description } = change;
-        const key = _.get(documentKey, '_id', '').toString();
-        switch (type) {
-            case 'delete':
-                return true;
-            case 'insert':
-                return !id;
-            case 'replace':
-            case 'update':
-                if (id && id === key)
-                    return true;
-                if (!description)
-                    return true;
-                if (!this.shouldConsiderFields())
-                    return true;
-                const { updatedFields, removedFields } = description;
-                const us = _.concat(removedFields, _.keys(updatedFields));
-                const qs = _.keys(this._fields);
-                return !_.isEmpty(_.intersection(qs, us));
-        }
-        return false;
-    }
-    load(change) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isEmpty(this._config))
-                return this.emitOne();
-            if (!this.shouldReload(change))
-                return;
-            const id = _getIdFromQuery(this._query);
-            const { operationType: type, documentKey } = change;
-            const key = _.get(documentKey, '_id', '').toString();
-            if (type === 'delete' && id === key)
-                return this.emitDelete(key);
-            try {
-                let data;
-                if (!_.isEmpty(this._sort))
-                    data = yield this._loadSortedFirstDocument();
-                else
-                    data = id ? yield this._loadDocumentById(id) : yield this._loadDocument();
-                if (!data)
-                    return this.emitOne();
-                for (const populate of this._populates) {
-                    if (data === null || data === void 0 ? void 0 : data.populate)
-                        yield data.populate(populate).execPopulate();
-                }
-                if (_.isEmpty(this._virtuals))
-                    return this.emitOne(data.toJSON());
-                const jsonData = _.cloneDeep(_.omit(data.toJSON(), this._virtuals));
-                for (const virtual of this._virtuals) {
-                    jsonData[virtual] = yield Promise.resolve(data[virtual]);
-                }
-                this.emitOne(jsonData);
-            }
-            catch (error) {
-                this.emitError(error);
-            }
-        });
-    }
-    _pipeFilter(change) {
-        if (!_.isEmpty(this._sort))
-            return true;
-        const { operationType: type } = change;
-        if ('delete' === type)
-            return true;
-        const { documentKey, fullDocument: document } = change;
-        const key = _.get(documentKey, '_id', '').toString();
-        if (key === _getIdFromQuery(this._query))
-            return true;
-        const test = (0, sift_1.default)(_.omit(this._query, ['createdAt', 'updatedAt']));
-        return test(document);
-    }
-    _loadDocumentById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._model.findById(id, this._fields);
-        });
-    }
-    _loadSortedFirstDocument() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const docs = yield this._model
-                .find(this._query, this._fields, this._paging)
-                .sort(this._sort)
-                .setOptions({ allowDiskUse: true });
-            return _.first(docs);
-        });
-    }
-    _loadDocument() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._model.findOne(this._query, this._fields);
-        });
-    }
-}
-exports.default = DocumentStore;
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sift_1 = require("sift");
+const _ = require("lodash");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const a_store_1 = require("./a.store");
+const store_type_enum_1 = require("../_enums/store.type.enum");
+const observable_model_1 = require("../mongodb/functions/observable.model");
+const _getIdFromQuery = (query) => (_.isString(query) ? query : _.get(query, '_id', '').toString());
+class DocumentStore extends a_store_1.default {
+    constructor(model, target) {
+        super(model, target);
+        this._type = store_type_enum_1.default.DOCUMENT;
+        Object.setPrototypeOf(this, DocumentStore.prototype);
+    }
+    extractFromConfig() {
+        super.extractFromConfig();
+        const { skip = 0 } = this._config;
+        this._paging = skip ? {} : { skip, limit: 1 };
+    }
+    restartSubscription() {
+        this.subscription = (0, observable_model_1.default)(this.model)
+            .pipe((0, operators_1.throttleTime)(this._delay, rxjs_1.asyncScheduler, { leading: true, trailing: true }))
+            .pipe((0, operators_1.filter)((change) => this._pipeFilter(change)))
+            .subscribe({
+            next: (change) => this.load(change)
+        });
+    }
+    shouldReload(change) {
+        if (this.isInitialSubscription(change))
+            return true;
+        const id = _getIdFromQuery(this._query);
+        const { operationType: type, documentKey, updateDescription: description } = change;
+        const key = _.get(documentKey, '_id', '').toString();
+        switch (type) {
+            case 'delete':
+                return true;
+            case 'insert':
+                return !id;
+            case 'replace':
+            case 'update':
+                if (id && id === key)
+                    return true;
+                if (!description)
+                    return true;
+                if (!this.shouldConsiderFields())
+                    return true;
+                const { updatedFields, removedFields } = description;
+                const us = _.concat(removedFields, _.keys(updatedFields));
+                const qs = _.keys(this._fields);
+                return !_.isEmpty(_.intersection(qs, us));
+        }
+        return false;
+    }
+    load(change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_.isEmpty(this._config))
+                return this.emitOne();
+            if (!this.shouldReload(change))
+                return;
+            const id = _getIdFromQuery(this._query);
+            const { operationType: type, documentKey } = change;
+            const key = _.get(documentKey, '_id', '').toString();
+            if (type === 'delete' && id === key)
+                return this.emitDelete(key);
+            try {
+                let data;
+                if (!_.isEmpty(this._sort))
+                    data = yield this._loadSortedFirstDocument();
+                else
+                    data = id ? yield this._loadDocumentById(id) : yield this._loadDocument();
+                if (!data)
+                    return this.emitOne();
+                for (const populate of this._populates) {
+                    if (data === null || data === void 0 ? void 0 : data.populate)
+                        yield data.populate(populate).execPopulate();
+                }
+                if (_.isEmpty(this._virtuals))
+                    return this.emitOne(data.toJSON());
+                const jsonData = _.cloneDeep(_.omit(data.toJSON(), this._virtuals));
+                for (const virtual of this._virtuals) {
+                    jsonData[virtual] = yield Promise.resolve(data[virtual]);
+                }
+                this.emitOne(jsonData);
+            }
+            catch (error) {
+                this.emitError(error);
+            }
+        });
+    }
+    _pipeFilter(change) {
+        if (!_.isEmpty(this._sort))
+            return true;
+        const { operationType: type } = change;
+        if ('delete' === type)
+            return true;
+        const { documentKey, fullDocument: document } = change;
+        const key = _.get(documentKey, '_id', '').toString();
+        if (key === _getIdFromQuery(this._query))
+            return true;
+        const test = (0, sift_1.default)(_.omit(this._query, ['createdAt', 'updatedAt']));
+        return test(document);
+    }
+    _loadDocumentById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._model.findById(id, this._fields);
+        });
+    }
+    _loadSortedFirstDocument() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const docs = yield this._model
+                .find(this._query, this._fields, this._paging)
+                .sort(this._sort)
+                .setOptions({ allowDiskUse: true });
+            return _.first(docs);
+        });
+    }
+    _loadDocument() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._model.findOne(this._query, this._fields);
+        });
+    }
+}
+exports.default = DocumentStore;
 //# sourceMappingURL=document.store.js.map

package/lib/store/factories/store.factory.d.ts

@@ -1,4 +1,4 @@
-import AStore from '../a.store';
-import StoreScopeType from '../../_types/store.scope.type';
-declare const storeFactory: (scope: StoreScopeType, observe: string, target: string) => AStore;
-export default storeFactory;
+import AStore from '../a.store';
+import StoreScopeType from '../../_types/store.scope.type';
+declare const storeFactory: (scope: StoreScopeType, observe: string, target: string) => AStore;
+export default storeFactory;