@flowerforce/flowerbase 1.0.1-beta.9 → 1.0.2

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

@@ -1,57 +1,71 @@
-import { someAsync } from '../helpers/someAsync';
-import { evaluateExpression } from '../roles/helpers';
-import { MachineContext } from '../roles/machines/interface';
-import { evaluateDocumentFiltersWriteFn } from '../roles/machines/read/B/validators';
+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;
+  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>) => {
+  someAsync: jest
+    .fn()
+    .mockImplementation(
+      async (array: Array<unknown>, callback: (item: unknown) => Promise<boolean>) => {
         for (const item of array) {
-            if (await callback(item)) return true;
+          if (await callback(item)) return true
         }
-        return false;
-    })
-}));
+        return false
+      }
+    )
+}))
 
 jest.mock('../roles/helpers', () => ({
-    evaluateExpression: jest.fn(),
-}));
+  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();
-    });
-});
+  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

@@ -1,58 +1,58 @@
-import { evaluateExpression } from '../roles/helpers';
-import { Params, Role } from '../roles/interface';
-import { evaluateTopLevelReadFn } from '../roles/machines/read/C/validators';
+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(),
-}));
+  evaluateExpression: jest.fn()
+}))
 
 const mockedRole = {} as Role
 
 const mockUser = {}
 const mockParams = {
-    type: "read"
+  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)
-    });
-});
+  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

@@ -1,66 +1,66 @@
-import { evaluateExpression } from '../roles/helpers';
-import { Params, Role } from '../roles/interface';
-import { evaluateTopLevelWriteFn } from '../roles/machines/read/C/validators';
+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(),
-}));
+  evaluateExpression: jest.fn()
+}))
 
 const mockedRole = {} as Role
 
 const mockUser = {}
 const mockParams = {
-    type: "read"
+  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)
-    });
-});
+  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

@@ -3,63 +3,65 @@ import { API_VERSION } from '../../constants'
 import { exposeRoutes } from '../initializer/exposeRoutes'
 
 jest.mock('../../constants', () => ({
-    API_VERSION: '/api/client/v2'
+  API_VERSION: '/api/client/v2'
 }))
 
 const config: {
-    app?: FastifyInstance
+  app?: FastifyInstance
 } = {}
 
 describe('exposeRoutes', () => {
+  beforeAll(async () => {
+    config.app = Fastify()
+    await exposeRoutes(config.app)
+    await config.app.ready()
+    jest.clearAllMocks()
+  })
 
-    beforeAll(async () => {
-        config.app = Fastify()
-        await exposeRoutes(config.app)
-        await config.app.ready()
-        jest.clearAllMocks();
-    })
+  afterAll(async () => {
+    await config.app!.close()
+  })
 
-    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 /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`
     })
 
-    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'
-        })
+    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()
+  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

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