@roit/roit-data-firestore 1.2.0 → 1.2.3

package/.github/workflows/deploy.yml

@@ -73,6 +73,7 @@ jobs:
             node-version: '18.x'
             registry-url: 'https://registry.npmjs.org'
         - run: npm ci
+        - run: npm run build
         - run: npm publish
           env:
             NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -84,6 +84,15 @@ The anotation Cacheable is responsible from handler storage data in cache, local
 })
 ```
 
+##### Cache environment variables
+
+| Environment variable            | Description                             | Default value                                        |
+| -------------------|------------------------------------| ----------------------------------------     |
+| firestore.cache.redisUrl              | Ex: redis://localhost:63279           |
+| firestore.cache.timeout           | Timeout to Redis response (ms)            | 2000                  |
+| firestore.cache.reconnectInSecondsAfterTimeout      | Time to try to reconnect after Redis timeout (s)          | 30  |
+| firestore.debug        | Toggle debugging logs           | false                |
+
 ## BaseRepository and ReadonlyRepository
 To standardize the BaseRepository already provides the common methods for implementation
 

package/dist/cache/CacheResolver.d.ts

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

package/dist/cache/CacheResolver.js

@@ -0,0 +1,88 @@
+"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.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) {
+        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) {
+        return `${roit_environment_1.Environment.currentEnv()}:${repositoryClassName}:${methodSignature}:${paramValue.join(',')}`;
+    }
+    buildRepositoryKey(repositoryClassName) {
+        return `${roit_environment_1.Environment.currentEnv()}:${repositoryClassName}`;
+    }
+    getCacheResult(repositoryClassName, methodSignature, ...paramValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.repositorys.get(repositoryClassName)) {
+                return null;
+            }
+            const key = this.buildKey(repositoryClassName, methodSignature, paramValue);
+            return this.cacheProvider.getCacheResult(key);
+        });
+    }
+    revokeCacheFromRepository(repositoryClassName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.buildRepositoryKey(repositoryClassName);
+            if (!this.repositorys.get(repositoryClassName)) {
+                return;
+            }
+            const keys = yield this.cacheProvider.getKeys(`${key}`);
+            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);
+                }
+            }
+            yield this.cacheProvider.delete(key);
+        });
+    }
+    cacheResult(repositoryClassName, methodSignature, valueToCache, ...paramValue) {
+        var _a, _b, _c;
+        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);
+                return true;
+            }
+            return false;
+        });
+    }
+}
+exports.CacheResolver = CacheResolver;
+CacheResolver.instance = new CacheResolver;

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

@@ -0,0 +1,6 @@
+export interface CacheProvider {
+    getCacheResult(key: string): Promise<any | null | any[]>;
+    getKeys(query: string): Promise<string[]>;
+    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/InMemoryCacheProvider.d.ts

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

package/dist/cache/providers/InMemoryCacheProvider.js

@@ -0,0 +1,46 @@
+"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] Memory Caching >', `Return value in cache from key: ${key}`);
+            }
+            else {
+                console.log("[DEBUG] Memory Caching > ", `Key [${key}] is not found in the cache`);
+            }
+        }
+        return Promise.resolve(result);
+    }
+    getKeys(query) {
+        try {
+            return Promise.resolve(this.cache.keys().filter(key => key.includes(query)));
+        }
+        catch (error) {
+            console.log(`[DEBUG] Memory Caching > Error when getting KEYS with query: ${query}, error: ${error}`);
+        }
+        return Promise.resolve([]);
+    }
+    saveCacheResult(key, valueToCache, ttl) {
+        this.cache.set(key, valueToCache, ttl || 0);
+        if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+            console.debug('[DEBUG] Memory 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,19 @@
+import { CacheProvider } from "./CacheProvider";
+export declare class RedisCacheProvider implements CacheProvider {
+    /**
+     * Redis module instance loaded dynamically.
+     */
+    private redis;
+    /**
+     * Connected redis client.
+     */
+    private client;
+    private isRedisReady;
+    constructor();
+    private handleTimeoutError;
+    getKeys(query: string): Promise<string[]>;
+    getCacheResult(key: string): Promise<any | null>;
+    saveCacheResult(key: string, valueToCache: any, ttl: number | undefined): Promise<void>;
+    delete(key: string): Promise<void>;
+    private loadRedis;
+}

package/dist/cache/providers/RedisCacheProvider.js

@@ -0,0 +1,137 @@
+"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 roit_environment_1 = require("roit-environment");
+const PlatformTools_1 = require("../../platform/PlatformTools");
+const promise_timeout_1 = require("promise-timeout");
+const REDIS_TIMEOUT = roit_environment_1.Environment.getProperty('firestore.cache.timeout') || 2000;
+const REDIS_RECONNECT = roit_environment_1.Environment.getProperty('firestore.cache.reconnectInSecondsAfterTimeout') || 30;
+class RedisCacheProvider {
+    constructor() {
+        this.isRedisReady = false;
+        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;
+            }
+            const isJest = typeof jest !== 'undefined';
+            if (isJest) {
+                return;
+            }
+            this.redis = this.loadRedis();
+            this.client = this.redis.createClient({ url });
+            this.client.on('error', (err) => {
+                this.isRedisReady = false;
+                if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                    console.warn('[WARN] Redis error', err);
+                }
+            });
+            this.client.on('ready', () => {
+                this.isRedisReady = true;
+                if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                    console.log('[DEBUG] Redis Caching > Redis is ready');
+                }
+            });
+            this.client.connect();
+        }
+    }
+    handleTimeoutError(error) {
+        if (error.message === 'Timeout' && this.isRedisReady) {
+            console.log('Setting isRedisReady as false');
+            this.isRedisReady = false;
+            // Stop everything for a while to unburden Redis
+            setTimeout(() => {
+                console.log('Setting isRedisReady as true');
+                this.isRedisReady = true;
+            }, REDIS_RECONNECT * 1000);
+        }
+    }
+    getKeys(query) {
+        try {
+            if (this.isRedisReady) {
+                return (0, promise_timeout_1.timeout)(this.client.KEYS(`*${query}*`), REDIS_TIMEOUT);
+            }
+        }
+        catch (error) {
+            this.handleTimeoutError(error);
+            console.log(`[DEBUG] Redis Caching > Error when getting KEYS with query: ${query}, error: ${error}`);
+        }
+        return Promise.resolve([]);
+    }
+    getCacheResult(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.isRedisReady) {
+                    const result = yield (0, promise_timeout_1.timeout)(this.client.get(key), REDIS_TIMEOUT);
+                    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);
+                    }
+                    return null;
+                }
+            }
+            catch (error) {
+                this.handleTimeoutError(error);
+                console.log(`[DEBUG] Redis Caching > Error when getting key from redis. ${key}`, { error });
+                return null;
+            }
+        });
+    }
+    saveCacheResult(key, valueToCache, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isRedisReady) {
+                try {
+                    yield (0, promise_timeout_1.timeout)(this.client.set(key, JSON.stringify(valueToCache), {
+                        EX: ttl || 0
+                    }), REDIS_TIMEOUT);
+                    if (Boolean(roit_environment_1.Environment.getProperty('firestore.debug'))) {
+                        console.debug('[DEBUG] Redis Caching >', `Storage cache from key: ${key}`);
+                    }
+                }
+                catch (error) {
+                    this.handleTimeoutError(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 (0, promise_timeout_1.timeout)(this.client.del(key), REDIS_TIMEOUT);
+                }
+            }
+            catch (error) {
+                this.handleTimeoutError(error);
+                console.log(`[DEBUG] Redis Caching > Error when deleting key from redis. ${key}`);
+            }
+        });
+    }
+    loadRedis() {
+        try {
+            return PlatformTools_1.PlatformTools.load("redis");
+        }
+        catch (e) {
+            throw new Error(`Cannot use cache because redis is not installed. Please run "npm i redis@4.0.6 --save-exact".`);
+        }
+    }
+}
+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/config/BaseRepository.d.ts

@@ -0,0 +1,38 @@
+import { QueryResult } from "../model";
+import { Config } from '../model/MQuery';
+import { Paging } from "../model/Paging";
+export declare abstract class BaseRepository<T> {
+    /**
+     * FindAll
+     * Get all available records in the collection
+     * @param paging
+     */
+    findAll: (paging?: Paging) => Promise<T[]>;
+    /**
+     * FindById
+     * Get registe
+     */
+    findById: (id: Required<string>) => Promise<T | undefined>;
+    create: (item: T | Array<T>) => Promise<Array<T>>;
+    update: (items: T | Array<T>) => Promise<Array<T>>;
+    createOrUpdate: (items: T | Array<T>) => Promise<Array<T>>;
+    /**
+     * Update partial data
+     */
+    updatePartial: (id: Required<string>, itemPartial: Partial<T>) => Promise<void>;
+    /**
+     * Delete Row or Rows in bath
+     * @param id
+     */
+    delete: (id: Required<string> | Array<string>) => Promise<Array<string>>;
+    /**
+     * Distributed counters
+     * https://firebase.google.com/docs/firestore/solutions/counters#web
+     *
+     * @param field field from increment
+     * @param increment value increment, default value 1
+     */
+    incrementField: (id: Required<string>, field: Required<string>, increment?: number) => Promise<void>;
+    query(config: Config): Promise<T[]>;
+    queryPaginated(config: Config): Promise<QueryResult<T>>;
+}

package/dist/config/BaseRepository.js

@@ -0,0 +1,70 @@
+"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);
+};
+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.BaseRepository = void 0;
+const Query_1 = require("../decorators/Query");
+const ManualQueryHelper_1 = require("../query/ManualQueryHelper");
+class BaseRepository {
+    query(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const className = this.constructor.prototype.constructor.name;
+            return ManualQueryHelper_1.ManualQueryHelper.executeQueryManual(className, config);
+        });
+    }
+    queryPaginated(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const className = this.constructor.prototype.constructor.name;
+            return ManualQueryHelper_1.ManualQueryHelper.executeQueryManualPaginated(className, config);
+        });
+    }
+}
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "findAll", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "findById", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "create", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "update", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "createOrUpdate", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "updatePartial", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "delete", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], BaseRepository.prototype, "incrementField", void 0);
+exports.BaseRepository = BaseRepository;

package/dist/config/ClassCollectionMap.d.ts

@@ -0,0 +1,7 @@
+export declare class ClassCollectionMap {
+    private static instance;
+    private classMap;
+    private constructor();
+    register(className: string, collection: string): void;
+    static getInstance(): ClassCollectionMap;
+}

package/dist/config/ClassCollectionMap.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassCollectionMap = void 0;
+class ClassCollectionMap {
+    constructor() {
+        this.classMap = new Map;
+    }
+    register(className, collection) {
+        this.classMap.set(className, collection);
+    }
+    static getInstance() {
+        return this.instance;
+    }
+}
+exports.ClassCollectionMap = ClassCollectionMap;
+ClassCollectionMap.instance = new ClassCollectionMap;

package/dist/config/ClassMethodQueryMap.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions } from '../decorators/Query';
+export declare class ClassMethodQueryMap {
+    private static instance;
+    private collectionMap;
+    private queryConfig;
+    constructor();
+    register(className: string, methodSignature: string, options?: QueryOptions): void;
+    get(className: string): Array<string> | undefined;
+    getMethodConfig(className: string, methodSignature: string): QueryOptions | undefined;
+    static getInstance(): ClassMethodQueryMap;
+}

package/dist/config/ClassMethodQueryMap.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassMethodQueryMap = void 0;
+class ClassMethodQueryMap {
+    constructor() {
+        this.collectionMap = new Map;
+        this.queryConfig = new Map;
+    }
+    register(className, methodSignature, options) {
+        let list = this.collectionMap.get(className);
+        if (!list) {
+            list = new Array;
+        }
+        list.push(methodSignature);
+        this.collectionMap.set(className, list);
+        if (options) {
+            this.queryConfig.set(`${className}:${methodSignature}`, options);
+        }
+    }
+    get(className) {
+        return this.collectionMap.get(className);
+    }
+    getMethodConfig(className, methodSignature) {
+        return this.queryConfig.get(`${className}:${methodSignature}`);
+    }
+    static getInstance() {
+        return this.instance;
+    }
+}
+exports.ClassMethodQueryMap = ClassMethodQueryMap;
+ClassMethodQueryMap.instance = new ClassMethodQueryMap;

package/dist/config/FirestoreInstance.d.ts

@@ -0,0 +1,7 @@
+import { Firestore } from "@google-cloud/firestore";
+export declare class FirestoreInstance {
+    private static instance;
+    private firestore;
+    constructor();
+    static getInstance(): Firestore;
+}

package/dist/config/FirestoreInstance.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreInstance = void 0;
+const firestore_1 = require("@google-cloud/firestore");
+const roit_environment_1 = require("roit-environment");
+const RepositorySystemException_1 = require("../exception/RepositorySystemException");
+class FirestoreInstance {
+    constructor() {
+        if (roit_environment_1.Environment.acceptedEnv(roit_environment_1.Env.TEST)) {
+            return;
+        }
+        const projectId = roit_environment_1.Environment.getProperty("firestore.projectId") || roit_environment_1.Environment.systemProperty("PROJECT_ID");
+        if (!projectId) {
+            throw new RepositorySystemException_1.RepositorySystemException(`ProjectId is required in env.yaml {firestore.projectId}`);
+        }
+        try {
+            this.firestore = new firestore_1.Firestore({
+                projectId
+            });
+        }
+        catch (err) {
+            console.error(err);
+            throw new RepositorySystemException_1.RepositorySystemException(`Error in initializeApp: ${err}`);
+        }
+    }
+    static getInstance() {
+        return this.instance.firestore;
+    }
+}
+exports.FirestoreInstance = FirestoreInstance;
+FirestoreInstance.instance = new FirestoreInstance();

package/dist/config/ReadonlyRepository.d.ts

@@ -0,0 +1,9 @@
+import { Paging } from "../model/Paging";
+import { Config } from '../model/MQuery';
+import { QueryResult } from "../model";
+export declare abstract class ReadonlyRepository<T> {
+    findAll: (paging?: Paging) => Promise<T[]>;
+    findById: (id: string) => Promise<T> | undefined;
+    query(config: Config): Promise<T[]>;
+    queryPaginated(config: Config): Promise<QueryResult<T>>;
+}

package/dist/config/ReadonlyRepository.js

@@ -0,0 +1,46 @@
+"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);
+};
+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.ReadonlyRepository = void 0;
+const Query_1 = require("../decorators/Query");
+const ManualQueryHelper_1 = require("../query/ManualQueryHelper");
+class ReadonlyRepository {
+    query(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const className = this.constructor.prototype.constructor.name;
+            return ManualQueryHelper_1.ManualQueryHelper.executeQueryManual(className, config);
+        });
+    }
+    queryPaginated(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const className = this.constructor.prototype.constructor.name;
+            return ManualQueryHelper_1.ManualQueryHelper.executeQueryManualPaginated(className, config);
+        });
+    }
+}
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], ReadonlyRepository.prototype, "findAll", void 0);
+__decorate([
+    (0, Query_1.Query)(),
+    __metadata("design:type", Function)
+], ReadonlyRepository.prototype, "findById", void 0);
+exports.ReadonlyRepository = ReadonlyRepository;

package/dist/decorators/Cacheable.d.ts

@@ -0,0 +1,2 @@
+import { CacheableOptions } from "../model/CacheableOptions";
+export declare function Cacheable(options?: CacheableOptions): (constructor: Function) => void;