@flusys/nestjs-form-builder 1.1.0-beta → 1.1.0

package/cjs/services/form-builder-config.service.js

@@ -39,29 +39,19 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let FormBuilderConfigService = class FormBuilderConfigService {
-    /**
-   * Check if company feature is enabled
-   */ isCompanyFeatureEnabled() {
-        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    isCompanyFeatureEnabled(tenant) {
+        return tenant?.enableCompanyFeature ?? this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
     }
-    /**
-   * Get database mode
-   */ getDatabaseMode() {
+    getDatabaseMode() {
         return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
     }
-    /**
-   * Check if multi-tenant mode is enabled
-   */ isMultiTenant() {
+    isMultiTenant() {
         return this.getDatabaseMode() === 'multi-tenant';
     }
-    /**
-   * Get module options
-   */ getOptions() {
+    getOptions() {
         return this.options;
     }
-    /**
-   * Get form builder configuration
-   */ getConfig() {
+    getConfig() {
         return this.options.config;
     }
     constructor(options){

package/cjs/services/form-builder-datasource.provider.js

@@ -12,8 +12,7 @@ const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
 const _core = require("@nestjs/core");
 const _express = require("express");
-const _interfaces = require("../interfaces");
-const _formbuilderconstants = require("../config/form-builder.constants");
+const _formbuilderconfigservice = require("./form-builder-config.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -83,66 +82,28 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let FormBuilderDataSourceProvider = class FormBuilderDataSourceProvider extends _modules.MultiTenantDataSourceService {
-    // Factory Methods
-    /**
-   * Build parent options from FormBuilderModuleOptions
-   */ static buildParentOptions(options) {
+    static buildParentOptions(options) {
         return {
             bootstrapAppConfig: options.bootstrapAppConfig,
-            defaultDatabaseConfig: options.config?.defaultDatabaseConfig
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
         };
     }
-    // Feature Flags
-    /**
-   * Get global enable company feature flag
-   */ getEnableCompanyFeature() {
-        return this.formBuilderOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    async getFormBuilderEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+        const { getFormBuilderEntitiesByConfig } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
+        return getFormBuilderEntitiesByConfig(enable);
     }
-    /**
-   * Get enable company feature for specific tenant
-   * Falls back to global setting if not specified per-tenant
-   */ getEnableCompanyFeatureForTenant(tenant) {
-        return tenant?.enableCompanyFeature ?? this.getEnableCompanyFeature();
-    }
-    /**
-   * Get enable company feature for current request context
-   */ getEnableCompanyFeatureForCurrentTenant() {
-        return this.getEnableCompanyFeatureForTenant(this.getCurrentTenant() ?? undefined);
-    }
-    // Entity Management
-    /**
-   * Get form builder entities based on company feature flag
-   */ async getFormBuilderEntities(enableCompanyFeature) {
-        const enable = enableCompanyFeature ?? this.getEnableCompanyFeature();
-        const { Form, FormResult, FormWithCompany } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
-        if (enable) {
-            return [
-                FormWithCompany,
-                FormResult
-            ];
-        }
-        return [
-            Form,
-            FormResult
-        ];
-    }
-    // Overrides
-    /**
-   * Override to dynamically set entities based on tenant config
-   */ async createDataSourceFromConfig(config) {
-        const currentTenant = this.getCurrentTenant();
-        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+    async createDataSourceFromConfig(config) {
+        const enableCompanyFeature = this.configService.isCompanyFeatureEnabled(this.getCurrentTenant() ?? undefined);
         const entities = await this.getFormBuilderEntities(enableCompanyFeature);
         return super.createDataSourceFromConfig(config, entities);
     }
-    /**
-   * Override to use FormBuilder-specific static cache
-   */ async getSingleDataSource() {
-        // Return existing initialized connection from FormBuilder-specific cache
+    async getSingleDataSource() {
         if (FormBuilderDataSourceProvider.singleDataSource?.isInitialized) {
             return FormBuilderDataSourceProvider.singleDataSource;
         }
-        // If another request is creating the connection, wait for it
         if (FormBuilderDataSourceProvider.singleConnectionLock) {
             return FormBuilderDataSourceProvider.singleConnectionLock;
         }
@@ -150,7 +111,6 @@ let FormBuilderDataSourceProvider = class FormBuilderDataSourceProvider extends
         if (!config) {
             throw new Error('No database config available. Provide defaultDatabaseConfig in FormBuilderModule options.');
         }
-        // Create connection with lock to prevent race conditions
         const connectionPromise = this.createDataSourceFromConfig(config);
         FormBuilderDataSourceProvider.singleConnectionLock = connectionPromise;
         try {
@@ -161,20 +121,15 @@ let FormBuilderDataSourceProvider = class FormBuilderDataSourceProvider extends
             FormBuilderDataSourceProvider.singleConnectionLock = null;
         }
     }
-    /**
-   * Override to use FormBuilder-specific static cache for tenant connections
-   */ async getOrCreateTenantConnection(tenant) {
-        // Return existing initialized connection from FormBuilder-specific cache
+    async getOrCreateTenantConnection(tenant) {
         const existing = FormBuilderDataSourceProvider.tenantConnections.get(tenant.id);
         if (existing?.isInitialized) {
             return existing;
         }
-        // If another request is creating this tenant's connection, wait for it
         const pendingConnection = FormBuilderDataSourceProvider.connectionLocks.get(tenant.id);
         if (pendingConnection) {
             return pendingConnection;
         }
-        // Create connection with lock to prevent race conditions
         const config = this.buildTenantDatabaseConfig(tenant);
         const connectionPromise = this.createDataSourceFromConfig(config);
         FormBuilderDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
@@ -186,11 +141,10 @@ let FormBuilderDataSourceProvider = class FormBuilderDataSourceProvider extends
             FormBuilderDataSourceProvider.connectionLocks.delete(tenant.id);
         }
     }
-    constructor(formBuilderOptions, request){
-        super(FormBuilderDataSourceProvider.buildParentOptions(formBuilderOptions), request), _define_property(this, "formBuilderOptions", void 0), _define_property(this, "logger", void 0), this.formBuilderOptions = formBuilderOptions, this.logger = new _common.Logger(FormBuilderDataSourceProvider.name);
+    constructor(configService, request){
+        super(FormBuilderDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), _define_property(this, "logger", void 0), this.configService = configService, this.logger = new _common.Logger(FormBuilderDataSourceProvider.name);
     }
 };
-// Override parent's static properties to have FormBuilder-specific cache
 _define_property(FormBuilderDataSourceProvider, "tenantConnections", new Map());
 _define_property(FormBuilderDataSourceProvider, "singleDataSource", null);
 _define_property(FormBuilderDataSourceProvider, "tenantsRegistry", new Map());
@@ -201,12 +155,12 @@ FormBuilderDataSourceProvider = _ts_decorate([
     (0, _common.Injectable)({
         scope: _common.Scope.REQUEST
     }),
-    _ts_param(0, (0, _common.Inject)(_formbuilderconstants.FORM_BUILDER_MODULE_OPTIONS)),
+    _ts_param(0, (0, _common.Inject)(_formbuilderconfigservice.FormBuilderConfigService)),
     _ts_param(1, (0, _common.Optional)()),
     _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _interfaces.FormBuilderModuleOptions === "undefined" ? Object : _interfaces.FormBuilderModuleOptions,
+        typeof _formbuilderconfigservice.FormBuilderConfigService === "undefined" ? Object : _formbuilderconfigservice.FormBuilderConfigService,
         typeof _express.Request === "undefined" ? Object : _express.Request
     ])
 ], FormBuilderDataSourceProvider);

package/cjs/services/form-result.service.js

@@ -46,27 +46,68 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let FormResultService = class FormResultService extends _classes.RequestScopedApiService {
-    /**
-   * Resolve entity class for this service
-   * @returns FormResult (same entity regardless of company feature)
-   */ resolveEntity() {
+    resolveEntity() {
         return _entities.FormResult;
     }
-    /**
-   * Get DataSource provider for this service
-   * @returns FormBuilderDataSourceProvider instance
-   */ getDataSourceProvider() {
+    getDataSourceProvider() {
         return this.dataSourceProvider;
     }
-    /**
-   * Initialize form repository for form lookups
-   */ async ensureFormRepositoryInitialized() {
+    async ensureFormRepositoryInitialized() {
         if (!this.formRepository) {
             const enableCompanyFeature = this.formBuilderConfig.isCompanyFeatureEnabled();
             const formEntity = enableCompanyFeature ? _entities.FormWithCompany : _entities.Form;
             this.formRepository = await this.dataSourceProvider.getRepository(formEntity);
         }
     }
+    async getActiveForm(formId) {
+        await this.ensureFormRepositoryInitialized();
+        const form = await this.formRepository.findOne({
+            where: {
+                id: formId,
+                isActive: true,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!form) {
+            throw new _common.NotFoundException('Form not found or inactive');
+        }
+        return form;
+    }
+    applyCompanyFilterToQuery(query, user) {
+        if (this.formBuilderConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            query.innerJoin('form', 'f', 'f.id = form_result.formId').andWhere('f.company_id = :companyId', {
+                companyId: user.companyId
+            });
+        }
+    }
+    async validateSubmissionAccess(form, user, isPublic) {
+        if (isPublic) {
+            if (form.accessType !== _formaccesstypeenum.FormAccessType.PUBLIC) {
+                throw new _common.UnauthorizedException('This form is not available for public submission');
+            }
+            return;
+        }
+        if (form.accessType === _formaccesstypeenum.FormAccessType.PUBLIC) return;
+        if (!user) {
+            throw new _common.UnauthorizedException('Authentication required to submit this form');
+        }
+        if (form.accessType === _formaccesstypeenum.FormAccessType.ACTION_GROUP && form.actionGroups?.length) {
+            const hasPermission = await (0, _permissionutils.validateUserPermissions)(user, form.actionGroups, this.cacheManager, this.formBuilderConfig.isCompanyFeatureEnabled(), this.logger, 'submitting form', form.id);
+            if (!hasPermission) {
+                throw new _common.ForbiddenException('You do not have permission to submit this form');
+            }
+        } else if (form.accessType !== _formaccesstypeenum.FormAccessType.AUTHENTICATED) {
+            throw new _common.BadRequestException('Invalid form access type');
+        }
+    }
+    buildUserDraftWhere(formId, userId) {
+        return {
+            formId,
+            submittedById: userId,
+            isDraft: true,
+            deletedAt: (0, _typeorm.IsNull)()
+        };
+    }
     // Query Customization
     async getSelectQuery(query, _user, select) {
         if (!select || !select.length) {
@@ -91,22 +132,28 @@ let FormResultService = class FormResultService extends _classes.RequestScopedAp
             isRaw: false
         };
     }
-    /**
-   * Override: Extra query manipulation - Auto-filter by user's company via Form
-   */ async getExtraManipulateQuery(query, filterDto, user) {
+    async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        // If company feature enabled and user has companyId, filter via Form's company
-        const enableCompanyFeature = this.formBuilderConfig.isCompanyFeatureEnabled();
-        if (enableCompanyFeature && user?.companyId) {
-            query.innerJoin('form', 'f', 'f.id = form_result.formId').andWhere('f.company_id = :companyId', {
-                companyId: user.companyId
-            });
-        }
+        this.applyCompanyFilterToQuery(query, user);
         return result;
     }
-    /**
-   * Override: Convert entity to response DTO
-   */ convertEntityToResponseDto(entity, _isRaw) {
+    applyComputedFields(data, form, isDraft) {
+        if (isDraft) {
+            return data;
+        }
+        const schema = form.schema;
+        const settings = schema?.settings;
+        const computedFields = settings?.computedFields;
+        if (!computedFields || computedFields.length === 0) {
+            return data;
+        }
+        const computedValues = (0, _computedfieldutils.calculateComputedFields)(data, computedFields);
+        return {
+            ...data,
+            _computed: computedValues
+        };
+    }
+    convertEntityToResponseDto(entity, _isRaw) {
         return {
             id: entity.id,
             formId: entity.formId,
@@ -126,137 +173,55 @@ let FormResultService = class FormResultService extends _classes.RequestScopedAp
         };
     }
     // Form Submission
-    /**
-   * Submit a form (authenticated or public)
-   */ async submitForm(dto, user, isPublic = false) {
+    async submitForm(dto, user, isPublic = false) {
         await this.ensureRepositoryInitialized();
-        await this.ensureFormRepositoryInitialized();
-        // Get the form
-        const form = await this.formRepository.findOne({
-            where: {
-                id: dto.formId,
-                isActive: true,
-                deletedAt: (0, _typeorm.IsNull)()
-            }
-        });
-        if (!form) {
-            throw new _common.NotFoundException('Form not found or inactive');
-        }
-        // Validate access
-        if (isPublic) {
-            if (form.accessType !== _formaccesstypeenum.FormAccessType.PUBLIC) {
-                throw new _common.UnauthorizedException('This form is not available for public submission');
-            }
-        } else {
-            // For non-public submissions
-            switch(form.accessType){
-                case _formaccesstypeenum.FormAccessType.PUBLIC:
-                    break;
-                case _formaccesstypeenum.FormAccessType.AUTHENTICATED:
-                    if (!user) {
-                        throw new _common.UnauthorizedException('Authentication required to submit this form');
-                    }
-                    break;
-                case _formaccesstypeenum.FormAccessType.ACTION_GROUP:
-                    if (!user) {
-                        throw new _common.UnauthorizedException('Authentication required to submit this form');
-                    }
-                    // Validate user has at least one of the required permissions
-                    if (form.actionGroups?.length) {
-                        const hasPermission = await (0, _permissionutils.validateUserPermissions)(user, form.actionGroups, this.cacheManager, this.formBuilderConfig.isCompanyFeatureEnabled(), this.logger, 'submitting form', form.id);
-                        if (!hasPermission) {
-                            throw new _common.ForbiddenException('You do not have permission to submit this form');
-                        }
-                    }
-                    break;
-                default:
-                    throw new _common.BadRequestException('Invalid form access type');
-            }
-        }
+        const form = await this.getActiveForm(dto.formId);
+        await this.validateSubmissionAccess(form, user, isPublic);
         const isDraft = dto.isDraft ?? false;
-        // For authenticated users with drafts
+        // Handle existing draft for authenticated users
         if (user?.id) {
-            // Check for existing draft
             const existingDraft = await this.repository.findOne({
-                where: {
-                    formId: dto.formId,
-                    submittedById: user.id,
-                    isDraft: true,
-                    deletedAt: (0, _typeorm.IsNull)()
-                }
+                where: this.buildUserDraftWhere(dto.formId, user.id)
             });
             if (existingDraft) {
                 if (isDraft) {
-                    // Update existing draft instead of creating new one
-                    existingDraft.data = dto.data;
-                    existingDraft.schemaVersionSnapshot = form.schema;
-                    existingDraft.schemaVersion = form.schemaVersion;
-                    existingDraft.submittedAt = new Date();
-                    existingDraft.metadata = dto.metadata ?? existingDraft.metadata;
+                    Object.assign(existingDraft, {
+                        data: dto.data,
+                        schemaVersionSnapshot: form.schema,
+                        schemaVersion: form.schemaVersion,
+                        submittedAt: new Date(),
+                        metadata: dto.metadata ?? existingDraft.metadata
+                    });
                     const saved = await this.repository.save(existingDraft);
                     return this.convertEntityToResponseDto(saved, false);
-                } else {
-                    // Final submission: delete existing draft first
-                    await this.repository.softRemove(existingDraft);
                 }
+                await this.repository.softRemove(existingDraft);
             }
         }
-        // Calculate computed fields if this is a final submission (not draft)
-        let finalData = dto.data;
-        if (!isDraft) {
-            const schema = form.schema;
-            const settings = schema?.settings;
-            const computedFields = settings?.computedFields;
-            if (computedFields && computedFields.length > 0) {
-                const computedValues = (0, _computedfieldutils.calculateComputedFields)(dto.data, computedFields);
-                // Merge computed values with submitted data (computed fields use their key as the property name)
-                finalData = {
-                    ...dto.data,
-                    _computed: computedValues
-                };
-            }
-        }
-        // Create the result with schema snapshot
-        const resultData = {
+        const saved = await this.repository.save({
             formId: dto.formId,
             schemaVersionSnapshot: form.schema,
             schemaVersion: form.schemaVersion,
-            data: finalData,
+            data: this.applyComputedFields(dto.data, form, isDraft),
             submittedById: user?.id ?? null,
             submittedAt: new Date(),
             isDraft,
             metadata: dto.metadata ?? null
-        };
-        const saved = await this.repository.save(resultData);
+        });
         return this.convertEntityToResponseDto(saved, false);
     }
-    /**
-   * Get user's draft for a specific form
-   * Returns the most recent draft if exists, null otherwise
-   */ async getMyDraft(formId, user) {
+    async getMyDraft(formId, user) {
         await this.ensureRepositoryInitialized();
         const draft = await this.repository.findOne({
-            where: {
-                formId,
-                submittedById: user.id,
-                isDraft: true,
-                deletedAt: (0, _typeorm.IsNull)()
-            },
+            where: this.buildUserDraftWhere(formId, user.id),
             order: {
                 updatedAt: 'DESC'
             }
         });
-        if (!draft) {
-            return null;
-        }
-        return this.convertEntityToResponseDto(draft, false);
+        return draft ? this.convertEntityToResponseDto(draft, false) : null;
     }
-    /**
-   * Update existing draft or convert to submission
-   */ async updateDraft(draftId, dto, user) {
+    async updateDraft(draftId, dto, user) {
         await this.ensureRepositoryInitialized();
-        await this.ensureFormRepositoryInitialized();
-        // Find the draft
         const draft = await this.repository.findOne({
             where: {
                 id: draftId,
@@ -267,74 +232,35 @@ let FormResultService = class FormResultService extends _classes.RequestScopedAp
         if (!draft) {
             throw new _common.NotFoundException('Draft not found');
         }
-        // Get form for fresh schema snapshot (in case form was updated)
-        const form = await this.formRepository.findOne({
-            where: {
-                id: dto.formId,
-                isActive: true,
-                deletedAt: (0, _typeorm.IsNull)()
-            }
-        });
-        if (!form) {
-            throw new _common.NotFoundException('Form not found or inactive');
-        }
+        const form = await this.getActiveForm(dto.formId);
         const isDraft = dto.isDraft ?? false;
-        // Calculate computed fields if this is a final submission (not draft)
-        let finalData = dto.data;
-        if (!isDraft) {
-            const schema = form.schema;
-            const settings = schema?.settings;
-            const computedFields = settings?.computedFields;
-            if (computedFields && computedFields.length > 0) {
-                const computedValues = (0, _computedfieldutils.calculateComputedFields)(dto.data, computedFields);
-                finalData = {
-                    ...dto.data,
-                    _computed: computedValues
-                };
-            }
-        }
-        // Update the draft
-        draft.data = finalData;
-        draft.schemaVersionSnapshot = form.schema;
-        draft.schemaVersion = form.schemaVersion;
-        draft.submittedAt = new Date();
-        draft.isDraft = isDraft;
-        draft.metadata = dto.metadata ?? draft.metadata;
+        Object.assign(draft, {
+            data: this.applyComputedFields(dto.data, form, isDraft),
+            schemaVersionSnapshot: form.schema,
+            schemaVersion: form.schemaVersion,
+            submittedAt: new Date(),
+            isDraft,
+            metadata: dto.metadata ?? draft.metadata
+        });
         const saved = await this.repository.save(draft);
         return this.convertEntityToResponseDto(saved, false);
     }
-    /**
-   * Get results for a specific form
-   */ async getByFormId(formId, user, pagination) {
+    async getByFormId(formId, user, pagination) {
         await this.ensureRepositoryInitialized();
-        const query = this.repository.createQueryBuilder(this.entityName);
-        query.where('form_result.formId = :formId', {
+        const query = this.repository.createQueryBuilder(this.entityName).where('form_result.formId = :formId', {
             formId
-        });
-        query.andWhere('form_result.deletedAt IS NULL');
-        // Apply company filter via Form if enabled
-        const enableCompanyFeature = this.formBuilderConfig.isCompanyFeatureEnabled();
-        if (enableCompanyFeature && user?.companyId) {
-            query.innerJoin('form', 'f', 'f.id = form_result.formId').andWhere('f.company_id = :companyId', {
-                companyId: user.companyId
-            });
-        }
-        // Pagination
+        }).andWhere('form_result.deletedAt IS NULL');
+        this.applyCompanyFilterToQuery(query, user);
         const page = pagination?.page ?? 0;
         const pageSize = pagination?.pageSize ?? 10;
-        query.skip(page * pageSize).take(pageSize);
-        query.orderBy('form_result.submittedAt', 'DESC');
+        query.skip(page * pageSize).take(pageSize).orderBy('form_result.submittedAt', 'DESC');
         const [entities, total] = await query.getManyAndCount();
-        const data = entities.map((e)=>this.convertEntityToResponseDto(e, false));
         return {
-            data,
+            data: entities.map((e)=>this.convertEntityToResponseDto(e, false)),
             total
         };
     }
-    /**
-   * Check if user has already submitted this form (non-draft)
-   * Used for single response mode
-   */ async hasUserSubmitted(formId, user) {
+    async hasUserSubmitted(formId, user) {
         await this.ensureRepositoryInitialized();
         const count = await this.repository.count({
             where: {