@solidxai/core 0.1.6-beta.9 → 0.1.7

package/src/entities/saved-filters.entity.ts

@@ -3,10 +3,11 @@ import { Entity, Column, JoinColumn, ManyToOne, Index } from 'typeorm';
 import { User } from 'src/entities/user.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { ViewMetadata } from 'src/entities/view-metadata.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_saved_fitlers")
 export class SavedFilters extends CommonEntity {
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     filterQueryJson: any;
 
     @Index({ unique: true })
@@ -28,7 +29,7 @@ export class SavedFilters extends CommonEntity {
     @JoinColumn()
     view: ViewMetadata;
 
-    @Column({ name: "description", type: "text", nullable: true })
+    @Column({ name: "description", nullable: true })
     description: string;
 
     @Column({ nullable: true, default: false })

package/src/entities/security-rule.entity.ts

@@ -2,6 +2,7 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { RoleMetadata } from 'src/entities/role-metadata.entity';
 import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_security_rule")
 export class SecurityRule extends CommonEntity {
@@ -22,7 +23,7 @@ export class SecurityRule extends CommonEntity {
     @JoinColumn()
     modelMetadata: ModelMetadata;
 
-    @Column({ type: "text" })
+    @Column({ ...getColumnType('longText'), nullable: true })
     securityRuleConfig: any;
 
     @Column({ type: "varchar", nullable: true })

package/src/entities/sms-template.entity.ts

@@ -12,7 +12,7 @@ export class SmsTemplate extends CommonEntity {
     body: string;
     @Column({ type: "varchar", nullable: true })
     smsProviderTemplateId: string;
-    @Column({ name: "description", type: "text", nullable: true })
+    @Column({ name: "description", nullable: true })
     description: string;
     @Column({ name: "active", nullable: true, default: true })
     active: boolean = true;

package/src/entities/user-view-metadata.entity.ts

@@ -1,5 +1,6 @@
 import { CommonEntity } from 'src/entities/common.entity'
 import { Entity, JoinColumn, ManyToOne, Index, Column } from 'typeorm';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 import { ViewMetadata } from 'src/entities/view-metadata.entity';
 import { User } from 'src/entities/user.entity'
 
@@ -9,7 +10,7 @@ export class UserViewMetadata extends CommonEntity {
     @ManyToOne(() => User, { nullable: false })
     @JoinColumn()
     user: User;
-    @Column({ name: "layout", type: "text", nullable: true })
+    @Column({ name: "layout", nullable: true, ...getColumnType('longText') })
     layout: any = "{}";
     @Index()
     @ManyToOne(() => ViewMetadata, { nullable: false })

package/src/entities/user.entity.ts

@@ -11,109 +11,144 @@ export class User extends CommonEntity {
     @Column({ type: "varchar", nullable: true })
     @Expose()
     fullName: string;
+
     @Index({ unique: true })
     @Column({ type: "varchar" })
     @Expose()
     username: string;
-    // @Index({ unique: true })
+
+    @Index()
     @Column({ type: "varchar", nullable: true })
     @Expose()
     email: string;
-    // @Index({ unique: true })
+
+    @Index()
     @Column({ type: "varchar", nullable: true })
     @Expose()
     mobile: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     password: string;
+
     @Column({ nullable: true, default: true })
     @Expose()
     forcePasswordChange: boolean = true;
+
     @Column({ type: "varchar", default: "local" })
     // don't send to client
     lastLoginProvider: string = "local";
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client (test)
     accessCode: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleAccessToken: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleId: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleProfilePicture: string;
+
     @Column({ default: true })
     @Expose()
     active: boolean = true;
+
     @Column({ nullable: true })
     // don't send to client
     forgotPasswordConfirmedAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     verificationTokenOnForgotPassword: string;
+
     @Column({ nullable: true })
     // don't send to client
     verificationTokenOnForgotPasswordExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnRegistrationAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistration: string;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistrationExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnRegistrationAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistration: string;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistrationExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnLoginAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnLogin: string;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnLoginExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnLoginAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnLogin: string;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnLoginExpiresAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     @Expose()
     customPayload: string;
+
     @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.users, { cascade: true })
     @JoinTable()
     @Expose()
     roles: RoleMetadata[];
+
     @OneToMany(() => UserViewMetadata, userViewMetadata => userViewMetadata.user, { cascade: true })
     // don't send to client
     userViewMetadata: UserViewMetadata[];
+
     // dont send to client
     @Column({ type: "varchar", default: "bcrypt" })
     passwordScheme: string;
+
     // dont send to client
     @Column({ type: "int", default: 1 })
     passwordSchemeVersion: number;
+
     // dont send to client
     @Column({ nullable: true })
     rehashedAt: Date;
+
     // dont send to client
     @Column({ type: "int", default: 0 })
     failedLoginAttempts: number = 0;
+
     @Expose()
     _media: any;
+
 }

package/src/entities/view-metadata.entity.ts

@@ -1,5 +1,6 @@
 import { CommonEntity } from "src/entities/common.entity"
 import { Entity, Column, ManyToOne, Index, JoinColumn, OneToMany } from "typeorm";
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 import { ModuleMetadata } from 'src/entities/module-metadata.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { UserViewMetadata } from 'src/entities/user-view-metadata.entity'
@@ -16,9 +17,11 @@ export class ViewMetadata extends CommonEntity {
     @Column({ name: "type", type: "varchar" })
     type: string;
 
+    //TODO: To make this truly cross db compatible, we should avoid setting a db type
     @Column({ name: "context", type: "text" })
     context: any = "{}";
 
+    //TODO: To make this truly cross db compatible, we should avoid setting a db type
     @Column({ name: "layout", type: "text" })
     layout: any;
 

package/src/helpers/bootstrap.helper.ts

@@ -0,0 +1,222 @@
+import { ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { NextFunction, Request, Response } from 'express';
+import helmet from 'helmet';
+import qs from 'qs';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
+import { CommandFactory } from 'nest-commander';
+import { WrapResponseInterceptor } from '../interceptors/wrap-response.interceptor';
+import { buildDefaultCorsOptions } from './cors.helper';
+import { buildDefaultSecurityHeaderOptions, buildPermissionsPolicyHeader, PermissionsPolicyConfig } from './security.helper';
+import { parseBooleanEnv } from './environment.helper';
+
+// ---- Shared process handlers ----
+
+function registerGlobalProcessHandlers() {
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  });
+
+  process.on('uncaughtException', (err) => {
+    console.error('Uncaught Exception thrown:', err);
+  });
+
+  // Suppress pg deprecation warning caused by TypeORM's internal query scheduling
+  process.on('warning', (warning) => {
+    if (warning.name === 'DeprecationWarning' && (warning.message.includes('client.query()') || warning.message.includes('punycode'))) {
+      return;
+    }
+    console.warn(warning);
+  });
+}
+
+// ---- HTTP server bootstrap ----
+
+export interface SolidSwaggerOptions {
+  title?: string;
+  description?: string;
+  version?: string;
+}
+
+export interface SolidBootstrapOptions {
+  /** Global API prefix. Defaults to 'api'. Set to '' to disable. */
+  globalPrefix?: string;
+  /** Swagger configuration. Set to false to disable Swagger entirely. */
+  swagger?: SolidSwaggerOptions | false;
+  /** Permissions-Policy header overrides (merged with defaults). */
+  permissionsPolicyOverrides?: Partial<PermissionsPolicyConfig>;
+}
+
+/**
+ * Bootstraps a SolidX NestJS HTTP application with sensible defaults:
+ * security headers, CORS, Winston logger, ValidationPipe,
+ * WrapResponseInterceptor, qs deep query parsing, Swagger, and the
+ * pg BIGINT type parser.
+ *
+ * @example
+ * // main.ts
+ * bootstrapSolidApp(() => AppModule.forRoot(), {
+ *   swagger: { title: 'My API', description: 'My API description' },
+ * });
+ */
+export async function bootstrapSolidApp(
+  appModuleFactory: () => Promise<any>,
+  options: SolidBootstrapOptions = {},
+): Promise<void> {
+  registerGlobalProcessHandlers();
+
+  const { globalPrefix = 'api', swagger = {}, permissionsPolicyOverrides = {} } = options;
+
+  const appModule = await appModuleFactory();
+  const app = await NestFactory.create(appModule);
+
+  const apiEnabled = parseBooleanEnv('API_ENABLED', true);
+
+  if (!apiEnabled) {
+    await app.init();
+    app
+      .get(WINSTON_MODULE_NEST_PROVIDER)
+      .log('API server disabled via API_ENABLED=false. Skipping HTTP listen.', 'Bootstrap');
+    return;
+  }
+
+  // Health check at root path
+  const server = app.getHttpAdapter().getInstance();
+  server.get('/', (_req, res) => res.status(200).send('SOLID OK'));
+
+  // Security headers
+  app.use(helmet(buildDefaultSecurityHeaderOptions()));
+
+  // Permissions-Policy header
+  app.use((_req: Request, res: Response, next: NextFunction) => {
+    res.setHeader('Permissions-Policy', buildPermissionsPolicyHeader(permissionsPolicyOverrides));
+    next();
+  });
+
+  // Winston logger
+  app.useLogger(app.get(WINSTON_MODULE_NEST_PROVIDER));
+
+  const port = process.env.PORT || 3000;
+
+  if (globalPrefix) {
+    app.setGlobalPrefix(globalPrefix);
+  }
+
+  // qs-based deep query parsing (dot notation, nested objects, arrays)
+  app.use((req: Request, _res: Response, next: NextFunction) => {
+    if (req.query) {
+      req.query = qs.parse(req.url.split('?')[1], {
+        allowDots: true,
+        depth: 20,
+        arrayLimit: 100,
+      });
+    }
+    next();
+  });
+
+  // Global ValidationPipe
+  app.useGlobalPipes(
+    new ValidationPipe({
+      transform: true,
+      transformOptions: { enableImplicitConversion: true },
+    }),
+  );
+
+  // Swagger
+  if (swagger !== false) {
+    const { title = 'Solid Starters', description = 'Solid Starters API', version = '1.0' } = swagger;
+    const swaggerConfig = new DocumentBuilder()
+      .setTitle(title)
+      .setDescription(description)
+      .setVersion(version)
+      .setExternalDoc('Postman Collection', '/docs-json')
+      .addBearerAuth(
+        {
+          description: 'Please enter token in following format: Bearer <JWT>',
+          name: 'Authorization',
+          bearerFormat: 'Bearer',
+          scheme: 'Bearer',
+          type: 'http',
+          in: 'Header',
+        },
+        'jwt',
+      )
+      .build();
+    const document = SwaggerModule.createDocument(app, swaggerConfig);
+    SwaggerModule.setup('/docs', app, document);
+  }
+
+  // Global interceptor
+  app.useGlobalInterceptors(new WrapResponseInterceptor());
+
+  // CORS
+  app.enableCors(buildDefaultCorsOptions());
+
+  // Fix pg returning BIGINT columns as strings
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const types = require('pg').types;
+  types.setTypeParser(types.builtins.INT8, (val: string) => parseInt(val));
+
+  await app.listen(port);
+}
+
+// ---- CLI bootstrap ----
+
+/**
+ * Bootstraps a SolidX NestJS CLI application using nest-commander.
+ * Handles verbose flag stripping, project root validation, and clean process exit.
+ *
+ * @example
+ * // main-cli.ts
+ * #!/usr/bin/env node
+ * import { bootstrapSolidCli } from '@solidxai/core';
+ * import { AppModule } from './app.module';
+ *
+ * bootstrapSolidCli(() => AppModule.forRoot());
+ */
+export async function bootstrapSolidCli(
+  appModuleFactory: () => Promise<any>,
+): Promise<void> {
+  registerGlobalProcessHandlers();
+
+  process.on('exit', (code) => {
+    if (code !== 0) {
+      console.error(`Exiting with error status code: ${code}`);
+    }
+  });
+
+  // Validate that cwd is a valid Solid API project
+  const packageJsonPath = resolve(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    console.error('Does not seem to be a valid solid-api project.');
+    console.error('Exit reason: missing package.json in the current directory.');
+    process.exit(1);
+  }
+
+  // Strip --verbose / -v before nest-commander processes argv
+  const showLogs = process.argv.includes('--verbose') || process.argv.includes('-v');
+  for (const flag of ['--verbose', '-v']) {
+    const idx = process.argv.indexOf(flag);
+    if (idx !== -1) process.argv.splice(idx, 1);
+  }
+
+  const appModule = await appModuleFactory();
+  process.env.SOLID_CLI_RUNNING = 'true';
+
+  // @ts-ignore
+  const app = await CommandFactory.createWithoutRunning(appModule, {
+    logger: showLogs ? ['debug', 'error', 'fatal', 'log', 'verbose', 'warn'] : false,
+  });
+
+  try {
+    await CommandFactory.runApplication(app);
+  } catch (e) {
+    console.error('CLI exited abruptly due to an error:', e);
+    process.exit(1);
+  }
+
+  process.exit(0);
+}

package/src/helpers/cache.helper.ts

@@ -0,0 +1,5 @@
+export function shouldUseCache(): boolean {
+  const env = (process.env.ENV ?? process.env.NODE_ENV ?? '').toLowerCase();
+  return env === 'prod' || env === 'production';
+}
+

package/src/helpers/cors.helper.ts

@@ -1,8 +1,12 @@
+import { Logger } from '@nestjs/common';
 import { CorsOptions } from 'cors';
 
+const logger = new Logger('CorsHelper');
+
 /** Build CorsOptions from env; supports wildcards like https://*.example.com */
 export function buildDefaultCorsOptions(): CorsOptions {
   const rawOrigins = process.env.SECURITY_CORS_ORIGINS ?? '*';
+  logger.log(`CORS allowed origins: ${rawOrigins}`);
 
   const allowed = rawOrigins.split(',').map(s => s.trim()).filter(Boolean);
 
@@ -18,17 +22,33 @@ export function buildDefaultCorsOptions(): CorsOptions {
   };
 
   const matchers = allowed.map(patternToRegex);
-  const isAllowed = (origin: string) =>
-    matchers.length > 0 && matchers.some(rx => rx.test(origin));
+  logger.log(`CORS regexes: ${matchers.map(r => r.toString()).join(', ')}`);
 
   return {
     origin: (origin, cb) => {
-      if (!origin) return cb(null, true);           // allow no-origin (CLI/mobile/internal)
-      if (isAllowed(origin)) return cb(null, true);
-      return cb(new Error(`Origin ${origin} not allowed by CORS`), false);
+      if (!origin) {
+        logger.debug('CORS origin callback skipped regex evaluation because origin was empty');
+        // allow no-origin (CLI/mobile/internal)
+        return cb(null, true);
+      }
+
+      const matchingRegex = matchers.find(rx => rx.test(origin));
+      if (matchingRegex) {
+        logger.debug(`CORS origin matched: origin=${origin}; regex=${matchingRegex.toString()}`);
+        return cb(null, true);
+      }
+
+      logger.debug(`CORS origin did not match any regex: origin=${origin}; regexes=${matchers.map(r => r.toString()).join(', ')}`);
+      return cb(new Error(`Origin ${origin} not allowed by CORS. Allowed origins: ${allowed.join(', ')}`), false);
     },
     methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
     allowedHeaders: ['Content-Type', 'Authorization'],
     credentials: true,
   };
-}
+}
+
+
+// [2026-04-07T08:27:19.943Z] INFO: CORS allowed origins: leadyatra.indusindnipponlife.com
+// [2026-04-07T08:27:19.944Z] INFO: CORS regexes: /^https?:\/\/leadyatra\.indusindnipponlife\.com(?::\d+)?$/i
+// [2026-04-07T08:27:19.947Z] DEBUG: Mounting ClsMiddleware to *
+// [2026-04-07T08:27:19.950Z] INFO: CityMasterController {/api/city-master}:

package/src/helpers/field-crud-managers/MediaFieldCrudManager.ts

@@ -11,6 +11,7 @@ export interface MediaFieldOptions {
     fieldName: string | undefined | null;
     mediaMaxSizeKb: number | undefined | null;
     mediaTypes: string[];
+    isUpdate: boolean | undefined | null;
 }
 
 type MediaType = 'image' | 'audio' | 'video' | 'file' | 'pdf';
@@ -119,25 +120,24 @@ export class MediaFieldCrudManager implements FieldCrudManager {
     }
 
     validate(dto: any, files: Array<Express.Multer.File>): ValidationError[] {
-        const isValidateForUpdate = dto.id !== undefined; //FIXME: This is a hack, since we are using PUT for update. Once we support PATCH, this will be removed
         const fieldFiles = files.filter(file => file.fieldname === this.options.fieldName);
-        return this.applyValidations(fieldFiles, isValidateForUpdate);
+        return this.applyValidations(fieldFiles);
     }
 
-    private applyValidations(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private applyValidations(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         switch (this.options.type) {
             case SolidMediaType.mediaSingle:
-                return this.validateMediaSingle(fieldFiles, isValidateForUpdate);
+                return this.validateMediaSingle(fieldFiles);
             case SolidMediaType.mediaMultiple:
-                return this.validateMediaMultiple(fieldFiles, isValidateForUpdate);
+                return this.validateMediaMultiple(fieldFiles);
             default:
                 return [];
         }
     }
 
-    private validateMediaSingle(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private validateMediaSingle(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         const errors: ValidationError[] = [];
-        if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
+        if (!this.options.isUpdate && this.options.required && fieldFiles.length === 0) {
             errors.push({
                 field: this.options.fieldName,
                 error: `${this.options.fieldName} is required`
@@ -184,9 +184,9 @@ export class MediaFieldCrudManager implements FieldCrudManager {
         return errors;
     }
 
-    private validateMediaMultiple(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private validateMediaMultiple(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         const errors: ValidationError[] = [];
-        if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
+        if (!this.options.isUpdate && this.options.required && fieldFiles.length === 0) {
             errors.push({
                 field: this.options.fieldName,
                 error: `${this.options.fieldName} is required`

package/src/helpers/field-crud-managers/SelectionDynamicFieldCrudManager.ts

@@ -7,7 +7,7 @@ export interface SelectionDynamicFieldOptions {
     selectionDynamicProvider: string;
     selectionValueType: SelectionValueType;
     required: boolean | undefined | null;
-    selectionDynamicProviderCtxt: any;
+    selectionDynamicProviderCtxt: ISelectionProviderContext;
     fieldName: string;
     discoveryService: DiscoveryService;
     isMultiSelect: boolean | undefined | null;
@@ -85,8 +85,11 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
     private async applyFormatValidations(fieldValue: any): Promise<ValidationError[]> {
         const errors: ValidationError[] = [];
         !this.isValidSelectionValueType(fieldValue, this.options.selectionValueType) ? errors.push({ field: this.options.fieldName, error: 'Field value type is invalid' }) : "no errors";
-        const _isValidSelectionValue = await this.isValidSelectionValue(fieldValue, this.options.selectionDynamicProvider)
-        !_isValidSelectionValue ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        const ctxt = this.options.selectionDynamicProviderCtxt;
+        if (ctxt.validateOnSave !== false) {
+            const _isValidSelectionValue = await this.isValidSelectionValue(fieldValue, this.options.selectionDynamicProvider, ctxt);
+            !_isValidSelectionValue ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        }
         return errors;
     }
 
@@ -106,11 +109,11 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
         }
     }
 
-    private async isValidSelectionValue(fieldValue: any, selectionDynamicProvider: string): Promise<boolean> {
+    private async isValidSelectionValue(fieldValue: any, selectionDynamicProvider: string, ctxt: ISelectionProviderContext): Promise<boolean> {
         const providerInstance = this.providerInstance<any>(selectionDynamicProvider);
         try {
             // Use the value method first
-            const valueOption = await providerInstance.value(fieldValue, JSON.parse(this.options.selectionDynamicProviderCtxt));
+            const valueOption = await providerInstance.value(fieldValue, ctxt);
             if (valueOption && valueOption.value === fieldValue) {
                 return true;
             }
@@ -118,7 +121,7 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
         }
         catch (error) {
             // Use the values method as a fallback, if the value method is not implemented
-            const values = await providerInstance.values('', JSON.parse(this.options.selectionDynamicProviderCtxt));
+            const values = await providerInstance.values('', ctxt);
             const isValid = values.some(v => v.value === fieldValue);
             return isValid;
         }

package/src/helpers/solid-registry.ts

@@ -5,12 +5,8 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
-import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule, ISettingsProvider, SettingDefinition } from "../interfaces";
-import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
 import { ObjectLiteral } from 'typeorm';
-import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
-import { RelationMetadata } from 'typeorm/metadata/RelationMetadata';
-import { Setting } from 'src/entities/setting.entity';
 
 type ControllerMetadata = {
   name: string;
@@ -86,6 +82,7 @@ export class SolidRegistry {
   private securityRuleConfigProviders: Set<InstanceWrapper> = new Set();
   private errorCodeProviders: Set<InstanceWrapper> = new Set();
   private settingsProviders: Set<InstanceWrapper> = new Set();
+  private auditableModels: Set<string> = new Set();
 
   registerErrorCodeProvider(errorCodeProvider: InstanceWrapper): void {
     this.errorCodeProviders.add(errorCodeProvider);
@@ -342,6 +339,14 @@ export class SolidRegistry {
     });
   }
 
+  registerAuditableModels(models: Set<string>): void {
+    this.auditableModels = models;
+  }
+
+  isAuditableModel(modelSingularName: string): boolean {
+    return this.auditableModels.has(modelSingularName.toLowerCase());
+  }
+
   getCommonEntityKeys(): (keyof CommonEntity | 'createdBy' | 'updatedBy')[] {
     return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt'];
     // return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];