@flowerforce/flowerbase 1.0.1-beta.3

package/src/state.ts

@@ -0,0 +1,24 @@
+import { FastifyInstance } from "fastify";
+import { Endpoints } from "./features/endpoints/interface";
+import { Functions } from "./features/functions/interface";
+import { Rules } from "./features/rules/interface";
+import { Triggers } from "./features/triggers/interface";
+import { Services } from "./services/interface";
+
+type State = { functions: Functions; triggers: Triggers; services?: Services; endpoints: Endpoints, rules: Rules, app?: FastifyInstance }
+
+export class StateManager {
+    private static _state: State = {
+        functions: {},
+        triggers: [],
+        endpoints: [],
+        rules: {}
+    };
+    static select<K extends keyof typeof this._state>(key: K): NonNullable<typeof this._state[K]> {
+        return this._state[key] as NonNullable<typeof this._state[K]>;
+    }
+
+    static setData<K extends keyof typeof this._state>(key: K, value: typeof this._state[K]) {
+        this._state[key] = value;
+    }
+}

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

@@ -0,0 +1,54 @@
+import { MachineContext } from "../roles/machines/interface";
+import { STEP_A_STATES } from "../roles/machines/read/A";
+import * as Utils from "../roles/machines/utils";
+const { evaluateSearch, checkSearchRequest } = STEP_A_STATES
+
+const endValidation = jest.fn()
+const goToNextValidationStage = jest.fn()
+const next = jest.fn()
+
+
+describe('STEP_A_STATES', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('checkSearchRequest should go to evaluateSearch if is a search operation', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        const mockContext = {
+            params: {
+                type: "search"
+            },
+            role: {
+                name: "test"
+            }
+        } as MachineContext
+        await checkSearchRequest({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(next).toHaveBeenCalledWith("evaluateSearch")
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "A", step: 1, stepName: "checkSearchRequest" })
+        mockedLogInfo.mockRestore()
+    });
+    it('checkSearchRequest should go to next stage if operation is not search', async () => {
+        const mockContext = {
+            params: {
+                type: "read"
+            },
+            role: {
+                name: "test"
+            }
+        } as MachineContext
+        await checkSearchRequest({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(goToNextValidationStage).toHaveBeenCalled()
+    });
+    it('evaluateSearch should end a failed validation ', () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        const mockContext = {
+            role: {
+                name: "test"
+            }
+        } as MachineContext
+        evaluateSearch({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: false })
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "A", step: 2, stepName: "evaluateSearch" })
+        mockedLogInfo.mockRestore()
+    });
+});

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

@@ -0,0 +1,113 @@
+import { MachineContext } from "../roles/machines/interface";
+import { STEP_B_STATES } from "../roles/machines/read/B";
+import { evaluateDocumentFiltersReadFn, evaluateDocumentFiltersWriteFn } from "../roles/machines/read/B/validators"
+import * as Utils from "../roles/machines/utils";
+const { checkDocumentsFilters, evaluateDocumentsFiltersRead, evaluateDocumentsFiltersWrite } = STEP_B_STATES
+
+jest.mock('../roles/machines/B/validators', () => ({
+    evaluateDocumentFiltersReadFn: jest.fn(),
+    evaluateDocumentFiltersWriteFn: jest.fn(),
+}));
+
+
+const endValidation = jest.fn()
+const goToNextValidationStage = jest.fn()
+const next = jest.fn()
+
+describe('STEP_B_STATES', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('checkDocumentsFilters should go to next stage if document_filters is not defined', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        const mockContext = {
+            params: {
+                type: "search"
+            },
+            role: {
+                name: "test"
+            }
+        } as MachineContext
+        await checkDocumentsFilters({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(goToNextValidationStage).toHaveBeenCalled()
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "B", step: 1, stepName: "checkDocumentsFilters" })
+        mockedLogInfo.mockRestore()
+    });
+    it('checkDocumentsFilters should go to evaluateDocumentsFiltersRead step if document_filters is defined', async () => {
+        const mockContext = {
+            params: {
+                type: "search"
+            },
+            role: {
+                name: "test",
+                document_filters: {}
+            }
+        } as MachineContext
+        await checkDocumentsFilters({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(next).toHaveBeenCalledWith("evaluateDocumentsFiltersRead")
+    });
+    it('evaluateDocumentsFiltersRead should go to next stage if document_filters read is valid', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        const mockContext = {
+            params: {
+                type: "search"
+            },
+            role: {
+                name: "test",
+                document_filters: {
+                    read: true
+                }
+            }
+        } as MachineContext
+        (evaluateDocumentFiltersReadFn as jest.Mock).mockReturnValue(true);
+        await evaluateDocumentsFiltersRead({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(goToNextValidationStage).toHaveBeenCalled()
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "B", step: 2, stepName: "evaluateDocumentsFiltersRead" })
+        mockedLogInfo.mockRestore()
+    });
+    it('evaluateDocumentsFiltersRead should go to evaluateDocumentsFiltersWrite if document_filters read is not defined or not valid', async () => {
+        const mockContext = {
+            params: {
+                type: "search"
+            },
+            role: {
+                name: "test",
+            }
+        } as MachineContext
+        (evaluateDocumentFiltersReadFn as jest.Mock).mockReturnValue(false);
+        await evaluateDocumentsFiltersRead({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(next).toHaveBeenCalledWith("evaluateDocumentsFiltersWrite")
+    });
+    it('evaluateDocumentFiltersWriteFn should go to next stage if document_filters write is valid', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        const mockContext = {
+            params: {
+                type: "search"
+            },
+            role: {
+                name: "test",
+                document_filters: {
+                    write: true
+                }
+            }
+        } as MachineContext
+        (evaluateDocumentFiltersWriteFn as jest.Mock).mockReturnValue(true);
+        await evaluateDocumentsFiltersWrite({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(goToNextValidationStage).toHaveBeenCalled()
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "B", step: 3, stepName: "evaluateDocumentsFiltersWrite" })
+        mockedLogInfo.mockRestore()
+    });
+    it('evaluateDocumentFiltersWriteFn should end a failed validation if document_filters write is not defined or not valid', async () => {
+        const mockContext = {
+            params: {
+                type: "search"
+            },
+            role: {
+                name: "test",
+            }
+        } as MachineContext
+        (evaluateDocumentFiltersWriteFn as jest.Mock).mockReturnValue(false);
+        await evaluateDocumentsFiltersWrite({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: false })
+    });
+});

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

@@ -0,0 +1,87 @@
+import { MachineContext } from "../roles/machines/interface";
+import { STEP_C_STATES } from "../roles/machines/read/C";
+import { checkFieldsPropertyExists, evaluateTopLevelReadFn, evaluateTopLevelWriteFn } from "../roles/machines/read/C/validators";
+import * as Utils from "../roles/machines/utils";
+const { evaluateTopLevelRead, checkFieldsProperty, evaluateTopLevelWrite } = STEP_C_STATES
+
+const endValidation = jest.fn()
+const goToNextValidationStage = jest.fn()
+const next = jest.fn()
+
+
+jest.mock('../roles/machines/C/validators', () => ({
+    evaluateTopLevelReadFn: jest.fn(),
+    checkFieldsPropertyExists: jest.fn(),
+    evaluateTopLevelWriteFn: jest.fn()
+}));
+
+describe('STEP_C_STATES', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('evaluateTopLevelRead should go to evaluateTopLevelWrite if evaluateTopLevelReadFn returns false ', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        (evaluateTopLevelReadFn as jest.Mock).mockReturnValueOnce(false)
+        const mockContext = {} as MachineContext
+        await evaluateTopLevelRead({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(next).toHaveBeenCalledWith("evaluateTopLevelWrite", { check: false })
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "C", step: 1, stepName: "evaluateTopLevelRead" })
+        mockedLogInfo.mockRestore()
+    });
+    it('evaluateTopLevelRead should go to evaluateTopLevelWrite if evaluateTopLevelReadFn returns undefined ', async () => {
+        (evaluateTopLevelReadFn as jest.Mock).mockReturnValueOnce(undefined)
+        const mockContext = {} as MachineContext
+        await evaluateTopLevelRead({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(next).toHaveBeenCalledWith("evaluateTopLevelWrite", { check: undefined })
+    });
+    it('evaluateTopLevelRead should endValidation validation if evaluateTopLevelReadFn returns true ', async () => {
+        (evaluateTopLevelReadFn as jest.Mock).mockReturnValueOnce(true)
+        const mockContext = {} as MachineContext
+        await evaluateTopLevelRead({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: true })
+    });
+    it('checkFieldsProperty should go to next validation stage if checkFieldsPropertyExists returns true with initialStep checkIsValidFieldName', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        (checkFieldsPropertyExists as jest.Mock).mockReturnValue(true)
+        const mockContext = {} as MachineContext
+        await checkFieldsProperty({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(goToNextValidationStage).toHaveBeenCalledWith("checkIsValidFieldName")
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "C", step: 3, stepName: "checkFieldsProperty" })
+        mockedLogInfo.mockRestore()
+    });
+    it('checkFieldsProperty should go to next validation stage if checkFieldsPropertyExists returns fslse with initialStep checkAdditionalFields', async () => {
+        (checkFieldsPropertyExists as jest.Mock).mockReturnValue(false)
+        const mockContext = {} as MachineContext
+        await checkFieldsProperty({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(goToNextValidationStage).toHaveBeenCalledWith("checkAdditionalFields")
+    });
+    it('evaluateTopLevelWrite should end a success validation if evaluateTopLevelWriteFn returns true', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        (evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(true)
+        const mockContext = {} as MachineContext
+        await evaluateTopLevelWrite({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: true })
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "C", step: 2, stepName: "evaluateTopLevelWrite" })
+        mockedLogInfo.mockRestore()
+    });
+    it('evaluateTopLevelWrite should end a failed validation if evaluateTopLevelWriteFn returns false and prevParams.check is false', async () => {
+        (evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(false)
+        const mockContext = {
+            prevParams: {
+                check: false
+            }
+        } as unknown as MachineContext
+        await evaluateTopLevelWrite({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: false })
+    });
+    it('evaluateTopLevelWrite should go to next step checkFieldsProperty if evaluateTopLevelWriteFn returns false and prevParams.check is not false ', async () => {
+        (evaluateTopLevelWriteFn as jest.Mock).mockReturnValue(false)
+        const mockContext = {
+            prevParams: {
+                check: true
+            }
+        } as unknown as MachineContext
+        await evaluateTopLevelWrite({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(next).toHaveBeenCalledWith("checkFieldsProperty")
+    });
+});

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

@@ -0,0 +1,93 @@
+import { Role } from "../roles/interface";
+import { MachineContext } from "../roles/machines/interface";
+import { STEP_D_STATES } from "../roles/machines/read/D";
+import * as Utils from "../roles/machines/utils";
+const { checkAdditionalFields, checkIsValidFieldName } = STEP_D_STATES
+
+const endValidation = jest.fn()
+const goToNextValidationStage = jest.fn()
+const next = jest.fn()
+
+
+describe('STEP_D_STATES', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('checkAdditionalFields should end validation if additional fields is not defined', () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        const mockContext = {
+            role: {
+                name: "test"
+            }
+        } as MachineContext
+        checkAdditionalFields({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: false })
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "D", step: 1, stepName: "checkAdditionalFields" })
+        mockedLogInfo.mockRestore()
+    });
+    it('checkAdditionalFields should end validation if additional fields are empty', () => {
+        const mockContext = {
+            role: {
+                name: "test",
+                additional_fields: {}
+            }
+        } as MachineContext
+        checkAdditionalFields({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: false })
+
+    });
+    it('checkAdditionalFields should go to evaluateRead step if additional fields are defined and not empty', () => {
+        const mockContext = {
+            role: {
+                name: "test",
+                apply_when: {
+                    "%%true": true
+                },
+                additional_fields: {
+                    name: {
+                        write: true
+                    }
+                }
+            } as Role
+        } as MachineContext
+        checkAdditionalFields({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(next).toHaveBeenCalledWith("evaluateRead")
+
+    });
+    it('checkIsValidFieldName should end a failed validation, with an empty document', async () => {
+        const mockedLogInfo = jest.spyOn(Utils, 'logMachineInfo').mockImplementation(() => 'Mocked Value');
+        const mockContext = {
+            params: {
+                cursor: { name: "test" }
+            },
+            role: {
+                name: "test"
+            }
+        } as MachineContext
+        await checkIsValidFieldName({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: false, document: {} })
+        expect(mockedLogInfo).toHaveBeenCalledWith({ enabled: mockContext.enableLog, machine: "D", step: 2, stepName: "checkIsValidFieldName" })
+        mockedLogInfo.mockRestore()
+    });
+    it('checkIsValidFieldName should end a success validation, with  document', async () => {
+
+        const mockContext = {
+            params: {
+                cursor: { name: "test" },
+            },
+            role: {
+                name: "testRole",
+                apply_when: {
+                    "%%true": true
+                },
+                fields: {
+                    name: {
+                        read: true
+                    }
+                }
+            } as Role
+        } as MachineContext
+        await checkIsValidFieldName({ endValidation, context: mockContext, goToNextValidationStage, next, initialStep: null })
+        expect(endValidation).toHaveBeenCalledWith({ success: true, document: { name: "test" } })
+    });
+});

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

@@ -0,0 +1,45 @@
+import { Params } from '../roles/interface';
+import { checkAdditionalFieldsFn } from '../roles/machines/read/D/validators';
+
+const mockedRole = {
+    name: "mock",
+    apply_when: {},
+}
+const additionalFields = {
+    name: {
+        write: true
+    }
+}
+
+const mockUser = {}
+const mockParams = {} as Params
+
+describe('comparePassword', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return true for existing additional fields', () => {
+        const isDefined = checkAdditionalFieldsFn({
+            role: { ...mockedRole, additional_fields: additionalFields },
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isDefined).toBe(true)
+    });
+    it('should return false for missing additional fields', () => {
+        const isDefined = checkAdditionalFieldsFn({
+            role: mockedRole,
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isDefined).toBe(false)
+    });
+    it('should return false for empty additional fields', () => {
+        const isDefined = checkAdditionalFieldsFn({
+            role: { ...mockedRole, additional_fields: {} },
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isDefined).toBe(false)
+    });
+});

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

@@ -0,0 +1,49 @@
+import { Document, ObjectId, WithId } from "mongodb"
+import { User } from '../../auth/dtos';
+import { getValidRule } from '../../services/mongodb-atlas/utils';
+import { checkApplyWhen } from "../roles/machines/utils";
+
+jest.mock('../../services/mongodb-atlas/utils', () => ({
+    getValidRule: jest.fn(),
+}));
+
+const mockUser = {
+    id: 'user123',
+    role: 'admin',
+    name: 'Test User',
+} as User;
+
+const mockDocument = {
+    _id: new ObjectId(),
+    field: 'value',
+} as WithId<Document>;
+
+describe('checkApplyWhen', () => {
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return true if getValidRule returns a valid rule', () => {
+        (getValidRule as jest.Mock).mockReturnValue([{ rule: 'some rule' }]);
+        const result = checkApplyWhen({ condition: 'test' }, mockUser, mockDocument);
+        expect(result).toBe(true);
+        expect(getValidRule).toHaveBeenCalledWith({
+            filters: [{ apply_when: { condition: 'test' } }],
+            user: mockUser,
+            record: mockDocument,
+        });
+    });
+
+    it('should return false if getValidRule returns an empty array', () => {
+        (getValidRule as jest.Mock).mockReturnValue([]);
+        const result = checkApplyWhen({ condition: 'test' }, mockUser, mockDocument);
+        expect(result).toBe(false);
+    });
+
+    it('should return false if document is null', () => {
+        (getValidRule as jest.Mock).mockReturnValue([]);
+        const result = checkApplyWhen({ condition: 'test' }, mockUser, null);
+        expect(result).toBe(false);
+    });
+});

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

@@ -0,0 +1,47 @@
+import { Params, Role } from '../roles/interface';
+import { checkFieldsPropertyExists } from '../roles/machines/read/C/validators';
+
+jest.mock('../roles/helpers', () => ({
+    evaluateExpression: jest.fn(),
+}));
+
+const mockUser = {}
+const mockParams = {} as Params
+
+describe('checkFieldsPropertyExists', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return false if role fields is not defined', () => {
+        const isValid = checkFieldsPropertyExists({
+            role: {} as Role,
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(false)
+    });
+    it('should return false if role fields is empty', () => {
+        const isValid = checkFieldsPropertyExists({
+            role: {
+                fields: {}
+            } as Role,
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(false)
+    });
+    it('should return true if role fields is note empty', () => {
+        const isValid = checkFieldsPropertyExists({
+            role: {
+                fields: {
+                    test: {}
+                },
+                apply_when: {},
+                name: "test",
+            } as Role,
+            user: mockUser,
+            params: mockParams
+        })
+        expect(isValid).toBe(true)
+    });
+});