@flusys/nestjs-form-builder 7.1.0 → 8.0.0

package/fesm/services/form.service.js

@@ -1,331 +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 { envConfig } from '@flusys/nestjs-core';
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
-import { BadRequestException, ForbiddenException, Inject, Injectable, NotFoundException, Scope, UnauthorizedException } from '@nestjs/common';
-import { IsNull } from 'typeorm';
-import { FORM_BUILDER_EVENT_ENTITIES, FORM_BUILDER_EVENT_MODULE, FORM_MESSAGES } from '../config';
-import { Form, FormWithCompany } from '../entities';
-import { FormAccessType } from '../enums/form-access-type.enum';
-import { validateUserPermissions } from '../utils/permission.utils';
-import { FormBuilderConfigService } from './form-builder-config.service';
-import { FormBuilderDataSourceProvider } from './form-builder-datasource.provider';
-export class FormService extends ApiService {
-    // Entity Conversion
-    async convertSingleDtoToEntity(dto, user) {
-        let form = {};
-        let isUpdate = false;
-        // NOTE: Using 'id' in dto check instead of instanceof - instanceof may not work after esbuild bundling
-        if ('id' in dto && dto.id && typeof dto.id === 'string') {
-            const dbData = await this.repository.findOne({
-                where: {
-                    id: dto.id
-                }
-            });
-            if (!dbData) {
-                throw new NotFoundException({
-                    message: 'Form not found',
-                    messageKey: FORM_MESSAGES.NOT_FOUND
-                });
-            }
-            form = dbData;
-            isUpdate = true;
-            // Auto-increment schema version if schema changed
-            if (dto.schema && JSON.stringify(dto.schema) !== JSON.stringify(form.schema)) {
-                dto.schemaVersion = form.schemaVersion + 1;
-            }
-        }
-        // Merge DTO into form
-        form = {
-            ...form,
-            ...dto
-        };
-        // Set company context if enabled
-        const enableCompanyFeature = this.formBuilderConfig.isCompanyFeatureEnabled();
-        if (enableCompanyFeature) {
-            if (isUpdate) {
-                // During update: Only set companyId if explicitly provided
-                if (dto.companyId !== undefined) {
-                    form.companyId = dto.companyId;
-                }
-                // If companyId is not in form at all, set from user
-                if (form.companyId === undefined) {
-                    form.companyId = user?.companyId ?? null;
-                }
-            } else {
-                // During creation: Use DTO's companyId if provided, otherwise use user's
-                form.companyId = dto.companyId ?? user?.companyId ?? null;
-            }
-        }
-        return form;
-    }
-    async getSelectQuery(query, _user, select) {
-        if (!select || !select.length) {
-            select = [
-                'id',
-                'name',
-                'description',
-                'slug',
-                'schema',
-                'schemaVersion',
-                'accessType',
-                'actionGroups',
-                'tags',
-                'isActive',
-                'createdAt',
-                'updatedAt'
-            ];
-        }
-        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
-        // Add company context fields if company feature is enabled
-        if (this.formBuilderConfig.isCompanyFeatureEnabled()) {
-            selectFields.push('form.companyId');
-        }
-        query.select(selectFields);
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    // Supports filtering by one or more tags (array-contains-all) via the generic get-all filter,
-    // e.g. { filter: { tags: ['survey', 'review'] } }, since tags is a JSON array column.
-    async getFilterQuery(query, filter, user) {
-        const { tags, ...rest } = filter;
-        if (tags !== undefined && tags !== null) {
-            const tagList = (Array.isArray(tags) ? tags : [
-                tags
-            ]).map(String);
-            if (tagList.length > 0) {
-                this.applyTagFilter(query, tagList);
-            }
-        }
-        return super.getFilterQuery(query, rest, user);
-    }
-    applyTagFilter(query, tags) {
-        const driver = envConfig.getTypeOrmConfig().type;
-        if (driver === 'postgres') {
-            query.andWhere(`${this.entityName}.tags @> :tagValues::jsonb`, {
-                tagValues: JSON.stringify(tags)
-            });
-        } else if (driver === 'mysql') {
-            query.andWhere(`JSON_CONTAINS(${this.entityName}.tags, :tagValues)`, {
-                tagValues: JSON.stringify(tags)
-            });
-        } else {
-            tags.forEach((tag, index)=>{
-                query.andWhere(`${this.entityName}.tags LIKE :tagValue${index}`, {
-                    [`tagValue${index}`]: `%"${tag}"%`
-                });
-            });
-        }
-    }
-    async getExtraManipulateQuery(query, filterDto, user) {
-        const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        // Apply company filter using shared utility
-        applyCompanyFilter(query, {
-            isCompanyFeatureEnabled: this.formBuilderConfig.isCompanyFeatureEnabled(),
-            entityAlias: 'form'
-        }, user);
-        return result;
-    }
-    convertEntityToResponseDto(entity, _isRaw) {
-        // Type guard for company-enabled entity
-        const entityWithCompany = entity;
-        return {
-            id: entity.id,
-            name: entity.name,
-            description: entity.description,
-            slug: entity.slug,
-            schema: entity.schema,
-            schemaVersion: entity.schemaVersion,
-            accessType: entity.accessType,
-            actionGroups: entity.actionGroups,
-            tags: entity.tags,
-            isActive: entity.isActive,
-            companyId: entityWithCompany.companyId ?? null,
-            createdAt: entity.createdAt,
-            updatedAt: entity.updatedAt,
-            deletedAt: entity.deletedAt,
-            createdById: entity.createdById,
-            updatedById: entity.updatedById,
-            deletedById: entity.deletedById
-        };
-    }
-    toPublicForm(form) {
-        return {
-            id: form.id,
-            name: form.name,
-            description: form.description,
-            schema: form.schema,
-            schemaVersion: form.schemaVersion
-        };
-    }
-    async findPublicActiveForm(where) {
-        await this.ensureDataSourceRepository();
-        return await this.repository.findOne({
-            where: {
-                ...where,
-                accessType: FormAccessType.PUBLIC,
-                isActive: true,
-                deletedAt: IsNull()
-            }
-        });
-    }
-    // Public Form Access
-    async getPublicForm(formId) {
-        const form = await this.findPublicActiveForm({
-            id: formId
-        });
-        if (!form) {
-            throw new NotFoundException({
-                message: 'Form not found or not available for public access',
-                messageKey: FORM_MESSAGES.NOT_PUBLIC
-            });
-        }
-        return this.toPublicForm(form);
-    }
-    async getFormForSubmission(formId, user) {
-        await this.ensureDataSourceRepository();
-        const form = await this.repository.findOne({
-            where: {
-                id: formId,
-                isActive: true,
-                deletedAt: IsNull()
-            }
-        });
-        if (!form) {
-            throw new NotFoundException({
-                message: 'Form not found or inactive',
-                messageKey: FORM_MESSAGES.NOT_FOUND
-            });
-        }
-        // Access validation based on accessType
-        if (form.accessType === FormAccessType.PUBLIC) {
-            return form; // Anyone can access
-        }
-        // All non-public forms require authentication
-        if (!user) {
-            throw new UnauthorizedException({
-                message: 'Authentication required to submit this form',
-                messageKey: FORM_MESSAGES.AUTH_REQUIRED
-            });
-        }
-        if (form.accessType === FormAccessType.AUTHENTICATED || form.accessType === FormAccessType.ACTION_GROUP) {
-            return form; // Permission check for ACTION_GROUP is handled by the controller/guard
-        }
-        throw new BadRequestException({
-            message: 'Invalid access type',
-            messageKey: FORM_MESSAGES.INVALID_ACCESS_TYPE
-        });
-    }
-    async getBySlug(slug) {
-        await this.ensureDataSourceRepository();
-        const form = await this.repository.findOne({
-            where: {
-                slug,
-                deletedAt: IsNull()
-            }
-        });
-        return form ? this.convertEntityToResponseDto(form, false) : null;
-    }
-    /**
-   * Get public form by slug (no authentication required)
-   * Returns null if form doesn't exist, is not public, or is inactive
-   */ async getPublicFormBySlug(slug) {
-        const form = await this.findPublicActiveForm({
-            slug
-        });
-        return form ? this.toPublicForm(form) : null;
-    }
-    async getFormAccessInfo(formId) {
-        await this.ensureDataSourceRepository();
-        const form = await this.repository.findOne({
-            where: {
-                id: formId,
-                deletedAt: IsNull()
-            },
-            select: [
-                'id',
-                'name',
-                'description',
-                'accessType',
-                'actionGroups',
-                'isActive'
-            ]
-        });
-        if (!form) {
-            throw new NotFoundException({
-                message: 'Form not found',
-                messageKey: FORM_MESSAGES.NOT_FOUND
-            });
-        }
-        return {
-            id: form.id,
-            name: form.name,
-            description: form.description,
-            accessType: form.accessType,
-            actionGroups: form.actionGroups,
-            isActive: form.isActive
-        };
-    }
-    async getAuthenticatedForm(formId, user) {
-        const form = await this.getFormForSubmission(formId, user);
-        // For action_group access, check permissions from cache
-        if (form.accessType === FormAccessType.ACTION_GROUP && form.actionGroups?.length) {
-            const hasPermission = await validateUserPermissions(user, form.actionGroups, this.cacheManager, this.formBuilderConfig.isCompanyFeatureEnabled());
-            if (!hasPermission) {
-                throw new ForbiddenException({
-                    message: 'You do not have permission to access this form',
-                    messageKey: FORM_MESSAGES.ACCESS_DENIED
-                });
-            }
-        }
-        return this.toPublicForm(form);
-    }
-    constructor(cacheManager, utilsService, formBuilderConfig, dataSourceProvider){
-        super(FORM_BUILDER_EVENT_ENTITIES.FORM, cacheManager, utilsService, FormService.name, true, FORM_BUILDER_EVENT_MODULE, dataSourceProvider, formBuilderConfig.isCompanyFeatureEnabled() ? FormWithCompany : Form), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "formBuilderConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.formBuilderConfig = formBuilderConfig;
-    }
-}
-FormService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(FormBuilderConfigService)),
-    _ts_param(3, Inject(FormBuilderDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof FormBuilderConfigService === "undefined" ? Object : FormBuilderConfigService,
-        typeof FormBuilderDataSourceProvider === "undefined" ? Object : FormBuilderDataSourceProvider
-    ])
-], FormService);