@flowerforce/flowerbase 1.0.1-beta.3

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

@@ -0,0 +1,190 @@
+import { ObjectId } from 'bson';
+import { User } from '../../fastify';
+import { Role } from '../roles/interface';
+import { MachineContext } from '../roles/machines/interface'
+import { checkIsValidFieldNameFn } from '../roles/machines/read/D/validators';
+
+const mockUser = {} as User
+const mockId = new ObjectId()
+
+describe('checkIsValidFieldNameFn', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return filtered fields based on role permissions, without excluding _id', () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            },
+            fields: {
+                name: { read: true, write: false },
+                email: { read: false, write: true },
+            },
+            additional_fields: {},
+        } as Role
+        const context = {
+            user: mockUser,
+            role: mockedRole,
+            params: {
+                cursor: { _id: mockId, name: 'Alice', email: 'alice@example.com', age: 25 },
+            },
+        }
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+        expect(result).toEqual({ name: 'Alice', email: 'alice@example.com', _id: mockId });
+    });
+    it("should exclude _id if role doesn't allows it", () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            },
+            fields: {
+                _id: { read: false, write: false },
+                name: { read: true, write: false },
+            },
+            additional_fields: {},
+        } as Role
+        const context = {
+            user: mockUser,
+            role: mockedRole,
+            params: {
+                cursor: { _id: mockId, name: 'Alice' },
+            },
+        };
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+
+        expect(result).toEqual({ name: 'Alice' });
+    });
+    it("should include _id if write role allows it", () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            },
+            fields: {
+                _id: { read: false, write: true },
+                name: { read: true, write: false },
+            },
+            additional_fields: {},
+        } as Role
+        const context = {
+            user: mockUser,
+            role: mockedRole,
+            params: {
+                cursor: { _id: mockId, name: 'Alice' },
+            },
+        };
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+
+        expect(result).toEqual({ _id: mockId, name: 'Alice' });
+    });
+    it("should include _id if read role allows it", () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            },
+            fields: {
+                _id: { read: true, write: false },
+                name: { read: true, write: false },
+            },
+            additional_fields: {},
+        } as Role
+        const context = {
+            user: mockUser,
+            role: mockedRole,
+            params: {
+                cursor: { _id: mockId, name: 'Alice' },
+            },
+        };
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+
+        expect(result).toEqual({ _id: mockId, name: 'Alice' });
+    });
+
+
+    it('should return an empty object if no fields are readable/writable', () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            },
+            fields: {
+                name: { read: false, write: false },
+            },
+            additional_fields: {},
+        } as Role
+        const context = {
+            role: mockedRole,
+            params: {
+                cursor: { name: 'Charlie', email: 'charlie@example.com' },
+            },
+        };
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+
+        expect(result).toEqual({});
+    });
+
+    it('should handle additional_fields correctly for read permission', () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            },
+            fields: {},
+            additional_fields: { phone: { read: true, write: false } },
+        } as Role
+        const context = {
+            role: mockedRole,
+            params: {
+                cursor: { _id: mockId, phone: '123456789', address: 'Unknown' },
+            },
+        };
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+        expect(result).toEqual({ _id: mockId, phone: '123456789' });
+    });
+    it('should handle additional_fields correctly for write permission', () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            },
+            fields: {},
+            additional_fields: { phone: { read: false, write: true }, address: { read: false, write: true } },
+        } as Role
+        const context = {
+            role: mockedRole,
+            params: {
+                cursor: { _id: mockId, phone: '123456789', address: 'Unknown' },
+            },
+        };
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+        expect(result).toEqual({ _id: mockId, phone: '123456789', address: 'Unknown' });
+    });
+    it('should return only the _id if fields and additional fields are not defined', () => {
+        const mockedRole = {
+            name: "test",
+            apply_when: {
+                "%%true": true
+            }
+        } as Role
+        const context = {
+            role: mockedRole,
+            params: {
+                cursor: { _id: mockId, phone: '123456789', address: 'Unknown' },
+            },
+        };
+
+        const result = checkIsValidFieldNameFn(context as MachineContext);
+        expect(result).toEqual({ _id: mockId });
+    });
+
+});

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

@@ -0,0 +1,38 @@
+
+import crypto from 'crypto';
+import { promisify } from 'node:util'
+import { comparePassword } from '../crypto';
+
+const scrypt = promisify(crypto.scrypt);
+
+describe('comparePassword', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return true for matching passwords', async () => {
+        const plaintext = 'mySecretPassword';
+        const salt = crypto.randomBytes(16).toString('hex');
+        const hashBuffer = (await scrypt(plaintext, salt, 64)) as Buffer;
+        const storedPassword = `${hashBuffer.toString('hex')}.${salt}`;
+        const result = await comparePassword(plaintext, storedPassword);
+        expect(result).toBe(true);
+    });
+
+    it('should return false for non-matching passwords', async () => {
+        const plaintext = 'mySecretPassword';
+        const wrongPassword = 'wrongPassword';
+
+        const salt = crypto.randomBytes(16).toString('hex');
+        const hashBuffer = (await scrypt(plaintext, salt, 64)) as Buffer;
+        const storedPassword = `${hashBuffer.toString('hex')}.${salt}`;
+
+        const result = await comparePassword(wrongPassword, storedPassword);
+        expect(result).toBe(false);
+    });
+
+    it('should throw an error if storedPassword format is incorrect', async () => {
+        await expect(comparePassword('anyPassword', 'invalidFormat'))
+            .rejects
+            .toThrow();
+    });
+});

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

@@ -0,0 +1,57 @@
+import { someAsync } from '../helpers/someAsync';
+import { evaluateExpression } from '../roles/helpers';
+import { MachineContext } from '../roles/machines/interface';
+import { evaluateDocumentFiltersReadFn } from '../roles/machines/read/B/validators';
+
+const mockContext = {
+    params: { type: 'read' },
+    role: { document_filters: { read: 'someFilterExpression' } },
+    user: { id: 'user123', name: 'Test User' },
+} as unknown as MachineContext;
+
+jest.mock('../helpers/someAsync', () => ({
+    someAsync: jest.fn().mockImplementation(async (array: Array<unknown>, callback: (item: unknown) => Promise<boolean>) => {
+        for (const item of array) {
+            if (await callback(item)) return true;
+        }
+        return false;
+    })
+}));
+
+jest.mock('../roles/helpers', () => ({
+    evaluateExpression: jest.fn(),
+}));
+
+describe('evaluateDocumentFiltersReadFn', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return true if at least one filter evaluates to true', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValue(true);
+        const result = await evaluateDocumentFiltersReadFn(mockContext);
+        expect(result).toBe(true);
+        expect(evaluateExpression).toHaveBeenCalledWith(mockContext.params, mockContext.role.document_filters?.read, mockContext.user);
+        expect(someAsync).toHaveBeenCalled();
+    });
+
+    it('should return false if no filters evaluate to true', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValue(false);
+        const result = await evaluateDocumentFiltersReadFn(mockContext);
+        expect(result).toBe(false);
+    });
+
+    it('should return false if role has no read filter', async () => {
+        mockContext.role.document_filters = {};
+        const result = await evaluateDocumentFiltersReadFn(mockContext);
+        expect(result).toBe(false);
+        expect(evaluateExpression).not.toHaveBeenCalled();
+    });
+
+    it('should return false if type is not in readOnly', async () => {
+        mockContext.params.type = 'write';
+        const result = await evaluateDocumentFiltersReadFn(mockContext);
+        expect(result).toBe(false);
+        expect(evaluateExpression).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,57 @@
+import { someAsync } from '../helpers/someAsync';
+import { evaluateExpression } from '../roles/helpers';
+import { MachineContext } from '../roles/machines/interface';
+import { evaluateDocumentFiltersWriteFn } from '../roles/machines/read/B/validators';
+
+const mockContext = {
+    params: { type: 'write' },
+    role: { document_filters: { write: 'someFilterExpression' } },
+    user: { id: 'user123', name: 'Test User' },
+} as unknown as MachineContext;
+
+jest.mock('../helpers/someAsync', () => ({
+    someAsync: jest.fn().mockImplementation(async (array: Array<unknown>, callback: (item: unknown) => Promise<boolean>) => {
+        for (const item of array) {
+            if (await callback(item)) return true;
+        }
+        return false;
+    })
+}));
+
+jest.mock('../roles/helpers', () => ({
+    evaluateExpression: jest.fn(),
+}));
+
+describe('evaluateDocumentFiltersWriteFn', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return true if at least one filter evaluates to true', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValue(true);
+        const result = await evaluateDocumentFiltersWriteFn(mockContext);
+        expect(result).toBe(true);
+        expect(evaluateExpression).toHaveBeenCalledWith(mockContext.params, mockContext.role.document_filters?.write, mockContext.user);
+        expect(someAsync).toHaveBeenCalled();
+    });
+
+    it('should return false if no filters evaluate to true', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValue(false);
+        const result = await evaluateDocumentFiltersWriteFn(mockContext);
+        expect(result).toBe(false);
+    });
+
+    it('should return false if type is not in valid', async () => {
+        const mockClone = { ...mockContext, params: { type: 'test' as MachineContext["params"]["type"] } } as MachineContext
+        const result = await evaluateDocumentFiltersWriteFn(mockClone);
+        expect(result).toBe(false);
+        expect(evaluateExpression).not.toHaveBeenCalled();
+    });
+
+    it('should return false if role has no write filter', async () => {
+        const mockClone = { ...mockContext, role: { ...mockContext.role, document_filters: {} } } as MachineContext
+        const result = await evaluateDocumentFiltersWriteFn(mockClone);
+        expect(result).toBe(false);
+        expect(evaluateExpression).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,58 @@
+import { evaluateExpression } from '../roles/helpers';
+import { Params, Role } from '../roles/interface';
+import { evaluateTopLevelReadFn } from '../roles/machines/read/C/validators';
+
+jest.mock('../roles/helpers', () => ({
+    evaluateExpression: jest.fn(),
+}));
+
+const mockedRole = {} as Role
+
+const mockUser = {}
+const mockParams = {
+    type: "read"
+} as Params
+
+describe('evaluateTopLevelReadFn', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return false if type is different from read', async () => {
+        const isValid = await evaluateTopLevelReadFn({
+            role: mockedRole,
+            user: mockUser,
+            params: { type: "write" } as Params
+        })
+        expect(isValid).toBe(false)
+        expect(evaluateExpression).not.toHaveBeenCalled()
+    });
+    it('should return undefined if type is read and role read is not defined', async () => {
+        const isValid = await evaluateTopLevelReadFn({
+            role: mockedRole,
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(undefined)
+        expect(evaluateExpression).not.toHaveBeenCalled()
+    });
+    it('should return false if type is read and role read defined but evaluate expression returns false', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValueOnce(false)
+        const isValid = await evaluateTopLevelReadFn({
+            role: { ...mockedRole, read: false },
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(false)
+        expect(evaluateExpression).toHaveBeenCalledWith(mockParams, false, mockUser)
+    });
+    it('should return true if type is read and role read defined and evaluate expression returns true', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValueOnce(true)
+        const isValid = await evaluateTopLevelReadFn({
+            role: { ...mockedRole, read: false },
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(true)
+        expect(evaluateExpression).toHaveBeenCalledWith(mockParams, false, mockUser)
+    });
+});

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

@@ -0,0 +1,66 @@
+import { evaluateExpression } from '../roles/helpers';
+import { Params, Role } from '../roles/interface';
+import { evaluateTopLevelWriteFn } from '../roles/machines/read/C/validators';
+
+jest.mock('../roles/helpers', () => ({
+    evaluateExpression: jest.fn(),
+}));
+
+const mockedRole = {} as Role
+
+const mockUser = {}
+const mockParams = {
+    type: "read"
+} as Params
+
+describe('evaluateTopLevelWriteFn', () => {
+    it('should return undefined if type is different from read and write', async () => {
+        const isValid = await evaluateTopLevelWriteFn({
+            role: mockedRole,
+            user: mockUser,
+            params: { type: "delete" } as Params
+        })
+        expect(isValid).toBe(undefined)
+        expect(evaluateExpression).not.toHaveBeenCalled()
+    });
+    it('should return false if type is read but evaluate expression returns false', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValueOnce(false)
+        const isValid = await evaluateTopLevelWriteFn({
+            role: { ...mockedRole, write: false },
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(false)
+        expect(evaluateExpression).toHaveBeenCalledWith(mockParams, false, mockUser)
+    });
+    it('should return true if type is read and evaluate expression returns true', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValueOnce(true)
+        const isValid = await evaluateTopLevelWriteFn({
+            role: { ...mockedRole, write: false },
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(true)
+        expect(evaluateExpression).toHaveBeenCalledWith(mockParams, false, mockUser)
+    });
+    it('should return false if type is write but evaluate expression returns false', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValueOnce(false)
+        const isValid = await evaluateTopLevelWriteFn({
+            role: { ...mockedRole, write: false },
+            user: mockUser,
+            params: { type: "write" } as Params
+        })
+        expect(isValid).toBe(false)
+        expect(evaluateExpression).toHaveBeenCalledWith(mockParams, false, mockUser)
+    });
+    it('should return true if type is write and evaluate expression returns true', async () => {
+        (evaluateExpression as jest.Mock).mockResolvedValueOnce(true)
+        const isValid = await evaluateTopLevelWriteFn({
+            role: { ...mockedRole, write: false },
+            user: mockUser,
+            params: { type: "write" } as Params
+        })
+        expect(isValid).toBe(true)
+        expect(evaluateExpression).toHaveBeenCalledWith(mockParams, false, mockUser)
+    });
+});

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

@@ -0,0 +1,65 @@
+import Fastify, { FastifyInstance } from 'fastify'
+import { API_VERSION } from '../../constants'
+import { exposeRoutes } from '../initializer/exposeRoutes'
+
+jest.mock('../../constants', () => ({
+    API_VERSION: '/api/client/v2'
+}))
+
+const config: {
+    app?: FastifyInstance
+} = {}
+
+describe('exposeRoutes', () => {
+
+    beforeAll(async () => {
+        config.app = Fastify()
+        await exposeRoutes(config.app)
+        await config.app.ready()
+        jest.clearAllMocks();
+    })
+
+    afterAll(async () => {
+        await config.app!.close()
+    })
+
+    it('GET /health should return status ok and uptime', async () => {
+        const response = await config.app!.inject({
+            method: 'GET',
+            url: '/health',
+        })
+        expect(response.statusCode).toBe(200)
+        const body = JSON.parse(response.body)
+        expect(body).toHaveProperty('status', 'ok')
+        expect(body).toHaveProperty('uptime')
+        expect(typeof body.uptime).toBe('number')
+    })
+
+    it(`GET ${API_VERSION}/app/:appId/location should return correct location data`, async () => {
+        const appId = 'it'
+        const response = await config.app!.inject({
+            method: 'GET',
+            url: `${API_VERSION}/app/${appId}/location`,
+        })
+
+        expect(response.statusCode).toBe(200)
+        expect(JSON.parse(response.body)).toEqual({
+            deployment_model: 'LOCAL',
+            location: 'IE',
+            hostname: 'http://localhost:3000',
+            ws_hostname: 'wss://localhost:3000'
+        })
+    })
+
+    it('exposeRoutes should handle errors in the catch block', async () => {
+        const mockedApp = Fastify()
+        // Forced fail on get method
+        jest.spyOn(mockedApp, 'get').mockImplementation(() => {
+            throw new Error('Route registration failed')
+        })
+        const mockErrorLog = jest.spyOn(console, 'error').mockImplementation(() => { })
+        await exposeRoutes(mockedApp)
+        expect(mockErrorLog).toHaveBeenCalledWith('Error while exposing routes', 'Route registration failed')
+        mockErrorLog.mockRestore()
+    })
+})

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

@@ -0,0 +1,75 @@
+import Fastify from 'fastify'
+import { User } from '../../auth/dtos';
+import { Functions } from '../../features/functions/interface';
+import { Rules } from '../../features/rules/interface'
+import { services } from "../../services";
+import { generateContextData } from "../context/helpers";
+
+const originalEnv = process.env;
+
+jest.mock('../../services', () => ({
+    services: {
+        api: jest.fn(),
+        aws: jest.fn(),
+        'mongodb-atlas': jest.fn(),
+    },
+}));
+
+const mockFunctions = {
+    test: {
+        name: "test",
+        code: "test"
+    }
+} as Functions
+
+const currentFunction = mockFunctions.test
+const GenerateContextMock = jest.fn()
+const mockUser = {} as User
+const mockRules = {} as Rules
+const mockEnv = {
+    ...originalEnv,
+    test: "someTestVariable",
+    NODE_ENV: "dev",
+};
+
+
+describe('generateContextData', () => {
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = mockEnv
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+
+    it('should return an object with context configuration', async () => {
+
+        const mockApp = Fastify()
+        const { context, console: contextConsole } = generateContextData({ services, app: mockApp, functionsList: mockFunctions, currentFunction, GenerateContext: GenerateContextMock, user: mockUser, rules: mockRules })
+        expect(context.user).toEqual(mockUser)
+
+        const testVariable = context.values.get("test")
+        expect(testVariable).toBe(mockEnv.test)
+
+        expect(context.environment.tag).toBe(mockEnv.NODE_ENV)
+
+        expect(context.user).toEqual(mockUser)
+
+        const mockedLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+        contextConsole.log('Test', 'generateContextData')
+        expect(mockedLog).toHaveBeenCalledWith('Test', 'generateContextData');
+        mockedLog.mockRestore();
+
+        context.services.get("api")
+        expect(services.api).toHaveBeenCalled()
+        const mockErrorLog = jest.spyOn(console, 'error').mockImplementation(() => { })
+        context.services.get("notfound" as keyof typeof services)
+        expect(mockErrorLog).toHaveBeenCalled()
+        mockErrorLog.mockRestore()
+
+        context.functions.execute("test")
+        expect(GenerateContextMock).toHaveBeenCalled()
+    });
+});

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

@@ -0,0 +1,29 @@
+import rulesMatcherUtils from "../rules-matcher/utils";
+
+describe('getDefaultRule', () => {
+
+    it('should return the default rule', () => {
+        expect(rulesMatcherUtils.getDefaultRule(2)).toEqual({ op: '$eq', value: 2 })
+        expect(rulesMatcherUtils.getDefaultRule("test")).toEqual({ op: '$eq', value: "test" })
+        expect(rulesMatcherUtils.getDefaultRule(true)).toEqual({ op: '$exists', value: true })
+        expect(rulesMatcherUtils.getDefaultRule(["test"])).toEqual({ op: '$in', value: ["test"] })
+        expect(rulesMatcherUtils.getDefaultRule({ name: "John" })).toEqual({
+            name: "John",
+            op: "name",
+            value: "John"
+        })
+        expect(rulesMatcherUtils.getDefaultRule({ name: "John", value: "test" })).toEqual({
+            name: "John",
+            op: "name",
+            value: "test"
+        })
+        expect(rulesMatcherUtils.getDefaultRule({ name: "John", value: "test", op: "$in" })).toEqual({
+            name: "John",
+            op: "$in",
+            value: "test"
+        })
+        expect(rulesMatcherUtils.getDefaultRule(undefined)).toEqual({ op: '$eq', value: undefined })
+    });
+
+
+});

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

@@ -0,0 +1,12 @@
+import rulesMatcherUtils from "../rules-matcher/utils";
+
+describe('getKey function', () => {
+    it('should handle a basic rule correctly', () => {
+        const mockKeys = {}
+        const mockOptions = { prefix: 'user' }
+        const block = { name: { $eq: 'John' } };
+        const response = rulesMatcherUtils.getKey(block, mockKeys, mockOptions);
+        expect(response).toBe(true)
+        expect(mockKeys).toEqual({ "user.name": true })
+    });
+});

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

@@ -0,0 +1,11 @@
+import rulesMatcherUtils from "../rules-matcher/utils";
+
+describe('getKeys', () => {
+
+    it('should handle $and operator correctly', () => {
+        expect(rulesMatcherUtils.getKeys(undefined)).toBe(null)
+        expect(rulesMatcherUtils.getKeys(() => { })).toEqual([])
+        // NOTE -> this cast is forced to test a case that should never be verified
+        expect(rulesMatcherUtils.getKeys("test" as unknown as Record<string, unknown>)).toEqual(null)
+    });
+});