@flusys/nestjs-form-builder 0.1.0-beta.3

package/fesm/index.js

@@ -0,0 +1,16 @@
+// Config
+export * from './config/index';
+// Controllers
+export * from './controllers/index';
+// DTOs
+export * from './dtos/index';
+// Entities
+export * from './entities/index';
+// Enums
+export * from './enums/index';
+// Interfaces
+export * from './interfaces/index';
+// Modules
+export * from './modules/index';
+// Services
+export * from './services/index';

package/fesm/interfaces/form-builder-module.interface.js

@@ -0,0 +1,3 @@
+/**
+ * Async options for Form Builder Module
+ */ export { };

package/fesm/interfaces/form-result.interface.js

@@ -0,0 +1,6 @@
+/**
+ * Form Result Interface
+ * Represents a form submission in responses
+ *
+ * Note: No companyId field - company context is derived from the linked Form via formId
+ */ export { };

package/fesm/interfaces/form.interface.js

@@ -0,0 +1,3 @@
+/**
+ * Public form interface - limited fields for public access
+ */ export { };

package/fesm/interfaces/index.js

@@ -0,0 +1,3 @@
+export * from './form.interface';
+export * from './form-result.interface';
+export * from './form-builder-module.interface';

package/fesm/modules/form-builder.module.js

@@ -0,0 +1,152 @@
+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;
+}
+import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
+import { Module } from '@nestjs/common';
+import { FormBuilderConfigService } from '../config/form-builder-config.service';
+import { FORM_BUILDER_MODULE_OPTIONS } from '../config/form-builder.constants';
+import { FormController, FormResultController } from '../controllers';
+import { FormBuilderDataSourceProvider, FormService, FormResultService } from '../services';
+export class FormBuilderModule {
+    /**
+   * Register FormBuilderModule synchronously
+   */ static forRoot(options) {
+        const controllers = this.getControllers(options);
+        const providers = this.getProviders(options);
+        return {
+            module: FormBuilderModule,
+            global: options.global ?? false,
+            imports: [
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? controllers : [],
+            providers,
+            exports: [
+                FormBuilderConfigService,
+                FormBuilderDataSourceProvider,
+                FormService,
+                FormResultService
+            ]
+        };
+    }
+    /**
+   * Register FormBuilderModule asynchronously
+   */ static forRootAsync(options) {
+        const controllers = this.getControllers(options);
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: FormBuilderModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? controllers : [],
+            providers: [
+                ...asyncProviders,
+                ...this.getProviders(options, false)
+            ],
+            exports: [
+                FormBuilderConfigService,
+                FormBuilderDataSourceProvider,
+                FormService,
+                FormResultService
+            ]
+        };
+    }
+    // ==================== Private Helper Methods ====================
+    /**
+   * Get controllers
+   */ static getControllers(options) {
+        return [
+            FormController,
+            FormResultController
+        ];
+    }
+    /**
+   * Get providers
+   * @param options Module options
+   * @param includeOptionsProvider Whether to include the FORM_BUILDER_MODULE_OPTIONS provider
+   */ static getProviders(options, includeOptionsProvider = true) {
+        const providers = [
+            FormBuilderConfigService,
+            FormBuilderDataSourceProvider,
+            FormService,
+            FormResultService
+        ];
+        // Only include options provider for sync registration
+        if (includeOptionsProvider) {
+            providers.unshift({
+                provide: FORM_BUILDER_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
+    }
+    /**
+   * Create async providers for forRootAsync
+   */ static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: FORM_BUILDER_MODULE_OPTIONS,
+                    useFactory: async (...args)=>{
+                        const config = await options.useFactory(...args);
+                        return {
+                            ...options,
+                            config
+                        };
+                    },
+                    inject: options.inject || []
+                }
+            ];
+        }
+        if (options.useClass) {
+            return [
+                {
+                    provide: FORM_BUILDER_MODULE_OPTIONS,
+                    useFactory: async (optionsFactory)=>{
+                        const config = await optionsFactory.createFormBuilderOptions();
+                        return {
+                            ...options,
+                            config
+                        };
+                    },
+                    inject: [
+                        options.useClass
+                    ]
+                },
+                {
+                    provide: options.useClass,
+                    useClass: options.useClass
+                }
+            ];
+        }
+        if (options.useExisting) {
+            return [
+                {
+                    provide: FORM_BUILDER_MODULE_OPTIONS,
+                    useFactory: async (optionsFactory)=>{
+                        const config = await optionsFactory.createFormBuilderOptions();
+                        return {
+                            ...options,
+                            config
+                        };
+                    },
+                    inject: [
+                        options.useExisting
+                    ]
+                }
+            ];
+        }
+        return [];
+    }
+}
+FormBuilderModule = _ts_decorate([
+    Module({})
+], FormBuilderModule);

package/fesm/modules/index.js

@@ -0,0 +1 @@
+export * from './form-builder.module';

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

@@ -0,0 +1,162 @@
+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 { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, Logger, Optional, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { Request } from 'express';
+import { FormBuilderModuleOptions } from '../interfaces';
+import { FORM_BUILDER_MODULE_OPTIONS } from '../config/form-builder.constants';
+export class FormBuilderDataSourceProvider extends MultiTenantDataSourceService {
+    // ==================== Factory Methods ====================
+    /**
+   * Build parent options from FormBuilderModuleOptions
+   */ static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig
+        };
+    }
+    // ==================== Feature Flags ====================
+    /**
+   * Get global enable company feature flag
+   */ getEnableCompanyFeature() {
+        return this.formBuilderOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    /**
+   * 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
+   * Note: FormResult is always the same - company context derived from Form via formId
+   */ async getFormBuilderEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.getEnableCompanyFeature();
+        const { Form, FormResult, FormWithCompany } = await import('../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);
+        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
+        if (FormBuilderDataSourceProvider.singleDataSource?.isInitialized) {
+            return FormBuilderDataSourceProvider.singleDataSource;
+        }
+        // If another request is creating the connection, wait for it
+        if (FormBuilderDataSourceProvider.singleConnectionLock) {
+            return FormBuilderDataSourceProvider.singleConnectionLock;
+        }
+        const config = this.getDefaultDatabaseConfig();
+        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 {
+            const dataSource = await connectionPromise;
+            FormBuilderDataSourceProvider.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            FormBuilderDataSourceProvider.singleConnectionLock = null;
+        }
+    }
+    /**
+   * Override to use FormBuilder-specific static cache for tenant connections
+   */ async getOrCreateTenantConnection(tenant) {
+        // Return existing initialized connection from FormBuilder-specific cache
+        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);
+        try {
+            const dataSource = await connectionPromise;
+            FormBuilderDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            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 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());
+_define_property(FormBuilderDataSourceProvider, "initialized", false);
+_define_property(FormBuilderDataSourceProvider, "connectionLocks", new Map());
+_define_property(FormBuilderDataSourceProvider, "singleConnectionLock", null);
+FormBuilderDataSourceProvider = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject(FORM_BUILDER_MODULE_OPTIONS)),
+    _ts_param(1, Optional()),
+    _ts_param(1, Inject(REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof FormBuilderModuleOptions === "undefined" ? Object : FormBuilderModuleOptions,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], FormBuilderDataSourceProvider);

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

@@ -0,0 +1,242 @@
+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 { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { BadRequestException, Inject, Injectable, Logger, NotFoundException, Scope, UnauthorizedException } from '@nestjs/common';
+import { IsNull } from 'typeorm';
+import { FormBuilderConfigService } from '../config/form-builder-config.service';
+import { Form, FormResult, FormWithCompany } from '../entities';
+import { FormAccessType } from '../enums/form-access-type.enum';
+import { FormBuilderDataSourceProvider } from './form-builder-datasource.provider';
+export class FormResultService extends RequestScopedApiService {
+    /**
+   * Resolve entity class for this service
+   * @returns FormResult (same entity regardless of company feature)
+   */ resolveEntity() {
+        return FormResult;
+    }
+    /**
+   * Get DataSource provider for this service
+   * @returns FormBuilderDataSourceProvider instance
+   */ getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    /**
+   * Initialize form repository for form lookups
+   */ async ensureFormRepositoryInitialized() {
+        if (!this.formRepository) {
+            const enableCompanyFeature = this.formBuilderConfig.isCompanyFeatureEnabled();
+            const formEntity = enableCompanyFeature ? FormWithCompany : Form;
+            this.formRepository = await this.dataSourceProvider.getRepository(formEntity);
+        }
+    }
+    // ==================== Entity Conversion ====================
+    async convertSingleDtoToEntity(dto, user) {
+        let result = {};
+        // 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('Form result not found');
+            }
+            result = dbData;
+        }
+        // Merge DTO into result
+        result = {
+            ...result,
+            ...dto
+        };
+        return result;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select || !select.length) {
+            select = [
+                'id',
+                'formId',
+                'schemaVersionSnapshot',
+                'schemaVersion',
+                'data',
+                'submittedById',
+                'submittedAt',
+                'isDraft',
+                'metadata',
+                'createdAt',
+                'updatedAt'
+            ];
+        }
+        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
+        query.select(selectFields);
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    /**
+   * Override: Extra query manipulation - Auto-filter by user's company via Form
+   */ 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
+            });
+        }
+        return result;
+    }
+    /**
+   * Override: Convert entity to response DTO
+   */ convertEntityToResponseDto(entity, _isRaw) {
+        return {
+            id: entity.id,
+            formId: entity.formId,
+            schemaVersionSnapshot: entity.schemaVersionSnapshot,
+            schemaVersion: entity.schemaVersion,
+            data: entity.data,
+            submittedById: entity.submittedById,
+            submittedAt: entity.submittedAt,
+            isDraft: entity.isDraft,
+            metadata: entity.metadata,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            deletedAt: entity.deletedAt,
+            createdById: entity.createdById,
+            updatedById: entity.updatedById,
+            deletedById: entity.deletedById
+        };
+    }
+    // ==================== Form Submission ====================
+    /**
+   * Submit a form (authenticated or public)
+   * Creates a result with schema snapshot
+   */ 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: IsNull()
+            }
+        });
+        if (!form) {
+            throw new NotFoundException('Form not found or inactive');
+        }
+        // Validate access
+        if (isPublic) {
+            if (form.accessType !== FormAccessType.PUBLIC) {
+                throw new UnauthorizedException('This form is not available for public submission');
+            }
+        } else {
+            // For non-public submissions
+            switch(form.accessType){
+                case FormAccessType.PUBLIC:
+                    break;
+                case FormAccessType.AUTHENTICATED:
+                    if (!user) {
+                        throw new UnauthorizedException('Authentication required to submit this form');
+                    }
+                    break;
+                case FormAccessType.ACTION_GROUP:
+                    if (!user) {
+                        throw new UnauthorizedException('Authentication required to submit this form');
+                    }
+                    break;
+                default:
+                    throw new BadRequestException('Invalid form access type');
+            }
+        }
+        // Create the result with schema snapshot
+        const resultData = {
+            formId: dto.formId,
+            schemaVersionSnapshot: form.schema,
+            schemaVersion: form.schemaVersion,
+            data: dto.data,
+            submittedById: user?.id ?? null,
+            submittedAt: new Date(),
+            isDraft: dto.isDraft ?? false,
+            metadata: dto.metadata ?? null
+        };
+        const saved = await this.repository.save(resultData);
+        return this.convertEntityToResponseDto(saved, false);
+    }
+    /**
+   * Get results for a specific form
+   */ async getByFormId(formId, user, pagination) {
+        await this.ensureRepositoryInitialized();
+        const query = this.repository.createQueryBuilder(this.entityName);
+        query.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
+        const page = pagination?.page ?? 0;
+        const pageSize = pagination?.pageSize ?? 10;
+        query.skip(page * pageSize).take(pageSize);
+        query.orderBy('form_result.submittedAt', 'DESC');
+        const [entities, total] = await query.getManyAndCount();
+        const data = entities.map((e)=>this.convertEntityToResponseDto(e, false));
+        return {
+            data,
+            total
+        };
+    }
+    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    constructor(cacheManager, utilsService, formBuilderConfig, dataSourceProvider){
+        // Repository will be set asynchronously by RequestScopedApiService
+        super('form_result', null, cacheManager, utilsService, FormResultService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "formBuilderConfig", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "logger", void 0), _define_property(this, "formRepository", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.formBuilderConfig = formBuilderConfig, this.dataSourceProvider = dataSourceProvider, this.logger = new Logger(FormResultService.name), this.formRepository = null;
+    }
+}
+FormResultService = _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
+    ])
+], FormResultService);