@flowerforce/flowerbase 1.0.1-beta.3

package/src/utils/__tests__/getWinningRole.test.ts

@@ -0,0 +1,66 @@
+
+import { Document, ObjectId, WithId } from "mongodb"
+import { User } from '../../auth/dtos';
+import { Role } from "../roles/interface";
+import * as Utils from "../roles/machines/utils";
+
+const { getWinningRole } = Utils
+
+const mockUser = {
+    id: 'user123',
+    role: 'admin',
+    name: 'Test User',
+} as User;
+
+const mockDocument = {
+    _id: new ObjectId(),
+    field: 'value',
+} as WithId<Document>;
+
+const mockRoles = [
+    { name: 'Editor', apply_when: { condition: 'test' } },
+    { name: 'Viewer', apply_when: { condition: 'other' } }
+] as Role[]
+
+
+describe('getWinningRole', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return null if roles array is empty', () => {
+        expect(getWinningRole(mockDocument, mockUser, [])).toBeNull();
+        expect(getWinningRole(mockDocument, mockUser, undefined)).toBeNull();
+    });
+
+    it('should return the first matching role', () => {
+        const mockCheckApplyWhen = jest.spyOn(Utils, "checkApplyWhen").mockReturnValueOnce(true)
+        const result = getWinningRole(mockDocument, mockUser, mockRoles);
+        expect(result).toEqual(mockRoles[0]);
+        expect(mockCheckApplyWhen).toHaveBeenCalledWith(mockRoles[0].apply_when, mockUser, mockDocument);
+        expect(mockCheckApplyWhen).toHaveBeenCalledTimes(1);
+        mockCheckApplyWhen.mockReset()
+    });
+
+    it('should return null if no roles match', () => {
+        const mockCheckApplyWhen = jest.spyOn(Utils, "checkApplyWhen").mockReturnValue(false)
+        const result = getWinningRole(mockDocument, mockUser, mockRoles);
+        expect(result).toBeNull();
+        expect(mockCheckApplyWhen).toHaveBeenCalledTimes(mockRoles.length);
+        mockCheckApplyWhen.mockReset()
+    });
+
+    it('should check all roles until it finds a match', () => {
+        const mockCheckApplyWhen = jest.spyOn(Utils, "checkApplyWhen").mockReturnValueOnce(false).mockReturnValueOnce(true)
+        const result = getWinningRole(mockDocument, mockUser, mockRoles);
+        expect(result).toEqual(mockRoles[1]);
+        expect(mockCheckApplyWhen).toHaveBeenCalledTimes(2);
+        mockCheckApplyWhen.mockReset()
+    });
+
+    it('should handle null document correctly', () => {
+        jest.spyOn(Utils, "checkApplyWhen").mockReturnValue(true)
+        const result = getWinningRole(null, mockUser, mockRoles);
+        expect(result).toEqual(mockRoles[0]);
+    });
+});

package/src/utils/__tests__/hashPassword.test.ts

@@ -0,0 +1,28 @@
+import { hashPassword } from '../crypto';
+
+describe('hashPassword', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return a hashed password with a valid format', async () => {
+        const plaintext = 'mySecretPassword';
+        const hashedPassword = await hashPassword(plaintext);
+        expect(hashedPassword).toMatch(/^[a-f0-9]+\.[a-f0-9]+$/);
+        const [storedHash, salt] = hashedPassword.split('.');
+        expect(storedHash).toBeDefined();
+        expect(salt).toBeDefined();
+    });
+    it('should generate different hashes for different passwords', async () => {
+        const hash1 = await hashPassword('password1');
+        const hash2 = await hashPassword('password2');
+        expect(hash1).not.toBe(hash2);
+    });
+    it('should generate different hashes for the same password (due to different salts)', async () => {
+        const plaintext = 'samePassword';
+        const hash1 = await hashPassword(plaintext);
+        const hash2 = await hashPassword(plaintext);
+        expect(hash1).not.toBe(hash2);
+    });
+
+});

package/src/utils/__tests__/isEmpty.test.ts

@@ -0,0 +1,17 @@
+import rulesMatcherUtils from "../rules-matcher/utils";
+
+describe('isEmpty', () => {
+
+    it('should check if a value is Empty', () => {
+        expect(rulesMatcherUtils.isEmpty(undefined)).toBe(true)
+        expect(rulesMatcherUtils.isEmpty(null)).toBe(true)
+        expect(rulesMatcherUtils.isEmpty(() => { })).toBe(false)
+        expect(rulesMatcherUtils.isEmpty("")).toBe(true)
+        expect(rulesMatcherUtils.isEmpty("test")).toBe(false)
+        expect(rulesMatcherUtils.isEmpty(["test"])).toBe(false)
+        expect(rulesMatcherUtils.isEmpty([])).toBe(true)
+        expect(rulesMatcherUtils.isEmpty({})).toBe(true)
+        expect(rulesMatcherUtils.isEmpty({ some: "test" })).toBe(false)
+        expect(rulesMatcherUtils.isEmpty(new Date())).toBe(false)
+    });
+});

package/src/utils/__tests__/logMachineInfo.test.ts

@@ -0,0 +1,15 @@
+import { logMachineInfo } from "../roles/machines/utils";
+
+describe('logMachineInfo', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should log all the info only if enabled', () => {
+        const log = jest.spyOn(console, "log").mockImplementation()
+        logMachineInfo({ enabled: true, machine: "A", step: 1, stepName: "test" })
+        logMachineInfo({ enabled: false, machine: "A", step: 1, stepName: "test" })
+        expect(log).toHaveBeenNthCalledWith(1, "MACHINE A -> STEP 1: test")
+        log.mockRestore()
+    });
+});

package/src/utils/__tests__/operators.test.ts

@@ -0,0 +1,99 @@
+import { operators } from "../rules-matcher/utils";
+
+describe('operators', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("should check equals values", () => {
+        expect(operators.$eq("a", "a")).toBe(true)
+        expect(!operators.$eq("a", "b")).toBe(true)
+    })
+    it("should check different values", () => {
+        expect(operators.$ne("a", "a")).toBe(false)
+        expect(operators.$ne("a", "b")).toBe(true)
+    })
+    it("should check string length values", () => {
+        // test $strGt
+        expect(operators.$strGt("test", 2)).toBe(true)
+        expect(operators.$strGt("test", 15)).toBe(false)
+        expect(operators.$strGt("test", 4)).toBe(false)
+        // test $strGte
+        expect(operators.$strGte("test", 2)).toBe(true)
+        expect(operators.$strGte("test", 15)).toBe(false)
+        expect(operators.$strGte("test", 4)).toBe(true)
+        // test $strLt
+        expect(operators.$strLt("test", 2)).toBe(false)
+        expect(operators.$strLt("test", 15)).toBe(true)
+        expect(operators.$strLt("test", 4)).toBe(false)
+        // test $strLte
+        expect(operators.$strLte("test", 2)).toBe(false)
+        expect(operators.$strLte("test", 15)).toBe(true)
+        expect(operators.$strLte("test", 4)).toBe(true)
+    })
+    it("should check if a value exists", () => {
+        expect(operators.$exists({ name: 1 }, true)).toBe(true)
+        expect(operators.$exists({}, false)).toBe(true)
+        expect(operators.$exists({}, true)).toBe(false)
+        expect(operators.$exists(undefined, false)).toBe(true)
+        expect(operators.$exists(null, true)).toBe(false)
+        expect(operators.$exists("", true)).toBe(false)
+        expect(operators.$exists("test", true)).toBe(true)
+        expect(operators.$exists(0, true)).toBe(true)
+        expect(operators.$exists([], true)).toBe(false)
+        expect(operators.$exists([1], true)).toBe(true)
+        expect(operators.$exists(new Date(), true)).toBe(true)
+        expect(operators.$exists(() => { }, true)).toBe(true)
+    })
+    it("should compare numbers", () => {
+        // test $gt
+        expect(operators.$gt(2, 3)).toBe(false)
+        expect(operators.$gt(2, 2)).toBe(false)
+        expect(operators.$gt(3, 2)).toBe(true)
+        // test $gte
+        expect(operators.$gte(2, 3)).toBe(false)
+        expect(operators.$gte(2, 2)).toBe(true)
+        expect(operators.$gte(3, 2)).toBe(true)
+        // test $lt
+        expect(operators.$lt(2, 3)).toBe(true)
+        expect(operators.$lt(2, 2)).toBe(false)
+        expect(operators.$lt(3, 2)).toBe(false)
+        // test $lte
+        expect(operators.$lte(2, 3)).toBe(true)
+        expect(operators.$lte(2, 2)).toBe(true)
+        expect(operators.$lte(3, 2)).toBe(false)
+    }
+    )
+    it("should find a value in an array", () => {
+        expect(operators.$in(2, [3])).toBe(false)
+        expect(operators.$in(3, [3, 4, 5])).toBe(true)
+        expect(operators.$in([3, 4], [3, 4, 5])).toBe(true)
+        expect(operators.$in([3, 6], [3, 4, 5])).toBe(true)
+        expect(operators.$in({ name: "ciao" }, [{ name: "ciao" }, 4, 5])).toBe(false)
+    })
+    it("should check if a value isn't in an array", () => {
+        expect(operators.$nin(2, [3])).toBe(true)
+        expect(operators.$nin(3, [3, 4, 5])).toBe(false)
+        expect(operators.$nin([3, 4], [3, 4, 5])).toBe(false)
+        expect(operators.$nin([3, 6], [3, 4, 5])).toBe(false)
+        expect(operators.$nin({ name: "ciao" }, [{ name: "ciao" }, 4, 5])).toBe(true)
+    })
+    it("should find all values in an array", () => {
+        expect(operators.$all(2, [3])).toBe(false)
+        expect(operators.$all(3, [3, 4, 5])).toBe(false)
+        expect(operators.$all([3], [3, 4, 5])).toBe(false)
+        expect(operators.$all([3, 4, 5], [3, 4, 5])).toBe(true)
+        expect(operators.$all([3, 6], [3, 4, 5])).toBe(false)
+        expect(operators.$all({ name: "ciao" }, [{ name: "ciao" }, 4, 5])).toBe(false)
+        expect(operators.$all([{ name: "ciao" }, 4, 5], [{ name: "ciao" }, 4, 5])).toBe(false)
+    })
+    it("should check regex", () => {
+        const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
+        expect(operators.$regex("test@gmail.com", emailRegex)).toBe(true)
+        expect(operators.$regex("test.com", emailRegex)).toBe(false)
+        const numberRegex = /^\d+$/
+        expect(operators.$regex("1234567890", numberRegex)).toBe(true)
+        expect(operators.$regex("12345r", numberRegex)).toBe(false)
+
+    })
+});

package/src/utils/__tests__/readFileContent.test.ts

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import { readFileContent, readJsonContent } from '..';
+
+jest.mock('fs');
+
+describe('File Reading Functions', () => {
+    const mockFilePath = '/mock/path/file.txt';
+    const mockJsonPath = '/mock/path/data.json';
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should read file content correctly', () => {
+        const mockContent = 'Hello, world!';
+        (fs.readFileSync as jest.Mock).mockReturnValue(mockContent);
+        const result = readFileContent(mockFilePath);
+        expect(fs.readFileSync).toHaveBeenCalledWith(mockFilePath, 'utf-8');
+        expect(result).toBe(mockContent);
+    });
+
+    it('should read JSON content correctly', () => {
+        const mockJsonContent = '{"name": "Alice", "age": 30}';
+        (fs.readFileSync as jest.Mock).mockReturnValue(mockJsonContent);
+        const result = readJsonContent(mockJsonPath);
+        expect(fs.readFileSync).toHaveBeenCalledWith(mockJsonPath, 'utf-8');
+        expect(result).toEqual(JSON.parse(mockJsonContent));
+    });
+
+    it('should throw an error when JSON is invalid', () => {
+        const invalidJson = '{name: Alice, age: 30}';
+        (fs.readFileSync as jest.Mock).mockReturnValue(invalidJson);
+        expect(() => readJsonContent(mockJsonPath)).toThrow(SyntaxError);
+    });
+});

package/src/utils/__tests__/registerPlugins.test.ts

@@ -0,0 +1,59 @@
+import cors from '@fastify/cors'
+import fastifyMongodb from '@fastify/mongodb'
+import { authController } from '../../auth/controller'
+import jwtAuthPlugin from '../../auth/plugins/jwt'
+import { localUserPassController } from '../../auth/providers/local-userpass/controller'
+import { Functions } from '../../features/functions/interface'
+import { registerPlugins } from '../initializer/registerPlugins'
+
+const MOCKED_API_VERSION = '/api/client/v2'
+
+jest.mock('../../constants', () => ({
+    API_VERSION: '/api/client/v2'
+}))
+
+const mockDbUrl = 'mongodb://localhost:27017/testdb'
+const mockSecret = 'test-secret'
+
+const errorMock = jest.fn().mockImplementation(() => {
+    throw new Error('Plugin registration failed')
+})
+const registerMock = jest.fn()
+
+describe('registerPlugins', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should register all plugins successfully', async () => {
+        await registerPlugins({
+            register: registerMock,
+            mongodbUrl: mockDbUrl,
+            jwtSecret: mockSecret,
+            functionsList: {} as Functions
+        })
+
+        // Check Plugins Registration
+        expect(registerMock).toHaveBeenCalledTimes(5)
+        expect(registerMock).toHaveBeenCalledWith(cors, { origin: '*', methods: ['POST', 'GET'] })
+        expect(registerMock).toHaveBeenCalledWith(fastifyMongodb, { forceClose: true, url: mockDbUrl })
+        expect(registerMock).toHaveBeenCalledWith(jwtAuthPlugin, { secret: mockSecret })
+        expect(registerMock).toHaveBeenCalledWith(authController, { prefix: `${MOCKED_API_VERSION}/auth` })
+        expect(registerMock).toHaveBeenCalledWith(localUserPassController, { prefix: `${MOCKED_API_VERSION}/app/:appId/auth/providers/local-userpass` })
+    })
+
+    it('should handle errors in the catch block', async () => {
+
+        const errorLog = jest.spyOn(console, 'error').mockImplementation(() => { })
+
+        await registerPlugins({
+            register: errorMock,
+            mongodbUrl: mockDbUrl,
+            jwtSecret: mockSecret,
+            functionsList: {} as Functions
+        })
+
+        expect(errorLog).toHaveBeenCalledWith('Error while registering plugins', 'Plugin registration failed')
+        errorLog.mockRestore()
+    })
+})

package/src/utils/__tests__/rule.test.ts

@@ -0,0 +1,51 @@
+import rulesMatcherUtils from '../rules-matcher/utils';
+
+
+describe('rule function', () => {
+    it('should return valid true if the operator and value match', () => {
+        const mockData = {
+            user: { name: 'John', age: 25 }
+        };
+        const mockOptions = { prefix: 'user' };
+        const mockValueBlock = { name: { $eq: 'John' } };
+        const result = rulesMatcherUtils.rule(mockValueBlock, mockData, mockOptions);
+        expect(result.valid).toBe(true);
+        expect(result.name).toBe('user.name___$eq');
+    });
+
+    it('should return valid false if the operator and value do not match', () => {
+        const mockData = {
+            user: { name: 'John', age: 25 }
+        };
+        const mockOptions = { prefix: 'user' };
+        const mockValueBlock = { name: { $eq: 'Doe' } };
+        const result = rulesMatcherUtils.rule(mockValueBlock, mockData, mockOptions);
+
+        expect(result.valid).toBe(false);
+        expect(result.name).toBe('user.name___$eq');
+    });
+
+    it('should handle $ref: values correctly', () => {
+        const mockData = {
+            user: { name: 'John', age: 25 }
+        };
+        const mockOptions = { prefix: 'user' };
+        const mockValueBlock = { name: { $eq: '$ref:user.refName' } };
+        const result = rulesMatcherUtils.rule(mockValueBlock, mockData, mockOptions);
+
+        expect(result.valid).toBe(false);
+        expect(result.name).toBe('user.name___$eq');
+    });
+
+    it('should throw an error if the operator is missing', () => {
+
+        const mockData = {
+            user: { name: 'John', age: 25 }
+        };
+        const mockOptions = { prefix: 'user' };
+        const missingOperatorBlock = { name: { $notFoundOperator: 'value' } };
+        expect(() => {
+            rulesMatcherUtils.rule(missingOperatorBlock, mockData, mockOptions);
+        }).toThrow('Error missing operator:$notFoundOperator');
+    });
+});

package/src/utils/__tests__/rulesMatcherInterfaces.test.ts

@@ -0,0 +1,57 @@
+import { RulesModes, RulesOperators, RulesOperatorsInArray, RulesValuesType } from '../rules-matcher/interface';
+
+describe('Enums and Types', () => {
+    it('should have correct values in RulesOperators enum', () => {
+        expect(RulesOperators.$exists).toBe('$exists');
+        expect(RulesOperators.$eq).toBe('$eq');
+        expect(RulesOperators.$ne).toBe('$ne');
+        expect(RulesOperators.$gt).toBe('$gt');
+        expect(RulesOperators.$gte).toBe('$gte');
+        expect(RulesOperators.$lt).toBe('$lt');
+        expect(RulesOperators.$lte).toBe('$lte');
+        expect(RulesOperators.$strGt).toBe('$strGt');
+        expect(RulesOperators.$strGte).toBe('$strGte');
+        expect(RulesOperators.$strLt).toBe('$strLt');
+        expect(RulesOperators.$strLte).toBe('$strLte');
+        expect(RulesOperators.$in).toBe('$in');
+        expect(RulesOperators.$nin).toBe('$nin');
+        expect(RulesOperators.$all).toBe('$all');
+        expect(RulesOperators.$regex).toBe('$regex');
+    });
+
+    it('should validate RulesOperatorsInArray type', () => {
+        const valid: RulesOperatorsInArray<{ age: number }> = {
+            age: {
+                $gt: 25
+            }
+        };
+        expect(valid).toHaveProperty('age');
+        expect(valid.age).toHaveProperty('$gt', 25);
+        const partial: RulesOperatorsInArray<{ name: string }> = {
+            name: {
+                $eq: 'John Doe'
+            }
+        };
+        expect(partial).toHaveProperty('name');
+        expect(partial.name).toHaveProperty('$eq', 'John Doe');
+    });
+
+    it('should validate RulesValuesType type', () => {
+        const valid: RulesValuesType<{ age: number }> = {
+            "$form.isValid": true,
+            age: 30
+        };
+        expect(valid["$form.isValid"]).toBe(true);
+        expect(valid.age).toBe(30);
+        const withoutFormValid: RulesValuesType<{ age: number }> = {
+            age: 25
+        };
+        expect(withoutFormValid["$form.isValid"]).toBeUndefined();
+        expect(withoutFormValid.age).toBe(25);
+    });
+
+    it('should validate RulesModes enum values', () => {
+        expect(RulesModes.$and).toBe('$and');
+        expect(RulesModes.$or).toBe('$or');
+    });
+});

package/src/utils/__tests__/rulesMatcherUtils.test.ts

@@ -0,0 +1,56 @@
+import rulesMatcherUtils from "../rules-matcher/utils";
+const { forceArray, isNumber, isFunction, isString, isDate, isObject, getPath, forceNumber, getDefaultStringValue, getTypeOf } = rulesMatcherUtils
+
+describe('rulesMatcherUtils', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should check all utils', () => {
+        // isNumber
+        expect(isNumber(2)).toBe(true)
+        expect(isNumber("33")).toBe(true)
+        expect(isNumber("ciao")).toBe(false)
+        expect(isNumber("ciao12")).toBe(false)
+        // isFunction
+        expect(isFunction(2)).toBe(false)
+        expect(isFunction("ciao")).toBe(false)
+        expect(isFunction(() => { })).toBe(true)
+        expect(isFunction(function test() { })).toBe(true)
+        // isString
+        expect(isString(2)).toBe(false)
+        expect(isString("2")).toBe(true)
+        expect(isString("ciao")).toBe(true)
+        // isDate
+        expect(isDate(2)).toBe(false)
+        expect(isDate(new Date())).toBe(true)
+        expect(isDate({})).toBe(false)
+        // isObject
+        expect(isObject({})).toBe(true)
+        expect(isObject("test")).toBe(false)
+        expect(isObject([])).toBe(true)
+        // forceNumber
+        expect(forceNumber([1, 2, 3])).toBe(3)
+        expect(forceNumber("2")).toBe(2)
+        expect(forceNumber("test")).toBe(0)
+        // getDefaultStringValue
+        expect(getDefaultStringValue("$required")).toEqual({ op: '$exists', value: true })
+        expect(getDefaultStringValue("$exists")).toEqual({ op: '$exists', value: true })
+        expect(getDefaultStringValue("test")).toEqual({ op: '$eq', value: "test" })
+        // getTypeOf
+        expect(getTypeOf([])).toBe("array")
+        expect(getTypeOf(2)).toBe("number")
+        expect(getTypeOf(null)).toBe(null)
+        expect(getTypeOf("test")).toBe(typeof "test")
+        expect(getTypeOf(undefined)).toBe(typeof undefined)
+        // forceArray
+        expect(forceArray(["test"])).toEqual(["test"])
+        expect(forceArray(2)).toEqual([2])
+        expect(forceArray({ test: "test" })).toEqual([{ test: "test" }])
+        // getPath 
+        expect(getPath("data.name", "user")).toBe("user.data.name")
+        expect(getPath("data.name")).toBe("data.name")
+        expect(getPath("^data.name")).toBe("data.name")
+        expect(getPath("$data.name")).toBe("$data.name")
+    });
+});

package/src/utils/__tests__/someAsync.test.ts

@@ -0,0 +1,55 @@
+import { someAsync } from "../helpers/someAsync";
+
+const mockArray = [1, 3, 4, 4, 5]
+
+describe('someAsync function', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return true', async () => {
+        let i = 0
+        const callback = async (el: unknown, index: number): Promise<boolean> => {
+            i = index
+            return new Promise(resolve => {
+                setTimeout(() => {
+                    resolve(index < 6);
+                }, 0);
+            });
+        }
+        const response = await someAsync(mockArray, callback)
+        expect(response).toEqual(true)
+        expect(i).toEqual(0)
+    });
+    it('should return true for the last element', async () => {
+        let i = 0
+        const callback = async (el: unknown, index: number): Promise<boolean> => {
+            i = index
+            return new Promise(resolve => {
+                setTimeout(() => {
+                    resolve(index > 3);
+                }, 0);
+            });
+        }
+        const response = await someAsync(mockArray, callback)
+        expect(response).toEqual(true)
+        expect(i).toEqual(4)
+    });
+
+    it('should return false', async () => {
+        let i = 0
+        const callback = async (el: unknown, index: number): Promise<boolean> => {
+            i = index
+            return new Promise(resolve => {
+                setTimeout(() => {
+                    resolve(index > 4);
+                }, 0);
+            });
+        }
+        const response = await someAsync(mockArray, callback)
+        expect(response).toEqual(false)
+        expect(i).toEqual(4)
+    });
+
+
+
+})

package/src/utils/context/helpers.ts

@@ -0,0 +1,71 @@
+import { mongodb } from '@fastify/mongodb'
+import { Arguments } from '../../auth/dtos'
+import { Function } from '../../features/functions/interface'
+import { GenerateContextDataParams } from './interface'
+
+/**
+ * > Used to generate the current context data
+ * @testable
+ * @param user -> the current user
+ * @param services -> the list of all services
+ * @param app -> the fastify instance
+ * @param rules -> the rules object
+ * @param currentFunction -> the function's name that should be called
+ * @param functionsList -> the list of all functions
+ */
+export const generateContextData = ({
+  user,
+  services,
+  app,
+  rules,
+  currentFunction,
+  functionsList,
+  GenerateContext
+}: GenerateContextDataParams) => ({
+  BSON: mongodb.BSON,
+  console: {
+    log: (...args: Arguments) => {
+      console.log(...args)
+    }
+  },
+  context: {
+    user,
+    environment: {
+      tag: process.env.NODE_ENV
+    },
+    values: {
+      get: (key: string) => process.env[key],
+    },
+    services: {
+      get: (serviceName: keyof typeof services) => {
+        try {
+          return services[serviceName](app, {
+            rules,
+            user,
+            run_as_system: currentFunction.run_as_system
+          })
+        } catch (error) {
+          console.error(
+            'Something went wrong while generating context function',
+            serviceName,
+            error
+          )
+        }
+      }
+    },
+    functions: {
+      execute: (name: keyof typeof functionsList, ...args: Arguments) => {
+        const currentFunction = functionsList[name] as Function
+        return GenerateContext({
+          args,
+          app,
+          rules,
+          user,
+          currentFunction,
+          functionsList,
+          services
+        })
+      }
+    }
+  }
+})

package/src/utils/context/index.ts

@@ -0,0 +1,52 @@
+import m from 'module'
+import vm from 'vm'
+import { EJSON } from 'bson'
+import { generateContextData } from './helpers'
+import { GenerateContextParams } from './interface'
+
+/**
+ * > Used to generate the current context
+ * @testable
+ * @param args -> generic arguments
+ * @param app -> the fastify instance
+ * @param rules -> the rules object
+ * @param user -> the current user
+ * @param currentFunction -> the function's name that should be called
+ * @param functionsList -> the list of all functions
+ * @param services -> the list of all services
+ */
+export async function GenerateContext({
+  args,
+  app,
+  rules,
+  user,
+  currentFunction,
+  functionsList,
+  services
+}: GenerateContextParams) {
+  const contextData = generateContextData({
+    user,
+    services,
+    app,
+    rules,
+    currentFunction,
+    functionsList,
+    GenerateContext
+  })
+
+  try {
+    vm.runInContext(m.wrap(currentFunction.code), vm.createContext(contextData))(
+      exports,
+      require,
+      module,
+      __filename,
+      __dirname
+    )
+  }
+  catch (e) {
+    console.log(e)
+  }
+
+
+  return await module.exports(...EJSON.deserialize(args))
+}