@flowerforce/flowerbase 1.7.2 → 1.7.3-beta.1

package/dist/features/functions/controller.js

@@ -115,7 +115,7 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                 return JSON.stringify({ message: result.message, name: result.name });
             }
             res.type('application/json');
-            return JSON.stringify(result);
+            return JSON.stringify(bson_1.EJSON.serialize(result, { relaxed: false }));
         }
         catch (error) {
             res.status(400);

package/dist/services/mongodb-atlas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAyC,oBAAoB,EAAE,MAAM,SAAS,CAAA;AA8/BrF,QAAA,MAAM,YAAY,EAAE,oBAuBlB,CAAA;AAEF,eAAe,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/index.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAyC,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAysCrF,QAAA,MAAM,YAAY,EAAE,oBA6BlB,CAAA;AAEF,eAAe,YAAY,CAAA"}

package/dist/services/mongodb-atlas/index.js

@@ -14,6 +14,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_1 = __importDefault(require("lodash/get"));
 const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const set_1 = __importDefault(require("lodash/set"));
+const unset_1 = __importDefault(require("lodash/unset"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
 const utils_1 = require("../../monitoring/utils");
 const machines_1 = require("../../utils/roles/machines");
 const utils_2 = require("../../utils/roles/machines/utils");
@@ -39,6 +42,206 @@ const logService = (message, payload) => {
         return;
     console.log('[service-debug]', message, payload !== null && payload !== void 0 ? payload : '');
 };
+const findOptionKeys = new Set([
+    'sort',
+    'skip',
+    'limit',
+    'session',
+    'hint',
+    'maxTimeMS',
+    'collation',
+    'allowPartialResults',
+    'noCursorTimeout',
+    'batchSize',
+    'returnKey',
+    'showRecordId',
+    'comment',
+    'let',
+    'projection'
+]);
+const isPlainObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const looksLikeFindOptions = (value) => {
+    if (!isPlainObject(value))
+        return false;
+    return Object.keys(value).some((key) => findOptionKeys.has(key));
+};
+const resolveFindArgs = (projectionOrOptions, options) => {
+    if (typeof options !== 'undefined') {
+        return {
+            projection: projectionOrOptions,
+            options
+        };
+    }
+    if (looksLikeFindOptions(projectionOrOptions)) {
+        const resolvedOptions = projectionOrOptions;
+        const projection = isPlainObject(resolvedOptions) && isPlainObject(resolvedOptions.projection)
+            ? resolvedOptions.projection
+            : undefined;
+        return {
+            projection,
+            options: resolvedOptions
+        };
+    }
+    return {
+        projection: projectionOrOptions,
+        options: undefined
+    };
+};
+const normalizeInsertManyResult = (result) => {
+    if (!(result === null || result === void 0 ? void 0 : result.insertedIds) || Array.isArray(result.insertedIds))
+        return result;
+    return Object.assign(Object.assign({}, result), { insertedIds: Object.values(result.insertedIds) });
+};
+const hasAtomicOperators = (data) => Object.keys(data).some((key) => key.startsWith('$'));
+const normalizeUpdatePayload = (data) => hasAtomicOperators(data) ? data : { $set: data };
+const hasOperatorExpressions = (value) => isPlainObject(value) && Object.keys(value).some((key) => key.startsWith('$'));
+const matchesPullCondition = (item, operand) => {
+    if (!isPlainObject(operand))
+        return (0, isEqual_1.default)(item, operand);
+    if (hasOperatorExpressions(operand)) {
+        if (Array.isArray(operand.$in)) {
+            return (operand.$in).some((candidate) => (0, isEqual_1.default)(candidate, item));
+        }
+        return false;
+    }
+    return Object.entries(operand).every(([key, value]) => (0, isEqual_1.default)((0, get_1.default)(item, key), value));
+};
+const applyDocumentUpdateOperators = (baseDocument, update) => {
+    const updated = (0, cloneDeep_1.default)(baseDocument);
+    for (const [operator, payload] of Object.entries(update)) {
+        if (!isPlainObject(payload))
+            continue;
+        switch (operator) {
+            case '$set':
+                Object.entries(payload).forEach(([path, value]) => (0, set_1.default)(updated, path, value));
+                break;
+            case '$unset':
+                Object.keys(payload).forEach((path) => {
+                    (0, unset_1.default)(updated, path);
+                });
+                break;
+            case '$inc':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    const increment = typeof value === 'number' ? value : 0;
+                    if (typeof currentValue === 'undefined') {
+                        (0, set_1.default)(updated, path, increment);
+                        return;
+                    }
+                    if (typeof currentValue !== 'number') {
+                        throw new Error(`Cannot apply $inc to a non-numeric value at path "${path}"`);
+                    }
+                    (0, set_1.default)(updated, path, currentValue + increment);
+                });
+                break;
+            case '$push':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    const targetArray = Array.isArray(currentValue) ? [...currentValue] : [];
+                    if (isPlainObject(value) && Array.isArray(value.$each)) {
+                        targetArray.push(...(value.$each));
+                    }
+                    else {
+                        targetArray.push(value);
+                    }
+                    (0, set_1.default)(updated, path, targetArray);
+                });
+                break;
+            case '$addToSet':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    const targetArray = Array.isArray(currentValue) ? [...currentValue] : [];
+                    const valuesToAdd = isPlainObject(value) && Array.isArray(value.$each)
+                        ? value.$each
+                        : [value];
+                    valuesToAdd.forEach((entry) => {
+                        if (!targetArray.some((existing) => (0, isEqual_1.default)(existing, entry))) {
+                            targetArray.push(entry);
+                        }
+                    });
+                    (0, set_1.default)(updated, path, targetArray);
+                });
+                break;
+            case '$pull':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    if (!Array.isArray(currentValue))
+                        return;
+                    const filtered = currentValue.filter((entry) => !matchesPullCondition(entry, value));
+                    (0, set_1.default)(updated, path, filtered);
+                });
+                break;
+            case '$pop':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    if (!Array.isArray(currentValue) || !currentValue.length)
+                        return;
+                    const next = [...currentValue];
+                    if (value === -1) {
+                        next.shift();
+                    }
+                    else {
+                        next.pop();
+                    }
+                    (0, set_1.default)(updated, path, next);
+                });
+                break;
+            case '$mul':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    const factor = typeof value === 'number' ? value : 1;
+                    if (typeof currentValue === 'undefined') {
+                        (0, set_1.default)(updated, path, 0);
+                        return;
+                    }
+                    if (typeof currentValue !== 'number') {
+                        throw new Error(`Cannot apply $mul to a non-numeric value at path "${path}"`);
+                    }
+                    (0, set_1.default)(updated, path, currentValue * factor);
+                });
+                break;
+            case '$min':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    const comparableCurrent = currentValue;
+                    const comparableValue = value;
+                    if (typeof currentValue === 'undefined' || comparableCurrent > comparableValue) {
+                        (0, set_1.default)(updated, path, value);
+                    }
+                });
+                break;
+            case '$max':
+                Object.entries(payload).forEach(([path, value]) => {
+                    const currentValue = (0, get_1.default)(updated, path);
+                    const comparableCurrent = currentValue;
+                    const comparableValue = value;
+                    if (typeof currentValue === 'undefined' || comparableCurrent < comparableValue) {
+                        (0, set_1.default)(updated, path, value);
+                    }
+                });
+                break;
+            case '$rename':
+                Object.entries(payload).forEach(([fromPath, toPath]) => {
+                    if (typeof toPath !== 'string')
+                        return;
+                    const currentValue = (0, get_1.default)(updated, fromPath);
+                    if (typeof currentValue === 'undefined')
+                        return;
+                    (0, set_1.default)(updated, toPath, currentValue);
+                    (0, unset_1.default)(updated, fromPath);
+                });
+                break;
+            case '$currentDate':
+                Object.keys(payload).forEach((path) => (0, set_1.default)(updated, path, new Date()));
+                break;
+            case '$setOnInsert':
+                break;
+            default:
+                break;
+        }
+    }
+    return updated;
+};
 const getUpdatedPaths = (update) => {
     const entries = Object.entries(update !== null && update !== void 0 ? update : {});
     const hasOperators = entries.some(([key]) => key.startsWith('$'));
@@ -108,11 +311,12 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
        *  - Validates the result using `checkValidation` to ensure read permission.
        *  - If validation fails, returns an empty object; otherwise returns the validated document.
        */
-        findOne: (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (query = {}, projection, options) {
+        findOne: (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (query = {}, projectionOrOptions, options) {
             var _a;
             try {
-                const resolvedOptions = projection || options
-                    ? Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), (projection ? { projection } : {})) : undefined;
+                const { projection, options: normalizedOptions } = resolveFindArgs(projectionOrOptions, options);
+                const resolvedOptions = projection || normalizedOptions
+                    ? Object.assign(Object.assign({}, (normalizedOptions !== null && normalizedOptions !== void 0 ? normalizedOptions : {})), (projection ? { projection } : {})) : undefined;
                 const resolvedQuery = query !== null && query !== void 0 ? query : {};
                 if (!run_as_system) {
                     (0, utils_3.checkDenyOperation)(normalizedRules, collection.collectionName, model_1.CRUD_OPERATIONS.READ);
@@ -303,6 +507,7 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
          */
         updateOne: (query, data, options) => __awaiter(void 0, void 0, void 0, function* () {
             try {
+                const normalizedData = normalizeUpdatePayload(data);
                 if (!run_as_system) {
                     (0, utils_3.checkDenyOperation)(normalizedRules, collection.collectionName, model_1.CRUD_OPERATIONS.UPDATE);
                     // Apply access control filters
@@ -313,28 +518,17 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
                         : formattedQuery;
                     const result = yield collection.findOne({ $and: safeQuery });
                     if (!result) {
+                        if (options === null || options === void 0 ? void 0 : options.upsert) {
+                            const upsertResult = yield collection.updateOne({ $and: safeQuery }, normalizedData, options);
+                            emitMongoEvent('updateOne');
+                            return upsertResult;
+                        }
                         throw new Error('Update not permitted');
                     }
                     const winningRole = (0, utils_2.getWinningRole)(result, user, roles);
                     // Check if the update data contains MongoDB update operators (e.g., $set, $inc)
-                    const hasOperators = Object.keys(data).some((key) => key.startsWith('$'));
-                    const updatedPaths = getUpdatedPaths(data);
-                    // Flatten the update object to extract the actual fields being modified
-                    // const docToCheck = hasOperators
-                    //   ? Object.values(data).reduce((acc, operation) => ({ ...acc, ...operation }), {})
-                    //   : data
-                    const pipeline = [
-                        {
-                            $match: { $and: safeQuery }
-                        },
-                        {
-                            $limit: 1
-                        },
-                        ...Object.entries(data).map(([key, value]) => ({ [key]: value }))
-                    ];
-                    const [docToCheck] = hasOperators
-                        ? yield collection.aggregate(pipeline).toArray()
-                        : [data];
+                    const updatedPaths = getUpdatedPaths(normalizedData);
+                    const docToCheck = applyDocumentUpdateOperators(result, normalizedData);
                     // Validate update permissions
                     const { status, document } = winningRole
                         ? yield (0, machines_1.checkValidation)(winningRole, {
@@ -349,11 +543,11 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
                     if (!status || !areDocumentsEqual) {
                         throw new Error('Update not permitted');
                     }
-                    const res = yield collection.updateOne({ $and: safeQuery }, data, options);
+                    const res = yield collection.updateOne({ $and: safeQuery }, normalizedData, options);
                     emitMongoEvent('updateOne');
                     return res;
                 }
-                const result = yield collection.updateOne(query, data, options);
+                const result = yield collection.updateOne(query, normalizedData, options);
                 emitMongoEvent('updateOne');
                 return result;
             }
@@ -386,20 +580,19 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
                         throw new Error('Update not permitted');
                     }
                     const winningRole = (0, utils_2.getWinningRole)(result, user, roles);
-                    const hasOperators = Object.keys(data).some((key) => key.startsWith('$'));
-                    const updatedPaths = Array.isArray(data) ? [] : getUpdatedPaths(data);
-                    const pipeline = [
-                        {
-                            $match: { $and: safeQuery }
-                        },
-                        {
-                            $limit: 1
-                        },
-                        ...Object.entries(data).map(([key, value]) => ({ [key]: value }))
-                    ];
-                    const [docToCheck] = hasOperators
-                        ? yield collection.aggregate(pipeline).toArray()
-                        : [data];
+                    const normalizedData = Array.isArray(data)
+                        ? data
+                        : normalizeUpdatePayload(data);
+                    const updatedPaths = Array.isArray(normalizedData)
+                        ? []
+                        : getUpdatedPaths(normalizedData);
+                    const [docToCheck] = Array.isArray(normalizedData)
+                        ? yield collection.aggregate([
+                            { $match: { $and: safeQuery } },
+                            { $limit: 1 },
+                            ...normalizedData
+                        ]).toArray()
+                        : [applyDocumentUpdateOperators(result, normalizedData)];
                     const { status, document } = winningRole
                         ? yield (0, machines_1.checkValidation)(winningRole, {
                             type: 'write',
@@ -413,8 +606,8 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
                         throw new Error('Update not permitted');
                     }
                     const updateResult = options
-                        ? yield collection.findOneAndUpdate({ $and: safeQuery }, data, options)
-                        : yield collection.findOneAndUpdate({ $and: safeQuery }, data);
+                        ? yield collection.findOneAndUpdate({ $and: safeQuery }, normalizedData, options)
+                        : yield collection.findOneAndUpdate({ $and: safeQuery }, normalizedData);
                     if (!updateResult) {
                         emitMongoEvent('findOneAndUpdate');
                         return updateResult;
@@ -463,10 +656,11 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
          *
          * This ensures that both pre-query filtering and post-query validation are applied consistently.
          */
-        find: (query = {}, projection, options) => {
+        find: (query = {}, projectionOrOptions, options) => {
             try {
-                const resolvedOptions = projection || options
-                    ? Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), (projection ? { projection } : {})) : undefined;
+                const { projection, options: normalizedOptions } = resolveFindArgs(projectionOrOptions, options);
+                const resolvedOptions = projection || normalizedOptions
+                    ? Object.assign(Object.assign({}, (normalizedOptions !== null && normalizedOptions !== void 0 ? normalizedOptions : {})), (projection ? { projection } : {})) : undefined;
                 if (!run_as_system) {
                     (0, utils_3.checkDenyOperation)(normalizedRules, collection.collectionName, model_1.CRUD_OPERATIONS.READ);
                     // Pre-query filtering based on access control rules
@@ -722,12 +916,12 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
                     }
                     const result = yield collection.insertMany(documents, options);
                     emitMongoEvent('insertMany');
-                    return result;
+                    return normalizeInsertManyResult(result);
                 }
                 // If system mode is active, insert all documents without validation
                 const result = yield collection.insertMany(documents, options);
                 emitMongoEvent('insertMany');
-                return result;
+                return normalizeInsertManyResult(result);
             }
             catch (error) {
                 emitMongoEvent('insertMany', undefined, error);
@@ -736,6 +930,7 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
         }),
         updateMany: (query, data, options) => __awaiter(void 0, void 0, void 0, function* () {
             try {
+                const normalizedData = normalizeUpdatePayload(data);
                 if (!run_as_system) {
                     (0, utils_3.checkDenyOperation)(normalizedRules, collection.collectionName, model_1.CRUD_OPERATIONS.UPDATE);
                     // Apply access control filters
@@ -747,21 +942,8 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
                         throw new Error('Update not permitted');
                     }
                     // Check if the update data contains MongoDB update operators (e.g., $set, $inc)
-                    const hasOperators = Object.keys(data).some((key) => key.startsWith('$'));
-                    const updatedPaths = getUpdatedPaths(data);
-                    // Flatten the update object to extract the actual fields being modified
-                    // const docToCheck = hasOperators
-                    //   ? Object.values(data).reduce((acc, operation) => ({ ...acc, ...operation }), {})
-                    //   : data
-                    const pipeline = [
-                        {
-                            $match: { $and: formattedQuery }
-                        },
-                        ...Object.entries(data).map(([key, value]) => ({ [key]: value }))
-                    ];
-                    const docsToCheck = hasOperators
-                        ? yield collection.aggregate(pipeline).toArray()
-                        : result;
+                    const updatedPaths = getUpdatedPaths(normalizedData);
+                    const docsToCheck = result.map((currentDoc) => applyDocumentUpdateOperators(currentDoc, normalizedData));
                     const filteredItems = yield Promise.all(docsToCheck.map((currentDoc) => __awaiter(void 0, void 0, void 0, function* () {
                         const winningRole = (0, utils_2.getWinningRole)(currentDoc, user, roles);
                         const { status, document } = winningRole
@@ -780,11 +962,11 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
                         console.log('check1 In updateMany --> (!areDocumentsEqual)');
                         throw new Error('Update not permitted');
                     }
-                    const res = yield collection.updateMany({ $and: formattedQuery }, data, options);
+                    const res = yield collection.updateMany({ $and: formattedQuery }, normalizedData, options);
                     emitMongoEvent('updateMany');
                     return res;
                 }
-                const result = yield collection.updateMany(query, data, options);
+                const result = yield collection.updateMany(query, normalizedData, options);
                 emitMongoEvent('updateMany');
                 return result;
             }
@@ -860,6 +1042,10 @@ const getOperators = (collection, { rules, collName, user, run_as_system, monito
     };
 };
 const MongodbAtlas = (app, { rules, user, run_as_system, monitoring } = {}) => ({
+    startSession: (options) => {
+        const mongoClient = app.mongo.client;
+        return mongoClient.startSession(options);
+    },
     db: (dbName) => {
         return {
             collection: (collName) => {

package/dist/services/mongodb-atlas/model.d.ts

@@ -1,5 +1,5 @@
 import { FastifyInstance } from 'fastify';
-import { Collection, Document, FindCursor, FindOneAndUpdateOptions, FindOneOptions, FindOptions, Filter as MongoFilter, UpdateFilter, WithId } from 'mongodb';
+import { ClientSession, ClientSessionOptions, Collection, Document, FindCursor, FindOneAndUpdateOptions, FindOneOptions, FindOptions, Filter as MongoFilter, UpdateFilter, WithId } from 'mongodb';
 import { User } from '../../auth/dtos';
 import { Filter, Rules } from '../../features/rules/interface';
 import { Role } from '../../utils/roles/interface';
@@ -14,6 +14,7 @@ export type MongodbAtlasFunction = (app: FastifyInstance, { rules, user, run_as_
     db: (dbName: string) => {
         collection: (collName: string) => ReturnType<GetOperatorsFunction>;
     };
+    startSession: (options?: ClientSessionOptions) => ClientSession;
 };
 export type GetValidRuleParams<T extends Role | Filter> = {
     filters: T[];

package/dist/services/mongodb-atlas/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/model.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/model.ts"],"names":[],"mappings":"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"}

package/dist/utils/context/helpers.d.ts

@@ -15,7 +15,7 @@ type JwtUtils = {
  * @param currentFunction -> the function's name that should be called
  * @param functionsList -> the list of all functions
  */
-export declare const generateContextData: ({ user, services, app, rules, currentFunction, functionName, functionsList, GenerateContext, request }: GenerateContextDataParams) => {
+export declare const generateContextData: ({ user, services, app, rules, currentFunction, functionName, functionsList, GenerateContext, GenerateContextSync, request }: GenerateContextDataParams) => {
     BSON: typeof mongodb.BSON;
     EJSON: {
         parse: (text: string, options?: mongodb.BSON.EJSONOptions) => any;
@@ -57,6 +57,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                 db: (dbName: string) => {
                     collection: (collName: string) => ReturnType<import("../../services/mongodb-atlas/model").GetOperatorsFunction>;
                 };
+                startSession: (options?: mongodb.ClientSessionOptions) => mongodb.ClientSession;
             } | {
                 get: <T = null>({ url, headers, resolveBody }: import("../../services/api/model").GetParams) => Promise<{
                     status: number;
@@ -204,6 +205,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
             db: (dbName: string) => {
                 collection: (collName: string) => ReturnType<import("../../services/mongodb-atlas/model").GetOperatorsFunction>;
             };
+            startSession: (options?: mongodb.ClientSessionOptions) => mongodb.ClientSession;
         } | {
             get: <T = null>({ url, headers, resolveBody }: import("../../services/api/model").GetParams) => Promise<{
                 status: number;
@@ -350,6 +352,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
             db: (dbName: string) => {
                 collection: (collName: string) => ReturnType<import("../../services/mongodb-atlas/model").GetOperatorsFunction>;
             };
+            startSession: (options?: mongodb.ClientSessionOptions) => mongodb.ClientSession;
         } | {
             get: <T = null>({ url, headers, resolveBody }: import("../../services/api/model").GetParams) => Promise<{
                 status: number;
@@ -493,7 +496,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
             };
         } | undefined;
         functions: {
-            execute: (name: keyof typeof functionsList, ...args: Arguments) => Promise<unknown>;
+            execute: (name: keyof typeof functionsList, ...args: Arguments) => unknown;
         };
     };
 };

package/dist/utils/context/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAGvD,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,wGAUjC,yBAAyB;;;;;;;;;;;;;uBA4DP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;;;;+BA5CU,MAAM,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BApBzC,CAAC;iCAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAf,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAf,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;4BAyEN,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAgBrE,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAGvD,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,6HAWjC,yBAAyB;;;;;;;;;;;;;uBA4DP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;;;;+BA5CU,MAAM,OAAO,QAAQ;;;;sCA3HrC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAsG+B,CAAC;iCAC5C,CAAD;;;;;;;;;;;;;;;;;;;kCAvGY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsG+B,CAAC;6BAC5C,CAAD;;;;;;;;;;;;;;;;;;kCAvGY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsG+B,CAAC;6BAC5C,CAAD;;;;;;;;;;;;;;;4BAyEiB,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAgBrE,CAAA"}

package/dist/utils/context/helpers.js

@@ -108,7 +108,7 @@ const createJwtUtils = () => {
  * @param currentFunction -> the function's name that should be called
  * @param functionsList -> the list of all functions
  */
-const generateContextData = ({ user, services, app, rules, currentFunction, functionName, functionsList, GenerateContext, request }) => {
+const generateContextData = ({ user, services, app, rules, currentFunction, functionName, functionsList, GenerateContext, GenerateContextSync, request }) => {
     var _a;
     const BSON = mongodb_1.mongodb.BSON;
     const Binary = BSON === null || BSON === void 0 ? void 0 : BSON.Binary;
@@ -177,7 +177,7 @@ const generateContextData = ({ user, services, app, rules, currentFunction, func
             functions: {
                 execute: (name, ...args) => {
                     const currentFunction = functionsList[name];
-                    return GenerateContext({
+                    return GenerateContextSync({
                         args,
                         app,
                         rules,

package/dist/utils/context/index.d.ts

@@ -11,4 +11,5 @@ import { GenerateContextParams } from './interface';
  * @param services -> the list of all services
  */
 export declare function GenerateContext({ args, app, rules, user, currentFunction, functionsList, services, functionName, runAsSystem, deserializeArgs, enqueue, request }: GenerateContextParams): Promise<unknown>;
+export declare function GenerateContextSync({ args, app, rules, user, currentFunction, functionsList, services, functionName, runAsSystem, deserializeArgs, request }: GenerateContextParams): unknown;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/context/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/context/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA0GnD;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,EACpC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,eAAsB,EACtB,OAAO,EACP,OAAO,EACR,EAAE,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,CAwJ1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/context/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA4JnD;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,EACpC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,eAAsB,EACtB,OAAO,EACP,OAAO,EACR,EAAE,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,CA2G1C;AAED,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,eAAsB,EACtB,OAAO,EACR,EAAE,qBAAqB,GAAG,OAAO,CA4BjC"}