@solidstarters/solid-core 1.2.98 → 1.2.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.98",
+  "version": "1.2.99",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/controllers/setting.controller.ts

@@ -88,7 +88,8 @@ export class SettingController {
 
   @ApiBearerAuth("jwt")
   @Post('/bulk-update')
-  async updateSettings(@Body() updateSettingsDto: UpdateSettingsDto) {
-    return this.service.updateSettings(updateSettingsDto.settings);
+  @UseInterceptors(AnyFilesInterceptor())
+  async updateSettings(@Body() updateSettingsDto: UpdateSettingsDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.updateSettings(updateSettingsDto.settings, files);
   }
 }

package/src/dtos/update-settings.dto.ts

@@ -1,7 +1,6 @@
-import { IsNotEmpty, IsObject } from 'class-validator';
+import { IsObject, IsOptional } from 'class-validator';
 
 export class UpdateSettingsDto {
-    @IsObject()
-    @IsNotEmpty()
+    @IsOptional()
     settings: Record<string, any>;
 } 

package/src/entities/common.entity.ts

@@ -1,5 +1,5 @@
-import { PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, DeleteDateColumn, Index, ManyToOne, JoinColumn } from "typeorm"
-import { Locale } from "./locale.entity";
+import { Column, CreateDateColumn, DeleteDateColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
+import type { User } from "./user.entity";
 
 export abstract class CommonEntity {
     @PrimaryGeneratedColumn({ type: 'integer' })
@@ -25,4 +25,10 @@ export abstract class CommonEntity {
 
     @Column({ type: "int", name: 'default_entity_locale_id', default: null })
     defaultEntityLocaleId: number;
+
+    @ManyToOne(() => require('./user.entity').User?.default ?? require('./user.entity').User, { nullable: true })
+    createdBy: User;
+
+    @ManyToOne(() => require('./user.entity').User?.default ?? require('./user.entity').User, { nullable: true })
+    updatedBy: User;    
 }

package/src/entities/menu-item-metadata.entity.ts

@@ -23,7 +23,7 @@ export class MenuItemMetadata extends CommonEntity {
     @ManyToOne(() => ActionMetadata, { onDelete: "CASCADE", nullable: true })
     @JoinColumn({ referencedColumnName: 'id' })
     action: ActionMetadata;
-    @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.users, { cascade: true })
+    @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.menuItems, { cascade: true })
     @JoinTable()
     roles: RoleMetadata[];
     @Column({ name: "sequence_number", type: "int", nullable: true })

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

@@ -9,6 +9,7 @@ export interface PasswordFieldOptions {
     required: boolean | undefined | null;
     regexPattern: string | undefined | null;
     fieldName: string | undefined | null;
+    isUpdate: Boolean;
 }
 
 export class PasswordFieldCrudManager implements FieldCrudManager {
@@ -24,7 +25,10 @@ export class PasswordFieldCrudManager implements FieldCrudManager {
 
     private applyValidations(fieldValue: any, dto: any): ValidationError[] {
         const errors: ValidationError[] = [];
-        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        if (!this.options?.isUpdate && this.isApplyRequiredValidation() && isEmpty(fieldValue)) {
+            errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` });
+        }
+        // this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
         if (isNotEmpty(fieldValue)) {
             errors.push(...this.applyFormatValidations(fieldValue, dto));
         }

package/src/helpers/model-metadata-helper.service.ts

@@ -0,0 +1,109 @@
+// Return the system fields metadata for a model
+
+import { Injectable, Logger } from "@nestjs/common";
+import { SolidRegistry } from "./solid-registry";
+import { In } from "typeorm";
+
+@Injectable()
+export class ModelMetadataHelperService {
+    private readonly logger = new Logger(ModelMetadataHelperService.name);
+
+    constructor(private readonly registry: SolidRegistry) {
+    }
+
+    getSystemFieldsMetadata(): any[] {
+        const systemFieldsMetadata = [
+            {
+                name: "id",
+                displayName: "Id",
+                type: "int",
+                ormType: "bigint",
+                isSystem: true,
+            },
+            {
+                name: "createdAt",
+                displayName: "Created At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "updatedAt",
+                displayName: "Updated At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "deletedAt",
+                displayName: "Deleted At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "deletedTracker",
+                displayName: "Deleted Tracker",
+                type: "shortText",
+                ormType: "varchar",
+                isSystem: true,
+            },
+            {
+                name: "publishedAt",
+                displayName: "Published At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "localeName",
+                displayName: "Locale",
+                type: "shortText",
+                ormType: "varchar",
+                isSystem: true,
+            },
+            {
+                name: "defaultEntityLocaleId",
+                displayName: "Default Entity Locale Id",
+                type: "int",
+                ormType: "integer",
+                isSystem: true,
+            },
+            {
+                name: "createdBy",
+                displayName: "Created By",
+                type: "relation",
+                ormType: "int",
+                isSystem: true,
+                relationType: "many-to-one",
+                relationCoModelSingularName: "user",
+                relationCreateInverse: false,
+                relationCascade: "restrict",
+                relationModelModuleName: "solid-core"
+            },
+            {
+                name: "updatedBy",
+                displayName: "Updated By",
+                type: "relation",
+                ormType: "int",
+                isSystem: true,
+                relationType: "many-to-one",
+                relationCoModelSingularName: "user",
+                relationCreateInverse: false,
+                relationCascade: "restrict",
+                relationModelModuleName: "solid-core"
+            },
+        ]
+
+        // Do an additional check and add a warning if the common entity keys and system field metadata keys don't match exactly
+        const commonEntityKeys = this.registry.getCommonEntityKeys();
+        const systemFieldNames = systemFieldsMetadata.map(field => field.name);
+        const missingKeys = commonEntityKeys.filter(key => !systemFieldNames.includes(key));
+        if (missingKeys.length > 0) {
+            this.logger.warn(`Missing system fields metadata for common entity keys: ${missingKeys.join(', ')}`);
+        }
+        return systemFieldsMetadata;
+    }
+
+
+}

package/src/helpers/schematic.service.ts

@@ -1,6 +1,8 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { CommandService } from './command.service';
 import { snakeCase } from "lodash";
+import { CommonEntity } from 'src/entities/common.entity';
+import { SolidRegistry } from './solid-registry';
 
 export const ADD_MODULE_COMMAND = 'add-module';
 export type GenerateModuleOptions = {
@@ -14,25 +16,19 @@ type FieldOptions = {
   dataSource: string;
   fields: any[]; //FIXME This type can be improved
   modelEnableSoftDelete?: boolean;
-  parentModel?: string;
+  parentModel?: string; 
   parentModule?: string;
+  draftPublishWorkflowEnabled?: boolean;
 };
 export const REMOVE_FIELDS_COMMAND = 'remove-fields';
 export const REFRESH_MODEL_COMMAND = 'refresh-model';
 
-enum SYSTEM_FIELDS_TO_IGNORE_FOR_CODE_GENERATION {
-  ID = 'id',
-  CREATED_AT = 'createdAt',
-  UPDATED_AT = 'updatedAt',
-  DELETED_AT = 'deletedAt'
-}
-
 //TODO Rename to CodeBuilder service
 @Injectable()
 export class SchematicService {
   private readonly logger = new Logger(SchematicService.name);
   private readonly SCHEMATIC_PROJECT = '@solidstarters/solid-code-builder';
-  constructor(private readonly commandService: CommandService) { }
+  constructor(private readonly commandService: CommandService, private readonly solidRegistry: SolidRegistry) { }
 
   async executeSchematicCommand(
     command: string,
@@ -79,9 +75,13 @@ export class SchematicService {
         modelCommand += ` --parent-module=${fieldOptions.parentModule}`;
       }
 
+      if (fieldOptions.draftPublishWorkflowEnabled) {
+        modelCommand += ` --draft-publish-workflow-enabled=${fieldOptions.draftPublishWorkflowEnabled}`;
+      }
+      
       let fieldCommand = fieldOptions.fields
         .filter((field) => {
-          return !Object.values(SYSTEM_FIELDS_TO_IGNORE_FOR_CODE_GENERATION).includes(field.name);
+          return !this.solidRegistry.getCommonEntityKeys().includes(field.name);
         })
         .map((field) => {
           return `--fields='${JSON.stringify(field)}'`;
@@ -101,5 +101,4 @@ export class SchematicService {
       throw new Error('Schematic command not supported.');
     }
   }
-
 }

package/src/helpers/solid-registry.ts

@@ -1,8 +1,9 @@
 import { Injectable } from '@nestjs/common';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
-import { ISelectionProvider, ISelectionProviderContext } from "../interfaces";
+import { CommonEntity } from 'src/entities/common.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { EntityManager } from 'typeorm';
+import { ISelectionProvider, ISelectionProviderContext } from "../interfaces";
 import { Locale } from 'src/entities/locale.entity';
 
 type ControllerMetadata = {
@@ -147,4 +148,8 @@ export class SolidRegistry {
     return entityMetadata.target;
   }
 
+  getCommonEntityKeys(): (keyof CommonEntity) [] {
+        return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];
+  }
+
 }

package/src/index.ts

@@ -242,7 +242,7 @@ export * from './repository/field.repository'
 
 //softDeleteAwareEventSubscriber.subscriber.ts
 export * from './subscribers/model.subscriber'
-export * from './subscribers/softDeleteAwareEventSubscriber.subscriber' //rename
+export * from './subscribers/soft-delete-aware-event.subscriber' //rename
 export * from './subscribers/view-metadata.subscriber' //rename
 export * from './subscribers/audit.subscriber'
 
@@ -259,4 +259,4 @@ export * from './interfaces'
 export * from './solid-core.module'
 
 export * from './winston.logger'
-export * from './transformers/datetime-transformer'
+export { default as datetimeTransformer } from './transformers/datetime-transformer'

package/src/seeders/system-fields-seeder.service.ts

@@ -0,0 +1,53 @@
+// This class will add the system fields in the field-metadata table if they are missing.
+// Fetch all the models and their fields metadata and check if the system fields are present.
+
+import { InjectRepository } from "@nestjs/typeorm";
+import { ModelMetadata } from "src/entities/model-metadata.entity";
+import { ModelMetadataHelperService } from "src/helpers/model-metadata-helper.service";
+import { FieldRepository } from "src/repository/field.repository";
+import { Repository } from "typeorm";
+
+export class SystemFieldsSeederService {
+   // This service is responsible for seeding the system fields metadata for all models.
+   // It will check if the system fields are already present in the field-metadata table.
+   // If not, it will add them.
+   constructor(
+      private readonly modelHelperService: ModelMetadataHelperService,
+      @InjectRepository(ModelMetadata)
+      private readonly modelRepository: Repository<ModelMetadata>, // Replace with actual model repository type
+      @InjectRepository(FieldRepository)
+      private readonly fieldRepository: Repository<FieldRepository>, // Replace with actual field repository type
+   ) {}
+  
+   async seed() {
+     // Get the model repo
+     const models = await this.modelRepository.find({
+       relations: ['fields'], // Assuming 'fields' is the relation to field metadata
+     });
+
+     for (const model of models) {
+         // Check if the system fields are already present
+         await this.seedMissingSystemFields(model);
+      }
+   }
+
+    private async seedMissingSystemFields(model: ModelMetadata) {
+        const existingSystemFields = model.fields.filter(field => field.isSystem);
+        const systemFieldsMetadata = this.modelHelperService.getSystemFieldsMetadata();
+
+        // Find out which system fields are missing
+        const missingFields = systemFieldsMetadata.filter(
+            sysField => !existingSystemFields.some(field => field.name === sysField.name)
+        );
+
+        // If there are missing fields, add them
+        if (missingFields.length > 0) {
+            const newFields = missingFields.map(field => ({
+                ...field,
+                model: model, // Associate the field with the current model
+            }));
+            await this.fieldRepository.save(newFields);
+        }
+    }
+}
+   

package/src/services/authentication.service.ts

@@ -362,7 +362,7 @@ export class AuthenticationService {
                     solidAppName: process.env.SOLID_APP_NAME,
                     solidAppWebsiteUrl: process.env.SOLID_APP_WEBSITE_URL,
                     firstName: user.username,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                     emailVerificationTokenOnRegistration: user.emailVerificationTokenOnRegistration,
                 },
                 this.commonConfiguration.shouldQueueEmails,
@@ -379,7 +379,7 @@ export class AuthenticationService {
                     otp: user.mobileVerificationTokenOnRegistration,
                     mobileVerificationTokenOnRegistration: user.mobileVerificationTokenOnRegistration,
                     firstName: user.username,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                 }
             );
         }
@@ -544,7 +544,7 @@ export class AuthenticationService {
                     solidAppWebsiteUrl: process.env.SOLID_APP_WEBSITE_URL,
                     firstName: user.username,
                     emailVerificationTokenOnLogin: user.emailVerificationTokenOnLogin,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                 },
                 this.commonConfiguration.shouldQueueEmails,
                 'user',
@@ -560,7 +560,7 @@ export class AuthenticationService {
                     otp: user.mobileVerificationTokenOnLogin,
                     mobileVerificationTokenOnLogin: user.mobileVerificationTokenOnLogin,
                     firstName: user.username,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                 }
             );
         }

package/src/services/computed-fields/concat-computed-field-provider.service.ts

@@ -25,6 +25,9 @@ export class ConcatComputedFieldProvider implements IComputedFieldProvider<any>
         const fields = ctxt.fields;
         const slugify = ctxt.slugify || false;
 
+        if (!Array.isArray(fields) || fields?.length === 0) {
+            return '';
+        }
         let concatenatedString = '';
         for (let i = 0; i < fields.length; i++) {
             const field = fields[i];

package/src/services/crud.service.ts

@@ -109,8 +109,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         });
     }
 
-    private async validateAndTransformDto(field: FieldMetadata, dto: any, files: Express.Multer.File[], hasMediaFields: boolean, isPartialUpdate: boolean = false) {
-        const fieldManager: FieldCrudManager = this.fieldCrudManager(field, this.entityManager, isPartialUpdate);
+    private async validateAndTransformDto(field: FieldMetadata, dto: any, files: Express.Multer.File[], hasMediaFields: boolean, isPartialUpdate: boolean = false, isUpdate: boolean = false) {
+        const fieldManager: FieldCrudManager = this.fieldCrudManager(field, this.entityManager, isPartialUpdate, isUpdate);
         const validationErrors = fieldManager.validate(dto, files);
         const errors = (validationErrors instanceof Promise) ? await validationErrors : validationErrors;
         if (errors.length > 0) {
@@ -150,10 +150,11 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
     }
 
     //TODO: Will the updates be partial i.e PATCH or full i.e PUT
-    async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false, solidRequestContext: any = {}): Promise<T> {
+    async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false, solidRequestContext: any = {}, isUpdate: boolean = false): Promise<T> {
         if (!id) {
             throw new Error('Id is required for update');
         }
+        isUpdate = true;
         const model = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
@@ -185,7 +186,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // 2. Loop through the fields with a switch statement
         // 3. Handle the fields based on field type
         for (const field of fieldsToProcess) {
-            const transformed = await this.validateAndTransformDto(field, updateDto, files, hasMediaFields, isPartialUpdate);
+            const transformed = await this.validateAndTransformDto(field, updateDto, files, hasMediaFields, isPartialUpdate, isUpdate);
             updateDto = transformed.dto;
             hasMediaFields = transformed.hasMediaFields;
         }
@@ -257,8 +258,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false): FieldCrudManager {
-        const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name };
+    private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false, isUpdate: boolean = false): FieldCrudManager {
+        const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name, isUpdate};
         switch (fieldMetadata.type) {
             case SolidFieldType.shortText: {
                 const options = { ...commonOptions, length: fieldMetadata.max, regexPattern: fieldMetadata.regexPattern };

package/src/services/model-metadata.service.ts

@@ -928,7 +928,7 @@ export class ModelMetadataService {
         modelEnableSoftDelete: model.enableSoftDelete,
         parentModel: model.parentModel?.singularName,
         parentModule: model.parentModel?.module?.name,
-
+        draftPublishWorkflowEnabled: model.draftPublishWorkflow,
       },
       dryRun
     );

package/src/services/setting.service.ts

@@ -48,6 +48,7 @@ export class SettingService extends CRUDService<Setting> {
       authPagesLayout: "center",
       authPagesTheme: "light",
       appLogo: "",
+      companylogo: "",
       appLogoPosition: "in_form_view",
       showAuthContent: false,
       appTitle: process.env.SOLID_APP_NAME || "Solid App",
@@ -130,6 +131,7 @@ export class SettingService extends CRUDService<Setting> {
       authPagesLayout: "center",
       authPagesTheme: "light",
       appLogo: "",
+      companylogo: "",
       appLogoPosition: "in_form_view", //in_form_view | in_image_view
       showAuthContent: false,
       appTitle: process.env.SOLID_APP_NAME || "Solid App",
@@ -176,14 +178,41 @@ export class SettingService extends CRUDService<Setting> {
     }
   }
 
-  async updateSettings(settings: Record<string, any>): Promise<Setting[]> {
+  async updateSettings(settings: Record<string, any> = {}, files: Array<Express.Multer.File> = []): Promise<Setting[]> {
     const existingSettings = await this.repo.find();
     const existingKeys = new Set(existingSettings.map(s => s.key));
 
     const settingsToUpdate: Setting[] = [];
     const settingsToCreate: Setting[] = [];
 
+    if (files && files.length > 0) {
+      for (const file of files) {
+        const key = file.fieldname;
+        const fileStoragePath = `${this.configService.get('app-builder.fileStorageDir')}/${file.filename}-${file.originalname}`;
+        
+        await this.fileService.copyFile(file.path, fileStoragePath);
+        await this.fileService.deleteFile(file.path);
+
+        if (existingKeys.has(key)) {
+          const existingSetting = existingSettings.find(s => s.key === key);
+          if (existingSetting) {
+            existingSetting.value = fileStoragePath;
+            settingsToUpdate.push(existingSetting);
+          }
+        } else {
+          const newSetting = new Setting();
+          newSetting.key = key;
+          newSetting.value = fileStoragePath;
+          settingsToCreate.push(newSetting);
+        }
+      }
+    }
+
     for (const [key, value] of Object.entries(settings)) {
+      if (files && files.some(f => f.fieldname === key)) {
+        continue;
+      }
+
       const stringValue = typeof value === 'boolean' ? value.toString() :
         Array.isArray(value) ? value.join(',') :
           value === null || value === undefined ? '' : String(value);

package/src/solid-core.module.ts

@@ -119,7 +119,7 @@ import { Msg91OTPService } from './services/sms/Msg91OTPService';
 import { Msg91SMSService } from './services/sms/Msg91SMSService';
 // import { UserService } from './services/user.service';
 import { Msg91WhatsappService } from './services/whatsapp/Msg91WhatsappService';
-import { SoftDeleteAwareEventSubscriber } from './subscribers/softDeleteAwareEventSubscriber.subscriber';
+import { SoftDeleteAwareEventSubscriber } from './subscribers/soft-delete-aware-event.subscriber';
 
 import { PermissionMetadataController } from './controllers/permission-metadata.controller';
 import { PermissionMetadata } from './entities/permission-metadata.entity';
@@ -181,6 +181,9 @@ import { ImportTransactionErrorLog } from './entities/import-transaction-error-l
 import { ImportTransactionErrorLogService } from './services/import-transaction-error-log.service';
 import { ImportTransactionErrorLogController } from './controllers/import-transaction-error-log.controller';
 import { LocaleListSelectionProvider } from './services/selection-providers/locale-list-selection-provider.service';
+import { CreatedByUpdatedBySubscriber } from './subscribers/created-by-updated-by.subscriber';
+import { SystemFieldsSeederService } from './seeders/system-fields-seeder.service';
+import { ModelMetadataHelperService } from './helpers/model-metadata-helper.service';
 
 
 @Global()
@@ -299,6 +302,7 @@ import { LocaleListSelectionProvider } from './services/selection-providers/loca
     ModuleMetadataService,
     ModuleMetadataHelperService,
     ModelMetadataService,
+    ModelMetadataHelperService,
     FieldMetadataService,
     RemoveFieldsCommand,
     RefreshModelCommand,
@@ -391,6 +395,9 @@ import { LocaleListSelectionProvider } from './services/selection-providers/loca
     FieldRepository,
     ImportTransactionService,
     ImportTransactionErrorLogService,
+    CreatedByUpdatedBySubscriber,
+    SystemFieldsSeederService,
+    
   ],
   exports: [
     ModuleMetadataService,

package/src/subscribers/audit.subscriber.ts

@@ -1,21 +1,20 @@
-import { Connection, EntitySubscriberInterface, EventSubscriber, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
-import { ChatterMessageService } from '../services/chatter-message.service';
-import { EntityMetadata } from 'typeorm';
-import { InjectRepository } from '@nestjs/typeorm';
-import { ModelMetadata } from '../entities/model-metadata.entity';
-import { Repository } from 'typeorm';
 import { Injectable } from '@nestjs/common';
+import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+import { DataSource, EntityMetadata, EntitySubscriberInterface, EventSubscriber, InsertEvent, RemoveEvent, Repository, UpdateEvent } from 'typeorm';
+import { ModelMetadata } from '../entities/model-metadata.entity';
+import { ChatterMessageService } from '../services/chatter-message.service';
 @Injectable()
 @EventSubscriber()
 export class AuditSubscriber implements EntitySubscriberInterface {
-    
+
     constructor(
-        private readonly connection: Connection,    
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
         private readonly chatterMessageService: ChatterMessageService,
         @InjectRepository(ModelMetadata)
         private readonly modelMetadataRepo: Repository<ModelMetadata>,
     ) {
-        connection.subscribers.push(this);
+        this.dataSource.subscribers.push(this);
     }
 
     private async shouldTrackAudit(entity: any, metadata: EntityMetadata): Promise<boolean> {
@@ -33,8 +32,8 @@ export class AuditSubscriber implements EntitySubscriberInterface {
             return false;
         }
 
-        const auditFields = model.fields.filter(field => 
-            field.enableAuditTracking && 
+        const auditFields = model.fields.filter(field =>
+            field.enableAuditTracking &&
             !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
             !(field.type === 'relation' && field.relationType === 'one-to-many')
         );

package/src/subscribers/created-by-updated-by.subscriber.ts

@@ -0,0 +1,54 @@
+import { Injectable } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { User } from "src/entities/user.entity";
+import { ActiveUserData } from "src/interfaces/active-user-data.interface";
+import { RequestContextService } from "src/services/request-context.service";
+import { DataSource, EntitySubscriberInterface, EventSubscriber, InsertEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+@EventSubscriber()
+export class CreatedByUpdatedBySubscriber implements EntitySubscriberInterface {
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        private readonly requestContextService: RequestContextService,
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    async beforeInsert(event: InsertEvent<any>) {
+        await this.stampUserField(event, true);
+    }
+
+    async beforeUpdate(event: UpdateEvent<any>) {
+        await this.stampUserField(event, false);
+    }
+
+    private async stampUserField(event: InsertEvent<any> | UpdateEvent<any>, isInsert: boolean){
+        if (!event.entity) {
+            return;
+        }
+        // Get the current active user details from the request context
+        const activeUserOrUndefined = this.requestContextService.getActiveUser;
+        if (!activeUserOrUndefined) {
+            return;
+        }
+
+        const loadedUser = await this.loadUser(activeUserOrUndefined as unknown as ActiveUserData);
+        if (isInsert) {
+            event.entity.createdBy = loadedUser;
+            event.entity.updatedBy = loadedUser; // For insert, we set both createdBy and updatedBy to the same user
+        }
+        else {
+            event.entity.updatedBy = loadedUser;
+        }
+    }
+
+    private async loadUser(activeUser: ActiveUserData): Promise<User> {
+        const userRepo = this.dataSource.getRepository(User); // Assuming 'User' is the entity name for users in your application
+        const loadedUser = await userRepo.findOne({
+            where: { id: activeUser.sub }, // Assuming 'sub' is the user ID in the JWT token
+        });
+        return loadedUser;;
+    }
+}