@flusys/nestjs-form-builder 7.1.0 → 8.0.0

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

@@ -1,253 +0,0 @@
-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.js

@@ -1,221 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController, FORM_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { CurrentUser, Public, RequirePermission } from '@flusys/nestjs-shared/decorators';
-import { JwtAuthGuard, PermissionGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Controller, HttpCode, HttpStatus, Inject, Param, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { FORM_MESSAGES } from '../config';
-import { CreateFormDto, FormResponseDto, UpdateFormDto } from '../dtos';
-import { FormService } from '../services/form.service';
-export class FormController extends createApiController(CreateFormDto, UpdateFormDto, FormResponseDto, {
-    entityName: 'form',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                FORM_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                FORM_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                FORM_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                FORM_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                FORM_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                FORM_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                FORM_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    // Public Endpoints
-    /**
-   * Get form access info (no authentication required)
-   */ async getFormAccessInfo(id) {
-        const data = await this.formService.getFormAccessInfo(id);
-        return {
-            success: true,
-            message: 'Form access info retrieved',
-            messageKey: FORM_MESSAGES.GET_ACCESS_INFO_SUCCESS,
-            data
-        };
-    }
-    async getPublicForm(id) {
-        const data = await this.formService.getPublicForm(id);
-        return {
-            success: true,
-            message: 'Form retrieved',
-            messageKey: FORM_MESSAGES.GET_SUCCESS,
-            data
-        };
-    }
-    async getAuthenticatedForm(id, user) {
-        const data = await this.formService.getAuthenticatedForm(id, user);
-        return {
-            success: true,
-            message: 'Form retrieved',
-            messageKey: FORM_MESSAGES.GET_SUCCESS,
-            data
-        };
-    }
-    async getBySlug(slug, _user) {
-        const data = await this.formService.getBySlug(slug);
-        return {
-            success: true,
-            message: 'Form retrieved',
-            messageKey: FORM_MESSAGES.GET_SUCCESS,
-            data
-        };
-    }
-    async getPublicFormBySlug(slug) {
-        const data = await this.formService.getPublicFormBySlug(slug);
-        return {
-            success: true,
-            message: 'Form retrieved',
-            messageKey: FORM_MESSAGES.GET_SUCCESS,
-            data
-        };
-    }
-    constructor(formService){
-        super(formService), _define_property(this, "formService", void 0), this.formService = formService;
-    }
-}
-_ts_decorate([
-    Post('access-info/:id'),
-    Public(),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Get form access info (no auth required)'
-    }),
-    _ts_param(0, Param('id')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], FormController.prototype, "getFormAccessInfo", null);
-_ts_decorate([
-    Post('public/:id'),
-    Public(),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Get public form for submission (no auth required)'
-    }),
-    _ts_param(0, Param('id')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], FormController.prototype, "getPublicForm", null);
-_ts_decorate([
-    Post('authenticated/:id'),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Get form for authenticated submission'
-    }),
-    _ts_param(0, Param('id')),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], FormController.prototype, "getAuthenticatedForm", null);
-_ts_decorate([
-    Post('by-slug/:slug'),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    ApiBearerAuth(),
-    RequirePermission(FORM_PERMISSIONS.READ),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Get form by slug'
-    }),
-    _ts_param(0, Param('slug')),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], FormController.prototype, "getBySlug", null);
-_ts_decorate([
-    Post('public/by-slug/:slug'),
-    Public(),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Get public form by slug (no auth required)'
-    }),
-    _ts_param(0, Param('slug')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], FormController.prototype, "getPublicFormBySlug", null);
-FormController = _ts_decorate([
-    ApiTags('Form Builder - Forms'),
-    Controller('form-builder/form'),
-    _ts_param(0, Inject(FormService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof FormService === "undefined" ? Object : FormService
-    ])
-], FormController);

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

@@ -1,208 +0,0 @@
-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);
-        });
-    });
-});