@roit/roit-data-firestore 1.2.39 → 1.2.42

package/dist/firestore-read-audit/providers/BigQueryFirestoreReadAuditProvider.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BigQueryFirestoreReadAuditProvider = void 0;
 const PlatformTools_1 = require("../../platform/PlatformTools");
@@ -35,67 +26,63 @@ class BigQueryFirestoreReadAuditProvider {
             }
         }
     }
-    createFirestoreAuditDatasetAndTableIfNecessary() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const TWO_DAYS_IN_MS = '172800000';
-            const schema = [
-                { name: 'collection', type: 'STRING' },
-                { name: 'service', type: 'STRING' },
-                { name: 'projectId', type: 'STRING' },
-                { name: 'env', type: 'STRING' },
-                { name: 'repositoryClassName', type: 'STRING' },
-                { name: 'functionSignature', type: 'STRING' },
-                { name: 'params', type: 'STRING' },
-                { name: 'queryResult', type: 'STRING' },
-                { name: 'queryResultLength', type: 'INTEGER' },
-                { name: 'insertAt', type: 'DATETIME' },
-            ];
-            const options = {
-                schema,
-                location: 'US',
-                timePartitioning: {
-                    type: 'DAY',
-                    expirationMS: TWO_DAYS_IN_MS,
-                    field: 'insertAt'
-                }
-            };
-            const handleBigQueryError = (e) => {
-                if (!JSON.stringify(e.errors).includes('Exists')) {
-                    console.log('Error [createFirestoreAuditDatasetAndTableIfNecessary]', e);
-                }
-            };
-            try {
-                yield this.bigQuery.createDataset(dataset);
-            }
-            catch (e) {
-                handleBigQueryError(e);
+    async createFirestoreAuditDatasetAndTableIfNecessary() {
+        const TWO_DAYS_IN_MS = '172800000';
+        const schema = [
+            { name: 'collection', type: 'STRING' },
+            { name: 'service', type: 'STRING' },
+            { name: 'projectId', type: 'STRING' },
+            { name: 'env', type: 'STRING' },
+            { name: 'repositoryClassName', type: 'STRING' },
+            { name: 'functionSignature', type: 'STRING' },
+            { name: 'params', type: 'STRING' },
+            { name: 'queryResult', type: 'STRING' },
+            { name: 'queryResultLength', type: 'INTEGER' },
+            { name: 'insertAt', type: 'DATETIME' },
+        ];
+        const options = {
+            schema,
+            location: 'US',
+            timePartitioning: {
+                type: 'DAY',
+                expirationMS: TWO_DAYS_IN_MS,
+                field: 'insertAt'
             }
-            try {
-                yield this.bigQuery
-                    .dataset(dataset)
-                    .createTable(table, options);
+        };
+        const handleBigQueryError = (e) => {
+            if (!JSON.stringify(e.errors).includes('Exists')) {
+                console.log('Error [createFirestoreAuditDatasetAndTableIfNecessary]', e);
             }
-            catch (e) {
-                handleBigQueryError(e);
-            }
-        });
+        };
+        try {
+            await this.bigQuery.createDataset(dataset);
+        }
+        catch (e) {
+            handleBigQueryError(e);
+        }
+        try {
+            await this.bigQuery
+                .dataset(dataset)
+                .createTable(table, options);
+        }
+        catch (e) {
+            handleBigQueryError(e);
+        }
     }
-    persistFirestoreRead(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.isTableCreated) {
-                    yield this.createFirestoreAuditDatasetAndTableIfNecessary();
-                }
-                this.isTableCreated = true;
-                yield this.bigQuery
-                    .dataset(dataset)
-                    .table(table)
-                    .insert([props]);
-            }
-            catch (error) {
-                console.log(JSON.stringify(error.errors));
+    async persistFirestoreRead(props) {
+        try {
+            if (!this.isTableCreated) {
+                await this.createFirestoreAuditDatasetAndTableIfNecessary();
             }
-        });
+            this.isTableCreated = true;
+            await this.bigQuery
+                .dataset(dataset)
+                .table(table)
+                .insert([props]);
+        }
+        catch (error) {
+            console.log(JSON.stringify(error.errors));
+        }
     }
     loadBigQuery() {
         try {

package/dist/firestore-read-audit/providers/PubSubFirestoreReadAuditProvider.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PubSubFirestoreReadAuditProvider = void 0;
 const PlatformTools_1 = require("../../platform/PlatformTools");
@@ -27,23 +18,21 @@ class PubSubFirestoreReadAuditProvider {
         }
         this.topic = this.pubsub.topic(envTopic, { batching: { maxMessages: 1 } });
     }
-    persistFirestoreRead(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const limitBytes = 9900000;
-            let buffer = Buffer.from(JSON.stringify(params));
-            if (buffer.length > limitBytes) {
-                params.queryResult = 'too-big-to-save';
-                buffer = Buffer.from(JSON.stringify(params));
-            }
-            try {
-                yield this.topic.publishMessage({
-                    data: buffer
-                });
-            }
-            catch (error) {
-                console.log(JSON.stringify(error));
-            }
-        });
+    async persistFirestoreRead(params) {
+        const limitBytes = 9900000;
+        let buffer = Buffer.from(JSON.stringify(params));
+        if (buffer.length > limitBytes) {
+            params.queryResult = 'too-big-to-save';
+            buffer = Buffer.from(JSON.stringify(params));
+        }
+        try {
+            await this.topic.publishMessage({
+                data: buffer
+            });
+        }
+        catch (error) {
+            console.log(JSON.stringify(error));
+        }
     }
     loadPubSub() {
         try {

package/dist/model/CacheProviders.js

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

package/dist/model/MQuery.d.ts

@@ -5,12 +5,15 @@ export declare class MQuery {
     operator: FirebaseFirestore.WhereFilterOp;
     value: any;
 }
+export declare class MQueryOr {
+    or: Array<MQuery | MQuerySimple>;
+}
 export declare class MQuerySimple {
     [key: string]: string | number;
 }
 export declare class Config {
     orderBy?: OrderBy;
-    query?: Array<MQuery | MQuerySimple>;
+    query?: Array<MQuery | MQuerySimple | MQueryOr>;
     select?: Array<string>;
     paging?: Paging;
 }

package/dist/model/MQuery.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Options = exports.OrderBy = exports.Config = exports.MQuerySimple = exports.MQuery = void 0;
+exports.Options = exports.OrderBy = exports.Config = exports.MQuerySimple = exports.MQueryOr = exports.MQuery = void 0;
 class MQuery {
     constructor() {
         this.operator = '==';
     }
 }
 exports.MQuery = MQuery;
+class MQueryOr {
+}
+exports.MQueryOr = MQueryOr;
 class MQuerySimple {
 }
 exports.MQuerySimple = MQuerySimple;

package/dist/query/ManualQueryHelper.js

@@ -1,15 +1,7 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManualQueryHelper = void 0;
+const firestore_1 = require("@google-cloud/firestore");
 const FirestoreInstance_1 = require("../config/FirestoreInstance");
 const MQuery_1 = require("../model/MQuery");
 const QueryCreatorConfig_1 = require("./QueryCreatorConfig");
@@ -17,162 +9,175 @@ const QueryPredicateFunctionTransform_1 = require("./QueryPredicateFunctionTrans
 const ArchiveService_1 = require("../archive/ArchiveService");
 // import { ArchiveConfig } from "../config/ArchiveConfig";
 class ManualQueryHelper {
-    static executeQueryManual(className, config, queryRef = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this.handleExecuteQueryManual(className, config, { showCount: false }, queryRef);
-            if (queryRef) {
-                return result;
-            }
-            const { data } = result;
-            return data;
-        });
+    static async executeQueryManual(className, config, queryRef = false) {
+        const result = await this.handleExecuteQueryManual(className, config, { showCount: false }, queryRef);
+        if (queryRef) {
+            return result;
+        }
+        const { data } = result;
+        return data;
     }
-    static executeQueryManualPaginated(className, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.handleExecuteQueryManual(className, config, { showCount: true });
-        });
+    static async executeQueryManualPaginated(className, config) {
+        return this.handleExecuteQueryManual(className, config, { showCount: true });
     }
     /**
      * Processa documentos arquivados, recuperando seus dados completos do Cloud Storage
      */
-    static processArchivedDocuments(docs, collectionName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const archiveService = yield ArchiveService_1.ArchiveService.getInstance();
-            // Verifica se o arquivamento está habilitado
-            if (!archiveService.isEnabled()) {
-                return docs;
+    static async processArchivedDocuments(docs, collectionName) {
+        const archiveService = await ArchiveService_1.ArchiveService.getInstance();
+        // Verifica se o arquivamento está habilitado
+        if (!archiveService.isEnabled()) {
+            return docs;
+        }
+        const docsMap = new Map();
+        const recoveryPromises = docs.map(async (doc) => {
+            docsMap.set(doc.id, doc);
+            if (!archiveService.isDocumentArchived(doc)) {
+                return null;
             }
-            const docsMap = new Map();
-            const recoveryPromises = docs.map((doc) => __awaiter(this, void 0, void 0, function* () {
-                docsMap.set(doc.id, doc);
-                if (!archiveService.isDocumentArchived(doc)) {
-                    return null;
-                }
-                try {
-                    // O ArchiveService agora gerencia o cache internamente baseado na configuração
-                    const archivedData = yield archiveService.getArchivedDocument(collectionName, doc);
-                    if (archivedData) {
-                        // Remove o flag de arquivamento e mescla os dados
-                        // const { fbArchivedAt, ...archivedDataWithoutFlag } = archivedData;
-                        return Object.assign(Object.assign({}, doc), archivedData);
-                    }
-                    return doc;
-                }
-                catch (error) {
-                    console.warn(`Erro ao recuperar documento arquivado ${doc.id}:`, error);
-                    return doc;
-                }
-            }));
-            const recoveredDocs = yield Promise.all(recoveryPromises);
-            recoveredDocs.forEach(doc => {
-                if (doc) {
-                    docsMap.set(doc.id, doc);
+            try {
+                // O ArchiveService agora gerencia o cache internamente baseado na configuração
+                const archivedData = await archiveService.getArchivedDocument(collectionName, doc);
+                if (archivedData) {
+                    // Remove o flag de arquivamento e mescla os dados
+                    // const { fbArchivedAt, ...archivedDataWithoutFlag } = archivedData;
+                    return { ...doc, ...archivedData };
                 }
-            });
-            return Array.from(docsMap.values());
+                return doc;
+            }
+            catch (error) {
+                console.warn(`Erro ao recuperar documento arquivado ${doc.id}:`, error);
+                return doc;
+            }
         });
+        const recoveredDocs = await Promise.all(recoveryPromises);
+        recoveredDocs.forEach(doc => {
+            if (doc) {
+                docsMap.set(doc.id, doc);
+            }
+        });
+        return Array.from(docsMap.values());
     }
-    static handleExecuteQueryManual(className, config, options, queryRef = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield global.instances.startTracer('firestore.query', (span) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                try {
-                    const cacheResolver = global.instances.cacheResolver;
-                    const result = yield cacheResolver.getCacheResult(className, 'any', JSON.stringify(Object.assign(Object.assign({}, config), { options })));
-                    if (result) {
-                        return result;
-                    }
-                    const repositoryOptions = QueryPredicateFunctionTransform_1.QueryPredicateFunctionTransform.classConfig.get(className);
-                    const traceQuery = [];
-                    const pushTraceQuery = (query) => {
-                        traceQuery.push({ field: query.field, operator: query.operator, value: '?' });
-                    };
-                    if (repositoryOptions) {
-                        const firestoreInstance = FirestoreInstance_1.FirestoreInstance.getInstance();
-                        const collection = firestoreInstance.collection(repositoryOptions.collection);
-                        let queryList;
-                        let queryExecute = collection;
-                        if ((config === null || config === void 0 ? void 0 : config.query) && ((_a = config === null || config === void 0 ? void 0 : config.query) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                            queryList = config.query.map(query => {
-                                if (Object.keys(query).length === 1) {
-                                    return this.convertToMQuery(query);
+    static async handleExecuteQueryManual(className, config, options, queryRef = false) {
+        return await global.instances.startTracer('firestore.query', async (span) => {
+            try {
+                const cacheResolver = global.instances.cacheResolver;
+                const result = await cacheResolver.getCacheResult(className, 'any', JSON.stringify({ ...config, options }));
+                if (result) {
+                    return result;
+                }
+                const repositoryOptions = QueryPredicateFunctionTransform_1.QueryPredicateFunctionTransform.classConfig.get(className);
+                const traceQuery = [];
+                const pushTraceQuery = (query) => {
+                    traceQuery.push({ field: query.field, operator: query.operator, value: '?' });
+                };
+                if (repositoryOptions) {
+                    const firestoreInstance = FirestoreInstance_1.FirestoreInstance.getInstance();
+                    const collection = firestoreInstance.collection(repositoryOptions.collection);
+                    let queryList;
+                    let queryExecute = collection;
+                    if (config?.query && config?.query?.length > 0) {
+                        queryList = config.query.map(query => {
+                            return query;
+                        });
+                        for (const queryItem of queryList) {
+                            if (queryItem && typeof queryItem === 'object' && 'or' in queryItem && Array.isArray(queryItem.or)) {
+                                const orFilters = queryItem.or.map((orCondition) => {
+                                    const mQuery = Object.keys(orCondition).length === 1
+                                        ? this.convertToMQuery(orCondition)
+                                        : orCondition;
+                                    pushTraceQuery(mQuery);
+                                    return firestore_1.Filter.where(mQuery.field, mQuery.operator, mQuery.value);
+                                });
+                                if (orFilters.length > 0) {
+                                    const orFilter = firestore_1.Filter.or(...orFilters);
+                                    if (queryExecute === collection) {
+                                        queryExecute = collection.where(orFilter);
+                                    }
+                                    else {
+                                        queryExecute = queryExecute.where(orFilter);
+                                    }
                                 }
-                                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);
-                            });
-                        }
-                        if (config && (config === null || config === void 0 ? void 0 : config.select)) {
-                            if (queryExecute) {
-                                queryExecute = queryExecute.select(...config.select);
                             }
                             else {
-                                queryExecute = collection.select(...config.select);
+                                const mQuery = Object.keys(queryItem).length === 1
+                                    ? this.convertToMQuery(queryItem)
+                                    : queryItem;
+                                if (queryExecute === collection) {
+                                    queryExecute = collection.where(mQuery.field, mQuery.operator, mQuery.value);
+                                }
+                                else {
+                                    queryExecute = queryExecute.where(mQuery.field, mQuery.operator, mQuery.value);
+                                }
+                                pushTraceQuery(mQuery);
                             }
                         }
-                        if (config && (config === null || config === void 0 ? void 0 : config.orderBy)) {
-                            if (queryExecute) {
-                                queryExecute = queryExecute.orderBy(config.orderBy.field, config.orderBy.direction);
-                            }
-                            else {
-                                queryExecute = collection.orderBy(config.orderBy.field, config.orderBy.direction);
-                            }
+                    }
+                    if (config && config?.select) {
+                        if (queryExecute) {
+                            queryExecute = queryExecute.select(...config.select);
                         }
+                        else {
+                            queryExecute = collection.select(...config.select);
+                        }
+                    }
+                    if (config && config?.orderBy) {
                         if (queryExecute) {
-                            let count = null;
-                            if (config === null || config === void 0 ? void 0 : config.paging) {
-                                const { documentRef, totalItens } = yield new QueryCreatorConfig_1.QueryCreatorConfig().buildPaging(queryExecute, config.paging, options);
-                                queryExecute = documentRef;
-                                count = totalItens;
-                            }
-                            if (queryRef) {
-                                return queryExecute;
-                            }
-                            const snapshot = yield queryExecute.get();
-                            const data = this.getData(snapshot);
-                            // PROCESSAR DOCUMENTOS ARQUIVADOS
-                            const processedData = yield this.processArchivedDocuments(data, repositoryOptions.collection);
-                            yield cacheResolver.cacheResult(className, 'any', { data: processedData, count }, JSON.stringify(Object.assign(Object.assign({}, config), { options })));
-                            const firestoreReadAuditResolver = global.instances.firestoreReadAuditResolver;
-                            yield firestoreReadAuditResolver.persistFirestoreRead({
-                                collection: repositoryOptions.collection,
-                                repositoryClassName: className,
-                                functionSignature: 'manual-query',
-                                params: JSON.stringify(config),
-                                queryResult: data
-                            });
-                            span.setAttributes({
-                                'firestore.operation.name': 'query',
-                                'firestore.operation.query': JSON.stringify(traceQuery),
-                                'firestore.collection.name': repositoryOptions.collection,
-                                'firestore.operation.size': data.length,
-                            });
-                            return {
-                                data: processedData,
-                                totalItens: count
-                            };
+                            queryExecute = queryExecute.orderBy(config.orderBy.field, config.orderBy.direction);
+                        }
+                        else {
+                            queryExecute = collection.orderBy(config.orderBy.field, config.orderBy.direction);
                         }
                     }
-                    return {
-                        data: [],
-                        totalItens: 0
-                    };
-                }
-                catch (error) {
-                    span.setStatus({
-                        code: 2,
-                        message: error.message
-                    });
-                    span.recordException(error);
-                    throw error;
+                    if (queryExecute) {
+                        let count = null;
+                        if (config?.paging) {
+                            const { documentRef, totalItens } = await new QueryCreatorConfig_1.QueryCreatorConfig().buildPaging(queryExecute, config.paging, options);
+                            queryExecute = documentRef;
+                            count = totalItens;
+                        }
+                        if (queryRef) {
+                            return queryExecute;
+                        }
+                        const snapshot = await queryExecute.get();
+                        const data = this.getData(snapshot);
+                        // PROCESSAR DOCUMENTOS ARQUIVADOS
+                        const processedData = await this.processArchivedDocuments(data, repositoryOptions.collection);
+                        await cacheResolver.cacheResult(className, 'any', { data: processedData, count }, JSON.stringify({ ...config, options }));
+                        const firestoreReadAuditResolver = global.instances.firestoreReadAuditResolver;
+                        await firestoreReadAuditResolver.persistFirestoreRead({
+                            collection: repositoryOptions.collection,
+                            repositoryClassName: className,
+                            functionSignature: 'manual-query',
+                            params: JSON.stringify(config),
+                            queryResult: data
+                        });
+                        span.setAttributes({
+                            'firestore.operation.name': 'query',
+                            'firestore.operation.query': JSON.stringify(traceQuery),
+                            'firestore.collection.name': repositoryOptions.collection,
+                            'firestore.operation.size': data.length,
+                        });
+                        return {
+                            data: processedData,
+                            totalItens: count
+                        };
+                    }
                 }
-            }));
+                return {
+                    data: [],
+                    totalItens: 0
+                };
+            }
+            catch (error) {
+                console.error(error);
+                span.setStatus({
+                    code: 2,
+                    message: error.message
+                });
+                span.recordException(error);
+                throw error;
+            }
         });
     }
     static convertToMQuery(query) {
@@ -188,7 +193,7 @@ class ManualQueryHelper {
         let items = [];
         try {
             snapshot.forEach((doc) => {
-                let element = Object.assign({}, doc.data());
+                let element = { ...doc.data() };
                 element.id = doc.id;
                 items.push(element);
             });