@flusys/nestjs-form-builder 6.0.2 → 6.1.1

package/fesm/services/form-result.service.spec.js

@@ -0,0 +1,657 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { FormResult } from '../entities';
+import { FormAccessType } from '../enums/form-access-type.enum';
+import * as permissionUtils from '../utils/permission.utils';
+import { FormResultService } from './form-result.service';
+import { FormBuilderConfigService } from './form-builder-config.service';
+import { FormBuilderDataSourceProvider } from './form-builder-datasource.provider';
+jest.mock('../utils/permission.utils', ()=>({
+        validateUserPermissions: jest.fn()
+    }));
+function buildForm(overrides = {}) {
+    return {
+        id: 'form-uuid-1',
+        name: 'Customer Survey',
+        description: null,
+        slug: 'customer-survey',
+        schema: {
+            sections: [],
+            settings: {}
+        },
+        schemaVersion: 1,
+        accessType: FormAccessType.AUTHENTICATED,
+        actionGroups: null,
+        tags: null,
+        isActive: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function buildFormResult(overrides = {}) {
+    return {
+        id: 'result-uuid-1',
+        formId: 'form-uuid-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('FormResultService', ()=>{
+    let service;
+    let mockResultRepo;
+    let mockFormRepo;
+    let mockFormBuilderConfig;
+    async function buildService(companyFeatureEnabled = false) {
+        mockResultRepo = createMockRepository();
+        mockFormRepo = createMockRepository();
+        // `softRemove` isn't part of the shared repository mock's default method list — add it here.
+        mockResultRepo.softRemove = jest.fn();
+        // Extend the shared query-builder mock with the extra chain methods this service relies on
+        // (`innerJoin` for the company scoping join).
+        mockResultRepo.createQueryBuilder.mockReturnValue({
+            ...createMockQueryBuilder(),
+            innerJoin: jest.fn().mockReturnThis()
+        });
+        const mockDataSourceProvider = {
+            getRepository: jest.fn((entity)=>{
+                if (entity === FormResult) return Promise.resolve(mockResultRepo);
+                return Promise.resolve(mockFormRepo);
+            }),
+            getDataSource: jest.fn()
+        };
+        mockFormBuilderConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(companyFeatureEnabled)
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                FormResultService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: FormBuilderConfigService,
+                    useValue: mockFormBuilderConfig
+                },
+                {
+                    provide: FormBuilderDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(FormResultService);
+    }
+    afterEach(()=>{
+        jest.clearAllMocks();
+    });
+    // ==========================================================================
+    // getSelectQuery
+    // ==========================================================================
+    describe('getSelectQuery', ()=>{
+        it('applies the default field list, prefixed with the entity name', async ()=>{
+            await buildService(false);
+            const query = {
+                select: jest.fn().mockReturnThis()
+            };
+            await service.getSelectQuery(query, buildMockUser(), undefined);
+            expect(query.select).toHaveBeenCalledWith(expect.arrayContaining([
+                'form_result.id',
+                'form_result.formId',
+                'form_result.data',
+                'form_result.isDraft'
+            ]));
+        });
+        it('respects a custom select list', async ()=>{
+            await buildService(false);
+            const query = {
+                select: jest.fn().mockReturnThis()
+            };
+            await service.getSelectQuery(query, buildMockUser(), [
+                'id',
+                'data'
+            ]);
+            expect(query.select).toHaveBeenCalledWith([
+                'form_result.id',
+                'form_result.data'
+            ]);
+        });
+    });
+    // ==========================================================================
+    // getExtraManipulateQuery / applyCompanyFilterToQuery
+    // ==========================================================================
+    describe('getExtraManipulateQuery', ()=>{
+        it('joins the form table and filters by company when company feature is enabled', async ()=>{
+            await buildService(true);
+            const query = {
+                innerJoin: jest.fn().mockReturnThis(),
+                andWhere: jest.fn().mockReturnThis()
+            };
+            await service.getExtraManipulateQuery(query, {}, buildMockUser({
+                companyId: 'company-1'
+            }));
+            expect(query.innerJoin).toHaveBeenCalledWith('form', 'f', 'f.id = form_result.formId');
+            expect(query.andWhere).toHaveBeenCalledWith('f.company_id = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+        it('does not join when company feature is disabled', async ()=>{
+            await buildService(false);
+            const query = {
+                innerJoin: jest.fn().mockReturnThis(),
+                andWhere: jest.fn().mockReturnThis()
+            };
+            await service.getExtraManipulateQuery(query, {}, buildMockUser({
+                companyId: 'company-1'
+            }));
+            expect(query.innerJoin).not.toHaveBeenCalled();
+        });
+        it('does not join when the user has no companyId', async ()=>{
+            await buildService(true);
+            const query = {
+                innerJoin: jest.fn().mockReturnThis(),
+                andWhere: jest.fn().mockReturnThis()
+            };
+            await service.getExtraManipulateQuery(query, {}, buildMockUser({
+                companyId: undefined
+            }));
+            expect(query.innerJoin).not.toHaveBeenCalled();
+        });
+        it('does not join when there is no user (public queries)', async ()=>{
+            await buildService(true);
+            const query = {
+                innerJoin: jest.fn().mockReturnThis(),
+                andWhere: jest.fn().mockReturnThis()
+            };
+            await service.getExtraManipulateQuery(query, {}, null);
+            expect(query.innerJoin).not.toHaveBeenCalled();
+        });
+    });
+    // ==========================================================================
+    // convertEntityToResponseDto
+    // ==========================================================================
+    describe('convertEntityToResponseDto', ()=>{
+        it('maps entity fields to the response shape', async ()=>{
+            await buildService(false);
+            const entity = buildFormResult();
+            const dto = service.convertEntityToResponseDto(entity, false);
+            expect(dto).toMatchObject({
+                id: entity.id,
+                formId: entity.formId,
+                data: entity.data,
+                isDraft: false
+            });
+        });
+    });
+    // ==========================================================================
+    // submitForm
+    // ==========================================================================
+    describe('submitForm', ()=>{
+        it('throws NotFoundException when the form does not exist or is inactive', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(null);
+            await expect(service.submitForm({
+                formId: 'missing',
+                data: {}
+            }, buildMockUser(), false)).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'form.not.found'
+                })
+            });
+        });
+        it('rejects a public submission when the form is not marked PUBLIC', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                accessType: FormAccessType.AUTHENTICATED
+            }));
+            await expect(service.submitForm({
+                formId: 'form-uuid-1',
+                data: {}
+            }, null, true)).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'form.not.public'
+                })
+            });
+        });
+        it('allows a public submission to a PUBLIC form without a user', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                accessType: FormAccessType.PUBLIC
+            }));
+            mockResultRepo.save.mockResolvedValue(buildFormResult({
+                submittedById: null
+            }));
+            const result = await service.submitForm({
+                formId: 'form-uuid-1',
+                data: {
+                    field1: 'x'
+                }
+            }, null, true);
+            expect(mockResultRepo.findOne).not.toHaveBeenCalled();
+            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                formId: 'form-uuid-1',
+                submittedById: null,
+                isDraft: false
+            }));
+            expect(result.formId).toBe('form-uuid-1');
+        });
+        it('requires authentication for a non-public form submitted through the authenticated flow', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                accessType: FormAccessType.AUTHENTICATED
+            }));
+            await expect(service.submitForm({
+                formId: 'form-uuid-1',
+                data: {}
+            }, null, false)).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'form.auth.required'
+                })
+            });
+        });
+        it('allows submission to an ACTION_GROUP form when the user has the required permission', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                accessType: FormAccessType.ACTION_GROUP,
+                actionGroups: [
+                    'hr.submit'
+                ]
+            }));
+            permissionUtils.validateUserPermissions.mockResolvedValue(true);
+            mockResultRepo.findOne.mockResolvedValue(null);
+            mockResultRepo.save.mockResolvedValue(buildFormResult());
+            const result = await service.submitForm({
+                formId: 'form-uuid-1',
+                data: {}
+            }, buildMockUser(), false);
+            expect(result.formId).toBe('form-uuid-1');
+        });
+        it('rejects submission to an ACTION_GROUP form when the user lacks the required permission', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                accessType: FormAccessType.ACTION_GROUP,
+                actionGroups: [
+                    'hr.submit'
+                ]
+            }));
+            permissionUtils.validateUserPermissions.mockResolvedValue(false);
+            await expect(service.submitForm({
+                formId: 'form-uuid-1',
+                data: {}
+            }, buildMockUser(), false)).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'form.access.denied'
+                })
+            });
+        });
+        it('rejects submission for an unrecognized (non-AUTHENTICATED) access type', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                accessType: 'weird'
+            }));
+            await expect(service.submitForm({
+                formId: 'form-uuid-1',
+                data: {}
+            }, buildMockUser(), false)).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'form.invalid.access.type'
+                })
+            });
+        });
+        it('saves a new final submission with a schema snapshot and computed fields', async ()=>{
+            await buildService(false);
+            const form = buildForm({
+                schema: {
+                    settings: {
+                        computedFields: [
+                            {
+                                id: 'cf-1',
+                                name: 'Total',
+                                key: 'total',
+                                valueType: 'number',
+                                rules: [
+                                    {
+                                        id: 'r1',
+                                        computation: {
+                                            type: 'direct',
+                                            config: {
+                                                type: 'direct',
+                                                value: 99
+                                            }
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            });
+            mockFormRepo.findOne.mockResolvedValue(form);
+            mockResultRepo.findOne.mockResolvedValue(null);
+            mockResultRepo.save.mockResolvedValue(buildFormResult());
+            await service.submitForm({
+                formId: 'form-uuid-1',
+                data: {
+                    field1: 'x'
+                }
+            }, buildMockUser(), false);
+            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                schemaVersionSnapshot: form.schema,
+                schemaVersion: form.schemaVersion,
+                data: {
+                    field1: 'x',
+                    _computed: {
+                        total: 99
+                    }
+                },
+                isDraft: false
+            }));
+        });
+        it('does not compute fields when saving as a draft', async ()=>{
+            await buildService(false);
+            const form = buildForm({
+                schema: {
+                    settings: {
+                        computedFields: [
+                            {
+                                id: 'cf-1',
+                                name: 'Total',
+                                key: 'total',
+                                valueType: 'number',
+                                rules: [
+                                    {
+                                        id: 'r1',
+                                        computation: {
+                                            type: 'direct',
+                                            config: {
+                                                type: 'direct',
+                                                value: 99
+                                            }
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            });
+            mockFormRepo.findOne.mockResolvedValue(form);
+            mockResultRepo.findOne.mockResolvedValue(null);
+            mockResultRepo.save.mockResolvedValue(buildFormResult({
+                isDraft: true
+            }));
+            await service.submitForm({
+                formId: 'form-uuid-1',
+                data: {
+                    field1: 'x'
+                },
+                isDraft: true
+            }, buildMockUser(), false);
+            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                data: {
+                    field1: 'x'
+                },
+                isDraft: true
+            }));
+        });
+        it('replaces an existing draft with the final submission (soft-removes the draft, inserts a new record)', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm());
+            const existingDraft = buildFormResult({
+                id: 'draft-1',
+                isDraft: true
+            });
+            mockResultRepo.findOne.mockResolvedValue(existingDraft);
+            mockResultRepo.save.mockResolvedValue(buildFormResult({
+                id: 'final-1',
+                isDraft: false
+            }));
+            const result = await service.submitForm({
+                formId: 'form-uuid-1',
+                data: {
+                    field1: 'y'
+                }
+            }, buildMockUser(), false);
+            expect(mockResultRepo.softRemove).toHaveBeenCalledWith(existingDraft);
+            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                formId: 'form-uuid-1',
+                isDraft: false
+            }));
+            expect(result.id).toBe('final-1');
+        });
+        it('updates an existing draft in place when re-submitting as a draft', async ()=>{
+            await buildService(false);
+            mockFormRepo.findOne.mockResolvedValue(buildForm());
+            const existingDraft = buildFormResult({
+                id: 'draft-1',
+                isDraft: true
+            });
+            mockResultRepo.findOne.mockResolvedValue(existingDraft);
+            mockResultRepo.save.mockResolvedValue({
+                ...existingDraft,
+                data: {
+                    field1: 'z'
+                }
+            });
+            await service.submitForm({
+                formId: 'form-uuid-1',
+                data: {
+                    field1: 'z'
+                },
+                isDraft: true
+            }, buildMockUser(), false);
+            expect(mockResultRepo.softRemove).not.toHaveBeenCalled();
+            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'draft-1',
+                data: {
+                    field1: 'z'
+                }
+            }));
+        });
+    });
+    // ==========================================================================
+    // getMyDraft
+    // ==========================================================================
+    describe('getMyDraft', ()=>{
+        it('returns the most recent draft for the user', async ()=>{
+            await buildService(false);
+            mockResultRepo.findOne.mockResolvedValue(buildFormResult({
+                isDraft: true
+            }));
+            const result = await service.getMyDraft('form-uuid-1', buildMockUser());
+            expect(result?.isDraft).toBe(true);
+            expect(mockResultRepo.findOne).toHaveBeenCalledWith(expect.objectContaining({
+                where: expect.objectContaining({
+                    formId: 'form-uuid-1',
+                    isDraft: true
+                })
+            }));
+        });
+        it('returns null when the user has no draft', async ()=>{
+            await buildService(false);
+            mockResultRepo.findOne.mockResolvedValue(null);
+            const result = await service.getMyDraft('form-uuid-1', buildMockUser());
+            expect(result).toBeNull();
+        });
+    });
+    // ==========================================================================
+    // updateDraft
+    // ==========================================================================
+    describe('updateDraft', ()=>{
+        it('throws NotFoundException when the draft does not exist or does not belong to the user', async ()=>{
+            await buildService(false);
+            mockResultRepo.findOne.mockResolvedValue(null);
+            await expect(service.updateDraft('missing-draft', {
+                formId: 'form-uuid-1',
+                data: {}
+            }, buildMockUser())).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'form.result.not.found'
+                })
+            });
+        });
+        it('updates the draft with the latest form schema snapshot and data', async ()=>{
+            await buildService(false);
+            const existingDraft = buildFormResult({
+                id: 'draft-1',
+                isDraft: true
+            });
+            mockResultRepo.findOne.mockResolvedValue(existingDraft);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                schemaVersion: 2
+            }));
+            mockResultRepo.save.mockResolvedValue({
+                ...existingDraft,
+                schemaVersion: 2
+            });
+            const result = await service.updateDraft('draft-1', {
+                formId: 'form-uuid-1',
+                data: {
+                    field1: 'updated'
+                }
+            }, buildMockUser());
+            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'draft-1',
+                schemaVersion: 2
+            }));
+            expect(result).toBeDefined();
+        });
+        it('finalizes a draft (isDraft=false) and applies computed fields', async ()=>{
+            await buildService(false);
+            const existingDraft = buildFormResult({
+                id: 'draft-1',
+                isDraft: true
+            });
+            mockResultRepo.findOne.mockResolvedValue(existingDraft);
+            mockFormRepo.findOne.mockResolvedValue(buildForm({
+                schema: {
+                    settings: {
+                        computedFields: [
+                            {
+                                id: 'cf-1',
+                                name: 'Total',
+                                key: 'total',
+                                valueType: 'number',
+                                rules: [
+                                    {
+                                        id: 'r1',
+                                        computation: {
+                                            type: 'direct',
+                                            config: {
+                                                type: 'direct',
+                                                value: 7
+                                            }
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            }));
+            mockResultRepo.save.mockResolvedValue(buildFormResult({
+                id: 'draft-1',
+                isDraft: false
+            }));
+            await service.updateDraft('draft-1', {
+                formId: 'form-uuid-1',
+                data: {
+                    field1: 'final'
+                },
+                isDraft: false
+            }, buildMockUser());
+            expect(mockResultRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                data: {
+                    field1: 'final',
+                    _computed: {
+                        total: 7
+                    }
+                },
+                isDraft: false
+            }));
+        });
+    });
+    // ==========================================================================
+    // getByFormId
+    // ==========================================================================
+    describe('getByFormId', ()=>{
+        it('returns paginated results scoped to the given form', async ()=>{
+            await buildService(false);
+            const qb = mockResultRepo.createQueryBuilder();
+            qb.getManyAndCount.mockResolvedValue([
+                [
+                    buildFormResult()
+                ],
+                1
+            ]);
+            const result = await service.getByFormId('form-uuid-1', buildMockUser(), {
+                page: 0,
+                pageSize: 10
+            });
+            expect(qb.where).toHaveBeenCalledWith('form_result.formId = :formId', {
+                formId: 'form-uuid-1'
+            });
+            expect(result.total).toBe(1);
+            expect(result.data).toHaveLength(1);
+        });
+        it('applies default pagination when none is provided', async ()=>{
+            await buildService(false);
+            const qb = mockResultRepo.createQueryBuilder();
+            qb.getManyAndCount.mockResolvedValue([
+                [],
+                0
+            ]);
+            await service.getByFormId('form-uuid-1', buildMockUser());
+            expect(qb.skip).toHaveBeenCalledWith(0);
+            expect(qb.take).toHaveBeenCalledWith(10);
+        });
+    });
+    // ==========================================================================
+    // hasUserSubmitted
+    // ==========================================================================
+    describe('hasUserSubmitted', ()=>{
+        it('returns true when a non-draft submission exists', async ()=>{
+            await buildService(false);
+            mockResultRepo.count.mockResolvedValue(1);
+            const result = await service.hasUserSubmitted('form-uuid-1', buildMockUser());
+            expect(result).toBe(true);
+            expect(mockResultRepo.count).toHaveBeenCalledWith(expect.objectContaining({
+                where: expect.objectContaining({
+                    formId: 'form-uuid-1',
+                    isDraft: false
+                })
+            }));
+        });
+        it('returns false when no non-draft submission exists', async ()=>{
+            await buildService(false);
+            mockResultRepo.count.mockResolvedValue(0);
+            const result = await service.hasUserSubmitted('form-uuid-1', buildMockUser());
+            expect(result).toBe(false);
+        });
+    });
+});