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

package/fesm/entities/form.entity.js

@@ -1,15 +1,115 @@
+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;
 }
-import { Entity } from 'typeorm';
-import { FormBase } from './form-base.entity';
-export class Form extends FormBase {
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { Identity } from '@flusys/nestjs-shared/entities';
+import { Column, Entity, Index } from 'typeorm';
+import { FormAccessType } from '../enums/form-access-type.enum';
+export class Form extends Identity {
+    constructor(...args){
+        super(...args), _define_property(this, "name", void 0), _define_property(this, "description", void 0), _define_property(this, "slug", void 0), _define_property(this, "schema", void 0), _define_property(this, "schemaVersion", void 0), _define_property(this, "accessType", void 0), _define_property(this, "actionGroups", void 0), _define_property(this, "isActive", void 0), _define_property(this, "metadata", void 0);
+    }
 }
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Form.prototype, "name", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 500,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "description", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 255,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "slug", void 0);
+_ts_decorate([
+    Column({
+        type: 'json',
+        nullable: false
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], Form.prototype, "schema", void 0);
+_ts_decorate([
+    Column({
+        type: 'int',
+        nullable: false,
+        default: 1,
+        name: 'schema_version'
+    }),
+    _ts_metadata("design:type", Number)
+], Form.prototype, "schemaVersion", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 50,
+        default: 'AUTHENTICATED',
+        name: 'access_type'
+    }),
+    _ts_metadata("design:type", typeof FormAccessType === "undefined" ? Object : FormAccessType)
+], Form.prototype, "accessType", void 0);
+_ts_decorate([
+    Column({
+        type: 'simple-array',
+        nullable: true,
+        name: 'action_groups'
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "actionGroups", void 0);
+_ts_decorate([
+    Column({
+        type: 'boolean',
+        nullable: false,
+        default: true,
+        name: 'is_active'
+    }),
+    _ts_metadata("design:type", Boolean)
+], Form.prototype, "isActive", void 0);
+_ts_decorate([
+    Column('simple-json', {
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Form.prototype, "metadata", void 0);
 Form = _ts_decorate([
     Entity({
         name: 'form'
-    })
+    }),
+    Index([
+        'slug'
+    ], {
+        unique: true
+    }),
+    Index([
+        'isActive'
+    ])
 ], Form);

package/fesm/entities/index.js

@@ -1,29 +1,23 @@
-// Form Entities
-export * from './form-base.entity';
+// Entities without company feature
 export * from './form.entity';
-export * from './form-with-company.entity';
-// Form Result Entity (single - no company variant needed)
 export * from './form-result.entity';
-// Helper function to get entities based on config
+// Entities with company feature
+export * from './form-with-company.entity';
 import { Form } from './form.entity';
-import { FormWithCompany } from './form-with-company.entity';
 import { FormResult } from './form-result.entity';
-/**
- * Get form builder entities based on configuration
- * @param enableCompanyFeature Whether company feature is enabled
- * @returns Array of entity classes
- *
- * Note: FormResult is always the same regardless of company feature
- * because company context is derived from the linked Form via formId
- */ export function getFormBuilderEntitiesByConfig(enableCompanyFeature) {
-    if (enableCompanyFeature) {
-        return [
-            FormWithCompany,
-            FormResult
-        ];
-    }
-    return [
-        Form,
-        FormResult
-    ];
+import { FormWithCompany } from './form-with-company.entity';
+// Core entities (no company feature)
+export const FormCoreEntities = [
+    Form,
+    FormResult
+];
+// Company-specific entities
+export const FormCompanyEntities = [
+    FormWithCompany,
+    FormResult
+];
+export function getFormBuilderEntitiesByConfig(enableCompanyFeature) {
+    return enableCompanyFeature ? FormCompanyEntities : FormCoreEntities;
 }
+// Base type aliases for backwards compatibility with services
+export { Form as FormBase } from './form.entity';

package/fesm/index.js

@@ -1,5 +1,7 @@
 // Config
 export * from './config/index';
+// Docs
+export * from './docs/index';
 // Controllers
 export * from './controllers/index';
 // DTOs

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

@@ -1,3 +1,16 @@
+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);
@@ -13,8 +26,6 @@ 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,
@@ -22,21 +33,14 @@ export class FormBuilderModule {
                 CacheModule,
                 UtilsModule
             ],
-            controllers: options.includeController !== false ? controllers : [],
-            providers,
-            exports: [
-                FormBuilderConfigService,
-                FormBuilderDataSourceProvider,
-                FormService,
-                FormResultService
-            ]
+            controllers: options.includeController !== false ? this.CONTROLLERS : [],
+            providers: this.buildProviders(options),
+            exports: this.EXPORTS
         };
     }
     /**
    * Register FormBuilderModule asynchronously
    */ static forRootAsync(options) {
-        const controllers = this.getControllers(options);
-        const asyncProviders = this.createAsyncProviders(options);
         return {
             module: FormBuilderModule,
             global: options.global ?? false,
@@ -45,41 +49,22 @@ export class FormBuilderModule {
                 CacheModule,
                 UtilsModule
             ],
-            controllers: options.includeController !== false ? controllers : [],
+            controllers: options.includeController !== false ? this.CONTROLLERS : [],
             providers: [
-                ...asyncProviders,
-                ...this.getProviders(options, false)
+                ...this.buildAsyncProviders(options),
+                ...this.buildProviders()
             ],
-            exports: [
-                FormBuilderConfigService,
-                FormBuilderDataSourceProvider,
-                FormService,
-                FormResultService
-            ]
+            exports: this.EXPORTS
         };
     }
-    // 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) {
+    static buildProviders(options) {
         const providers = [
             FormBuilderConfigService,
             FormBuilderDataSourceProvider,
             FormService,
             FormResultService
         ];
-        // Only include options provider for sync registration
-        if (includeOptionsProvider) {
+        if (options) {
             providers.unshift({
                 provide: FORM_BUILDER_MODULE_OPTIONS,
                 useValue: options
@@ -87,65 +72,54 @@ export class FormBuilderModule {
         }
         return providers;
     }
-    /**
-   * Create async providers for forRootAsync
-   */ static createAsyncProviders(options) {
+    static buildAsyncProviders(options) {
         if (options.useFactory) {
             return [
                 {
                     provide: FORM_BUILDER_MODULE_OPTIONS,
-                    useFactory: async (...args)=>{
-                        const config = await options.useFactory(...args);
-                        return {
+                    useFactory: async (...args)=>({
                             ...options,
-                            config
-                        };
-                    },
+                            config: await options.useFactory(...args)
+                        }),
                     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
-                }
-            ];
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) {
+            return [];
         }
-        if (options.useExisting) {
-            return [
-                {
-                    provide: FORM_BUILDER_MODULE_OPTIONS,
-                    useFactory: async (optionsFactory)=>{
-                        const config = await optionsFactory.createFormBuilderOptions();
-                        return {
-                            ...options,
-                            config
-                        };
-                    },
-                    inject: [
-                        options.useExisting
-                    ]
-                }
-            ];
+        const providers = [
+            {
+                provide: FORM_BUILDER_MODULE_OPTIONS,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createFormBuilderOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
         }
-        return [];
+        return providers;
     }
 }
+_define_property(FormBuilderModule, "CONTROLLERS", [
+    FormController,
+    FormResultController
+]);
+_define_property(FormBuilderModule, "EXPORTS", [
+    FormBuilderConfigService,
+    FormBuilderDataSourceProvider,
+    FormService,
+    FormResultService
+]);
 FormBuilderModule = _ts_decorate([
     Module({})
 ], FormBuilderModule);

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

@@ -29,29 +29,19 @@ import { Injectable, Inject } from '@nestjs/common';
 import { FORM_BUILDER_MODULE_OPTIONS } from '../config/form-builder.constants';
 import { FormBuilderModuleOptions } from '../interfaces/form-builder-module.interface';
 export 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/fesm/services/form-builder-datasource.provider.js

@@ -29,69 +29,36 @@ 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';
+import { FormBuilderConfigService } from './form-builder-config.service';
 export class FormBuilderDataSourceProvider extends 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;
-    }
-    /**
-   * 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();
+    async getFormBuilderEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
         const { Form, FormResult, FormWithCompany } = await import('../entities');
-        if (enable) {
-            return [
-                FormWithCompany,
-                FormResult
-            ];
-        }
-        return [
+        return enable ? [
+            FormWithCompany,
+            FormResult
+        ] : [
             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;
         }
@@ -99,7 +66,6 @@ export class FormBuilderDataSourceProvider extends MultiTenantDataSourceService
         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 {
@@ -110,20 +76,15 @@ export class FormBuilderDataSourceProvider extends MultiTenantDataSourceService
             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);
@@ -135,11 +96,10 @@ export class FormBuilderDataSourceProvider extends MultiTenantDataSourceService
             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);
+    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 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());
@@ -150,12 +110,12 @@ FormBuilderDataSourceProvider = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST
     }),
-    _ts_param(0, Inject(FORM_BUILDER_MODULE_OPTIONS)),
+    _ts_param(0, Inject(FormBuilderConfigService)),
     _ts_param(1, Optional()),
     _ts_param(1, Inject(REQUEST)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof FormBuilderModuleOptions === "undefined" ? Object : FormBuilderModuleOptions,
+        typeof FormBuilderConfigService === "undefined" ? Object : FormBuilderConfigService,
         typeof Request === "undefined" ? Object : Request
     ])
 ], FormBuilderDataSourceProvider);