@roit/roit-data-firestore 0.0.20 → 0.0.22

package/README.md

@@ -75,8 +75,9 @@ The anotation Cacheable is responsible from handler storage data in cache, local
         'findById'
     ],
     cacheOnlyContainResults: true, // Cache data only query return value (optional, default true)
-    cacheProvider: 'Local', // Provider using  (optional, default 'Local')
-    includeOnlyMethods: [] // Includes only the methods that will be stored (optional, default [])
+    cacheProvider: CacheProviders.LOCAL, // REDIS or LOCAL  (optional, default 'Local')
+    includeOnlyMethods: [] // Includes only the methods that will be stored (optional, default []),
+    cacheExpiresInSeconds: 60 // Cache expiration in seconds
 })
 ```
 

package/dist/cache/CacheResolver.d.ts

@@ -2,11 +2,14 @@ import { CacheableOptions } from "../model/CacheableOptions";
 export declare class CacheResolver {
     private static instance;
     private repositorys;
-    private localCacheMap;
+    private providersImplMap;
+    private cacheProvider;
     private constructor();
     static getInstance(): CacheResolver;
     addRepository(repository: string, option?: CacheableOptions): void;
-    getCacheResult(repositoryClassName: string, methodSignature: string, ...paramValue: any[]): any | undefined;
-    cacheResult(repositoryClassName: string, methodSignature: string, valueToCache: any, ...paramValue: any[]): boolean;
     private buildKey;
+    buildRepositoryKey(repositoryClassName: string): string;
+    getCacheResult(repositoryClassName: string, methodSignature: string, ...paramValue: any[]): Promise<string | null>;
+    revokeCacheFromRepository(repository: string): Promise<void>;
+    cacheResult(repositoryClassName: string, methodSignature: string, valueToCache: any, ...paramValue: any[]): Promise<boolean>;
 }

package/dist/cache/CacheResolver.js

@@ -1,50 +1,90 @@
 "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 });
 exports.CacheResolver = void 0;
+const CacheableOptions_1 = require("../model/CacheableOptions");
+const providers_1 = require("./providers");
 const roit_environment_1 = require("roit-environment");
+const RedisCacheProvider_1 = require("./providers/RedisCacheProvider");
+const CacheProviders_1 = require("../model/CacheProviders");
 class CacheResolver {
     constructor() {
         this.repositorys = new Map;
-        this.localCacheMap = new Map;
+        this.providersImplMap = new Map;
+        this.providersImplMap.set(CacheProviders_1.CacheProviders.LOCAL, providers_1.InMemoryCacheProvider);
+        this.providersImplMap.set(CacheProviders_1.CacheProviders.REDIS, RedisCacheProvider_1.RedisCacheProvider);
     }
     static getInstance() {
         return this.instance;
     }
     addRepository(repository, option) {
-        this.repositorys.set(repository, option || {
-            cacheOnlyContainResults: true,
-            cacheProvider: 'Local',
-            excludesMethods: [],
-            includeOnlyMethods: []
-        });
+        const options = option || new CacheableOptions_1.CacheableOptions;
+        const implementation = options.cacheProvider || CacheProviders_1.CacheProviders.LOCAL;
+        const providerImpl = this.providersImplMap.get(implementation);
+        this.cacheProvider = new providerImpl();
+        this.repositorys.set(repository, options);
+    }
+    buildKey(repositoryClassName, methodSignature, ...paramValue) {
+        const service = roit_environment_1.Environment.getProperty('service');
+        return `${roit_environment_1.Environment.currentEnv()}:${service}:${repositoryClassName}:${methodSignature}:${paramValue.join(',')}`;
+    }
+    buildRepositoryKey(repositoryClassName) {
+        return `${roit_environment_1.Environment.currentEnv()}:${roit_environment_1.Environment.getProperty('service')}:${repositoryClassName}`;
     }
     getCacheResult(repositoryClassName, methodSignature, ...paramValue) {
-        const result = this.localCacheMap.get(this.buildKey(repositoryClassName, methodSignature, paramValue));
-        if (result) {
-            console.debug('[DEBUG] Caching >', `Return value in cache from key: ${this.buildKey(repositoryClassName, methodSignature, paramValue)}`);
-        }
-        return result;
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.buildKey(repositoryClassName, methodSignature, paramValue);
+            return this.cacheProvider.getCacheResult(key);
+        });
+    }
+    revokeCacheFromRepository(repository) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = yield this.cacheProvider.getCacheResult(repository);
+            if (keys && Array.isArray(keys)) {
+                for (const key of keys) {
+                    if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                        console.debug('[DEBUG] Caching >', `Removing key: ${key}`);
+                    }
+                    yield this.cacheProvider.delete(key);
+                }
+            }
+        });
     }
     cacheResult(repositoryClassName, methodSignature, valueToCache, ...paramValue) {
         var _a, _b, _c;
-        const option = this.repositorys.get(repositoryClassName);
-        if (option) {
-            const excludesMethod = Array.isArray(option === null || option === void 0 ? void 0 : option.excludesMethods) && ((_a = option === null || option === void 0 ? void 0 : option.excludesMethods) === null || _a === void 0 ? void 0 : _a.find(me => me == methodSignature));
-            const notIncludeOnlyMethod = Array.isArray(option === null || option === void 0 ? void 0 : option.includeOnlyMethods) && ((_b = option === null || option === void 0 ? void 0 : option.includeOnlyMethods) === null || _b === void 0 ? void 0 : _b.length) > 0 && ((_c = option === null || option === void 0 ? void 0 : option.includeOnlyMethods) === null || _c === void 0 ? void 0 : _c.find(me => me == methodSignature)) == undefined;
-            const notContainResult = (option === null || option === void 0 ? void 0 : option.cacheOnlyContainResults) ? ((Array.isArray(valueToCache) && valueToCache.length == 0) || valueToCache == null && valueToCache == undefined) : false;
-            if (excludesMethod || notIncludeOnlyMethod || notContainResult) {
-                return false;
-            }
-            this.localCacheMap.set(this.buildKey(repositoryClassName, methodSignature, paramValue), valueToCache);
-            if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
-                console.debug('[DEBUG] Caching >', `Storage cache from key: ${this.buildKey(repositoryClassName, methodSignature, paramValue)}`);
+        return __awaiter(this, void 0, void 0, function* () {
+            const option = this.repositorys.get(repositoryClassName);
+            if (option) {
+                const key = this.buildKey(repositoryClassName, methodSignature, paramValue);
+                const excludesMethod = Array.isArray(option === null || option === void 0 ? void 0 : option.excludesMethods) && ((_a = option === null || option === void 0 ? void 0 : option.excludesMethods) === null || _a === void 0 ? void 0 : _a.find(me => me == methodSignature));
+                const notIncludeOnlyMethod = Array.isArray(option === null || option === void 0 ? void 0 : option.includeOnlyMethods) && ((_b = option === null || option === void 0 ? void 0 : option.includeOnlyMethods) === null || _b === void 0 ? void 0 : _b.length) > 0 && ((_c = option === null || option === void 0 ? void 0 : option.includeOnlyMethods) === null || _c === void 0 ? void 0 : _c.find(me => me == methodSignature)) == undefined;
+                const notContainResult = (option === null || option === void 0 ? void 0 : option.cacheOnlyContainResults) ? ((Array.isArray(valueToCache) && valueToCache.length == 0) || !valueToCache) : false;
+                if (excludesMethod || notIncludeOnlyMethod || notContainResult) {
+                    return false;
+                }
+                yield this.cacheProvider.saveCacheResult(key, valueToCache, option.cacheExpiresInSeconds);
+                const repositoryKey = this.buildRepositoryKey(repositoryClassName);
+                let cache = yield this.cacheProvider.getCacheResult(repositoryKey);
+                if (!cache) {
+                    cache = [];
+                }
+                if (!cache.find(item => item === key)) {
+                    cache.push(key);
+                }
+                const cacheTtl = 0;
+                yield this.cacheProvider.saveCacheResult(repositoryKey, cache, cacheTtl);
+                return true;
             }
-            return true;
-        }
-        return false;
-    }
-    buildKey(repositoryClassName, methodSignature, ...paramValue) {
-        return `${repositoryClassName}:${methodSignature}:${paramValue.join(',')}`;
+            return false;
+        });
     }
 }
 exports.CacheResolver = CacheResolver;

package/dist/cache/providers/CacheProvider.d.ts

@@ -0,0 +1,5 @@
+export interface CacheProvider {
+    getCacheResult(key: string): Promise<any | null>;
+    saveCacheResult(key: string, valueToCache: any, ttl: number | undefined): Promise<void>;
+    delete(key: string): Promise<void>;
+}

package/dist/cache/providers/CacheProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cache/providers/InMemory.d.ts

@@ -0,0 +1,8 @@
+import { CacheableOptions } from "../../model/CacheableOptions";
+import { CacheProvider } from "./CacheProvider";
+export declare class InMemory implements CacheProvider {
+    private localCacheMap;
+    constructor();
+    getCacheResult(key: string): any;
+    saveCacheResult(key: string, option: CacheableOptions | undefined, methodSignature: string, valueToCache: any): boolean;
+}

package/dist/cache/providers/InMemory.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemory = void 0;
+const roit_environment_1 = require("roit-environment");
+const villar_1 = require("villar");
+const CacheProviders_1 = require("../../model/CacheProviders");
+let InMemory = class InMemory {
+    constructor() {
+        this.localCacheMap = new Map;
+        console.log("Fui chamado");
+    }
+    getCacheResult(key) {
+        const result = this.localCacheMap.get(key);
+        if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+            if (result) {
+                console.debug('[DEBUG] Caching >', `Return value in cache from key: ${key}`);
+            }
+            else {
+                console.log("[DEBUG] Does not have in cache", key);
+            }
+        }
+        return result;
+    }
+    saveCacheResult(key, option, methodSignature, valueToCache) {
+        var _a, _b, _c;
+        if (option) {
+            const excludesMethod = Array.isArray(option === null || option === void 0 ? void 0 : option.excludesMethods) && ((_a = option === null || option === void 0 ? void 0 : option.excludesMethods) === null || _a === void 0 ? void 0 : _a.find(me => me == methodSignature));
+            const notIncludeOnlyMethod = Array.isArray(option === null || option === void 0 ? void 0 : option.includeOnlyMethods) && ((_b = option === null || option === void 0 ? void 0 : option.includeOnlyMethods) === null || _b === void 0 ? void 0 : _b.length) > 0 && ((_c = option === null || option === void 0 ? void 0 : option.includeOnlyMethods) === null || _c === void 0 ? void 0 : _c.find(me => me == methodSignature)) == undefined;
+            const notContainResult = (option === null || option === void 0 ? void 0 : option.cacheOnlyContainResults) ? ((Array.isArray(valueToCache) && valueToCache.length == 0) || valueToCache == null && valueToCache == undefined) : false;
+            if (excludesMethod || notIncludeOnlyMethod || notContainResult) {
+                return false;
+            }
+            this.localCacheMap.set(key, valueToCache);
+            if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                console.debug('[DEBUG] Caching >', `Storage cache from key: ${key}`);
+            }
+            return true;
+        }
+        return false;
+    }
+};
+InMemory = __decorate([
+    (0, villar_1.Implementation)({
+        key: CacheProviders_1.CacheProviders.LOCAL
+    }),
+    __metadata("design:paramtypes", [])
+], InMemory);
+exports.InMemory = InMemory;

package/dist/cache/providers/InMemoryCacheProvider.d.ts

@@ -0,0 +1,7 @@
+import { CacheProvider } from "./CacheProvider";
+export declare class InMemoryCacheProvider implements CacheProvider {
+    private cache;
+    getCacheResult(key: string): Promise<any | null>;
+    saveCacheResult(key: string, valueToCache: any, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}

package/dist/cache/providers/InMemoryCacheProvider.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCacheProvider = void 0;
+const roit_environment_1 = require("roit-environment");
+const node_cache_1 = __importDefault(require("node-cache"));
+class InMemoryCacheProvider {
+    constructor() {
+        this.cache = new node_cache_1.default();
+    }
+    getCacheResult(key) {
+        const result = this.cache.get(key);
+        if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+            if (result) {
+                console.debug('[DEBUG] Local Caching >', `Return value in cache from key: ${key}`);
+            }
+            else {
+                console.log("[DEBUG] Local Caching > ", `Key [${key}] is not found in the cache`);
+            }
+        }
+        return Promise.resolve(result);
+    }
+    saveCacheResult(key, valueToCache, ttl) {
+        this.cache.set(key, valueToCache, ttl || 0);
+        if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+            console.debug('[DEBUG] Caching >', `Storage cache from key: ${key}`);
+        }
+        return Promise.resolve();
+    }
+    delete(key) {
+        this.cache.del(key);
+        return Promise.resolve();
+    }
+}
+exports.InMemoryCacheProvider = InMemoryCacheProvider;

package/dist/cache/providers/RedisCacheProvider.d.ts

@@ -0,0 +1,9 @@
+import { CacheProvider } from "./CacheProvider";
+export declare class RedisCacheProvider implements CacheProvider {
+    private redis;
+    constructor();
+    private isRedisReady;
+    getCacheResult(key: string): Promise<any | null>;
+    saveCacheResult(key: string, valueToCache: any, ttl: number | undefined): Promise<void>;
+    delete(key: string): Promise<void>;
+}

package/dist/cache/providers/RedisCacheProvider.js

@@ -0,0 +1,93 @@
+"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 });
+exports.RedisCacheProvider = void 0;
+const redis_1 = require("redis");
+const roit_environment_1 = require("roit-environment");
+class RedisCacheProvider {
+    constructor() {
+        if (!this.redis) {
+            const url = roit_environment_1.Environment.getProperty('firestore.cache.redisUrl');
+            if (!url) {
+                console.error(`[ERROR] Redis Caching > environtment variable "firestore.cache.redisUrl" was not found!`);
+                return;
+            }
+            this.redis = (0, redis_1.createClient)({ url });
+            this.redis.on('error', (err) => {
+                if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                    console.warn('[WARN] Redis error', err);
+                }
+            });
+            this.redis.on('ready', () => {
+                if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                    console.log('[DEBUG] Redis Caching > Redis is ready');
+                }
+            });
+            this.redis.connect();
+        }
+    }
+    isRedisReady() {
+        return this.redis && this.redis.isReady;
+    }
+    getCacheResult(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.isRedisReady()) {
+                    const result = yield this.redis.get(key);
+                    if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                        if (result) {
+                            console.debug('[DEBUG] Redis Caching >', `Return value in cache from key: ${key}`);
+                        }
+                        else {
+                            console.log("[DEBUG] Redis Caching > ", `Key [${key}] is not found in the cache`);
+                        }
+                    }
+                    if (result) {
+                        return JSON.parse(result);
+                    }
+                }
+            }
+            catch (error) {
+                return null;
+            }
+        });
+    }
+    saveCacheResult(key, valueToCache, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isRedisReady()) {
+                try {
+                    yield this.redis.set(key, JSON.stringify(valueToCache), {
+                        EX: ttl || 0
+                    });
+                    if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                        console.debug('[DEBUG] Caching >', `Storage cache from key: ${key}`);
+                    }
+                }
+                catch (error) {
+                    console.log(`[DEBUG] Redis Caching > Error when saving cache. Key: ${key}, value: ${valueToCache}, error: ${error}`);
+                }
+            }
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.isRedisReady()) {
+                    yield this.redis.del(key);
+                }
+            }
+            catch (error) {
+                console.log(`[DEBUG] Redis Caching > Error when deleting key from redis. ${key}`);
+            }
+        });
+    }
+}
+exports.RedisCacheProvider = RedisCacheProvider;

package/dist/cache/providers/index.d.ts

@@ -0,0 +1,2 @@
+export { CacheProvider } from './CacheProvider';
+export { InMemoryCacheProvider } from './InMemoryCacheProvider';

package/dist/cache/providers/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCacheProvider = void 0;
+var InMemoryCacheProvider_1 = require("./InMemoryCacheProvider");
+Object.defineProperty(exports, "InMemoryCacheProvider", { enumerable: true, get: function () { return InMemoryCacheProvider_1.InMemoryCacheProvider; } });

package/dist/emulator/FirestoreEmuator.js

@@ -1,7 +1,26 @@
 "use strict";
+var __createBinding = (this && this.__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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const roit_environment_1 = require("roit-environment");
-const shell = require("shelljs");
+const shell = __importStar(require("shelljs"));
 shell.exec('lsof -ti tcp:9005 | xargs kill');
 shell.exec('lsof -ti tcp:4000 | xargs kill');
 shell.exec(`firebase --config ${process.cwd()}/src/emulator/firebase.json emulators:start --project ${roit_environment_1.Environment.getProperty('firestore.projectId')}`);

package/dist/index.d.ts

@@ -10,3 +10,4 @@ export { Cacheable } from "./decorators/Cacheable";
  */
 export { BaseRepository } from "./config/BaseRepository";
 export { ReadonlyRepository } from "./config/ReadonlyRepository";
+export { CacheProviders } from "./model/CacheProviders";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadonlyRepository = exports.BaseRepository = exports.Cacheable = exports.Query = exports.Repository = void 0;
+exports.CacheProviders = exports.ReadonlyRepository = exports.BaseRepository = exports.Cacheable = exports.Query = exports.Repository = void 0;
 require("reflect-metadata");
 /**
  * decorators
@@ -18,3 +18,5 @@ var BaseRepository_1 = require("./config/BaseRepository");
 Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return BaseRepository_1.BaseRepository; } });
 var ReadonlyRepository_1 = require("./config/ReadonlyRepository");
 Object.defineProperty(exports, "ReadonlyRepository", { enumerable: true, get: function () { return ReadonlyRepository_1.ReadonlyRepository; } });
+var CacheProviders_1 = require("./model/CacheProviders");
+Object.defineProperty(exports, "CacheProviders", { enumerable: true, get: function () { return CacheProviders_1.CacheProviders; } });

package/dist/model/CacheProviders.d.ts

@@ -0,0 +1,4 @@
+export declare enum CacheProviders {
+    LOCAL = "LOCAL",
+    REDIS = "REDIS"
+}

package/dist/model/CacheProviders.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheProviders = void 0;
+var CacheProviders;
+(function (CacheProviders) {
+    CacheProviders["LOCAL"] = "LOCAL";
+    CacheProviders["REDIS"] = "REDIS";
+})(CacheProviders = exports.CacheProviders || (exports.CacheProviders = {}));

package/dist/model/CacheableOptions.d.ts

@@ -1,6 +1,13 @@
 export declare class CacheableOptions {
     cacheOnlyContainResults?: boolean;
+    /**
+     *  (default: CacheProviders.LOCAL)
+     */
     cacheProvider?: string;
+    /**
+     *  (default: 0) the standard TTL for cache element cache element. 0 = unlimited
+     */
+    cacheExpiresInSeconds?: number;
     excludesMethods?: Array<string>;
     includeOnlyMethods?: Array<string>;
 }

package/dist/model/CacheableOptions.js

@@ -1,9 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheableOptions = void 0;
+const CacheProviders_1 = require("./CacheProviders");
 class CacheableOptions {
     constructor() {
         this.cacheOnlyContainResults = true;
+        /**
+         *  (default: CacheProviders.LOCAL)
+         */
+        this.cacheProvider = CacheProviders_1.CacheProviders.LOCAL;
+        /**
+         *  (default: 0) the standard TTL for cache element cache element. 0 = unlimited
+         */
+        this.cacheExpiresInSeconds = 0;
         this.excludesMethods = new Array;
         this.includeOnlyMethods = new Array;
     }

package/dist/query/operator/CreateFunction.js

@@ -72,6 +72,10 @@ class CreateFunction {
                     yield document.update(Object.assign({ lastServiceModify,
                         updateAt,
                         updateTimestampAt }, item));
+                    let repositoryClassName = '';
+                    const cacheResolver = global.instances.cacheResolver;
+                    const key = cacheResolver.buildRepositoryKey(repositoryClassName);
+                    yield cacheResolver.revokeCacheFromRepository(key);
                 }
                 else {
                     console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed');
@@ -108,6 +112,10 @@ class CreateFunction {
                 item.lastServiceModify = global.instances.Environment.getProperty('service') || 'PROJECT_UNDEFINED';
                 const docRef = collection.doc(item.id);
                 batch.update(docRef, JSON.parse(JSON.stringify(item)));
+                let repositoryClassName = '';
+                const cacheResolver = global.instances.cacheResolver;
+                const key = cacheResolver.buildRepositoryKey(repositoryClassName);
+                yield cacheResolver.revokeCacheFromRepository(key);
             }
             if (!environmentUtil.areWeTesting()) {
                 yield batch.commit();
@@ -179,6 +187,10 @@ class CreateFunction {
                 batch.delete(docRef);
             });
             if (!environmentUtil.areWeTesting()) {
+                let repositoryClassName = '';
+                const cacheResolver = global.instances.cacheResolver;
+                const key = cacheResolver.buildRepositoryKey(repositoryClassName);
+                yield cacheResolver.revokeCacheFromRepository(key);
                 yield batch.commit();
             }
             else {
@@ -193,7 +205,7 @@ class CreateFunction {
             let methodSignature = '';
             const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
             const cacheResolver = global.instances.cacheResolver;
-            const result = cacheResolver.getCacheResult(repositoryClassName, methodSignature, 'Any');
+            const result = yield cacheResolver.getCacheResult(repositoryClassName, methodSignature, 'Any');
             if (result) {
                 return result;
             }
@@ -211,7 +223,7 @@ class CreateFunction {
                 const data = doc.data();
                 items.push(Object.assign({}, data));
             });
-            cacheResolver.cacheResult(repositoryClassName, methodSignature, items, 'Any');
+            yield cacheResolver.cacheResult(repositoryClassName, methodSignature, items, 'Any');
             return items;
         });
     }
@@ -221,7 +233,7 @@ class CreateFunction {
             let methodSignature = '';
             const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
             const cacheResolver = global.instances.cacheResolver;
-            const result = cacheResolver.getCacheResult(repositoryClassName, methodSignature, id);
+            const result = yield cacheResolver.getCacheResult(repositoryClassName, methodSignature, id);
             if (result) {
                 return result;
             }
@@ -233,7 +245,7 @@ class CreateFunction {
             }
             const response = yield collection.doc(id).get();
             const item = response.data();
-            cacheResolver.cacheResult(repositoryClassName, methodSignature, item, id);
+            yield cacheResolver.cacheResult(repositoryClassName, methodSignature, item, id);
             return item;
         });
     }