sml-baseline 1.0.0

package/dist/smlquery/smlquery.service.js

@@ -0,0 +1,1007 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmlqueryService = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const create_smlquery_dto_1 = require("./dto/create-smlquery.dto");
+const smlquery_entity_1 = require("./entities/smlquery.entity");
+let SmlqueryService = class SmlqueryService {
+    constructor(smlQueryModel, connection) {
+        this.smlQueryModel = smlQueryModel;
+        this.connection = connection;
+    }
+    getConnection(name) {
+        return this.connection;
+    }
+    async create(createSmlQueryDto) {
+        try {
+            const createdRecord = new this.smlQueryModel(createSmlQueryDto);
+            return await createdRecord.save();
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error saving new entities. ${e.detail}`,
+            });
+        }
+    }
+    async findAll(filters, limit, offset) {
+        try {
+            const query = {};
+            if (filters) {
+                for (const key in filters) {
+                    if (filters[key]) {
+                        query[key] = filters[key];
+                    }
+                }
+            }
+            const results = await this.smlQueryModel
+                .find(query)
+                .skip(offset)
+                .limit(limit);
+            return results;
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error retrieving entities. ${e.message}`,
+            });
+        }
+    }
+    async findOne(id) {
+        try {
+            const smlquery = await this.smlQueryModel.findById(id).exec();
+            if (!smlquery) {
+                throw new common_1.NotFoundException(`Smlquery with id ${id} not found`);
+            }
+            return smlquery;
+        }
+        catch (e) {
+            if (e instanceof common_1.NotFoundException) {
+                throw e;
+            }
+            throw new common_1.InternalServerErrorException({
+                description: `Error retrieving the entity with id ${id}. ${e.message}`,
+            });
+        }
+    }
+    async update(id, updateSmlqueryDto) {
+        try {
+            const updatedSmlquery = await this.smlQueryModel
+                .findByIdAndUpdate(id, updateSmlqueryDto, { new: true })
+                .exec();
+            if (!updatedSmlquery) {
+                throw new common_1.NotFoundException(`Smlquery with id ${id} not found`);
+            }
+            return updatedSmlquery;
+        }
+        catch (e) {
+            if (e instanceof common_1.NotFoundException) {
+                throw e;
+            }
+            throw new common_1.InternalServerErrorException({
+                description: `Error updating the entity with id ${id}. ${e.message}`,
+            });
+        }
+    }
+    async remove(id) {
+        try {
+            const deletedSmlquery = await this.smlQueryModel
+                .findByIdAndDelete(id)
+                .exec();
+            if (!deletedSmlquery) {
+                throw new common_1.NotFoundException(`Smlquery with id ${id} not found`);
+            }
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error removing the entity with id ${id}. ${e.message}`,
+            });
+        }
+    }
+    async runQueryV1(code, skip = 0, limit = 10, filters) {
+        try {
+            const smlquery = await this.smlQueryModel.findOne({ code }).exec();
+            if (!smlquery) {
+                throw new common_1.NotFoundException(`Smlquery with code ${code} not found`);
+            }
+            let { queryBody, collectionName } = smlquery;
+            if (filters) {
+                try {
+                    const dynamicParams = JSON.parse(filters);
+                    let query = JSON.stringify(queryBody.query);
+                    query = query.replace(/\$\{(.*?)\}/g, (match, key) => {
+                        return dynamicParams[key] !== undefined
+                            ? dynamicParams[key]
+                            : match;
+                    });
+                    queryBody.query = JSON.parse(query);
+                }
+                catch (e) {
+                }
+            }
+            if (!queryBody) {
+                throw new common_1.InternalServerErrorException('Query body is empty or undefined');
+            }
+            const collection = this.connection.collection(collectionName);
+            let data;
+            let count;
+            if (Array.isArray(queryBody.query)) {
+                const aggregationPipeline = [...queryBody.query];
+                aggregationPipeline.push({ $skip: skip });
+                aggregationPipeline.push({ $limit: limit });
+                data = await collection.aggregate(aggregationPipeline).toArray();
+                const countPipeline = [...queryBody.query];
+                countPipeline.push({ $count: 'totalCount' });
+                const countResult = await collection.aggregate(countPipeline).toArray();
+                count = countResult[0] ? countResult[0].totalCount : 0;
+            }
+            else if (typeof queryBody.query === 'object') {
+                const query = collection.find(queryBody.query);
+                count = await collection.countDocuments(queryBody.query);
+                query.skip(skip).limit(limit);
+                data = await query.toArray();
+            }
+            else {
+                throw new common_1.InternalServerErrorException('Invalid queryBody format');
+            }
+            return {
+                data,
+                count,
+            };
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error executing query for code ${code}. ${e.message}`,
+            });
+        }
+    }
+    async runQueryV2(code, skip = 0, limit = 10, filters, sort) {
+        try {
+            const smlquery = await this.smlQueryModel.findOne({ code }).exec();
+            if (!smlquery) {
+                throw new common_1.NotFoundException(`Smlquery with code ${code} not found`);
+            }
+            let { queryBody, collectionName } = smlquery;
+            let _query = queryBody;
+            if (queryBody.query) {
+                _query = queryBody.query;
+            }
+            if (filters) {
+                try {
+                    const dynamicParams = JSON.parse(filters);
+                    _query = JSON.stringify(_query);
+                    _query = _query.replace(/\$\{(.*?)\}/g, (match, key) => {
+                        return dynamicParams[key] !== undefined
+                            ? dynamicParams[key]
+                            : match;
+                    });
+                    _query = JSON.parse(_query);
+                }
+                catch (e) {
+                }
+            }
+            const sortObj = sort ? JSON.parse(sort) : { _id: 1 };
+            const collection = this.connection.collection(collectionName);
+            let data;
+            let count;
+            if (Array.isArray(_query)) {
+                const aggregationPipeline = [..._query];
+                aggregationPipeline.push({ $skip: skip });
+                aggregationPipeline.push({ $limit: limit });
+                aggregationPipeline.push({ $sort: sortObj });
+                data = await collection.aggregate(aggregationPipeline).toArray();
+                const countPipeline = [..._query];
+                countPipeline.push({ $count: 'totalCount' });
+                const countResult = await collection.aggregate(countPipeline).toArray();
+                count = countResult[0] ? countResult[0].totalCount : 0;
+            }
+            else if (typeof _query === 'object') {
+                const query = collection.find(_query);
+                query.sort(sortObj);
+                count = await collection.countDocuments(_query);
+                query.skip(skip).limit(limit);
+                data = await query.toArray();
+            }
+            else {
+                throw new common_1.InternalServerErrorException('Invalid queryBody format');
+            }
+            return {
+                data,
+                count,
+            };
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error executing query for code ${code}. ${e.message}`,
+            });
+        }
+    }
+    async runQueryV3(code, skip = 0, limit = 100, filters, sort, currentUser, referenceId) {
+        try {
+            const smlquery = await this.smlQueryModel.findOne({ code }).exec();
+            if (!smlquery) {
+                throw new common_1.NotFoundException(`Smlquery with code ${code} not found`);
+            }
+            let { queryBody, collectionName, queryMetadata, connectionName } = smlquery;
+            let _query = queryBody;
+            if (queryBody.query) {
+                _query = queryBody.query;
+            }
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            const currentYear = today.getFullYear();
+            const existsPlaceholder = JSON.stringify(queryBody).includes('{{currentUser}}')
+                || JSON.stringify(queryBody).includes('{{year}}') || JSON.stringify(queryBody).includes('{{today}}')
+                || JSON.stringify(queryBody).includes('{{referenceId}}');
+            if (filters || existsPlaceholder) {
+                try {
+                    let dynamicParams = {};
+                    if (filters) {
+                        dynamicParams = JSON.parse(filters);
+                    }
+                    const deepCloneWithRegex = (obj) => {
+                        if (obj === null || typeof obj !== 'object') {
+                            return obj;
+                        }
+                        if (obj instanceof RegExp) {
+                            return new RegExp(obj.source, obj.flags);
+                        }
+                        if (Array.isArray(obj)) {
+                            return obj.map((item) => deepCloneWithRegex(item));
+                        }
+                        const clonedObj = {};
+                        Object.keys(obj).forEach((key) => {
+                            clonedObj[key] = deepCloneWithRegex(obj[key]);
+                        });
+                        return clonedObj;
+                    };
+                    const clonedQuery = deepCloneWithRegex(_query);
+                    const regexPlaceholders = {};
+                    let regexCount = 0;
+                    const stringifyWithRegexPreserved = (obj) => {
+                        return JSON.stringify(obj, (key, value) => {
+                            if (value instanceof RegExp) {
+                                const placeholder = `__REGEX_PLACEHOLDER_${regexCount}__`;
+                                regexPlaceholders[placeholder] = value;
+                                regexCount++;
+                                return placeholder;
+                            }
+                            return value;
+                        });
+                    };
+                    let queryStr = stringifyWithRegexPreserved(clonedQuery);
+                    if (currentUser !== undefined &&
+                        dynamicParams['currentUser'] === undefined) {
+                        dynamicParams['currentUser'] = currentUser;
+                    }
+                    if (dynamicParams['today'] === undefined) {
+                        dynamicParams['today'] = today;
+                    }
+                    if (dynamicParams['year'] === undefined) {
+                        dynamicParams['year'] = currentYear;
+                    }
+                    if (referenceId !== undefined && referenceId !== '') {
+                        dynamicParams['referenceId'] = currentYear;
+                    }
+                    queryStr = queryStr.replace(/"\$\{(.*?)\}"/g, (match, key) => {
+                        if (dynamicParams[key] !== undefined) {
+                            if (typeof dynamicParams[key] === 'string') {
+                                return `"${dynamicParams[key]}"`;
+                            }
+                            else {
+                                return JSON.stringify(dynamicParams[key]);
+                            }
+                        }
+                        return match;
+                    });
+                    queryStr = queryStr.replace(/\$\{(.*?)\}/g, (match, key) => {
+                        if (dynamicParams[key] !== undefined) {
+                            if (typeof dynamicParams[key] === 'string') {
+                                return `"${dynamicParams[key]}"`;
+                            }
+                            else {
+                                return dynamicParams[key];
+                            }
+                        }
+                        return match;
+                    });
+                    queryStr = queryStr.replace(/"{{currentUser}}"/g, currentUser !== undefined
+                        ? `"${currentUser}"`
+                        : '"{{currentUser}}"');
+                    queryStr = queryStr.replace(/{{currentUser}}/g, currentUser !== undefined ? `"${currentUser}"` : '{{currentUser}}');
+                    queryStr = queryStr.replace(/"{{today}}"/g, `"${today.toISOString()}"`);
+                    queryStr = queryStr.replace(/{{today}}/g, `"${today.toISOString()}"`);
+                    queryStr = queryStr.replace(/"{{year}}"/g, `${currentYear}`);
+                    queryStr = queryStr.replace(/{{year}}/g, `${currentYear}`);
+                    queryStr = queryStr.replace(/{{referenceId}}/g, `${referenceId}`);
+                    _query = JSON.parse(queryStr);
+                    const restoreRegexes = (obj) => {
+                        if (!obj || typeof obj !== 'object')
+                            return obj;
+                        Object.keys(obj).forEach((key) => {
+                            const value = obj[key];
+                            if (typeof value === 'string' &&
+                                value.startsWith('__REGEX_PLACEHOLDER_') &&
+                                value.endsWith('__')) {
+                                obj[key] = regexPlaceholders[value];
+                            }
+                            else if (Array.isArray(value)) {
+                                value.forEach((item, index) => {
+                                    if (typeof item === 'string' &&
+                                        item.startsWith('__REGEX_PLACEHOLDER_') &&
+                                        item.endsWith('__')) {
+                                        value[index] = regexPlaceholders[item];
+                                    }
+                                    else if (typeof item === 'object') {
+                                        restoreRegexes(item);
+                                    }
+                                });
+                            }
+                            else if (typeof value === 'object') {
+                                restoreRegexes(value);
+                            }
+                        });
+                        return obj;
+                    };
+                    _query = restoreRegexes(_query);
+                }
+                catch (e) {
+                    console.error("Errore durante l'elaborazione dei filtri:", e);
+                }
+            }
+            let sortObj = sort ? JSON.parse(sort) : { _id: 1 };
+            if (queryMetadata.sort) {
+                sortObj = queryMetadata.sort;
+            }
+            const collection = this.getConnection(connectionName).collection(collectionName);
+            let data;
+            let count;
+            if (Array.isArray(_query)) {
+                const aggregationPipeline = [..._query];
+                if (sort) {
+                    aggregationPipeline.push({ $sort: sortObj });
+                }
+                aggregationPipeline.push({ $skip: skip });
+                aggregationPipeline.push({ $limit: limit });
+                data = await collection.aggregate(aggregationPipeline).toArray();
+                const countPipeline = [..._query];
+                countPipeline.push({ $count: 'totalCount' });
+                const countResult = await collection.aggregate(countPipeline).toArray();
+                count = countResult[0] ? countResult[0].totalCount : 0;
+            }
+            else if (typeof _query === 'object') {
+                const query = collection.find(_query);
+                query.sort(sortObj);
+                count = await collection.countDocuments(_query);
+                query.skip(skip).limit(limit);
+                data = await query.toArray();
+            }
+            else {
+                throw new common_1.InternalServerErrorException('Invalid queryBody format');
+            }
+            return {
+                data,
+                count,
+            };
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error executing query for code ${code}. ${e.message}`,
+            });
+        }
+    }
+    async runQueryV4(code, skip = 0, limit = 100, filters, sort, currentUser, referenceId) {
+        try {
+            const smlquery = await this.smlQueryModel.findOne({ code }).exec();
+            if (!smlquery) {
+                throw new common_1.NotFoundException(`Smlquery with code ${code} not found`);
+            }
+            let { queryBody, collectionName, queryMetadata, connectionName } = smlquery;
+            let _query = queryBody;
+            if (queryBody.query) {
+                _query = queryBody.query;
+            }
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            const currentYear = today.getFullYear();
+            const existsPlaceholder = JSON.stringify(queryBody).includes('{{currentUser}}')
+                || JSON.stringify(queryBody).includes('{{year}}')
+                || JSON.stringify(queryBody).includes('{{today}}')
+                || JSON.stringify(queryBody).includes('{{referenceId}}');
+            if (filters || existsPlaceholder) {
+                try {
+                    let dynamicParams = {};
+                    if (filters) {
+                        dynamicParams = JSON.parse(filters);
+                    }
+                    const deepCloneWithRegex = (obj) => {
+                        if (obj === null || typeof obj !== 'object') {
+                            return obj;
+                        }
+                        if (obj instanceof RegExp) {
+                            return new RegExp(obj.source, obj.flags);
+                        }
+                        if (Array.isArray(obj)) {
+                            return obj.map((item) => deepCloneWithRegex(item));
+                        }
+                        const clonedObj = {};
+                        Object.keys(obj).forEach((key) => {
+                            clonedObj[key] = deepCloneWithRegex(obj[key]);
+                        });
+                        return clonedObj;
+                    };
+                    const clonedQuery = deepCloneWithRegex(_query);
+                    const regexPlaceholders = {};
+                    let regexCount = 0;
+                    const stringifyWithRegexPreserved = (obj) => {
+                        return JSON.stringify(obj, (key, value) => {
+                            if (value instanceof RegExp) {
+                                const placeholder = `__REGEX_PLACEHOLDER_${regexCount}__`;
+                                regexPlaceholders[placeholder] = value;
+                                regexCount++;
+                                return placeholder;
+                            }
+                            return value;
+                        });
+                    };
+                    let queryStr = stringifyWithRegexPreserved(clonedQuery);
+                    if (currentUser !== undefined && dynamicParams['currentUser'] === undefined) {
+                        dynamicParams['currentUser'] = currentUser;
+                    }
+                    if (dynamicParams['today'] === undefined) {
+                        dynamicParams['today'] = today;
+                    }
+                    if (dynamicParams['year'] === undefined) {
+                        dynamicParams['year'] = currentYear;
+                    }
+                    if (referenceId !== undefined && referenceId !== '') {
+                        dynamicParams['referenceId'] = referenceId;
+                    }
+                    queryStr = queryStr.replace(/"\$\{(.*?)\}"/g, (match, key) => {
+                        if (dynamicParams[key] !== undefined) {
+                            const value = dynamicParams[key];
+                            if (typeof value === 'string') {
+                                const date = new Date(value);
+                                if (!isNaN(date.getTime())) {
+                                    return `"${date.toISOString()}"`;
+                                }
+                                return `"${value}"`;
+                            }
+                            else if (value instanceof Date) {
+                                return `"${value.toISOString()}"`;
+                            }
+                            else {
+                                return JSON.stringify(value);
+                            }
+                        }
+                        return match;
+                    });
+                    queryStr = queryStr.replace(/\$\{(.*?)\}/g, (match, key) => {
+                        if (dynamicParams[key] !== undefined) {
+                            const value = dynamicParams[key];
+                            if (typeof value === 'string') {
+                                const date = new Date(value);
+                                if (!isNaN(date.getTime())) {
+                                    return `"${date.toISOString()}"`;
+                                }
+                                return `"${value}"`;
+                            }
+                            else if (value instanceof Date) {
+                                return `"${value.toISOString()}"`;
+                            }
+                            else {
+                                return JSON.stringify(value);
+                            }
+                        }
+                        return match;
+                    });
+                    queryStr = queryStr.replace(/"{{currentUser}}"/g, currentUser !== undefined ? `"${currentUser}"` : '"{{currentUser}}"');
+                    queryStr = queryStr.replace(/{{currentUser}}/g, currentUser !== undefined ? `"${currentUser}"` : '{{currentUser}}');
+                    queryStr = queryStr.replace(/"{{today}}"/g, `"${today.toISOString()}"`);
+                    queryStr = queryStr.replace(/{{today}}/g, `"${today.toISOString()}"`);
+                    queryStr = queryStr.replace(/"{{year}}"/g, `${currentYear}`);
+                    queryStr = queryStr.replace(/{{year}}/g, `${currentYear}`);
+                    queryStr = queryStr.replace(/{{referenceId}}/g, `${referenceId}`);
+                    console.log(queryStr);
+                    _query = JSON.parse(queryStr);
+                    const restoreRegexes = (obj) => {
+                        if (!obj || typeof obj !== 'object')
+                            return obj;
+                        Object.keys(obj).forEach((key) => {
+                            const value = obj[key];
+                            if (typeof value === 'string' &&
+                                value.startsWith('__REGEX_PLACEHOLDER_') &&
+                                value.endsWith('__')) {
+                                obj[key] = regexPlaceholders[value];
+                            }
+                            else if (Array.isArray(value)) {
+                                value.forEach((item, index) => {
+                                    if (typeof item === 'string' &&
+                                        item.startsWith('__REGEX_PLACEHOLDER_') &&
+                                        item.endsWith('__')) {
+                                        value[index] = regexPlaceholders[item];
+                                    }
+                                    else if (typeof item === 'object') {
+                                        restoreRegexes(item);
+                                    }
+                                });
+                            }
+                            else if (typeof value === 'object') {
+                                restoreRegexes(value);
+                            }
+                        });
+                        return obj;
+                    };
+                    _query = restoreRegexes(_query);
+                }
+                catch (e) {
+                    console.error("Errore durante l'elaborazione dei filtri:", e);
+                }
+            }
+            let sortObj = sort ? JSON.parse(sort) : { _id: 1 };
+            if (queryMetadata.sort) {
+                sortObj = queryMetadata.sort;
+            }
+            const collection = this.getConnection(connectionName).collection(collectionName);
+            let data;
+            let count;
+            if (Array.isArray(_query)) {
+                const aggregationPipeline = [..._query];
+                if (sort) {
+                    aggregationPipeline.push({ $sort: sortObj });
+                }
+                aggregationPipeline.push({ $skip: skip });
+                aggregationPipeline.push({ $limit: limit });
+                data = await collection.aggregate(aggregationPipeline).toArray();
+                const countPipeline = [..._query];
+                countPipeline.push({ $count: 'totalCount' });
+                const countResult = await collection.aggregate(countPipeline).toArray();
+                count = countResult[0] ? countResult[0].totalCount : 0;
+            }
+            else if (typeof _query === 'object') {
+                const query = collection.find(_query);
+                query.sort(sortObj);
+                count = await collection.countDocuments(_query);
+                query.skip(skip).limit(limit);
+                data = await query.toArray();
+            }
+            else {
+                throw new common_1.InternalServerErrorException('Invalid queryBody format');
+            }
+            return {
+                data,
+                count,
+            };
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error executing query for code ${code}. ${e.message}`,
+            });
+        }
+    }
+    async runQueryV5(code, skip = 0, limit = 100, filters, sort, currentUser, userAttributes, referenceId, smlStore) {
+        try {
+            const smlquery = await this.smlQueryModel.findOne({ code }).exec();
+            if (!smlquery) {
+                throw new common_1.NotFoundException(`Smlquery with code ${code} not found`);
+            }
+            let { queryBody, collectionName, queryMetadata, connectionName } = smlquery;
+            let _query = queryBody;
+            if (queryBody.query) {
+                _query = queryBody.query;
+            }
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            const currentYear = today.getFullYear();
+            const existsPlaceholder = this.hasPlaceholders(_query);
+            if (filters || existsPlaceholder) {
+                try {
+                    let dynamicParams = {};
+                    if (filters) {
+                        dynamicParams = JSON.parse(filters);
+                    }
+                    const clonedQuery = this.deepClone(_query);
+                    if (currentUser !== undefined && dynamicParams['currentUser'] === undefined) {
+                        dynamicParams['currentUser'] = currentUser;
+                    }
+                    if (dynamicParams['today'] === undefined) {
+                        dynamicParams['today'] = today;
+                    }
+                    if (dynamicParams['year'] === undefined) {
+                        dynamicParams['year'] = currentYear;
+                    }
+                    if (referenceId !== undefined && referenceId !== '') {
+                        dynamicParams['referenceId'] = referenceId;
+                    }
+                    dynamicParams['sml'] = smlStore;
+                    _query = this.replacePlaceholders(clonedQuery, dynamicParams);
+                }
+                catch (e) {
+                    console.error("Errore durante l'elaborazione dei filtri:", e);
+                }
+            }
+            let sortObj = sort ? JSON.parse(sort) : { _id: 1 };
+            if (queryMetadata.sort) {
+                sortObj = queryMetadata.sort;
+            }
+            if (queryMetadata.limit) {
+                limit = queryMetadata.limit;
+            }
+            if (queryMetadata.offset) {
+                skip = queryMetadata.offset;
+            }
+            const collection = this.getConnection(connectionName).collection(collectionName);
+            let data;
+            let count;
+            if (Array.isArray(_query)) {
+                const aggregationPipeline = [..._query];
+                if (queryMetadata?.projection) {
+                    aggregationPipeline.push({ $project: queryMetadata.projection });
+                }
+                if (sort) {
+                    aggregationPipeline.push({ $sort: sortObj });
+                }
+                aggregationPipeline.push({ $skip: skip });
+                aggregationPipeline.push({ $limit: limit });
+                data = await collection.aggregate(aggregationPipeline).toArray();
+                console.log(_query);
+                const countPipeline = [..._query];
+                countPipeline.push({ $count: 'totalCount' });
+                const countResult = await collection.aggregate(countPipeline).toArray();
+                count = countResult[0] ? countResult[0].totalCount : 0;
+            }
+            else if (typeof _query === 'object') {
+                _query = this.convertObjectIds(_query);
+                const mongoQuery = this.normalizeQuery(_query);
+                const query = collection.find(mongoQuery);
+                query.sort(sortObj);
+                if (queryMetadata?.projection) {
+                    query.project(queryMetadata.projection);
+                }
+                count = await collection.countDocuments(mongoQuery);
+                query.skip(skip).limit(limit);
+                console.log(_query);
+                data = await query.toArray();
+            }
+            else {
+                throw new common_1.InternalServerErrorException('Invalid queryBody format');
+            }
+            return {
+                data,
+                count,
+            };
+        }
+        catch (e) {
+            console.log(e);
+            throw new common_1.InternalServerErrorException({
+                description: `Error executing query for code ${code}. ${e.message}`,
+            });
+        }
+    }
+    convertObjectIds(obj) {
+        if (obj !== null && typeof obj === 'object') {
+            const newObj = {};
+            for (const key of Object.keys(obj)) {
+                const value = obj[key];
+                if (key === '_id' &&
+                    typeof value === 'string' &&
+                    mongoose_2.Types.ObjectId.isValid(value)) {
+                    newObj[key] = new mongoose_2.Types.ObjectId(value);
+                }
+                else {
+                    newObj[key] = this.convertObjectIds(value);
+                }
+            }
+            return newObj;
+        }
+        return obj;
+    }
+    normalizeQuery(obj) {
+        const result = {};
+        for (const key in obj) {
+            const value = obj[key];
+            if (Array.isArray(value)) {
+                if (value.length === 0) {
+                    result[key] = value;
+                    continue;
+                }
+                const isValidArrayForIn = value.every(v => v === null ||
+                    typeof v === "string" ||
+                    typeof v === "number" ||
+                    typeof v === "boolean" ||
+                    v instanceof Object);
+                if (isValidArrayForIn) {
+                    result[key] = { $in: value };
+                    continue;
+                }
+                result[key] = value;
+                continue;
+            }
+            result[key] = value;
+        }
+        return result;
+    }
+    deepClone(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        if (obj instanceof RegExp) {
+            return new RegExp(obj.source, obj.flags);
+        }
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.deepClone(item));
+        }
+        const clonedObj = {};
+        Object.keys(obj).forEach(key => {
+            clonedObj[key] = this.deepClone(obj[key]);
+        });
+        return clonedObj;
+    }
+    hasPlaceholders(obj) {
+        if (typeof obj === 'string') {
+            return obj.includes('{{currentUser}}') ||
+                obj.includes('{{year}}') ||
+                obj.includes('{{today}}') ||
+                obj.includes('{{referenceId}}') ||
+                obj.includes('{{anomaliesReport_isabsite}}') ||
+                obj.includes('{{anomaliesReport_processarea}}') ||
+                obj.includes('${') ||
+                obj.includes('{{sml-');
+        }
+        if (Array.isArray(obj)) {
+            return obj.some(item => this.hasPlaceholders(item));
+        }
+        if (obj && typeof obj === 'object') {
+            return Object.values(obj).some(value => this.hasPlaceholders(value));
+        }
+        return false;
+    }
+    replacePlaceholders(obj, params) {
+        if (typeof obj === 'string') {
+            return this.replaceStringPlaceholders(obj, params);
+        }
+        if (obj instanceof RegExp) {
+            const pattern = obj.source;
+            const flags = obj.flags;
+            const newPattern = this.replaceStringPlaceholders(pattern, params);
+            return new RegExp(newPattern, flags);
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.replacePlaceholders(item, params));
+        }
+        if (obj && typeof obj === 'object' && !(obj instanceof RegExp) && !(obj instanceof Date)) {
+            const result = {};
+            Object.keys(obj).forEach(key => {
+                result[key] = this.replacePlaceholders(obj[key], params);
+            });
+            return result;
+        }
+        return obj;
+    }
+    replaceStringPlaceholders(str, params) {
+        let result = str;
+        const dollarBraceRegex = /^\$\{([^}]+)\}$/;
+        const dollarBraceMatch = str.match(dollarBraceRegex);
+        if (dollarBraceMatch) {
+            const key = dollarBraceMatch[1];
+            if (params.hasOwnProperty(key)) {
+                return this.formatValue(params[key]);
+            }
+            return str;
+        }
+        result = result.replace(/\$\{([^}]+)\}/g, (match, key) => {
+            if (params.hasOwnProperty(key)) {
+                const value = params[key];
+                if (typeof value === 'string') {
+                    return value;
+                }
+                else if (value instanceof Date) {
+                    return value.toISOString();
+                }
+                else {
+                    return String(value);
+                }
+            }
+            return match;
+        });
+        const doubleBraceRegex = /^\{\{([^}]+)\}\}$/;
+        const doubleBraceMatch = str.match(doubleBraceRegex);
+        if (doubleBraceMatch) {
+            const key = doubleBraceMatch[1];
+            if (key.startsWith('sml-')) {
+                const path = key.substring(4);
+                const smlObj = params['sml'];
+                const resolved = this.resolvePath(smlObj, path);
+                if (resolved !== undefined) {
+                    return this.formatValue(resolved);
+                }
+                return str;
+            }
+            switch (key) {
+                case 'currentUser':
+                    if (params.hasOwnProperty('currentUser')) {
+                        return params['currentUser'];
+                    }
+                    break;
+                case 'anomaliesReport_processarea':
+                    if (params.hasOwnProperty('anomaliesReport_processarea')) {
+                        return params['anomaliesReport_processarea'];
+                    }
+                    break;
+                case 'anomaliesReport_isabsite':
+                    if (params.hasOwnProperty('anomaliesReport_isabsite')) {
+                        return params['anomaliesReport_isabsite'];
+                    }
+                    break;
+                case 'today':
+                    return params['today'] || new Date();
+                case 'year':
+                    return params['year'] || new Date().getFullYear();
+                case 'referenceId':
+                    if (params.hasOwnProperty('referenceId')) {
+                        return params['referenceId'];
+                    }
+                    break;
+            }
+            return str;
+        }
+        result = result.replace(/\{\{currentUser\}\}/g, (match) => {
+            if (params.hasOwnProperty('currentUser')) {
+                return String(params['currentUser']);
+            }
+            return match;
+        });
+        result = result.replace(/\{\{anomaliesReport_isabsite\}\}/g, (match) => {
+            if (params.hasOwnProperty('anomaliesReport_isabsite')) {
+                return String(params['anomaliesReport_isabsite']);
+            }
+            return match;
+        });
+        result = result.replace(/\{\{anomaliesReport_processarea\}\}/g, (match) => {
+            if (params.hasOwnProperty('anomaliesReport_processarea')) {
+                return String(params['anomaliesReport_processarea']);
+            }
+            return match;
+        });
+        result = result.replace(/\{\{today\}\}/g, () => {
+            const today = params['today'] || new Date();
+            return today instanceof Date ? today.toISOString() : String(today);
+        });
+        result = result.replace(/\{\{year\}\}/g, () => {
+            return String(params['year'] || new Date().getFullYear());
+        });
+        result = result.replace(/\{\{referenceId\}\}/g, (match) => {
+            if (params.hasOwnProperty('referenceId')) {
+                return String(params['referenceId']);
+            }
+            return match;
+        });
+        result = result.replace(/\{\{sml-([^}]+)\}\}/g, (match, path) => {
+            const smlObj = params['sml'];
+            const resolved = this.resolvePath(smlObj, path);
+            if (resolved === undefined || resolved === null) {
+                return match;
+            }
+            if (resolved instanceof Date) {
+                return resolved.toISOString();
+            }
+            if (typeof resolved === 'object') {
+                try {
+                    return JSON.stringify(resolved);
+                }
+                catch {
+                    return String(resolved);
+                }
+            }
+            return String(resolved);
+        });
+        return result;
+    }
+    formatValue(value) {
+        if (typeof value === 'string') {
+            const dateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+            if (dateRegex.test(value)) {
+                const date = new Date(value);
+                if (!isNaN(date.getTime())) {
+                    return date;
+                }
+            }
+            return value;
+        }
+        if (value instanceof Date) {
+            return value;
+        }
+        if (typeof value === 'boolean' || typeof value === 'number') {
+            return value;
+        }
+        if (value === null || value === undefined) {
+            return value;
+        }
+        return value;
+    }
+    resolvePath(obj, path) {
+        if (!obj || !path)
+            return undefined;
+        const parts = path.split('.');
+        let cur = obj;
+        for (const p of parts) {
+            if (cur === null || cur === undefined)
+                return undefined;
+            cur = cur[p];
+        }
+        return cur;
+    }
+    async getCollectionsAndViews(connectionName) {
+        try {
+            const conn = this.getConnection(connectionName);
+            const db = conn.db;
+            const collections = await db
+                .listCollections({}, { nameOnly: false })
+                .toArray();
+            return collections.map(col => ({
+                name: col.name,
+                type: col.type === 'view' ? 'view' : 'collection',
+            }));
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error retrieving collections and views. ${e.message}`,
+            });
+        }
+    }
+    async getQueryColumns(queryCode) {
+        let columns = [];
+        try {
+            const smlquery = await this.smlQueryModel.findOne({ code: queryCode }).exec();
+            if (smlquery.queryMetadata?.projection) {
+                columns = columns.concat(Object.keys(smlquery.queryMetadata.projection));
+            }
+            else {
+                const collection = this.getConnection(smlquery.connectionName).collection(smlquery.collectionName);
+                const query = collection.find();
+                query.sort({ _id: -1 });
+                query.skip(0).limit(1);
+                const lastRecord = await query.toArray();
+                if (lastRecord[0]) {
+                    columns = columns.concat(Object.keys(lastRecord[0]));
+                }
+            }
+            return columns;
+        }
+        catch (e) {
+            throw new common_1.InternalServerErrorException({
+                description: `Error retriving query columns. ${e.detail}`,
+            });
+        }
+    }
+};
+exports.SmlqueryService = SmlqueryService;
+__decorate([
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [create_smlquery_dto_1.CreateSmlqueryDto]),
+    __metadata("design:returntype", Promise)
+], SmlqueryService.prototype, "create", null);
+exports.SmlqueryService = SmlqueryService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(smlquery_entity_1.Smlquery.name)),
+    __param(1, (0, mongoose_1.InjectConnection)()),
+    __metadata("design:paramtypes", [mongoose_2.Model,
+        mongoose_2.Connection])
+], SmlqueryService);
+//# sourceMappingURL=smlquery.service.js.map