@roit/roit-data-firestore 1.2.33 → 1.2.36

package/dist/archive/ArchiveService.d.ts

@@ -0,0 +1,41 @@
+export declare class ArchiveService {
+    private static instance;
+    private static readonly lock;
+    private static isInitializing;
+    private storage;
+    private bucketName;
+    private config;
+    private cacheResolver;
+    private projectId;
+    private firestore;
+    private isInitialized;
+    private isDebug;
+    /**
+    * Construtor privado para prevenir instanciação direta
+    */
+    private constructor();
+    static getInstance(): Promise<ArchiveService>;
+    private initialize;
+    static resetInstance(): void;
+    /**
+     * Verifica se o arquivamento está habilitado
+     */
+    isEnabled(): boolean;
+    /**
+     * Verifica se um documento está arquivado
+     */
+    isDocumentArchived(documentData: any): boolean;
+    private pipeline;
+    /**
+     * Recupera documento arquivado em formato JSON
+     */
+    private retrieveJsonDocument;
+    /**
+     * Verifica se um documento está arquivado e recupera seus dados completos
+     */
+    getArchivedDocument(collectionName: string, doc: any): Promise<Record<string, any> | null>;
+    /**
+     * Limpa o cache de documentos arquivados
+     */
+    clearArchivedCache(collectionName?: string, docId?: string): Promise<void>;
+}

package/dist/archive/ArchiveService.js

@@ -0,0 +1,229 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+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");
+const zlib = __importStar(require("zlib"));
+const stream_1 = require("stream");
+const ArchiveConfig_1 = require("../config/ArchiveConfig");
+const CacheResolver_1 = require("../cache/CacheResolver");
+const CacheProviders_1 = require("../model/CacheProviders");
+const firestore_1 = require("@google-cloud/firestore");
+class ArchiveService {
+    /**
+    * Construtor privado para prevenir instanciação direta
+    */
+    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;
+            }
+        });
+    }
+    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
+            });
+            if (!this.config.enabled) {
+                console.log('ArchiveService: Arquivamento desabilitado');
+                return;
+            }
+            this.storage = new storage_1.Storage();
+            this.bucketName = this.config.bucketName;
+            if (!this.bucketName) {
+                console.warn('ArchiveService: bucket_name não configurado');
+            }
+        });
+    }
+    static resetInstance() {
+        ArchiveService.instance = null;
+        ArchiveService.isInitializing = false;
+    }
+    /**
+     * Verifica se o arquivamento está habilitado
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Verifica se um documento está arquivado
+     */
+    isDocumentArchived(documentData) {
+        return true;
+        if (!this.isEnabled()) {
+            return false;
+        }
+        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);
+            });
+        });
+    }
+    /**
+     * 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);
+                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;
+                }
+            }
+            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;
+                }
+            }
+            catch (error) {
+                console.warn(`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);
+        });
+    }
+}
+exports.ArchiveService = ArchiveService;
+// Singleton instance
+ArchiveService.instance = null;
+ArchiveService.lock = new Promise((resolve) => resolve());
+ArchiveService.isInitializing = false;

package/dist/cache/CacheResolver.d.ts

@@ -12,4 +12,6 @@ export declare class CacheResolver {
     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>;
+    revokeArchiveCache(collectionName?: string, docId?: string): Promise<void>;
+    private revokeArchiveCacheForRepository;
 }

package/dist/cache/CacheResolver.js

@@ -16,12 +16,16 @@ 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");
 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);
+        this.providersImplMap.set(CacheProviders_1.CacheProviders.REDIS_ARCHIVE, RedisCacheArchiveProvider_1.RedisCacheArchiveProvider);
     }
     static getInstance() {
         return this.instance;
@@ -64,6 +68,8 @@ class CacheResolver {
                 }
             }
             yield this.cacheProvider.delete(key);
+            // REVOGAR CACHE DO ARCHIVE PARA A MESMA COLLECTION
+            yield this.revokeArchiveCacheForRepository(repositoryClassName);
         });
     }
     cacheResult(repositoryClassName, methodSignature, valueToCache, ...paramValue) {
@@ -84,6 +90,66 @@ class CacheResolver {
             return false;
         });
     }
+    revokeArchiveCache(collectionName, docId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const repositoryKey = this.buildRepositoryKey('ArchiveService');
+            if (!this.repositorys.get('ArchiveService')) {
+                return;
+            }
+            const keys = yield 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}`);
+                }
+                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;
+            }
+            // 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 = 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);
+                    }
+                }
+            }
+        });
+    }
 }
 exports.CacheResolver = CacheResolver;
 CacheResolver.instance = new CacheResolver;

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

@@ -0,0 +1,20 @@
+import { CacheProvider } from "./CacheProvider";
+export declare class RedisCacheArchiveProvider implements CacheProvider {
+    /**
+     * Redis module instance loaded dynamically.
+     */
+    private redis;
+    /**
+     * Connected redis client.
+     */
+    private client;
+    private isRedisReady;
+    private isDebug;
+    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/RedisCacheArchiveProvider.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.RedisCacheArchiveProvider = void 0;
+const PlatformTools_1 = require("../../platform/PlatformTools");
+const promise_timeout_1 = require("promise-timeout");
+const ArchiveConfig_1 = require("../../config/ArchiveConfig");
+const REDIS_TIMEOUT = ArchiveConfig_1.ArchiveConfig.getConfig().cache.timeout;
+const REDIS_RECONNECT = ArchiveConfig_1.ArchiveConfig.getConfig().cache.reconnectInSecondsAfterTimeout;
+class RedisCacheArchiveProvider {
+    constructor() {
+        this.isRedisReady = false;
+        this.isDebug = Boolean(ArchiveConfig_1.ArchiveConfig.getConfig().debug);
+        if (!this.redis) {
+            const url = ArchiveConfig_1.ArchiveConfig.getConfig().cache.redisUrl;
+            if (!url) {
+                console.error(`[ERROR] Redis Caching > environtment variable "firestore.cache.archive.redisUrl" was not found!`);
+                return;
+            }
+            if (process.env.JEST_WORKER_ID !== undefined) {
+                return;
+            }
+            this.redis = this.loadRedis();
+            this.client = this.redis.createClient({ url });
+            this.client.on('error', (err) => {
+                this.isRedisReady = false;
+                if (this.isDebug) {
+                    console.warn('[WARN] Redis error', err);
+                }
+            });
+            this.client.on('ready', () => {
+                this.isRedisReady = true;
+                if (this.isDebug) {
+                    console.log('[DEBUG] Redis Caching Archive > 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 (this.isDebug) {
+                        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 || ArchiveConfig_1.ArchiveConfig.getConfig().cache.expiresInSeconds
+                    }), REDIS_TIMEOUT);
+                    if (this.isDebug) {
+                        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.RedisCacheArchiveProvider = RedisCacheArchiveProvider;

package/dist/config/ArchiveConfig.d.ts

@@ -0,0 +1,16 @@
+export interface ArchiveConfig {
+    enabled: boolean;
+    bucketName: string;
+    debug: boolean;
+    projectId: string;
+    cache: {
+        enabled: boolean;
+        redisUrl: string;
+        timeout: number;
+        reconnectInSecondsAfterTimeout: number;
+        expiresInSeconds: number;
+    };
+}
+export declare class ArchiveConfig {
+    static getConfig(): ArchiveConfig;
+}

package/dist/config/ArchiveConfig.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchiveConfig = void 0;
+const FIRESTORE_PROJECT_ID = process.env.FIRESTORE_PROJECTID || '';
+const FIRESTORE_ARCHIVE_DEBUG = process.env.FIRESTORE_ARCHIVE_DEBUG || false;
+const FIRESTORE_ARCHIVE_ENABLED = process.env.FIRESTORE_ARCHIVE_ENABLED || false;
+const FIRESTORE_ARCHIVE_BUCKET_NAME = process.env.FIRESTORE_ARCHIVE_BUCKET_NAME || "firestore-archive-roit";
+const FIRESTORE_ARCHIVE_CACHE_ENABLED = process.env.FIRESTORE_ARCHIVE_CACHE_ENABLED || false;
+const FIRESTORE_ARCHIVE_CACHE_REDIS_URL = process.env.FIRESTORE_ARCHIVE_CACHE_REDISURL || '';
+const FIRESTORE_ARCHIVE_CACHE_REDIS_TIMEOUT = process.env.FIRESTORE_ARCHIVE_CACHE_REDIS_TIMEOUT || 2000;
+const FIRESTORE_ARCHIVE_CACHE_REDIS_RECONNECT_IN_SECONDS_AFTER_TIMEOUT = process.env.FIRESTORE_ARCHIVE_CACHE_REDIS_RECONNECT_IN_SECONDS_AFTER_TIMEOUT || 30;
+const FIRESTORE_ARCHIVE_CACHE_EXPIRES_IN_SECONDS = process.env.FIRESTORE_ARCHIVE_CACHE_EXPIRESINSECONDS || 3600;
+class ArchiveConfig {
+    static getConfig() {
+        return {
+            debug: ['true', true].includes(FIRESTORE_ARCHIVE_DEBUG),
+            enabled: ['true', true].includes(FIRESTORE_ARCHIVE_ENABLED),
+            bucketName: FIRESTORE_ARCHIVE_BUCKET_NAME,
+            projectId: FIRESTORE_PROJECT_ID,
+            cache: {
+                enabled: ['true', true].includes(FIRESTORE_ARCHIVE_CACHE_ENABLED),
+                redisUrl: FIRESTORE_ARCHIVE_CACHE_REDIS_URL,
+                timeout: FIRESTORE_ARCHIVE_CACHE_REDIS_TIMEOUT,
+                reconnectInSecondsAfterTimeout: FIRESTORE_ARCHIVE_CACHE_REDIS_RECONNECT_IN_SECONDS_AFTER_TIMEOUT,
+                expiresInSeconds: FIRESTORE_ARCHIVE_CACHE_EXPIRES_IN_SECONDS
+            }
+        };
+    }
+}
+exports.ArchiveConfig = ArchiveConfig;

package/dist/config/BaseRepository.d.ts

@@ -55,4 +55,10 @@ export declare abstract class BaseRepository<T> {
     }) => Promise<{
         [k: string]: string | number;
     }>;
+    /**
+     * Limpa o cache de documentos arquivados
+     * @param collectionName Nome da collection (opcional)
+     * @param docId ID do documento (opcional)
+     */
+    clearArchivedCache(collectionName?: string, docId?: string): Promise<void>;
 }

package/dist/config/BaseRepository.js

@@ -19,6 +19,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseRepository = void 0;
+const ArchiveService_1 = require("../archive/ArchiveService");
 const Query_1 = require("../decorators/Query");
 const ManualQueryHelper_1 = require("../query/ManualQueryHelper");
 class BaseRepository {
@@ -40,6 +41,17 @@ class BaseRepository {
             return ManualQueryHelper_1.ManualQueryHelper.executeQueryManualPaginated(className, config);
         });
     }
+    /**
+     * Limpa o cache de documentos arquivados
+     * @param collectionName Nome da collection (opcional)
+     * @param docId ID do documento (opcional)
+     */
+    clearArchivedCache(collectionName, docId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const archiveService = yield ArchiveService_1.ArchiveService.getInstance();
+            yield archiveService.clearArchivedCache(collectionName, docId);
+        });
+    }
 }
 __decorate([
     (0, Query_1.Query)(),

package/dist/emulator/FirestoreEmuator.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export { Cacheable } from "./decorators/Cacheable";
 export { BaseRepository } from "./config/BaseRepository";
 export { ReadonlyRepository } from "./config/ReadonlyRepository";
 export { GenericRepository } from "./config/GenericRepository";
+export { ArchiveConfig } from "./config/ArchiveConfig";
 export { CacheProviders } from "./model/CacheProviders";
 export { FirestoreInstance } from "./config/FirestoreInstance";
 export * from "./model";

package/dist/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -10,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirestoreInstance = exports.CacheProviders = exports.GenericRepository = exports.ReadonlyRepository = exports.BaseRepository = exports.Cacheable = exports.Query = exports.Repository = void 0;
+exports.FirestoreInstance = exports.CacheProviders = exports.ArchiveConfig = exports.GenericRepository = exports.ReadonlyRepository = exports.BaseRepository = exports.Cacheable = exports.Query = exports.Repository = void 0;
 require("reflect-metadata");
 /**
  * decorators
@@ -30,6 +34,8 @@ var ReadonlyRepository_1 = require("./config/ReadonlyRepository");
 Object.defineProperty(exports, "ReadonlyRepository", { enumerable: true, get: function () { return ReadonlyRepository_1.ReadonlyRepository; } });
 var GenericRepository_1 = require("./config/GenericRepository");
 Object.defineProperty(exports, "GenericRepository", { enumerable: true, get: function () { return GenericRepository_1.GenericRepository; } });
+var ArchiveConfig_1 = require("./config/ArchiveConfig");
+Object.defineProperty(exports, "ArchiveConfig", { enumerable: true, get: function () { return ArchiveConfig_1.ArchiveConfig; } });
 var CacheProviders_1 = require("./model/CacheProviders");
 Object.defineProperty(exports, "CacheProviders", { enumerable: true, get: function () { return CacheProviders_1.CacheProviders; } });
 var FirestoreInstance_1 = require("./config/FirestoreInstance");