@roit/roit-data-firestore 1.2.42 → 1.2.44

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

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