@roit/roit-data-firestore 1.2.43 → 1.2.45

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);

package/dist/model/CacheProviders.d.ts

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

package/dist/model/CacheProviders.js

@@ -5,5 +5,4 @@ var CacheProviders;
 (function (CacheProviders) {
     CacheProviders["LOCAL"] = "LOCAL";
     CacheProviders["REDIS"] = "REDIS";
-    CacheProviders["REDIS_ARCHIVE"] = "REDIS_ARCHIVE";
-})(CacheProviders || (exports.CacheProviders = CacheProviders = {}));
+})(CacheProviders = exports.CacheProviders || (exports.CacheProviders = {}));

package/dist/query/ManualQueryHelper.js

@@ -170,7 +170,6 @@ class ManualQueryHelper {
                 };
             }
             catch (error) {
-                console.error(error);
                 span.setStatus({
                     code: 2,
                     message: error.message

package/dist/query/QueryPredicateFunctionTransform.js

@@ -44,6 +44,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const Tracer_1 = require("../tracer/Tracer");
 const ArchiveService_1 = require("../archive/ArchiveService");
+const archive_1 = require("../archive");
 const functionQueryTemplate = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../template/FunctionQueryTemplate.txt'), 'utf8');
 const methodList = {
     'aggregation': fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../template/FunctionAggregationTemplate.txt'), 'utf8'),
@@ -73,13 +74,15 @@ class QueryPredicateFunctionTransform {
             environmentUtil: new EnvironmentUtil_1.EnvironmentUtil,
             firestoreReadAuditResolver: FirestoreReadAuditResolver_1.FirestoreReadAuditResolver.getInstance(),
             fieldValueIncrement: firestore_1.FieldValue.increment,
+            FieldValue: firestore_1.FieldValue,
             getTtlTimestamp: TtlBuilderUtil_1.TtlBuilderUtil.getTtlTimestamp,
             convertToMQuery: ManualQueryHelper_1.ManualQueryHelper.convertToMQuery,
             aggregateAverage: firestore_1.AggregateField.average,
             aggregateSum: firestore_1.AggregateField.sum,
             aggregateCount: firestore_1.AggregateField.count,
             startTracer: Tracer_1.startTracer,
-            archiveService: ArchiveService_1.ArchiveService.getInstance()
+            archiveService: ArchiveService_1.ArchiveService.getInstance(),
+            ARCHIVE_FIELDS: archive_1.ARCHIVE_METADATA_FIELDS
         };
         if (!options?.collection) {
             throw new Error(`Collection is required`);

package/dist/template/FunctionAggregationTemplate.txt

@@ -65,4 +65,4 @@ aggregation(config) {
             }
         })
     });
-}
+}

package/dist/template/FunctionAverageTemplate.txt

@@ -49,4 +49,4 @@ average(config) {
             }
         })
     });
-}
+}

package/dist/template/FunctionCountTemplate.txt

@@ -5,53 +5,48 @@ count(config) {
                 const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
                 const environmentUtil = global.instances.environmentUtil;
                 const convertToMQuery = global.instances.convertToMQuery;
+                
                 if (environmentUtil.areWeTesting()) {
                     console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed');
                     return 0;
                 }
+                
                 const collection = db.collection('<COLLECTION_REPLACE>');
-                let queryList;
-                let queryExecute;
-                const traceQuery = []
-                const pushTraceQuery = (query) => {
-                    traceQuery.push({ field: query.field, operator: query.operator, value: '?' })
-                }
-                if ((config === null || config === void 0 ? void 0 : config.query) && config.query.length > 0) {
-                    queryList = config.query.map(query => {
+                let queryExecute = collection;
+                const traceQuery = [];
+                
+                if (config?.query && config.query.length > 0) {
+                    const queryList = config.query.map(query => {
                         if (Object.keys(query).length === 1) {
                             return convertToMQuery(query);
                         }
                         return query;
                     });
-                    const queryInit = queryList[0];
-                    queryExecute = collection.where(queryInit.field, queryInit.operator, queryInit.value);
-                    pushTraceQuery(queryInit)
-                    queryList.shift();
-                    queryList.forEach(que => {
-                        queryExecute = queryExecute.where(que.field, que.operator, que.value);
-                        pushTraceQuery(que)
-                    });
-                }
-                else {
-                    queryExecute = collection;
+                    
+                    for (const query of queryList) {
+                        queryExecute = queryExecute.where(query.field, query.operator, query.value);
+                        traceQuery.push({ field: query.field, operator: query.operator, value: '?' });
+                    }
                 }
+                
                 const snapshot = yield queryExecute.count().get();
                 const count = snapshot.data().count;
+                
                 span.setAttributes({
                     'firestore.operation.name': 'count',
                     'firestore.operation.query': JSON.stringify(traceQuery),
                     'firestore.collection.name': '<COLLECTION_REPLACE>',
                     'firestore.operation.result.size': count,
-                })
+                });
                 return count;
             } catch (error) {
                 span.setStatus({
                     code: 2,
                     message: error.message
-                })
-                span.recordException(error)
-                throw error
+                });
+                span.recordException(error);
+                throw error;
             }
-        })
+        });
     });
-}
+}

package/dist/template/FunctionCreateOrUpdateTemplate.txt

@@ -19,12 +19,55 @@ createOrUpdate(items) {
                 const getTtlTimestamp = global.instances.getTtlTimestamp;
                 const collection = db.collection('<COLLECTION_REPLACE>');
                 const validatorDataHandle = global.instances.validatorDataHandle;
+                const archiveService = yield global.instances.archiveService;
                 const batch = db.batch();
-                for (const item of items) {
+                
+                // Preparar IDs e buscar documentos existentes em lote (otimização)
+                const itemsWithIds = items.map(item => {
+                    if (!item.id) item.id = uuid();
+                    return item;
+                });
+                
+                const docRefs = itemsWithIds.map(item => collection.doc(item.id));
+                const existingDocs = (archiveService.isEnabled() && docRefs.length > 0)
+                    ? yield db.getAll(...docRefs)
+                    : [];
+                
+                for (let i = 0; i < itemsWithIds.length; i++) {
+                    const item = itemsWithIds[i];
                     yield validatorDataHandle.validateModel(modelName, item, validatorOptions);
-                    if (!item.id) {
-                        item.id = uuid();
+                    
+                    const docRef = docRefs[i];
+                    let shouldUnarchive = false;
+                    
+                    // VERIFICAÇÃO DE DOCUMENTO ARQUIVADO
+                    if (archiveService.isEnabled() && existingDocs[i]?.exists) {
+                        const currentData = existingDocs[i].data();
+                        
+                        if (currentData && archiveService.isDocumentArchived(currentData)) {
+                            const archivePath = currentData.fbArchivePath;
+                            const updateResult = yield archiveService.updateArchivedDocument(
+                                '<COLLECTION_REPLACE>',
+                                item.id,
+                                item,
+                                archivePath,
+                                { unarchive: true }
+                            );
+                            
+                            if (updateResult.result.success && updateResult.mergedData) {
+                                if (updateResult.mergedData.createAt) {
+                                    item.createAt = updateResult.mergedData.createAt;
+                                    item.createTimestampAt = updateResult.mergedData.createTimestampAt;
+                                }
+                                const originalItem = Object.assign({}, item);
+                                Object.assign(item, updateResult.mergedData, originalItem);
+                                shouldUnarchive = true;
+                            } else {
+                                throw new Error('Failed to update archived document; aborting createOrUpdate to prevent inconsistent state and stale archive overwriting user changes.');
+                            }
+                        }
                     }
+                    
                     if (!item.createAt) {
                         item.createAt = newDate();
                         item.createTimestampAt = new Date(item.createAt).getTime();
@@ -32,40 +75,46 @@ createOrUpdate(items) {
                     item.updateAt = newDate();
                     item.updateTimestampAt = new Date(item.updateAt).getTime();
                     item.lastServiceModify = process.env.SERVICE || 'PROJECT_UNDEFINED';
-                    const docRef = collection.doc(item.id);
-                    if (ttlExpirationIn && item?.ttlExpirationAt) {
-                        delete item.ttlExpirationAt;
-                    }
-                    batch.set(docRef, JSON.parse(JSON.stringify(item)), { merge: true });
+                    
+                    // Preparar dados para persistir (consolidado)
+                    const itemData = JSON.parse(JSON.stringify(item));
                     if (ttlExpirationIn && ttlUnit) {
-                        const ttl = getTtlTimestamp(ttlExpirationIn, ttlUnit);
-                        batch.set(docRef, {
-                            ttlExpirationAt: ttl,
-                        }, { merge: true });
+                        itemData.ttlExpirationAt = getTtlTimestamp(ttlExpirationIn, ttlUnit);
+                    }
+
+                    if (shouldUnarchive) {
+                        const FieldValue = global.instances.FieldValue;
+                        const ARCHIVE_FIELDS = global.instances.ARCHIVE_FIELDS;
+                        itemData[ARCHIVE_FIELDS.ARCHIVED_AT] = FieldValue.delete();
+                        itemData[ARCHIVE_FIELDS.ARCHIVE_PATH] = FieldValue.delete();
+                        itemData[ARCHIVE_FIELDS.ARCHIVE_HASH] = FieldValue.delete();
                     }
+
+                    batch.set(docRef, itemData, { merge: true });
                 }
+                
                 if (!environmentUtil.areWeTesting()) {
                     yield batch.commit();
                     yield this.revokeCache();
-                }
-                else {
+                } else {
                     console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed');
                 }
+                
                 span.setAttributes({
                     'firestore.operation.name': 'createOrUpdate',
                     'firestore.operation.size': items.length,
                     'firestore.collection.name': '<COLLECTION_REPLACE>',
-                })                 
+                });
                 return items;
 
             } catch (error) {
                 span.setStatus({
                     code: 2,
                     message: error.message
-                })
-                span.recordException(error)
-                throw error
+                });
+                span.recordException(error);
+                throw error;
             }
-        })
+        });
     });
-}
+}