@flusys/nestjs-form-builder 6.0.1 → 6.1.0

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

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _formresultcontroller = require("./form-result.controller");
+const _formresultservice = require("../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 _testing.Test.createTestingModule({
+            controllers: [
+                _formresultcontroller.FormResultController
+            ],
+            // UtilsService is a real (dependency-free) provider — required to satisfy the
+            // Slug interceptor applied by the inherited insert/update endpoints.
+            providers: [
+                {
+                    provide: _formresultservice.FormResultService,
+                    useValue: mockService
+                },
+                _modules.UtilsService
+            ]
+        }).compile();
+        controller = module.get(_formresultcontroller.FormResultController);
+    });
+    afterEach(()=>{
+        jest.clearAllMocks();
+    });
+    describe('submitForm', ()=>{
+        it('submits on behalf of the authenticated user (isPublic=false)', async ()=>{
+            const user = (0, _loggedusermock.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: {}
+            }, (0, _loggedusermock.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 = (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toBeNull();
+        });
+    });
+    describe('updateDraft', ()=>{
+        it('updates the identified draft', async ()=>{
+            const user = (0, _loggedusermock.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
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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 = (0, _loggedusermock.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/cjs/controllers/form.controller.spec.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _formaccesstypeenum = require("../enums/form-access-type.enum");
+const _formcontroller = require("./form.controller");
+const _formservice = require("../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 _testing.Test.createTestingModule({
+            controllers: [
+                _formcontroller.FormController
+            ],
+            // UtilsService is a real (dependency-free) provider — required to satisfy the
+            // Slug interceptor applied by the inherited insert/update endpoints.
+            providers: [
+                {
+                    provide: _formservice.FormService,
+                    useValue: mockService
+                },
+                _modules.UtilsService
+            ]
+        }).compile();
+        controller = module.get(_formcontroller.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: _formaccesstypeenum.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: _formaccesstypeenum.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 = (0, _loggedusermock.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: _formaccesstypeenum.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', (0, _loggedusermock.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', (0, _loggedusermock.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: _formaccesstypeenum.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 = (0, _loggedusermock.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 = (0, _loggedusermock.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/cjs/docs/form-builder-swagger.config.spec.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _formbuilderswaggerconfig = require("./form-builder-swagger.config");
+describe('formBuilderSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = (0, _formbuilderswaggerconfig.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 = (0, _formbuilderswaggerconfig.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 = (0, _formbuilderswaggerconfig.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 = (0, _formbuilderswaggerconfig.formBuilderSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = (0, _formbuilderswaggerconfig.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 = (0, _formbuilderswaggerconfig.formBuilderSwaggerConfig)({
+            databaseMode: 'multi-tenant'
+        });
+        const single = (0, _formbuilderswaggerconfig.formBuilderSwaggerConfig)({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+const _formresultentity = require("./form-result.entity");
+describe('getFormBuilderEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect((0, _index.getFormBuilderEntitiesByConfig)(false)).toBe(_index.FormCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect((0, _index.getFormBuilderEntitiesByConfig)(true)).toBe(_index.FormCompanyEntities);
+    });
+    it('FormResult is shared between core and company entity sets (not company-scoped)', ()=>{
+        expect((0, _index.getFormBuilderEntitiesByConfig)(false)).toContain(_formresultentity.FormResult);
+        expect((0, _index.getFormBuilderEntitiesByConfig)(true)).toContain(_formresultentity.FormResult);
+    });
+});