@roit/roit-data-firestore 1.2.39 → 1.2.41

package/dist/archive/ArchiveService.d.ts

@@ -9,7 +9,6 @@ export declare class ArchiveService {
     private projectId;
     private firestore;
     private isInitialized;
-    private isDebug;
     /**
     * Construtor privado para prevenir instanciação direta
     */

package/dist/archive/ArchiveService.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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.ArchiveService = void 0;
 const storage_1 = require("@google-cloud/storage");
@@ -46,65 +37,63 @@ class ArchiveService {
     */
     constructor() {
         this.isInitialized = false;
-        this.isDebug = Boolean(ArchiveConfig_1.ArchiveConfig.getConfig().debug);
         // Construtor vazio - inicialização será feita em initialize()
     }
-    static getInstance() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Se já existe uma instância, retorna ela
-            if (ArchiveService.instance && ArchiveService.instance.isInitialized) {
-                return ArchiveService.instance;
-            }
-            // Se está inicializando, aguarda
-            if (ArchiveService.isInitializing) {
-                yield ArchiveService.lock;
-                return ArchiveService.instance;
-            }
-            // Inicializa a instância
-            ArchiveService.isInitializing = true;
-            try {
-                if (!ArchiveService.instance) {
-                    ArchiveService.instance = new ArchiveService();
-                }
-                yield ArchiveService.instance.initialize();
-                return ArchiveService.instance;
-            }
-            finally {
-                ArchiveService.isInitializing = false;
-            }
-        });
+    static async getInstance() {
+        // Se já existe uma instância, retorna ela
+        if (ArchiveService.instance && ArchiveService.instance.isInitialized) {
+            return ArchiveService.instance;
+        }
+        // Se está inicializando, aguarda
+        if (ArchiveService.isInitializing) {
+            await ArchiveService.lock;
+            return ArchiveService.instance;
+        }
+        // Inicializa a instância
+        ArchiveService.isInitializing = true;
+        try {
+            if (!ArchiveService.instance) {
+                ArchiveService.instance = new ArchiveService();
+            }
+            await ArchiveService.instance.initialize();
+            return ArchiveService.instance;
+        }
+        finally {
+            ArchiveService.isInitializing = false;
+        }
     }
-    initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isInitialized) {
-                return;
-            }
-            this.config = ArchiveConfig_1.ArchiveConfig.getConfig();
-            this.cacheResolver = CacheResolver_1.CacheResolver.getInstance();
-            this.projectId = this.config.projectId;
-            if (this.isDebug) {
-                console.log(`[ARCHIVE SERVICE] Configuração: ${JSON.stringify(this.config)}`);
-            }
-            if (!this.firestore) {
-                this.firestore = new firestore_1.Firestore({
-                    projectId: 'roit-intern-infra'
-                });
-            }
-            // REGISTRAR O ARCHIVESERVICE COMO REPOSITORY
-            this.cacheResolver.addRepository('ArchiveService', {
-                cacheExpiresInSeconds: 3600,
-                cacheProvider: CacheProviders_1.CacheProviders.REDIS_ARCHIVE
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        this.config = ArchiveConfig_1.ArchiveConfig.getConfig();
+        this.cacheResolver = CacheResolver_1.CacheResolver.getInstance();
+        this.projectId = this.config.projectId;
+        (0, ArchiveConfig_1.onDebugLog)(`Configuração: ${JSON.stringify(this.config)}`);
+        if (!this.firestore) {
+            this.firestore = new firestore_1.Firestore({
+                projectId: 'roit-intern-infra'
             });
-            if (!this.config.enabled) {
-                console.log('ArchiveService: Arquivamento desabilitado');
-                return;
-            }
+        }
+        // REGISTRAR O ARCHIVESERVICE COMO REPOSITORY
+        this.cacheResolver.addRepository('ArchiveService', {
+            cacheExpiresInSeconds: 3600,
+            cacheProvider: CacheProviders_1.CacheProviders.REDIS_ARCHIVE
+        });
+        if (!this.config.enabled) {
+            (0, ArchiveConfig_1.onDebugLog)('Arquivamento desabilitado');
+            return;
+        }
+        else {
             this.storage = new storage_1.Storage();
             this.bucketName = this.config.bucketName;
             if (!this.bucketName) {
-                console.warn('ArchiveService: bucket_name não configurado');
+                (0, ArchiveConfig_1.onDebugWarn)('ArchiveService: bucket_name não configurado');
             }
-        });
+            else {
+                (0, ArchiveConfig_1.onDebugLog)(`Bucket configurado: ${this.bucketName}`);
+            }
+        }
     }
     static resetInstance() {
         ArchiveService.instance = null;
@@ -125,100 +114,88 @@ class ArchiveService {
         }
         return documentData && documentData.fbArchivedAt;
     }
-    pipeline(readStream, gunzip, writable) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                readStream.pipe(gunzip).pipe(writable);
-                writable.on('finish', resolve);
-                writable.on('error', reject);
-            });
+    async pipeline(readStream, gunzip, writable) {
+        return new Promise((resolve, reject) => {
+            readStream.pipe(gunzip).pipe(writable);
+            writable.on('finish', resolve);
+            writable.on('error', reject);
         });
     }
     /**
      * Recupera documento arquivado em formato JSON
      */
-    retrieveJsonDocument(collectionName, docId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const filePath = `${this.projectId}/${collectionName}/${docId}.json.gz`;
-                const bucket = this.storage.bucket(this.bucketName);
-                const file = bucket.file(filePath);
-                const [exists] = yield file.exists();
-                if (!exists) {
-                    return null;
-                }
-                const readStream = file.createReadStream();
-                const gunzip = zlib.createGunzip();
-                const chunks = [];
-                yield this.pipeline(readStream, gunzip, new stream_1.Writable({
-                    write(chunk, _enc, cb) {
-                        chunks.push(chunk);
-                        cb();
-                    }
-                }));
-                const result = Buffer.concat(chunks).toString('utf-8');
-                return JSON.parse(result);
-            }
-            catch (error) {
-                console.warn(`Erro ao recuperar documento JSON arquivado ${collectionName}/${docId}:`, error);
+    async retrieveJsonDocument(collectionName, docId) {
+        try {
+            const filePath = `${this.projectId}/${collectionName}/${docId}.json.gz`;
+            const bucket = this.storage.bucket(this.bucketName);
+            const file = bucket.file(filePath);
+            const [exists] = await file.exists();
+            if (!exists) {
                 return null;
             }
-        });
+            const readStream = file.createReadStream();
+            const gunzip = zlib.createGunzip();
+            const chunks = [];
+            await this.pipeline(readStream, gunzip, new stream_1.Writable({
+                write(chunk, _enc, cb) {
+                    chunks.push(chunk);
+                    cb();
+                }
+            }));
+            const result = Buffer.concat(chunks).toString('utf-8');
+            return JSON.parse(result);
+        }
+        catch (error) {
+            console.log(`${ArchiveConfig_1.DEBUG_PREFIX} Erro ao recuperar documento JSON arquivado ${collectionName}/${docId}:`, error);
+            return null;
+        }
     }
     /**
      * Verifica se um documento está arquivado e recupera seus dados completos
      */
-    getArchivedDocument(collectionName, doc) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isEnabled()) {
-                return null;
-            }
-            if (!this.bucketName) {
-                console.warn('ArchiveService: bucket_name não configurado, não é possível recuperar documentos arquivados');
-                return null;
-            }
-            const docId = doc.id;
-            // Verificar cache se habilitado
-            if (this.config.cache.enabled) {
-                const cacheKey = `archived_${collectionName}_${docId}`;
-                const cachedData = yield this.cacheResolver.getCacheResult('ArchiveService', 'getArchivedDocument', cacheKey);
-                if (cachedData) {
-                    if (this.isDebug) {
-                        console.log(`Cache hit para documento arquivado: ${collectionName}/${docId}`);
-                    }
-                    return cachedData;
-                }
+    async getArchivedDocument(collectionName, doc) {
+        if (!this.isEnabled()) {
+            return null;
+        }
+        if (!this.bucketName) {
+            console.warn(`${ArchiveConfig_1.DEBUG_PREFIX} ArchiveService: bucket_name não configurado, não é possível recuperar documentos arquivados`);
+            return null;
+        }
+        const docId = doc.id;
+        // Verificar cache se habilitado
+        if (this.config.cache.enabled) {
+            const cacheKey = `archived_${collectionName}_${docId}`;
+            const cachedData = await this.cacheResolver.getCacheResult('ArchiveService', 'getArchivedDocument', cacheKey);
+            if (cachedData) {
+                (0, ArchiveConfig_1.onDebugLog)(`Cache hit para documento arquivado: ${collectionName}/${docId}`);
+                return cachedData;
             }
-            try {
-                const archivedData = yield this.retrieveJsonDocument(collectionName, docId);
-                if (archivedData) {
-                    // Salvar no cache se habilitado
-                    if (this.config.cache.enabled) {
-                        const cacheKey = `archived_${collectionName}_${docId}`;
-                        yield this.cacheResolver.cacheResult('ArchiveService', 'getArchivedDocument', archivedData, cacheKey);
-                        if (this.isDebug) {
-                            console.log(`Documento arquivado cacheado: ${collectionName}/${docId}`);
-                        }
-                    }
-                    return archivedData;
+        }
+        try {
+            const archivedData = await this.retrieveJsonDocument(collectionName, docId);
+            if (archivedData) {
+                // Salvar no cache se habilitado
+                if (this.config.cache.enabled) {
+                    const cacheKey = `archived_${collectionName}_${docId}`;
+                    await this.cacheResolver.cacheResult('ArchiveService', 'getArchivedDocument', archivedData, cacheKey);
+                    (0, ArchiveConfig_1.onDebugLog)(`Documento arquivado cacheado: ${collectionName}/${docId}`);
                 }
+                return archivedData;
             }
-            catch (error) {
-                console.warn(`Erro ao recuperar documento arquivado ${collectionName}/${docId}:`, error);
-            }
-            return null;
-        });
+        }
+        catch (error) {
+            console.warn(`${ArchiveConfig_1.DEBUG_PREFIX} Erro ao recuperar documento arquivado ${collectionName}/${docId}:`, error);
+        }
+        return null;
     }
     /**
      * Limpa o cache de documentos arquivados
      */
-    clearArchivedCache(collectionName, docId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config.cache.enabled) {
-                return;
-            }
-            yield this.cacheResolver.revokeArchiveCache(collectionName, docId);
-        });
+    async clearArchivedCache(collectionName, docId) {
+        if (!this.config.cache.enabled) {
+            return;
+        }
+        await this.cacheResolver.revokeArchiveCache(collectionName, docId);
     }
 }
 exports.ArchiveService = ArchiveService;

package/dist/cache/CacheResolver.js

@@ -1,13 +1,4 @@
 "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");
@@ -15,10 +6,10 @@ const providers_1 = require("./providers");
 const RedisCacheProvider_1 = require("./providers/RedisCacheProvider");
 const CacheProviders_1 = require("../model/CacheProviders");
 const CurrentEnv_1 = require("../util/CurrentEnv");
-const IsDebug_1 = require("../util/IsDebug");
 const QueryPredicateFunctionTransform_1 = require("../query/QueryPredicateFunctionTransform");
 const RedisCacheArchiveProvider_1 = require("./providers/RedisCacheArchiveProvider");
 const ArchiveConfig_1 = require("../config/ArchiveConfig");
+const IsDebug_1 = require("../util/IsDebug");
 class CacheResolver {
     constructor() {
         this.repositorys = new Map;
@@ -43,112 +34,97 @@ class CacheResolver {
     buildRepositoryKey(repositoryClassName) {
         return `${CurrentEnv_1.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);
-        });
+    async getCacheResult(repositoryClassName, methodSignature, ...paramValue) {
+        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 (IsDebug_1.isDebug) {
-                        console.debug('[DEBUG] Caching >', `Removing key: ${key}`);
-                    }
-                    yield this.cacheProvider.delete(key);
+    async revokeCacheFromRepository(repositoryClassName) {
+        const key = this.buildRepositoryKey(repositoryClassName);
+        if (!this.repositorys.get(repositoryClassName)) {
+            return;
+        }
+        const keys = await this.cacheProvider.getKeys(`${key}`);
+        if (keys && Array.isArray(keys)) {
+            for (const key of keys) {
+                if (IsDebug_1.isDebug) {
+                    console.debug('[DEBUG] Caching >', `Removing key: ${key}`);
                 }
+                await this.cacheProvider.delete(key);
             }
-            yield this.cacheProvider.delete(key);
-            // REVOGAR CACHE DO ARCHIVE PARA A MESMA COLLECTION
-            yield this.revokeArchiveCacheForRepository(repositoryClassName);
-        });
+        }
+        await this.cacheProvider.delete(key);
+        // REVOGAR CACHE DO ARCHIVE PARA A MESMA COLLECTION
+        await this.revokeArchiveCacheForRepository(repositoryClassName);
     }
-    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;
+    async cacheResult(repositoryClassName, methodSignature, valueToCache, ...paramValue) {
+        const option = this.repositorys.get(repositoryClassName);
+        if (option) {
+            const key = this.buildKey(repositoryClassName, methodSignature, paramValue);
+            const excludesMethod = Array.isArray(option?.excludesMethods) && option?.excludesMethods?.find(me => me == methodSignature);
+            const notIncludeOnlyMethod = Array.isArray(option?.includeOnlyMethods) && option?.includeOnlyMethods?.length > 0 && option?.includeOnlyMethods?.find(me => me == methodSignature) == undefined;
+            const notContainResult = option?.cacheOnlyContainResults ? ((Array.isArray(valueToCache) && valueToCache.length == 0) || !valueToCache) : false;
+            if (excludesMethod || notIncludeOnlyMethod || notContainResult) {
+                return false;
             }
-            return false;
-        });
+            await this.cacheProvider.saveCacheResult(key, valueToCache, option.cacheExpiresInSeconds);
+            return true;
+        }
+        return false;
     }
-    revokeArchiveCache(collectionName, docId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const repositoryKey = this.buildRepositoryKey('ArchiveService');
-            if (!this.repositorys.get('ArchiveService')) {
-                return;
+    async revokeArchiveCache(collectionName, docId) {
+        const repositoryKey = this.buildRepositoryKey('ArchiveService');
+        if (!this.repositorys.get('ArchiveService')) {
+            return;
+        }
+        const keys = await this.cacheProvider.getKeys(`${repositoryKey}`);
+        if (!keys || !Array.isArray(keys)) {
+            return;
+        }
+        for (const key of keys) {
+            let shouldDelete = false;
+            if (collectionName && docId) {
+                // Limpar cache de documento específico
+                const cacheKey = `archived_${collectionName}_${docId}`;
+                shouldDelete = key.includes(`getArchivedDocument:${cacheKey}`);
             }
-            const keys = yield this.cacheProvider.getKeys(`${repositoryKey}`);
-            if (!keys || !Array.isArray(keys)) {
-                return;
+            else if (collectionName) {
+                // Limpar cache de collection específica
+                shouldDelete = key.includes(`getArchivedDocument:archived_${collectionName}`);
             }
-            for (const key of keys) {
-                let shouldDelete = false;
-                if (collectionName && docId) {
-                    // Limpar cache de documento específico
-                    const cacheKey = `archived_${collectionName}_${docId}`;
-                    shouldDelete = key.includes(`getArchivedDocument:${cacheKey}`);
-                }
-                else if (collectionName) {
-                    // Limpar cache de collection específica
-                    shouldDelete = key.includes(`getArchivedDocument:archived_${collectionName}`);
-                }
-                else {
-                    // Limpar todo o cache de arquivamento
-                    shouldDelete = key.includes('getArchivedDocument');
-                }
-                if (shouldDelete) {
-                    if (Boolean(ArchiveConfig_1.ArchiveConfig.getConfig().debug)) {
-                        console.debug('[DEBUG] Archive Cache >', `Removing key: ${key}`);
-                    }
-                    yield this.cacheProvider.delete(key);
-                }
-            }
-        });
-    }
-    revokeArchiveCacheForRepository(repositoryClassName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Verificar se ArchiveService está registrado
-            if (!this.repositorys.get('ArchiveService')) {
-                return;
+            else {
+                // Limpar todo o cache de arquivamento
+                shouldDelete = key.includes('getArchivedDocument');
             }
-            // Obter a collection do repositório que está sendo revogado
-            const repositoryOptions = QueryPredicateFunctionTransform_1.QueryPredicateFunctionTransform.classConfig.get(repositoryClassName);
-            if (!repositoryOptions || !repositoryOptions.collection) {
-                return;
+            if (shouldDelete) {
+                (0, ArchiveConfig_1.onDebugLog)(`Archive Cache > Removing key: ${key}`);
+                await this.cacheProvider.delete(key);
             }
-            const collectionName = repositoryOptions.collection;
-            // Revogar cache do archive para essa collection
-            const archiveKeys = yield this.cacheProvider.getKeys(`${CurrentEnv_1.currentEnv}:ArchiveService`);
-            if (archiveKeys && Array.isArray(archiveKeys)) {
-                for (const key of archiveKeys) {
-                    if (key.includes(`getArchivedDocument:archived_${collectionName}`)) {
-                        if (Boolean(ArchiveConfig_1.ArchiveConfig.getConfig().debug)) {
-                            console.debug('[DEBUG] Archive Cache >', `Removing archive key: ${key}`);
-                        }
-                        yield this.cacheProvider.delete(key);
-                    }
+        }
+    }
+    async revokeArchiveCacheForRepository(repositoryClassName) {
+        // Verificar se ArchiveService está registrado
+        if (!this.repositorys.get('ArchiveService')) {
+            return;
+        }
+        // Obter a collection do repositório que está sendo revogado
+        const repositoryOptions = QueryPredicateFunctionTransform_1.QueryPredicateFunctionTransform.classConfig.get(repositoryClassName);
+        if (!repositoryOptions || !repositoryOptions.collection) {
+            return;
+        }
+        const collectionName = repositoryOptions.collection;
+        // Revogar cache do archive para essa collection
+        const archiveKeys = await this.cacheProvider.getKeys(`${CurrentEnv_1.currentEnv}:ArchiveService`);
+        if (archiveKeys && Array.isArray(archiveKeys)) {
+            for (const key of archiveKeys) {
+                if (key.includes(`getArchivedDocument:archived_${collectionName}`)) {
+                    (0, ArchiveConfig_1.onDebugLog)(`Archive Cache > Removing archive key: ${key}`);
+                    await this.cacheProvider.delete(key);
                 }
             }
-        });
+        }
     }
 }
 exports.CacheResolver = CacheResolver;

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

@@ -9,7 +9,6 @@ export declare class RedisCacheArchiveProvider implements CacheProvider {
      */
     private client;
     private isRedisReady;
-    private isDebug;
     constructor();
     private handleTimeoutError;
     getKeys(query: string): Promise<string[]>;