@flusys/nestjs-form-builder 6.0.1 → 6.1.0

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

@@ -0,0 +1,129 @@
+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;
+}
+import { FormBuilderModule } from './form-builder.module';
+import { FORM_BUILDER_MODULE_OPTIONS } from '../config/form-builder.constants';
+import { FormController, FormResultController } from '../controllers';
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('FormBuilderModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with all controllers registered', ()=>{
+            const dynamicModule = FormBuilderModule.forRoot({});
+            expect(dynamicModule.module).toBe(FormBuilderModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                FormController,
+                FormResultController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(FormBuilderModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(FormBuilderModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register a FORM_BUILDER_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = FormBuilderModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === FORM_BUILDER_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+        it('should always export the same fixed set of services', ()=>{
+            expect(FormBuilderModule.forRoot({}).exports).toHaveLength(4);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = FormBuilderModule.forRootAsync({
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('useFactory: builds a FORM_BUILDER_MODULE_OPTIONS provider merging resolved config', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                foo: 'bar'
+            });
+            const dynamicModule = FormBuilderModule.forRootAsync({
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === FORM_BUILDER_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                foo: 'bar'
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createFormBuilderOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createFormBuilderOptions", jest.fn().mockResolvedValue({
+                        foo: 'from-class'
+                    }));
+                }
+            };
+            const dynamicModule = FormBuilderModule.forRootAsync({
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === FORM_BUILDER_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createFormBuilderOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                foo: 'from-class'
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createFormBuilderOptions", jest.fn());
+                }
+            };
+            const dynamicModule = FormBuilderModule.forRootAsync({
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === FORM_BUILDER_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no FORM_BUILDER_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = FormBuilderModule.forRootAsync({});
+            expect(providerTokens(dynamicModule.providers)).not.toContain(FORM_BUILDER_MODULE_OPTIONS);
+        });
+    });
+});

package/fesm/services/form-builder-config.service.spec.js

@@ -0,0 +1,117 @@
+import { FormBuilderConfigService } from './form-builder-config.service';
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: undefined,
+        config: undefined,
+        ...overrides
+    };
+}
+describe('FormBuilderConfigService', ()=>{
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('returns false when neither tenant nor bootstrap config enable the feature', ()=>{
+            const service = new FormBuilderConfigService(buildOptions());
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('returns true when bootstrapAppConfig enables the feature', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+        it('prefers the tenant override over bootstrapAppConfig when a tenant is passed', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: false
+                }
+            }));
+            const result = service.isCompanyFeatureEnabled({
+                enableCompanyFeature: true
+            });
+            expect(result).toBe(true);
+        });
+        it('falls back to bootstrapAppConfig when tenant does not specify enableCompanyFeature', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            }));
+            const result = service.isCompanyFeatureEnabled({
+                id: 'tenant-1'
+            });
+            expect(result).toBe(true);
+        });
+    });
+    describe('getDatabaseMode', ()=>{
+        it('returns the configured database mode', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+        });
+        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+        it('defaults to "single" when databaseMode is not set on bootstrapAppConfig', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: {}
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+    });
+    describe('isMultiTenant', ()=>{
+        it('returns true when database mode is multi-tenant', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('returns false when database mode is single', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getOptions', ()=>{
+        it('returns the exact options object it was constructed with', ()=>{
+            const options = buildOptions({
+                config: {
+                    tenants: []
+                }
+            });
+            const service = new FormBuilderConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+    describe('getConfig', ()=>{
+        it('returns the config sub-object', ()=>{
+            const config = {
+                tenants: []
+            };
+            const service = new FormBuilderConfigService(buildOptions({
+                config
+            }));
+            expect(service.getConfig()).toBe(config);
+        });
+        it('returns undefined when config was never provided', ()=>{
+            const service = new FormBuilderConfigService(buildOptions({
+                config: undefined
+            }));
+            expect(service.getConfig()).toBeUndefined();
+        });
+    });
+});

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

@@ -0,0 +1,143 @@
+import { FormBuilderDataSourceProvider } from './form-builder-datasource.provider';
+import { Form, FormResult, FormWithCompany } from '../entities';
+function buildConfigService(overrides = {}) {
+    const options = {
+        bootstrapAppConfig: {
+            databaseMode: 'single'
+        },
+        config: {
+            defaultDatabaseConfig: {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: 'password',
+                database: 'flusys_test'
+            },
+            tenantDefaultDatabaseConfig: undefined,
+            tenants: []
+        }
+    };
+    return {
+        getOptions: jest.fn().mockReturnValue(options),
+        isCompanyFeatureEnabled: jest.fn().mockReturnValue(overrides.isCompanyFeatureEnabled ?? false)
+    };
+}
+describe('FormBuilderDataSourceProvider', ()=>{
+    afterEach(()=>{
+        // Reset the isolated static caches this provider owns so tests don't leak state between runs.
+        FormBuilderDataSourceProvider.tenantConnections = new Map();
+        FormBuilderDataSourceProvider.singleDataSource = null;
+        FormBuilderDataSourceProvider.tenantsRegistry = new Map();
+        FormBuilderDataSourceProvider.initialized = false;
+        FormBuilderDataSourceProvider.connectionLocks = new Map();
+        FormBuilderDataSourceProvider.singleConnectionLock = null;
+    });
+    it('constructs and forwards bootstrap/database config to the base class', ()=>{
+        const configService = buildConfigService();
+        const provider = new FormBuilderDataSourceProvider(configService, undefined);
+        expect(configService.getOptions).toHaveBeenCalled();
+        expect(provider.getDatabaseMode()).toBe('single');
+        expect(provider.isMultiTenant()).toBe(false);
+    });
+    it('reflects multi-tenant mode from bootstrapAppConfig', ()=>{
+        const configService = buildConfigService();
+        configService.getOptions.mockReturnValue({
+            bootstrapAppConfig: {
+                databaseMode: 'multi-tenant'
+            },
+            config: {}
+        });
+        const provider = new FormBuilderDataSourceProvider(configService, undefined);
+        expect(provider.isMultiTenant()).toBe(true);
+    });
+    it('owns isolated static caches, separate from the base MultiTenantDataSourceService', ()=>{
+        // Each DataSource Provider must override BOTH static cache properties and the
+        // methods that read them — otherwise modules would share connections (see FLUSYS_NEST/CLAUDE.md).
+        expect(FormBuilderDataSourceProvider.tenantConnections).not.toBe(Object.getPrototypeOf(FormBuilderDataSourceProvider).tenantConnections);
+    });
+    describe('getFormBuilderEntities', ()=>{
+        it('returns core entities (no company feature) using the config service default', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: false
+            });
+            const provider = new FormBuilderDataSourceProvider(configService, undefined);
+            const entities = await provider.getFormBuilderEntities();
+            expect(entities).toEqual([
+                Form,
+                FormResult
+            ]);
+        });
+        it('returns company entities using the config service default', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: true
+            });
+            const provider = new FormBuilderDataSourceProvider(configService, undefined);
+            const entities = await provider.getFormBuilderEntities();
+            expect(entities).toEqual([
+                FormWithCompany,
+                FormResult
+            ]);
+        });
+        it('allows an explicit enableCompanyFeature override, bypassing config service', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: false
+            });
+            const provider = new FormBuilderDataSourceProvider(configService, undefined);
+            const entities = await provider.getFormBuilderEntities(true);
+            expect(entities).toEqual([
+                FormWithCompany,
+                FormResult
+            ]);
+            expect(configService.isCompanyFeatureEnabled).not.toHaveBeenCalled();
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('builds a DataSource using core entities when company feature disabled', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: false
+            });
+            const provider = new FormBuilderDataSourceProvider(configService, undefined);
+            const fakeDataSource = {
+                isInitialized: true
+            };
+            const superSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(provider)), 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: 'password',
+                database: 'flusys_test'
+            };
+            const result = await provider.createDataSourceFromConfig(config);
+            expect(superSpy).toHaveBeenCalledWith(config, [
+                Form,
+                FormResult
+            ]);
+            expect(result).toBe(fakeDataSource);
+            superSpy.mockRestore();
+        });
+        it('builds a DataSource using company entities when company feature enabled', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: true
+            });
+            const provider = new FormBuilderDataSourceProvider(configService, undefined);
+            const fakeDataSource = {
+                isInitialized: true
+            };
+            const superSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(provider)), 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                database: 'flusys_test'
+            };
+            const result = await provider.createDataSourceFromConfig(config);
+            expect(superSpy).toHaveBeenCalledWith(config, [
+                FormWithCompany,
+                FormResult
+            ]);
+            expect(result).toBe(fakeDataSource);
+            superSpy.mockRestore();
+        });
+    });
+});