@roit/roit-data-firestore 1.2.43 → 1.2.45

package/dist/template/FunctionCreateTemplate.txt

@@ -20,6 +20,7 @@ create(items) {
                 const collection = db.collection('<COLLECTION_REPLACE>');
                 const validatorDataHandle = global.instances.validatorDataHandle;
                 const batch = db.batch();
+                
                 for (const item of items) {
                     yield validatorDataHandle.validateModel(modelName, item, validatorOptions);
                     if (!item.id) {
@@ -32,35 +33,36 @@ create(items) {
                     item.updateAt = newDate();
                     item.updateTimestampAt = new Date(item.updateAt).getTime();
                     item.lastServiceModify = process.env.SERVICE || 'PROJECT_UNDEFINED';
-                    const docRef = collection.doc(item.id);
-                    batch.set(docRef, JSON.parse(JSON.stringify(item)));
+                    
+                    // 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);
                     }
+                    batch.set(collection.doc(item.id), itemData);
                 }
+                
                 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': 'create',
                     '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;
             }
-        })
+        });
     });
-}
+}

package/dist/template/FunctionDeleteTemplate.txt

@@ -13,33 +13,65 @@ delete(ids) {
                 }
                 const db = global.instances.globalDbFile.FirestoreInstance.getInstance();
                 const environmentUtil = global.instances.environmentUtil;
+                const archiveService = yield global.instances.archiveService;
                 const batch = db.batch();
                 const collection = db.collection('<COLLECTION_REPLACE>');
-                ids.forEach(id => {
-                    const docRef = collection.doc(id);
-                    batch.delete(docRef);
-                });
+                
+                // Verificar quais documentos estão arquivados antes de deletar
+                const archivedDocs = [];
+                if (archiveService.isEnabled()) {
+                    const docRefs = ids.map(id => collection.doc(id));
+                    const docs = docRefs.length > 0 ? yield db.getAll(...docRefs) : [];
+                    for (let i = 0; i < docs.length; i++) {
+                        const doc = docs[i];
+                        if (doc && doc.exists) {
+                            const data = doc.data();
+                            if (data && archiveService.isDocumentArchived(data) && data.fbArchivePath) {
+                                archivedDocs.push({ id: ids[i], archivePath: data.fbArchivePath });
+                            }
+                        }
+                    }
+                }
+                
+                for (const id of ids) {
+                    batch.delete(collection.doc(id));
+                }
+                
                 if (!environmentUtil.areWeTesting()) {
                     yield batch.commit();
+                    
+                    // Deletar arquivos do Storage para documentos arquivados
+                    if (archiveService.isEnabled() && archivedDocs.length > 0) {
+                        const deletePromises = archivedDocs.map(({ id: docId, archivePath }) => 
+                            archiveService.deleteArchivedDocument('<COLLECTION_REPLACE>', docId, archivePath)
+                                .catch(err => {
+                                    // Log erro mas não falha a operação principal
+                                    console.warn(`Failed to delete archived file for ${docId}:`, err);
+                                })
+                        );
+                        yield Promise.all(deletePromises);
+                    }
+                    
                     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': 'delete',
                     'firestore.collection.name': '<COLLECTION_REPLACE>',
-                    'firestore.collection.id': JSON.stringify(ids)
-                })
+                    'firestore.collection.id': JSON.stringify(ids),
+                    'firestore.archive.deleted': archivedDocs.length
+                });
                 return ids;
             } catch (error) {
                 span.setStatus({
                     code: 2,
                     message: error.message
-                })
-                span.recordException(error)
-                throw error
+                });
+                span.recordException(error);
+                throw error;
             }
-        })
+        });
     });
-}
+}

package/dist/template/FunctionFindAllTemplate.txt

@@ -18,31 +18,47 @@ findAll(paging) {
                     console.log('It was decreed that it is being executed try, no operation or effective transaction will be performed');
                     return [];
                 }
-                let { documentRef } = yield queryCreatorConfig.buildPaging(collection, paging, { showCount: false });
+                const { documentRef } = yield queryCreatorConfig.buildPaging(collection, paging, { showCount: false });
                 const snapshot = yield documentRef.get();
-                let items = new Array;
+                let items = [];
                 snapshot.forEach(doc => {
-                    const data = doc.data();
-                    items.push(Object.assign({}, data));
+                    items.push({ ...doc.data(), id: doc.id });
                 });
+                
                 // VERIFICAÇÃO DE ARQUIVAMENTO PARA MÚLTIPLOS DOCUMENTOS
-                const archivedItems = items.filter(item => archiveService.isDocumentArchived(item));
-                if (archivedItems.length > 0) {
-                    const recoveryPromises = archivedItems.map((item) => {
-                        return archiveService.getArchivedDocument('<COLLECTION_REPLACE>', item)
-                            .then(archivedData => archivedData ? { ...item, ...archivedData } : item);
-                    });
-                    
-                    const recoveredItems = yield Promise.all(recoveryPromises);
-                    
-                    // Substituir itens arquivados pelos recuperados
-                    items = items.map(item => {
+                if (archiveService.isEnabled()) {
+                    const archivedIndexes = [];
+                    items.forEach((item, index) => {
                         if (archiveService.isDocumentArchived(item)) {
-                            return recoveredItems.find(recovered => recovered.id === item.id) || item;
+                            archivedIndexes.push(index);
                         }
-                        return item;
                     });
+                    
+                    if (archivedIndexes.length > 0) {
+                        const recoveryPromises = archivedIndexes.map(index => 
+                            archiveService.getArchivedDocument('<COLLECTION_REPLACE>', items[index])
+                                .then(archivedData => ({ index, data: archivedData }))
+                                .catch(error => {
+                                    console.warn('Failed to recover archived document data', {
+                                        collection: '<COLLECTION_REPLACE>',
+                                        id: items[index] && items[index].id,
+                                        error: error && error.message ? error.message : String(error)
+                                    });
+                                    return { index, data: null };
+                                })
+                        );
+                        
+                        const recoveredResults = yield Promise.all(recoveryPromises);
+                        
+                        // Substituir itens arquivados pelos recuperados (O(n) em vez de O(n²))
+                        for (const { index, data } of recoveredResults) {
+                            if (data) {
+                                items[index] = { ...items[index], ...data };
+                            }
+                        }
+                    }
                 }
+                
                 yield cacheResolver.cacheResult(repositoryClassName, methodSignature, items, 'Any');
                 const firestoreReadAuditResolver = global.instances.firestoreReadAuditResolver;
                 yield firestoreReadAuditResolver.persistFirestoreRead({
@@ -55,16 +71,16 @@ findAll(paging) {
                     'firestore.operation.name': 'findAll',
                     '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;
             }
-        })
+        });
     });
-}
+}

package/dist/template/FunctionFindByIdTemplate.txt

@@ -18,17 +18,27 @@ findById(id) {
                     return undefined;
                 }
                 const response = yield collection.doc(id).get();
-                const item = response.data();
+                
+                const data = response.data();
+                let item = data ? { ...data, id: response.id } : undefined;
+                
                 // VERIFICAÇÃO DE ARQUIVAMENTO
-                if (item && archiveService.isDocumentArchived(item)) {
-                    const archivedData = yield archiveService.getArchivedDocument('<COLLECTION_REPLACE>', item);
-                    if (archivedData) {
-                        const completeData = { ...item, ...archivedData };
-                        yield cacheResolver.cacheResult(repositoryClassName, methodSignature, completeData, id);
+                if (archiveService.isEnabled() && item && archiveService.isDocumentArchived(item)) {
+                    try {
+                        const archivedData = yield archiveService.getArchivedDocument('<COLLECTION_REPLACE>', item);
+                        if (archivedData) {
+                            item = { ...item, ...archivedData };
+                        }
+                    } catch (error) {
+                        console.warn('Failed to recover archived document data', {
+                            collection: '<COLLECTION_REPLACE>',
+                            id,
+                            error: error && error.message ? error.message : String(error)
+                        });
                     }
-                } else {
-                    yield cacheResolver.cacheResult(repositoryClassName, methodSignature, item, id);
                 }
+                
+                yield cacheResolver.cacheResult(repositoryClassName, methodSignature, item, id);
                 const firestoreReadAuditResolver = global.instances.firestoreReadAuditResolver;
                 yield firestoreReadAuditResolver.persistFirestoreRead({
                     collection: '<COLLECTION_REPLACE>',
@@ -41,16 +51,16 @@ findById(id) {
                     'firestore.operation.name': 'findById',
                     'firestore.collection.name': '<COLLECTION_REPLACE>',
                     'firestore.collection.id': id
-                }) 
+                });
                 return item;
             } catch (error) {
                 span.setStatus({
                     code: 2,
                     message: error.message
-                })
-                span.recordException(error)
-                throw error
+                });
+                span.recordException(error);
+                throw error;
             }
-        })
+        });
     });
-}
+}

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