@roit/roit-data-firestore 1.2.42 → 1.2.44

package/dist/archive/ArchiveService.js

@@ -1,40 +1,37 @@
 "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;
-};
 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");
+const index_1 = require("./index");
+/**
+ * Logger interno para padronizar logs do ArchiveService
+ */
+class ArchiveLogger {
+    constructor(debug) {
+        this.prefix = '[ArchiveServices]';
+        this.isDebug = debug;
+    }
+    debug(message, ...args) {
+        if (this.isDebug) {
+            console.debug(`${this.prefix} ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.isDebug) {
+            console.info(`${this.prefix} ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        console.warn(`${this.prefix} ${message}`, ...args);
+    }
+    error(message, ...args) {
+        console.error(`${this.prefix} ${message}`, ...args);
+    }
+}
 class ArchiveService {
     /**
-    * Construtor privado para prevenir instanciação direta
-    */
+     * Construtor privado para prevenir instanciação direta
+     */
     constructor() {
         this.isInitialized = false;
         // Construtor vazio - inicialização será feita em initialize()
@@ -67,33 +64,23 @@ class ArchiveService {
             return;
         }
         this.config = ArchiveConfig_1.ArchiveConfig.getConfig();
-        this.cacheResolver = CacheResolver_1.CacheResolver.getInstance();
+        this.logger = new ArchiveLogger(this.config.debug);
+        // ProjectId do Firestore que está sendo arquivado (usado para paths no Storage)
         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'
-            });
-        }
-        // REGISTRAR O ARCHIVESERVICE COMO REPOSITORY
-        this.cacheResolver.addRepository('ArchiveService', {
-            cacheExpiresInSeconds: 3600,
-            cacheProvider: CacheProviders_1.CacheProviders.REDIS_ARCHIVE
-        });
+        if (!this.projectId) {
+            this.logger.warn('projectId não configurado - usando variável de ambiente');
+            this.projectId = process.env.FIRESTORE_PROJECTID || process.env.GCP_PROJECT || '';
+        }
+        this.logger.debug(`Configuração: projectId=${this.projectId}, enabled=${this.config.enabled}`);
         if (!this.config.enabled) {
-            (0, ArchiveConfig_1.onDebugLog)('Arquivamento desabilitado');
+            this.logger.info('Arquivamento desabilitado via configuração');
+            this.isInitialized = true;
             return;
         }
-        else {
-            this.storage = new storage_1.Storage();
-            this.bucketName = this.config.bucketName;
-            if (!this.bucketName) {
-                (0, ArchiveConfig_1.onDebugWarn)('ArchiveService: bucket_name não configurado');
-            }
-            else {
-                (0, ArchiveConfig_1.onDebugLog)(`Bucket configurado: ${this.bucketName}`);
-            }
+        if (!(0, index_1.hasArchivePlugin)()) {
+            this.logger.warn('Plugin firestore-archive não registrado - arquivamento desabilitado');
         }
+        this.isInitialized = true;
     }
     static resetInstance() {
         ArchiveService.instance = null;
@@ -101,9 +88,11 @@ class ArchiveService {
     }
     /**
      * Verifica se o arquivamento está habilitado
+     * Requer que o plugin firestore-archive esteja registrado
      */
     isEnabled() {
-        return this.config.enabled;
+        // Arquivamento só funciona com plugin registrado
+        return this.config.enabled && (0, index_1.hasArchivePlugin)();
     }
     /**
      * Verifica se um documento está arquivado
@@ -112,43 +101,7 @@ class ArchiveService {
         if (!this.isEnabled()) {
             return false;
         }
-        return documentData && documentData.fbArchivedAt;
-    }
-    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
-     */
-    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;
-        }
+        return (0, index_1.getArchivePlugin)().isDocumentArchived(documentData);
     }
     /**
      * Verifica se um documento está arquivado e recupera seus dados completos
@@ -157,45 +110,110 @@ class ArchiveService {
         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 = 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;
-            }
+        const archivePath = typeof doc?.[index_1.ARCHIVE_METADATA_FIELDS.ARCHIVE_PATH] === 'string'
+            ? doc[index_1.ARCHIVE_METADATA_FIELDS.ARCHIVE_PATH]
+            : '';
+        if (!archivePath || archivePath.trim().length === 0) {
+            throw new Error(`ArchiveService.getArchivedDocument: fbArchivePath is required. collection=${collectionName} docId=${docId}`);
+        }
+        // Delega para plugin (isEnabled já garante que existe)
+        return (0, index_1.getArchivePlugin)().getArchivedDocument({
+            collection: collectionName,
+            docId,
+            archivePath,
+            projectId: this.projectId,
+        });
+    }
+    /**
+     * Atualiza um documento arquivado no Cloud Storage
+     * Usado quando um documento arquivado é atualizado no Firestore
+     *
+     * @param collectionName - Nome da collection
+     * @param docId - ID do documento
+     * @param newData - Novos dados a serem mesclados com o documento arquivado
+     * @param archivePath - Path completo do objeto no Storage, normalmente o `fbArchivePath` do stub.
+     * @param options - Opções de atualização
+     * @returns Resultado da operação e dados mesclados
+     */
+    async updateArchivedDocument(collectionName, docId, newData, archivePath, options) {
+        if (!this.isEnabled()) {
+            return { result: { success: false, message: 'Arquivamento desabilitado ou plugin não registrado' } };
+        }
+        if (!archivePath || typeof archivePath !== 'string' || archivePath.trim().length === 0) {
+            throw new Error(`ArchiveService.updateArchivedDocument: fbArchivePath is required. collection=${collectionName} docId=${docId}`);
+        }
+        // Delega para plugin (isEnabled já garante que existe)
+        return (0, index_1.getArchivePlugin)().updateArchivedDocument({
+            collection: collectionName,
+            docId,
+            newData,
+            options,
+            projectId: this.projectId,
+            archivePath,
+        });
+    }
+    /**
+     * Deleta um documento arquivado do Cloud Storage
+     * Usado quando um documento é permanentemente deletado ou restaurado
+     *
+     * @param collectionName - Nome da collection
+     * @param docId - ID do documento
+     * @param archivePath - Path completo do objeto no Storage, normalmente o `fbArchivePath` do stub.
+     * @returns Resultado da operação
+     */
+    async deleteArchivedDocument(collectionName, docId, archivePath) {
+        if (!this.isEnabled()) {
+            return { success: false, message: 'Arquivamento desabilitado ou plugin não registrado' };
         }
-        catch (error) {
-            console.warn(`${ArchiveConfig_1.DEBUG_PREFIX} Erro ao recuperar documento arquivado ${collectionName}/${docId}:`, error);
+        if (!archivePath || typeof archivePath !== 'string' || archivePath.trim().length === 0) {
+            throw new Error(`ArchiveService.deleteArchivedDocument: fbArchivePath is required. collection=${collectionName} docId=${docId}`);
         }
-        return null;
+        // Delega para plugin (isEnabled já garante que existe)
+        return (0, index_1.getArchivePlugin)().deleteArchivedDocument({
+            collection: collectionName,
+            docId,
+            projectId: this.projectId,
+            archivePath,
+        });
+    }
+    /**
+     * Recupera dados completos de um documento arquivado e o prepara para restauração
+     * Combina os dados do stub (Firestore) com os dados arquivados (Storage)
+     *
+     * @param collectionName - Nome da collection
+     * @param stubData - Dados do stub no Firestore (inclui fbArchivedAt)
+     * @returns Dados completos mesclados ou null se não encontrado
+     */
+    async getCompleteArchivedDocument(collectionName, stubData) {
+        if (!this.isDocumentArchived(stubData)) {
+            return stubData;
+        }
+        const archivedData = await this.getArchivedDocument(collectionName, stubData);
+        if (!archivedData) {
+            this.logger.warn(`Dados arquivados não encontrados para documento: ${collectionName}/${stubData.id}`);
+            return stubData; // Retorna stub se não encontrar dados arquivados
+        }
+        // Mesclar: dados do storage sobrescrevem o stub, exceto fbArchivedAt
+        const { fbArchivedAt } = stubData;
+        return { ...stubData, ...archivedData, fbArchivedAt };
     }
     /**
      * Limpa o cache de documentos arquivados
+     * Delega para o plugin firestore-archive
      */
     async clearArchivedCache(collectionName, docId) {
-        if (!this.config.cache.enabled) {
+        if (!this.isEnabled()) {
             return;
         }
-        await this.cacheResolver.revokeArchiveCache(collectionName, docId);
+        await (0, index_1.getArchivePlugin)().invalidateCache(collectionName, docId);
+    }
+    /**
+     * Retorna o projectId do Firestore sendo arquivado
+     * (usado para organização de paths no Storage)
+     */
+    getProjectId() {
+        return this.projectId;
     }
 }
 exports.ArchiveService = ArchiveService;

package/dist/archive/IArchivePlugin.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Interface para plugins de arquivamento
+ *
+ * Esta interface define o contrato que plugins de archive devem implementar.
+ * O plugin `firestore-archive` implementa esta interface.
+ *
+ * @example
+ * ```typescript
+ * import { registerArchivePlugin } from '@roit/roit-data-firestore';
+ * import { createArchivePlugin } from 'firestore-archive';
+ *
+ * // Registrar o plugin no início da aplicação
+ * registerArchivePlugin(createArchivePlugin());
+ * ```
+ */
+export interface IArchivePlugin {
+    /**
+     * Verifica se o arquivamento está habilitado
+     */
+    isEnabled(): boolean;
+    /**
+     * Verifica se um documento está arquivado (tem fbArchivedAt)
+     */
+    isDocumentArchived(doc: Record<string, unknown>): boolean;
+    /**
+     * Recupera documento arquivado do Storage.
+     *
+     * @param collection - Nome da collection
+     * @param docId - ID do documento
+     * @param archivePath - Path completo do objeto no Storage, normalmente o `fbArchivePath` do stub.
+     * @param projectId - ID do projeto (opcional)
+     * @returns Resultado da operação
+     */
+    getArchivedDocument(params: {
+        collection: string;
+        docId: string;
+        archivePath: string;
+        projectId?: string;
+    }): Promise<Record<string, unknown> | null>;
+    /**
+     * Atualiza documento arquivado (merge dados do Storage com novos dados)
+     *
+     * @param collection - Nome da collection
+     * @param docId - ID do documento
+     * @param newData - Novos dados para mesclar
+     * @param options - Opções (unarchive: true para remover do Storage)
+     * @param projectId - ID do projeto (opcional)
+     * @param archivePath - Path completo do objeto no Storage, normalmente o `fbArchivePath` do stub. É obrigatório quando unarchive=true
+     * @returns Resultado com dados mesclados
+     */
+    updateArchivedDocument(params: {
+        collection: string;
+        docId: string;
+        newData: Record<string, unknown>;
+        options?: {
+            unarchive?: boolean;
+        };
+        projectId?: string;
+        archivePath: string;
+    }): Promise<{
+        result: {
+            success: boolean;
+            message?: string;
+            error?: Error;
+        };
+        mergedData?: Record<string, unknown>;
+    }>;
+    /**
+     * Deleta documento arquivado do Storage
+     *
+     * @param collection - Nome da collection
+     * @param docId - ID do documento
+     * @param projectId - ID do projeto (opcional)
+     * @returns Resultado da operação
+     */
+    deleteArchivedDocument(params: {
+        collection: string;
+        docId: string;
+        archivePath: string;
+        projectId?: string;
+    }): Promise<{
+        success: boolean;
+        message?: string;
+        error?: Error;
+    }>;
+    /**
+     * Invalida cache de documentos arquivados
+     *
+     * @param collection - Nome da collection (opcional)
+     * @param docId - ID do documento (opcional)
+     */
+    invalidateCache(collection?: string, docId?: string): Promise<void>;
+}
+/**
+ * Campos de metadados de arquivamento no Firestore
+ */
+export declare const ARCHIVE_METADATA_FIELDS: {
+    readonly ARCHIVED_AT: "fbArchivedAt";
+    readonly ARCHIVE_HASH: "fbArchiveHash";
+    readonly ARCHIVE_PATH: "fbArchivePath";
+    readonly RESTORED_AT: "fbRestoredAt";
+};

package/dist/archive/IArchivePlugin.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARCHIVE_METADATA_FIELDS = void 0;
+/**
+ * Campos de metadados de arquivamento no Firestore
+ */
+exports.ARCHIVE_METADATA_FIELDS = {
+    ARCHIVED_AT: 'fbArchivedAt',
+    ARCHIVE_HASH: 'fbArchiveHash',
+    ARCHIVE_PATH: 'fbArchivePath',
+    RESTORED_AT: 'fbRestoredAt',
+};

package/dist/archive/index.d.ts

@@ -0,0 +1,2 @@
+export { IArchivePlugin, ARCHIVE_METADATA_FIELDS } from './IArchivePlugin';
+export { registerArchivePlugin, getArchivePlugin, hasArchivePlugin, resetArchivePlugin, ArchivePluginRegistry, } from './ArchivePluginRegistry';

package/dist/archive/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchivePluginRegistry = exports.resetArchivePlugin = exports.hasArchivePlugin = exports.getArchivePlugin = exports.registerArchivePlugin = exports.ARCHIVE_METADATA_FIELDS = void 0;
+var IArchivePlugin_1 = require("./IArchivePlugin");
+Object.defineProperty(exports, "ARCHIVE_METADATA_FIELDS", { enumerable: true, get: function () { return IArchivePlugin_1.ARCHIVE_METADATA_FIELDS; } });
+var ArchivePluginRegistry_1 = require("./ArchivePluginRegistry");
+Object.defineProperty(exports, "registerArchivePlugin", { enumerable: true, get: function () { return ArchivePluginRegistry_1.registerArchivePlugin; } });
+Object.defineProperty(exports, "getArchivePlugin", { enumerable: true, get: function () { return ArchivePluginRegistry_1.getArchivePlugin; } });
+Object.defineProperty(exports, "hasArchivePlugin", { enumerable: true, get: function () { return ArchivePluginRegistry_1.hasArchivePlugin; } });
+Object.defineProperty(exports, "resetArchivePlugin", { enumerable: true, get: function () { return ArchivePluginRegistry_1.resetArchivePlugin; } });
+Object.defineProperty(exports, "ArchivePluginRegistry", { enumerable: true, get: function () { return ArchivePluginRegistry_1.ArchivePluginRegistry; } });

package/dist/cache/CacheResolver.js

@@ -7,8 +7,6 @@ const RedisCacheProvider_1 = require("./providers/RedisCacheProvider");
 const CacheProviders_1 = require("../model/CacheProviders");
 const CurrentEnv_1 = require("../util/CurrentEnv");
 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() {
@@ -16,7 +14,6 @@ class CacheResolver {
         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;
@@ -99,7 +96,9 @@ class CacheResolver {
                 shouldDelete = key.includes('getArchivedDocument');
             }
             if (shouldDelete) {
-                (0, ArchiveConfig_1.onDebugLog)(`Archive Cache > Removing key: ${key}`);
+                if (IsDebug_1.isDebug) {
+                    console.debug('[DEBUG] Archive Cache >', `Removing key: ${key}`);
+                }
                 await this.cacheProvider.delete(key);
             }
         }
@@ -120,7 +119,9 @@ class CacheResolver {
         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}`);
+                    if (IsDebug_1.isDebug) {
+                        console.debug('[DEBUG] Archive Cache >', `Removing archive key: ${key}`);
+                    }
                     await this.cacheProvider.delete(key);
                 }
             }

package/dist/config/ArchiveConfig.d.ts

@@ -1,20 +1,25 @@
+/**
+ * Configurações mínimas para o ArchiveService no roit-data-firestore.
+ *
+ * Nota: As configurações detalhadas de Storage e Cache agora são
+ * responsabilidade do plugin firestore-archive.
+ */
 export interface ArchiveConfig {
+    /** Se o arquivamento está habilitado */
     enabled: boolean;
-    bucketName: string;
+    /** Habilita logs de debug */
     debug: boolean;
+    /**
+     * ProjectId do Firestore que está sendo arquivado.
+     * Usado para organizar os arquivos no Storage: {projectId}/{collection}/{docId}.json.gz
+     */
     projectId: string;
-    cache: {
-        enabled: boolean;
-        redisUrl: string;
-        timeout: number;
-        reconnectInSecondsAfterTimeout: number;
-        expiresInSeconds: number;
-    };
 }
 export declare class ArchiveConfig {
+    private static instance;
     static getConfig(): ArchiveConfig;
+    /**
+     * Reseta a configuração (útil para testes)
+     */
+    static reset(): void;
 }
-export declare const DEBUG_PREFIX = "[ARCHIVE SERVICE]";
-export declare const onDebugLog: (message: string) => void;
-export declare const onDebugError: (message: string, error: any) => void;
-export declare const onDebugWarn: (message: string) => void;

package/dist/config/ArchiveConfig.js

@@ -1,49 +1,33 @@
 "use strict";
+/**
+ * Configurações mínimas para o ArchiveService no roit-data-firestore.
+ *
+ * Nota: As configurações detalhadas de Storage e Cache agora são
+ * responsabilidade do plugin firestore-archive.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onDebugWarn = exports.onDebugError = exports.onDebugLog = exports.DEBUG_PREFIX = 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;
+exports.ArchiveConfig = void 0;
+const parseBoolean = (value) => {
+    return value === true || value === 'true';
+};
 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
-            }
+        if (this.instance) {
+            return this.instance;
+        }
+        this.instance = {
+            enabled: parseBoolean(process.env.FIRESTORE_ARCHIVE_ENABLED),
+            debug: parseBoolean(process.env.FIRESTORE_ARCHIVE_DEBUG),
+            projectId: process.env.FIRESTORE_PROJECTID || process.env.GCP_PROJECT || '',
         };
+        return this.instance;
+    }
+    /**
+     * Reseta a configuração (útil para testes)
+     */
+    static reset() {
+        this.instance = null;
     }
 }
 exports.ArchiveConfig = ArchiveConfig;
-exports.DEBUG_PREFIX = '[ARCHIVE SERVICE]';
-const onDebugLog = (message) => {
-    if (ArchiveConfig.getConfig().debug) {
-        console.log(`${exports.DEBUG_PREFIX} ${message}`);
-    }
-};
-exports.onDebugLog = onDebugLog;
-const onDebugError = (message, error) => {
-    if (ArchiveConfig.getConfig().debug) {
-        console.error(`${exports.DEBUG_PREFIX} ${message}`, error);
-    }
-};
-exports.onDebugError = onDebugError;
-const onDebugWarn = (message) => {
-    if (ArchiveConfig.getConfig().debug) {
-        console.warn(`${exports.DEBUG_PREFIX} ${message}`);
-    }
-};
-exports.onDebugWarn = onDebugWarn;
+ArchiveConfig.instance = null;

package/dist/config/BaseRepository.js

@@ -36,7 +36,6 @@ class BaseRepository {
         await archiveService.clearArchivedCache(collectionName, docId);
     }
 }
-exports.BaseRepository = BaseRepository;
 __decorate([
     (0, Query_1.Query)(),
     __metadata("design:type", Function)
@@ -85,3 +84,4 @@ __decorate([
     (0, Query_1.Query)(),
     __metadata("design:type", Function)
 ], BaseRepository.prototype, "aggregation", void 0);
+exports.BaseRepository = BaseRepository;

package/dist/config/ReadonlyRepository.js

@@ -22,7 +22,6 @@ class ReadonlyRepository {
         return ManualQueryHelper_1.ManualQueryHelper.executeQueryManualPaginated(className, config);
     }
 }
-exports.ReadonlyRepository = ReadonlyRepository;
 __decorate([
     (0, Query_1.Query)(),
     __metadata("design:type", Function)
@@ -31,3 +30,4 @@ __decorate([
     (0, Query_1.Query)(),
     __metadata("design:type", Function)
 ], ReadonlyRepository.prototype, "findById", void 0);
+exports.ReadonlyRepository = ReadonlyRepository;

package/dist/exception/RepositoryException.js

@@ -20,4 +20,4 @@ var ErrorType;
 (function (ErrorType) {
     ErrorType["SYSTEM"] = "system";
     ErrorType["BUSINESS"] = "business";
-})(ErrorType || (exports.ErrorType = ErrorType = {}));
+})(ErrorType = exports.ErrorType || (exports.ErrorType = {}));

package/dist/index.d.ts

@@ -14,4 +14,8 @@ export { GenericRepository } from "./config/GenericRepository";
 export { ArchiveConfig } from "./config/ArchiveConfig";
 export { CacheProviders } from "./model/CacheProviders";
 export { FirestoreInstance } from "./config/FirestoreInstance";
+/**
+ * archive plugin system
+ */
+export { IArchivePlugin, ARCHIVE_METADATA_FIELDS, registerArchivePlugin, getArchivePlugin, hasArchivePlugin, resetArchivePlugin, } from "./archive";
 export * from "./model";

package/dist/index.js

@@ -14,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.ArchiveConfig = exports.GenericRepository = exports.ReadonlyRepository = exports.BaseRepository = exports.Cacheable = exports.Query = exports.Repository = void 0;
+exports.resetArchivePlugin = exports.hasArchivePlugin = exports.getArchivePlugin = exports.registerArchivePlugin = exports.ARCHIVE_METADATA_FIELDS = exports.FirestoreInstance = exports.CacheProviders = exports.ArchiveConfig = exports.GenericRepository = exports.ReadonlyRepository = exports.BaseRepository = exports.Cacheable = exports.Query = exports.Repository = void 0;
 require("reflect-metadata");
 /**
  * decorators
@@ -40,4 +40,13 @@ var CacheProviders_1 = require("./model/CacheProviders");
 Object.defineProperty(exports, "CacheProviders", { enumerable: true, get: function () { return CacheProviders_1.CacheProviders; } });
 var FirestoreInstance_1 = require("./config/FirestoreInstance");
 Object.defineProperty(exports, "FirestoreInstance", { enumerable: true, get: function () { return FirestoreInstance_1.FirestoreInstance; } });
+/**
+ * archive plugin system
+ */
+var archive_1 = require("./archive");
+Object.defineProperty(exports, "ARCHIVE_METADATA_FIELDS", { enumerable: true, get: function () { return archive_1.ARCHIVE_METADATA_FIELDS; } });
+Object.defineProperty(exports, "registerArchivePlugin", { enumerable: true, get: function () { return archive_1.registerArchivePlugin; } });
+Object.defineProperty(exports, "getArchivePlugin", { enumerable: true, get: function () { return archive_1.getArchivePlugin; } });
+Object.defineProperty(exports, "hasArchivePlugin", { enumerable: true, get: function () { return archive_1.hasArchivePlugin; } });
+Object.defineProperty(exports, "resetArchivePlugin", { enumerable: true, get: function () { return archive_1.resetArchivePlugin; } });
 __exportStar(require("./model"), exports);