@roit/roit-data-firestore 1.2.42 → 1.2.44

package/dist/template/FunctionQueryTemplate.txt

@@ -1,74 +1,100 @@
- async function(<params_replace>) {
+async function(<params_replace>) {
     return __awaiter(this, void 0, void 0, function* () {
         return yield global.instances.startTracer('firestore.query', async (span) => {
             try {
-                if(<params_validator_replace>) throw new Error('All parameters required, ref..: <params_replace>')
-
-                let repositoryClassName = '<repositoryClassName_value>'
-                let methodSignature = '<methodSignature_value>'
+                if (<params_validator_replace>) {
+                    throw new Error('All parameters required, ref..: <params_replace>');
+                }
 
-                const db = global.instances.globalDbFile.FirestoreInstance.getInstance()
-                const cacheResolver = global.instances.cacheResolver
-                const firestoreReadAuditResolver = global.instances.firestoreReadAuditResolver
+                const repositoryClassName = '<repositoryClassName_value>';
+                const methodSignature = '<methodSignature_value>';
 
-                const environmentUtil = global.instances.environmentUtil
-                if(environmentUtil.areWeTesting()) { 
-                    console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed')
-                    return []
+                const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
+                const cacheResolver = global.instances.cacheResolver;
+                const firestoreReadAuditResolver = global.instances.firestoreReadAuditResolver;
+                const environmentUtil = global.instances.environmentUtil;
+                const archiveService = await global.instances.archiveService;
+                
+                if (environmentUtil.areWeTesting()) {
+                    console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed');
+                    return [];
                 }
                 
-                const result = await cacheResolver.getCacheResult(repositoryClassName, methodSignature, <params_replace>)
+                const result = await cacheResolver.getCacheResult(repositoryClassName, methodSignature, <params_replace>);
                 
-                if(result) {
-                    return result
+                if (result) {
+                    return result;
                 }
 
-                const collection = db.collection('<collection_name_replace>')
+                const collection = db.collection('<collection_name_replace>');
+
+                if (Number(process.env.FIRESTORE_DEBUG)) {
+                    console.debug('[DEBUG] Executing query >', "<query_predicate_replace>");
+                }
 
-                if(Number(process.env.FIRESTORE_DEBUG)) { console.debug('[DEBUG] Executing query >', "<query_predicate_replace>") }
+                const collectionRef = collection<query_predicate_replace>;
+                const { documentRef } = await global.instances.queryCreatorConfig.buildPaging(collectionRef, paging, { showCount: false });
+                const snapshot = await documentRef.get();
 
-                let collectionRef = collection<query_predicate_replace>
-                let { documentRef } = await global.instances.queryCreatorConfig.buildPaging(collectionRef, paging, { showCount: false })
-                const snapshot = await documentRef.get()
+                let items = [];
+                snapshot.forEach(doc => {
+                    items.push({ ...doc.data(), id: doc.id });
+                });
 
-                let items = []
-                snapshot.forEach(doc => { 
-                    let element = { ...doc.data() }
-                    element.id = doc.id
-                    items.push(element)
-                })
+                // VERIFICAÇÃO DE ARQUIVAMENTO PARA DOCUMENTOS RETORNADOS
+                if (archiveService.isEnabled()) {
+                    const archivedItems = items.filter(item => archiveService.isDocumentArchived(item));
+                    
+                    if (archivedItems.length > 0) {
+                        const recoveryPromises = archivedItems.map(item => {
+                            return archiveService.getArchivedDocument('<collection_name_replace>', item)
+                                .then(archivedData => archivedData ? { ...item, ...archivedData } : item)
+                                .catch(() => item); // Fallback para stub se falhar
+                        });
+                        
+                        const recoveredItems = await Promise.all(recoveryPromises);
+                        
+                        // Substituir itens arquivados pelos recuperados
+                        const recoveredMap = new Map(recoveredItems.map(item => [item.id, item]));
+                        items = items.map(item => {
+                            if (archiveService.isDocumentArchived(item)) {
+                                return recoveredMap.get(item.id) || item;
+                            }
+                            return item;
+                        });
+                    }
+                }
 
-                await cacheResolver.cacheResult(repositoryClassName, methodSignature, items, <params_replace>)
+                await cacheResolver.cacheResult(repositoryClassName, methodSignature, items, <params_replace>);
 
                 await firestoreReadAuditResolver.persistFirestoreRead({
                     collection: '<collection_name_replace>',
-                    repositoryClassName: repositoryClassName,
+                    repositoryClassName,
                     functionSignature: methodSignature,
                     params: <params_replace>,
                     queryResult: items
-                })
+                });
 
                 span.setAttributes({
                     'firestore.operation.name': 'query',
                     'firestore.operation.query': "<query_predicate_replace>",
                     'firestore.collection.name': '<collection_name_replace>',
                     'firestore.operation.size': items.length
-                })             
+                });
 
-                if(<is_one_row>) {
-                    return items[0]
-                }        
-
-                return items
+                if (<is_one_row>) {
+                    return items[0];
+                }
 
+                return items;
             } catch (error) {
                 span.setStatus({
                     code: 2,
                     message: error.message
-                })
-                span.recordException(error)
-                throw error
+                });
+                span.recordException(error);
+                throw error;
             }
-        })
-    })
-}
+        });
+    });
+}

package/dist/template/FunctionSumTemplate.txt

@@ -1,37 +1,53 @@
 sum(config) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
-        const environmentUtil = global.instances.environmentUtil;
-        const convertToMQuery = global.instances.convertToMQuery;
-        const aggregateSum = global.instances.aggregateSum;
-        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;
-        if ((config === null || config === void 0 ? void 0 : config.query) && config.query.length > 0) {
-            queryList = config.query.map(query => {
-                if (Object.keys(query).length === 1) {
-                    return convertToMQuery(query);
+        return yield global.instances.startTracer('firestore.sum', async (span) => {
+            try {
+                const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
+                const environmentUtil = global.instances.environmentUtil;
+                const convertToMQuery = global.instances.convertToMQuery;
+                const aggregateSum = global.instances.aggregateSum;
+                
+                if (environmentUtil.areWeTesting()) {
+                    console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed');
+                    return 0;
                 }
-                return query;
-            });
-            const queryInit = queryList[0];
-            queryExecute = collection.where(queryInit.field, queryInit.operator, queryInit.value);
-            queryList.shift();
-            queryList.forEach(que => {
-                queryExecute = queryExecute.where(que.field, que.operator, que.value);
-            });
-        }
-        else {
-            queryExecute = collection;
-        }
-        const sumAggregateQuery = queryExecute.aggregate({
-            sum: aggregateSum(config.attributeSum),
+                
+                const collection = db.collection('<COLLECTION_REPLACE>');
+                let queryExecute = collection;
+                
+                if (config?.query && config.query.length > 0) {
+                    const queryList = config.query.map(query => {
+                        if (Object.keys(query).length === 1) {
+                            return convertToMQuery(query);
+                        }
+                        return query;
+                    });
+                    
+                    for (const query of queryList) {
+                        queryExecute = queryExecute.where(query.field, query.operator, query.value);
+                    }
+                }
+                
+                const sumAggregateQuery = queryExecute.aggregate({
+                    sum: aggregateSum(config.attributeSum),
+                });
+                const snapshot = yield sumAggregateQuery.get();
+                
+                span.setAttributes({
+                    'firestore.operation.name': 'sum',
+                    'firestore.collection.name': '<COLLECTION_REPLACE>',
+                    'firestore.aggregate.attribute': config.attributeSum
+                });
+                
+                return snapshot.data().sum;
+            } catch (error) {
+                span.setStatus({
+                    code: 2,
+                    message: error.message
+                });
+                span.recordException(error);
+                throw error;
+            }
         });
-        const snapshot = yield sumAggregateQuery.get();
-        return snapshot.data().sum;
     });
-}
+}

package/dist/template/FunctionUpdatePartialTemplate.txt

@@ -1,25 +1,80 @@
 updatePartial(id, item) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
-        const { newDate } = global.instances.dateRef;
-        const lastServiceModify = process.env.SERVICE || 'PROJECT_UNDEFINED';
-        const updateAt = newDate();
-        const updateTimestampAt = new Date(updateAt).getTime();
-        const environmentUtil = global.instances.environmentUtil;
-        const document = db.collection('<COLLECTION_REPLACE>').doc(id);
-        try {
-            if (!environmentUtil.areWeTesting()) {
-                yield document.set(Object.assign({ lastServiceModify,
-                    updateAt,
-                    updateTimestampAt }, item), { merge: true });
-                yield this.revokeCache();
+        return yield global.instances.startTracer('firestore.updatePartial', async (span) => {
+            try {
+                const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
+                const { newDate } = global.instances.dateRef;
+                const lastServiceModify = process.env.SERVICE || 'PROJECT_UNDEFINED';
+                const updateAt = newDate();
+                const updateTimestampAt = new Date(updateAt).getTime();
+                const environmentUtil = global.instances.environmentUtil;
+                const archiveService = yield global.instances.archiveService;
+                const document = db.collection('<COLLECTION_REPLACE>').doc(id);
+                
+                let shouldUnarchive = false;
+                
+                // VERIFICAÇÃO DE DOCUMENTO ARQUIVADO
+                if (archiveService.isEnabled()) {
+                    const currentDoc = yield document.get();
+                    
+                    if (currentDoc.exists) {
+                        const currentData = currentDoc.data();
+                        
+                        if (currentData && archiveService.isDocumentArchived(currentData)) {
+                            const archivePath = currentData.fbArchivePath;
+                            const updateResult = yield archiveService.updateArchivedDocument(
+                                '<COLLECTION_REPLACE>',
+                                id,
+                                item,
+                                archivePath,
+                                { unarchive: true }
+                            );
+                            
+                            if (!(updateResult && updateResult.result && updateResult.result.success && updateResult.mergedData)) {
+                                throw new Error('Failed to update archived document; aborting partial update to prevent inconsistent state and stale archive overwriting user changes.');
+                            }
+                            const originalItem = Object.assign({}, item);
+                            Object.assign(item, updateResult.mergedData, originalItem);
+                            shouldUnarchive = true;
+                        }
+                    }
+                }
+                
+                if (!environmentUtil.areWeTesting()) {
+                    const itemData = {
+                        ...item,
+                        lastServiceModify,
+                        updateAt,
+                        updateTimestampAt
+                    };
+
+                    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();
+                    }
+
+                    yield document.set(itemData, { merge: true });
+                    yield this.revokeCache();
+                } 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': 'updatePartial',
+                    'firestore.collection.name': '<COLLECTION_REPLACE>',
+                    'firestore.document.id': id,
+                });
+            } catch (error) {
+                span.setStatus({
+                    code: 2,
+                    message: error.message
+                });
+                span.recordException(error);
+                throw error;
             }
-            else {
-                console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed');
-            }
-        }
-        catch (e) {
-            console.error(e === null || e === void 0 ? void 0 : e.details);
-        }
+        });
     });
-}
+}

package/dist/template/FunctionUpdateTemplate.txt

@@ -19,48 +19,95 @@ update(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();
+                
+                // Validar IDs antes de processar
                 for (const item of items) {
-                    yield validatorDataHandle.validateModel(modelName, item, validatorOptions);
                     if (!item.id) {
                         throw new RepositoryBusinessException_1.RepositoryBusinessException(`Id is required`, []);
                     }
+                }
+                
+                // Buscar documentos existentes em lote (otimização)
+                const docRefs = items.map(item => collection.doc(item.id));
+                const existingDocs = (archiveService.isEnabled() && docRefs.length > 0)
+                    ? yield db.getAll(...docRefs)
+                    : [];
+                
+                for (let i = 0; i < items.length; i++) {
+                    const item = items[i];
+                    yield validatorDataHandle.validateModel(modelName, item, validatorOptions);
+                    
+                    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) {
+                                const originalItem = Object.assign({}, item);
+                                Object.assign(item, updateResult.mergedData, originalItem);
+                                shouldUnarchive = true;
+                            } else {
+                                throw new Error('Failed to update archived document; aborting update to prevent inconsistent state and stale archive overwriting user changes.');
+                            }
+                        }
+                    }
+                    
                     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 && ttlUpdate) {
-                        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': 'update',
                     'firestore.collection.name': '<COLLECTION_REPLACE>',
                     'firestore.operation.size': items.length,
-                })                 
+                });
                 return items;
             } catch (error) {
                 span.setStatus({
                     code: 2,
                     message: error.message
-                })
-                span.recordException(error)
-                throw error
+                });
+                span.recordException(error);
+                throw error;
             }
-        })        
+        });
     });
 }