@flusys/nestjs-form-builder 6.0.2 → 6.1.1

package/cjs/utils/permission.utils.spec.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _permissionutils = require("./permission.utils");
+function buildMockCache() {
+    return {
+        get: jest.fn(),
+        set: jest.fn(),
+        del: jest.fn()
+    };
+}
+describe('validateUserPermissions', ()=>{
+    it('returns true immediately without touching the cache when no permissions are required', async ()=>{
+        const cache = buildMockCache();
+        const result = await (0, _permissionutils.validateUserPermissions)((0, _loggedusermock.buildMockUser)(), [], cache, false);
+        expect(result).toBe(true);
+        expect(cache.get).not.toHaveBeenCalled();
+    });
+    it('returns true when the user has at least one of the required permissions', async ()=>{
+        const cache = buildMockCache();
+        cache.get.mockResolvedValue([
+            'hr.survey.submit',
+            'other.permission'
+        ]);
+        const result = await (0, _permissionutils.validateUserPermissions)((0, _loggedusermock.buildMockUser)(), [
+            'hr.survey.submit',
+            'employee.feedback.submit'
+        ], cache, false);
+        expect(result).toBe(true);
+    });
+    it('returns false when the user has none of the required permissions', async ()=>{
+        const cache = buildMockCache();
+        cache.get.mockResolvedValue([
+            'some.other.permission'
+        ]);
+        const result = await (0, _permissionutils.validateUserPermissions)((0, _loggedusermock.buildMockUser)(), [
+            'hr.survey.submit'
+        ], cache, false);
+        expect(result).toBe(false);
+    });
+    it('treats a missing cache entry as no permissions (returns false)', async ()=>{
+        const cache = buildMockCache();
+        cache.get.mockResolvedValue(undefined);
+        const result = await (0, _permissionutils.validateUserPermissions)((0, _loggedusermock.buildMockUser)(), [
+            'hr.survey.submit'
+        ], cache, false);
+        expect(result).toBe(false);
+    });
+    it('fails closed with a ForbiddenException when the cache lookup throws', async ()=>{
+        const cache = buildMockCache();
+        cache.get.mockRejectedValue(new Error('redis down'));
+        await expect((0, _permissionutils.validateUserPermissions)((0, _loggedusermock.buildMockUser)(), [
+            'hr.survey.submit'
+        ], cache, false)).rejects.toMatchObject({
+            response: expect.objectContaining({
+                messageKey: 'form.permission.check.failed'
+            })
+        });
+        await expect((0, _permissionutils.validateUserPermissions)((0, _loggedusermock.buildMockUser)(), [
+            'hr.survey.submit'
+        ], cache, false)).rejects.toBeInstanceOf(_common.ForbiddenException);
+    });
+    describe('cache key construction', ()=>{
+        it('uses a company/branch/user scoped key when the company feature is enabled and both are present', async ()=>{
+            const cache = buildMockCache();
+            cache.get.mockResolvedValue([]);
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1',
+                branchId: 'branch-1',
+                id: 'user-1'
+            });
+            await (0, _permissionutils.validateUserPermissions)(user, [
+                'perm.read'
+            ], cache, true);
+            expect(cache.get).toHaveBeenCalledWith('permissions:company:company-1:branch:branch-1:user:user-1');
+        });
+        it('uses "null" as the branch placeholder when branchId is missing under the company feature', async ()=>{
+            const cache = buildMockCache();
+            cache.get.mockResolvedValue([]);
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1',
+                branchId: undefined,
+                id: 'user-1'
+            });
+            await (0, _permissionutils.validateUserPermissions)(user, [
+                'perm.read'
+            ], cache, true);
+            expect(cache.get).toHaveBeenCalledWith('permissions:company:company-1:branch:null:user:user-1');
+        });
+        it('falls back to a plain user-scoped key when the company feature is enabled but companyId is missing', async ()=>{
+            const cache = buildMockCache();
+            cache.get.mockResolvedValue([]);
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: undefined,
+                id: 'user-1'
+            });
+            await (0, _permissionutils.validateUserPermissions)(user, [
+                'perm.read'
+            ], cache, true);
+            expect(cache.get).toHaveBeenCalledWith('permissions:user:user-1');
+        });
+        it('uses a plain user-scoped key when the company feature is disabled', async ()=>{
+            const cache = buildMockCache();
+            cache.get.mockResolvedValue([]);
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1',
+                id: 'user-1'
+            });
+            await (0, _permissionutils.validateUserPermissions)(user, [
+                'perm.read'
+            ], cache, false);
+            expect(cache.get).toHaveBeenCalledWith('permissions:user:user-1');
+        });
+    });
+});

package/fesm/controllers/form-result.controller.spec.js

@@ -0,0 +1,253 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { FormResultController } from './form-result.controller';
+import { FormResultService } from '../services/form-result.service';
+function buildResultDto(overrides = {}) {
+    return {
+        id: 'result-1',
+        formId: 'form-1',
+        schemaVersionSnapshot: {
+            sections: []
+        },
+        schemaVersion: 1,
+        data: {
+            field1: 'value1'
+        },
+        submittedById: 'user-uuid-1',
+        submittedAt: new Date(),
+        isDraft: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+describe('FormResultController', ()=>{
+    let controller;
+    let mockService;
+    beforeEach(async ()=>{
+        mockService = {
+            insert: jest.fn(),
+            insertMany: jest.fn(),
+            findById: jest.fn(),
+            findByIds: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            updateMany: jest.fn(),
+            delete: jest.fn(),
+            submitForm: jest.fn(),
+            getMyDraft: jest.fn(),
+            updateDraft: jest.fn(),
+            getByFormId: jest.fn(),
+            hasUserSubmitted: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            controllers: [
+                FormResultController
+            ],
+            // UtilsService is a real (dependency-free) provider — required to satisfy the
+            // Slug interceptor applied by the inherited insert/update endpoints.
+            providers: [
+                {
+                    provide: FormResultService,
+                    useValue: mockService
+                },
+                UtilsService
+            ]
+        }).compile();
+        controller = module.get(FormResultController);
+    });
+    afterEach(()=>{
+        jest.clearAllMocks();
+    });
+    describe('submitForm', ()=>{
+        it('submits on behalf of the authenticated user (isPublic=false)', async ()=>{
+            const user = buildMockUser();
+            mockService.submitForm.mockResolvedValue(buildResultDto());
+            const result = await controller.submitForm({
+                formId: 'form-1',
+                data: {
+                    field1: 'value1'
+                }
+            }, user);
+            expect(mockService.submitForm).toHaveBeenCalledWith({
+                formId: 'form-1',
+                data: {
+                    field1: 'value1'
+                }
+            }, user, false);
+            expect(result).toEqual({
+                success: true,
+                message: 'Form submitted successfully',
+                messageKey: 'form.result.submit.success',
+                data: expect.objectContaining({
+                    id: 'result-1'
+                })
+            });
+        });
+        it('propagates errors from the service (e.g. permission denied)', async ()=>{
+            mockService.submitForm.mockRejectedValue(Object.assign(new Error('denied'), {
+                messageKey: 'form.access.denied'
+            }));
+            await expect(controller.submitForm({
+                formId: 'form-1',
+                data: {}
+            }, buildMockUser())).rejects.toThrow();
+        });
+    });
+    describe('submitPublicForm', ()=>{
+        it('submits without a user and marks the submission as public', async ()=>{
+            mockService.submitForm.mockResolvedValue(buildResultDto({
+                submittedById: null
+            }));
+            const result = await controller.submitPublicForm({
+                formId: 'form-1',
+                data: {}
+            });
+            expect(mockService.submitForm).toHaveBeenCalledWith({
+                formId: 'form-1',
+                data: {}
+            }, null, true);
+            expect(result.data.submittedById).toBeNull();
+        });
+    });
+    describe('getMyDraft', ()=>{
+        it('returns the current draft for the user', async ()=>{
+            const user = buildMockUser();
+            mockService.getMyDraft.mockResolvedValue(buildResultDto({
+                isDraft: true
+            }));
+            const result = await controller.getMyDraft({
+                formId: 'form-1'
+            }, user);
+            expect(mockService.getMyDraft).toHaveBeenCalledWith('form-1', user);
+            expect(result.data?.isDraft).toBe(true);
+        });
+        it('returns null data when no draft exists', async ()=>{
+            mockService.getMyDraft.mockResolvedValue(null);
+            const result = await controller.getMyDraft({
+                formId: 'form-1'
+            }, buildMockUser());
+            expect(result.data).toBeNull();
+        });
+    });
+    describe('updateDraft', ()=>{
+        it('updates the identified draft', async ()=>{
+            const user = buildMockUser();
+            mockService.updateDraft.mockResolvedValue(buildResultDto({
+                isDraft: true
+            }));
+            const result = await controller.updateDraft({
+                draftId: 'draft-1',
+                formId: 'form-1',
+                data: {
+                    field1: 'new'
+                }
+            }, user);
+            expect(mockService.updateDraft).toHaveBeenCalledWith('draft-1', {
+                draftId: 'draft-1',
+                formId: 'form-1',
+                data: {
+                    field1: 'new'
+                }
+            }, user);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('getByFormId', ()=>{
+        it('returns paginated results with the requested page/pageSize', async ()=>{
+            mockService.getByFormId.mockResolvedValue({
+                data: [
+                    buildResultDto()
+                ],
+                total: 1
+            });
+            const result = await controller.getByFormId({
+                formId: 'form-1',
+                page: 1,
+                pageSize: 5
+            }, buildMockUser());
+            expect(mockService.getByFormId).toHaveBeenCalledWith('form-1', expect.any(Object), {
+                page: 1,
+                pageSize: 5
+            });
+            expect(result.meta).toEqual({
+                total: 1,
+                page: 1,
+                pageSize: 5,
+                count: 1
+            });
+        });
+        it('defaults to page 0 and pageSize 10 when not provided', async ()=>{
+            mockService.getByFormId.mockResolvedValue({
+                data: [],
+                total: 0
+            });
+            const result = await controller.getByFormId({
+                formId: 'form-1'
+            }, buildMockUser());
+            expect(mockService.getByFormId).toHaveBeenCalledWith('form-1', expect.any(Object), {
+                page: 0,
+                pageSize: 10
+            });
+            expect(result.meta).toEqual({
+                total: 0,
+                page: 0,
+                pageSize: 10,
+                count: 0
+            });
+        });
+    });
+    describe('hasUserSubmitted', ()=>{
+        it('returns a truthy submitted message when the user has submitted', async ()=>{
+            mockService.hasUserSubmitted.mockResolvedValue(true);
+            const result = await controller.hasUserSubmitted({
+                formId: 'form-1'
+            }, buildMockUser());
+            expect(result).toEqual({
+                success: true,
+                message: 'User has submitted this form',
+                messageKey: 'form.result.has.submitted.success',
+                data: true
+            });
+        });
+        it('returns a not-submitted message when the user has not submitted', async ()=>{
+            mockService.hasUserSubmitted.mockResolvedValue(false);
+            const result = await controller.hasUserSubmitted({
+                formId: 'form-1'
+            }, buildMockUser());
+            expect(result).toEqual({
+                success: true,
+                message: 'User has not submitted this form',
+                messageKey: 'form.result.has.not.submitted.success',
+                data: false
+            });
+        });
+    });
+    // ==========================================================================
+    // Inherited base CRUD wiring (createApiController)
+    // ==========================================================================
+    describe('inherited CRUD endpoints', ()=>{
+        it('delete delegates to FormResultService.delete', async ()=>{
+            mockService.delete.mockResolvedValue(null);
+            const user = buildMockUser();
+            const result = await controller.delete({
+                id: [
+                    'result-1'
+                ],
+                type: 'delete'
+            }, user);
+            expect(mockService.delete).toHaveBeenCalledWith({
+                id: [
+                    'result-1'
+                ],
+                type: 'delete'
+            }, user);
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/fesm/controllers/form.controller.spec.js

@@ -0,0 +1,208 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { FormAccessType } from '../enums/form-access-type.enum';
+import { FormController } from './form.controller';
+import { FormService } from '../services/form.service';
+describe('FormController', ()=>{
+    let controller;
+    let mockService;
+    beforeEach(async ()=>{
+        mockService = {
+            insert: jest.fn(),
+            insertMany: jest.fn(),
+            findById: jest.fn(),
+            findByIds: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            updateMany: jest.fn(),
+            delete: jest.fn(),
+            getFormAccessInfo: jest.fn(),
+            getPublicForm: jest.fn(),
+            getAuthenticatedForm: jest.fn(),
+            getBySlug: jest.fn(),
+            getPublicFormBySlug: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            controllers: [
+                FormController
+            ],
+            // UtilsService is a real (dependency-free) provider — required to satisfy the
+            // Slug interceptor applied by the inherited insert/update endpoints.
+            providers: [
+                {
+                    provide: FormService,
+                    useValue: mockService
+                },
+                UtilsService
+            ]
+        }).compile();
+        controller = module.get(FormController);
+    });
+    afterEach(()=>{
+        jest.clearAllMocks();
+    });
+    describe('getFormAccessInfo', ()=>{
+        it('returns access info without requiring authentication', async ()=>{
+            mockService.getFormAccessInfo.mockResolvedValue({
+                id: 'form-1',
+                name: 'Survey',
+                description: null,
+                accessType: FormAccessType.PUBLIC,
+                actionGroups: null,
+                isActive: true
+            });
+            const result = await controller.getFormAccessInfo('form-1');
+            expect(result).toEqual({
+                success: true,
+                message: 'Form access info retrieved',
+                messageKey: 'form.get.access.info.success',
+                data: expect.objectContaining({
+                    id: 'form-1',
+                    accessType: FormAccessType.PUBLIC
+                })
+            });
+            expect(mockService.getFormAccessInfo).toHaveBeenCalledWith('form-1');
+        });
+        it('propagates NotFoundException raised by the service', async ()=>{
+            mockService.getFormAccessInfo.mockRejectedValue(Object.assign(new Error('not found'), {
+                messageKey: 'form.not.found'
+            }));
+            await expect(controller.getFormAccessInfo('missing')).rejects.toThrow();
+        });
+    });
+    describe('getPublicForm', ()=>{
+        it('returns the public form projection', async ()=>{
+            mockService.getPublicForm.mockResolvedValue({
+                id: 'form-1',
+                name: 'Survey',
+                description: null,
+                schema: {
+                    sections: []
+                },
+                schemaVersion: 1
+            });
+            const result = await controller.getPublicForm('form-1');
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe('form.get.success');
+            expect(result.data.id).toBe('form-1');
+        });
+    });
+    describe('getAuthenticatedForm', ()=>{
+        it('forwards the current user to the service and returns the form', async ()=>{
+            const user = buildMockUser();
+            mockService.getAuthenticatedForm.mockResolvedValue({
+                id: 'form-1',
+                name: 'Survey',
+                description: null,
+                schema: {},
+                schemaVersion: 1
+            });
+            const result = await controller.getAuthenticatedForm('form-1', user);
+            expect(mockService.getAuthenticatedForm).toHaveBeenCalledWith('form-1', user);
+            expect(result.data.id).toBe('form-1');
+        });
+    });
+    describe('getBySlug', ()=>{
+        it('returns the form when found by slug', async ()=>{
+            mockService.getBySlug.mockResolvedValue({
+                id: 'form-1',
+                name: 'Survey',
+                description: null,
+                slug: 'survey',
+                schema: {},
+                schemaVersion: 1,
+                accessType: FormAccessType.AUTHENTICATED,
+                actionGroups: null,
+                tags: null,
+                companyId: null,
+                isActive: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                deletedAt: null,
+                createdById: null,
+                updatedById: null,
+                deletedById: null
+            });
+            const result = await controller.getBySlug('survey', buildMockUser());
+            expect(result.data?.slug).toBe('survey');
+        });
+        it('returns null data when no form matches the slug', async ()=>{
+            mockService.getBySlug.mockResolvedValue(null);
+            const result = await controller.getBySlug('missing', buildMockUser());
+            expect(result.data).toBeNull();
+        });
+    });
+    describe('getPublicFormBySlug', ()=>{
+        it('returns the public form projection when found', async ()=>{
+            mockService.getPublicFormBySlug.mockResolvedValue({
+                id: 'form-1',
+                name: 'Survey',
+                description: null,
+                schema: {},
+                schemaVersion: 1
+            });
+            const result = await controller.getPublicFormBySlug('survey');
+            expect(result.data?.id).toBe('form-1');
+        });
+        it('returns null data when no public form matches the slug', async ()=>{
+            mockService.getPublicFormBySlug.mockResolvedValue(null);
+            const result = await controller.getPublicFormBySlug('missing');
+            expect(result.data).toBeNull();
+        });
+    });
+    // ==========================================================================
+    // Inherited base CRUD wiring (createApiController)
+    // ==========================================================================
+    describe('inherited CRUD endpoints', ()=>{
+        it('insert delegates to FormService.insert and wraps the result', async ()=>{
+            mockService.insert.mockResolvedValue({
+                id: 'form-1',
+                name: 'Survey',
+                description: null,
+                slug: null,
+                schema: {},
+                schemaVersion: 1,
+                accessType: FormAccessType.AUTHENTICATED,
+                actionGroups: null,
+                tags: null,
+                companyId: null,
+                isActive: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                deletedAt: null,
+                createdById: null,
+                updatedById: null,
+                deletedById: null
+            });
+            const user = buildMockUser();
+            const result = await controller.insert({
+                name: 'Survey',
+                schema: {}
+            }, user);
+            expect(mockService.insert).toHaveBeenCalledWith({
+                name: 'Survey',
+                schema: {}
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data.name).toBe('Survey');
+        });
+        it('delete delegates to FormService.delete', async ()=>{
+            mockService.delete.mockResolvedValue(null);
+            const user = buildMockUser();
+            const result = await controller.delete({
+                id: [
+                    'form-1'
+                ],
+                type: 'delete'
+            }, user);
+            expect(mockService.delete).toHaveBeenCalledWith({
+                id: [
+                    'form-1'
+                ],
+                type: 'delete'
+            }, user);
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/fesm/docs/form-builder-swagger.config.spec.js

@@ -0,0 +1,71 @@
+import { formBuilderSwaggerConfig } from './form-builder-swagger.config';
+describe('formBuilderSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = formBuilderSwaggerConfig();
+        expect(config.title).toBe('Form Builder API');
+        expect(config.path).toBe('api/docs/form-builder');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeTags).toEqual([]);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should exclude companyId schema properties when the company feature is disabled', ()=>{
+        const config = formBuilderSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(config.excludeSchemaProperties).toEqual([
+            {
+                schemaName: 'CreateFormDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'UpdateFormDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'FormQueryDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'FormResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            }
+        ]);
+    });
+    it('should not exclude any schema properties when the company feature is enabled', ()=>{
+        const config = formBuilderSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should describe company isolation and multi-tenant support only when the company feature is enabled', ()=>{
+        const withCompany = formBuilderSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = formBuilderSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('Company isolation');
+        expect(withCompany.description).toContain('## Multi-Tenant Support');
+        expect(withoutCompany.description).not.toContain('Company isolation');
+        expect(withoutCompany.description).not.toContain('## Multi-Tenant Support');
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = formBuilderSwaggerConfig({
+            databaseMode: 'multi-tenant'
+        });
+        const single = formBuilderSwaggerConfig({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/fesm/entities/index.spec.js

@@ -0,0 +1,14 @@
+import { getFormBuilderEntitiesByConfig, FormCoreEntities, FormCompanyEntities } from './index';
+import { FormResult } from './form-result.entity';
+describe('getFormBuilderEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect(getFormBuilderEntitiesByConfig(false)).toBe(FormCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect(getFormBuilderEntitiesByConfig(true)).toBe(FormCompanyEntities);
+    });
+    it('FormResult is shared between core and company entity sets (not company-scoped)', ()=>{
+        expect(getFormBuilderEntitiesByConfig(false)).toContain(FormResult);
+        expect(getFormBuilderEntitiesByConfig(true)).toContain(FormResult);
+    });
+});