@solidstarters/solid-core 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "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",
@@ -8,6 +8,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "bin": {
+    "solidCore": "dist/cli.js"
+  },
   "scripts": {
     "build": "nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
@@ -30,20 +33,6 @@
     "@aws-sdk/client-s3": "^3.637.0",
     "@elasticemail/elasticemail-client": "^4.0.23",
     "@hapi/joi": "^17.1.1",
-    "@nestjs/axios": "^3.0.2",
-    "@nestjs/cache-manager": "^2.2.2",
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0",
-    "@nestjs/event-emitter": "^2.0.4",
-    "@nestjs/jwt": "^10.2.0",
-    "@nestjs/mapped-types": "^2.0.4",
-    "@nestjs/mongoose": "^10.0.10",
-    "@nestjs/passport": "^10.0.3",
-    "@nestjs/platform-express": "^10.0.0",
-    "@nestjs/serve-static": "^4.0.2",
-    "@nestjs/swagger": "^7.2.0",
-    "@nestjs/typeorm": "^10.0.1",
-    "@types/luxon": "^3.4.2",
     "amqplib": "^0.10.4",
     "axios": "^1.7.0",
     "bcrypt": "^5.1.1",
@@ -57,8 +46,6 @@
     "luxon": "^3.4.4",
     "mailgen": "^2.0.28",
     "mongoose": "^8.7.0",
-    "nest-commander": "^3.12.5",
-    "nest-winston": "^1.9.7",
     "nodemailer": "^6.9.13",
     "passport": "^0.7.0",
     "passport-google-oauth2": "^0.2.0",
@@ -70,22 +57,53 @@
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.1",
     "swagger-ui-express": "^5.0.0",
-    "typeorm": "^0.3.20",
-    "typeorm-naming-strategies": "^4.1.0",
     "uuid": "^9.0.1",
-    "winston": "^3.17.0",
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@nestjs/config": "^3.2.0"
+    "@nestjs/axios": "^3.0.2",
+    "@nestjs/cache-manager": "^2.2.2",
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/config": "^3.2.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/event-emitter": "^2.0.4",
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/mapped-types": "^2.0.4",
+    "@nestjs/mongoose": "^10.0.10",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/serve-static": "^4.0.2",
+    "@nestjs/swagger": "^7.2.0",
+    "@nestjs/typeorm": "^10.0.1",
+    "nest-commander": "^3.12.5",
+    "nest-winston": "^1.9.7",
+    "typeorm": "^0.3.20",
+    "typeorm-naming-strategies": "^4.1.0",
+    "winston": "^3.17.0"
   },
   "devDependencies": {
+    "@nestjs/axios": "^3.0.2",
+    "@nestjs/cache-manager": "^2.2.2",
     "@nestjs/cli": "^10.0.0",
+    "@nestjs/common": "^10.0.0",
     "@nestjs/config": "^3.2.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/event-emitter": "^2.0.4",
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/mapped-types": "^2.0.4",
+    "@nestjs/mongoose": "^10.0.10",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/serve-static": "^4.0.2",
+    "@nestjs/swagger": "^7.2.0",
     "@nestjs/testing": "^10.0.0",
+    "@nestjs/typeorm": "^10.0.1",
+    "nest-commander": "^3.12.5",
+    "nest-winston": "^1.9.7",
     "@types/express": "^4.17.17",
     "@types/hapi__joi": "^17.1.12",
     "@types/jest": "^29.5.2",
+    "@types/luxon": "^3.4.2",
     "@types/mongoose": "^5.11.97",
     "@types/multer": "^1.4.11",
     "@types/node": "^20.3.1",
@@ -110,7 +128,11 @@
     "ts-loader": "^9.4.3",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.1.3"
+    "typeorm": "^0.3.20",
+    "typeorm-naming-strategies": "^4.1.0",
+    "typescript": "^5.1.3",
+    "winston": "^3.17.0",
+    "@solidstarters/solid-code-builder": "^1.0.2"
   },
   "jest": {
     "moduleFileExtensions": [

package/rebuild.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+npm i
+npm run build 
+#rm /Users/oswald/.nvm/versions/node/v21.7.3/bin/solid
+npm i -g
+chmod +x dist/cli.js

package/src/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import { CommandFactory } from "nest-commander";
+import { SolidCoreCliModule } from "./solid-core-cli.module";
+
+async function bootstrap() {
+
+    // const app = await NestFactory.create(appModule);
+
+    // Create an instance of the application, capture the application context so we can inject it into a service in itself.
+    // @ts-ignore
+    const app = await CommandFactory.createWithoutRunning(SolidCoreCliModule, ['debug', 'error', 'fatal', 'log', 'verbose', 'warn']);
+    // const app = await CommandFactory.createWithoutRunning(AppModule, ['debug', 'error', 'fatal', 'log', 'verbose', 'warn']);
+    // const app = await CommandFactory.createWithoutRunning(AppModule, ['error', 'fatal']);
+
+    // Now run the command factory.
+    try {
+        await CommandFactory.runApplication(app);
+    }
+    catch (e) {
+        process.exit(1);
+    }
+
+    // Exit explicitly, make sure that any commands you have created and are using Promises, you do not keep them orphan/dangling.
+    process.exit(0);
+}
+
+// https://github.com/typeorm/typeorm/issues/8583
+// const types = require('pg').types;
+// types.setTypeParser(types.builtins.INT8, function(val) {
+//   return parseInt(val)
+// });
+
+bootstrap();

package/src/dtos/basic-filters.dto.ts

@@ -18,7 +18,7 @@ export class BasicFilterDto extends PaginationQueryDto {
     @ApiProperty({ description: "groupBy" })
     readonly groupBy?: string[];
 
-    
+
     @IsOptional()
     @ApiProperty({ description: "populate" })
     readonly populate?: string[];
@@ -44,4 +44,8 @@ export class BasicFilterDto extends PaginationQueryDto {
     @IsOptional()
     @ApiProperty({ description: "populateGroup" })
     readonly populateGroup?: boolean;
+
+    @IsOptional()
+    @ApiProperty({ description: "groupFilter" })
+    groupFilter?: BasicFilterDto
 }

package/src/index.ts

@@ -222,4 +222,6 @@ export * from './validators/is-parsable-int'
 
 export * from './constants'
 export * from './interfaces'
-export * from './solid-core.module'
+export * from './solid-core.module'
+
+ export * from './winston.logger'

package/src/services/crud.service.ts

@@ -163,7 +163,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
 
     //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): Promise<T> {
-            if (!id) {
+        if (!id) {
             throw new Error('Id is required for update');
         }
         const entity = await this.repo.findOne({
@@ -239,7 +239,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
     }
 
-    private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean=false): FieldCrudManager {
+    private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false): FieldCrudManager {
         const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name };
         switch (fieldMetadata.type) {
             case SolidFieldType.shortText: {
@@ -262,11 +262,11 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                 const options = { ...commonOptions };
                 return new JsonFieldCrudManager(options);
             }
-            case SolidFieldType.int:{
+            case SolidFieldType.int: {
                 const options = { ...commonOptions, min: fieldMetadata.min, max: fieldMetadata.max };
                 return new IntFieldCrudManager(options);
             }
-            case SolidFieldType.decimal:{
+            case SolidFieldType.decimal: {
                 const options = { ...commonOptions, min: fieldMetadata.min, max: fieldMetadata.max };
                 return new DecimalFieldCrudManager(options);
             }
@@ -274,21 +274,21 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                 const options = { ...commonOptions, min: fieldMetadata.min, max: fieldMetadata.max };
                 return new BigIntFieldCrudManager(options);
             }
-            case SolidFieldType.email:{
-                const options = { ...commonOptions, max: fieldMetadata.max?? MAX_EMAIL_LENGTH, regexPattern: fieldMetadata.regexPattern };
+            case SolidFieldType.email: {
+                const options = { ...commonOptions, max: fieldMetadata.max ?? MAX_EMAIL_LENGTH, regexPattern: fieldMetadata.regexPattern };
                 return new EmailFieldCrudManager(options);
             }
             case SolidFieldType.date:
-            case SolidFieldType.datetime:{
+            case SolidFieldType.datetime: {
                 const options = { ...commonOptions };
                 return new DateFieldCrudManager(options);
             }
-            case SolidFieldType.password:{
+            case SolidFieldType.password: {
                 const options = { ...commonOptions, min: fieldMetadata.min, max: fieldMetadata.max, regexPattern: fieldMetadata.regexPattern };
                 return new PasswordFieldCrudManager(options);
             }
             case SolidFieldType.mediaSingle:
-            case SolidFieldType.mediaMultiple:{
+            case SolidFieldType.mediaMultiple: {
                 // update will need to delete the existing media and save the new media    
                 // case 'mediaSingle':
                 //    Use the EntityController to extract uploaded content & pass to the entity service.
@@ -357,13 +357,13 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                     }
                 }
                 else throw new Error('Relation type not supported in crud service');
-            // return (fieldMetadata.relationType === 'many-to-one') ? new ManyToOneRelationFieldCrudManager(fieldMetadata, entityManager) : new ManyToManyRelationFieldCrudManager(fieldMetadata, entityManager); //FIXME many-to-many pending
-            //    ManyToOne -> fieldId. The value is saved as is. No transformation is required
-            //    OneToMany -> fieldIds. Get the value of the oneToMany field side.  No transformation is required (While saving special provision to be made)
-            //    ManyToMany
-            //     break;
+                // return (fieldMetadata.relationType === 'many-to-one') ? new ManyToOneRelationFieldCrudManager(fieldMetadata, entityManager) : new ManyToManyRelationFieldCrudManager(fieldMetadata, entityManager); //FIXME many-to-many pending
+                //    ManyToOne -> fieldId. The value is saved as is. No transformation is required
+                //    OneToMany -> fieldIds. Get the value of the oneToMany field side.  No transformation is required (While saving special provision to be made)
+                //    ManyToMany
+                //     break;
             }
-            case SolidFieldType.selectionStatic:{
+            case SolidFieldType.selectionStatic: {
 
                 //     Validation against the selectionStatic values. No transformation is required
                 //     If the value is not in the selectionStatic values, then throw
@@ -380,12 +380,12 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                 const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: fieldMetadata.selectionDynamicProviderCtxt, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService };
                 return new SelectionDynamicFieldCrudManager(options);
             }
-            case SolidFieldType.uuid:{
+            case SolidFieldType.uuid: {
                 const options = { ...commonOptions };
                 //    If no value is provided, then generate a uuid. Add to the dto
                 return new UUIDFieldCrudManager(options);
             }
-            case SolidFieldType.computed:{
+            case SolidFieldType.computed: {
 
                 //    The value will be computed by the computed provider
                 //    Invoke the appropriate computed provider, get the value and add to the dto
@@ -401,7 +401,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
     async find(basicFilterDto: BasicFilterDto) {
         const alias = 'entity';
         // Extract the required keys from the input query
-        let { limit, offset, populateMedia, populateGroup } = basicFilterDto;
+        let { limit, offset, populateMedia, populateGroup,groupFilter } = basicFilterDto;
 
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
@@ -409,7 +409,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
 
         if (basicFilterDto.groupBy) {
             // Get the records and the count
-            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, populateGroup, alias, populateMedia);
+            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter,populateGroup, alias, populateMedia);
             return {
                 groupMeta,
                 groupRecords,
@@ -417,7 +417,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
         else {
             // Get the records and the count
-            const {meta, records} = await this.handleNonGroupFind(qb, populateMedia, offset, limit);
+            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit);
             return {
                 meta,
                 records,
@@ -433,10 +433,10 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
             await this.handlePopulateMedia(populateMedia, entities);
         }
 
-        return  this.wrapFindResponse(offset, limit, count, entities);
+        return this.wrapFindResponse(offset, limit, count, entities);
     }
 
-    private async handleGroupFind(qb: SelectQueryBuilder<T>, populateGroup: boolean, alias: string, populateMedia: string[]) {
+    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto,populateGroup: boolean, alias: string, populateMedia: string[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -446,11 +446,11 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
             if (populateGroup) {
                 let groupByQb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias);
                 // For the group by records, apply the basic filter
-                const basicFilterDto = {
-                    limit: DEFAULT_LIMIT,
-                    offset: DEFAULT_OFFSET,
-                };
-                groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, basicFilterDto, alias);
+                // const basicFilterDto = {
+                //     limit: DEFAULT_LIMIT,
+                //     offset: DEFAULT_OFFSET,
+                // };
+                groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias);
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
 
@@ -459,7 +459,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                 if (populateMedia && populateMedia.length > 0) {
                     await this.handlePopulateMedia(populateMedia, entities);
                 }
-                const groupData = this.wrapFindResponse(basicFilterDto.offset, basicFilterDto.limit, count, entities);
+                const groupData = this.wrapFindResponse(groupFilter.offset, groupFilter.limit, count, entities);
                 groupRecords.push(this.crudHelperService.createGroupRecords(group, alias, groupData));
             }
             groupMeta.push(this.crudHelperService.createGroupMeta(group, alias));

package/src/solid-core-cli-db.module.ts

@@ -0,0 +1,62 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { join } from 'path';
+import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
+import { WinstonTypeORMLogger } from './winston.logger';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+
+@Module({
+    imports: [
+        TypeOrmModule.forRootAsync({
+            // This becomes the default by default.
+            // name: 'default',
+            useFactory: (logger: Logger) => {
+
+                const entities = [
+                    join(__dirname, './entities/*.entity.{ts,js}'),
+                ];
+
+                // DO NOT REMOVE BELOW COMMENT
+                // We no longer register subscribers on the TypeORM datasource. 
+                // instead we register them directly as NestJS providers, and they register themselves as subscribers on the data source during service instantiation in their respective constructor. 
+                // check ModelSubscriber for a reference. 
+                // Steps are    
+                // 1. Create the subscriber like a NestJS injectable service. 
+                // 2. Register the subscriber in the respective module like you would any other NestJS service. 
+                // 3. Make sure to not provide the subscribers array below. 
+                // const subscribers = [
+                //     join(__dirname, './app-builder/subscribers/*.subscriber.{ts,js}'),
+                //     join(__dirname, './common/subscribers/*.subscriber.{ts,js}'),
+                //     join(__dirname, './iam/subscribers/*.subscriber.{ts,js}'),
+                //     join(__dirname, './queues/subscribers/*.subscriber.{ts,js}'),
+                //     ...enabledModules.map(module =>
+                //         join(__dirname, `./${module}/subscribers/*.subscriber.{ts,js}`)
+                //     ),
+                // ];
+
+                return {
+                    // type of our database. 
+                    type: 'postgres',
+                    host: process.env.DEFAULT_DATABASE_HOST,
+                    port: +process.env.DEFAULT_DATABASE_PORT,
+                    username: process.env.DEFAULT_DATABASE_USER,
+                    password: process.env.DEFAULT_DATABASE_PASSWORD,
+                    // name of our database
+                    database: process.env.DEFAULT_DATABASE_NAME,
+                    // models will be loaded automatically
+                    // autoLoadEntities: true,
+                    entities: entities,
+                    // your entities will be synced with the database (recommended: disable in prod)
+                    synchronize: Boolean(process.env.DEFAULT_DATABASE_SYNCHRONIZE),
+                    logging: Boolean(process.env.DEFAULT_DATABASE_LOGGING),
+                    // logger: new WinstonTypeORMLogger(logger),  // Pass in the custom WinstonLogger
+                    namingStrategy: new SnakeNamingStrategy(),
+                    // subscribers: subscribers
+                }
+            },
+            inject: [WINSTON_MODULE_PROVIDER]
+        }),
+    ],
+})
+export class SolidCoreCliDBModule{
+}

package/src/solid-core-cli.module.ts

@@ -0,0 +1,40 @@
+import { Module } from '@nestjs/common';
+import { SolidCoreCliDBModule } from './solid-core-cli-db.module';
+import { SolidCoreModule } from './solid-core.module'; // Import main module
+import { WinstonLoggerConfig } from './winston.logger';
+import { WinstonModule } from 'nest-winston';
+import { CacheModule } from '@nestjs/cache-manager';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+import { RedisOptions } from './config/redis.options';
+import { ConfigModule } from '@nestjs/config';
+import Joi from '@hapi/joi';
+
+@Module({
+  imports: [
+    WinstonModule.forRoot(WinstonLoggerConfig),
+    ConfigModule.forRoot({
+      isGlobal: true,
+      // Here we are specifying the path of the environment file.
+      // If not specified then it assumes a file named .env
+      // envFilePath: '.environment'
+
+      // This we do in live environments, where these variables should ideally come 
+      // from the OS provided environment.
+      // ignoreEnvFile: true
+
+      validationSchema: Joi.object({
+        DEFAULT_DATABASE_HOST: Joi.required(),
+        DEFAULT_DATABASE_PORT: Joi.number().default(5432),
+      }),
+
+      // load: [appConfig],
+    }),
+
+    SolidCoreCliDBModule,
+    CacheModule.registerAsync(RedisOptions),
+    EventEmitterModule.forRoot(),
+    SolidCoreModule, // Import main module without exposing forRoot()
+  ],
+  exports: [SolidCoreModule], // Ensure CLI can use all exports
+})
+export class SolidCoreCliModule{}

package/src/solid-core.module.ts

@@ -121,17 +121,17 @@ import { Msg91SMSService } from './services/sms/Msg91SMSService';
 import { Msg91WhatsappService } from './services/whatsapp/Msg91WhatsappService';
 import { SoftDeleteAwareEventSubscriber } from './subscribers/softDeleteAwareEventSubscriber.subscriber';
 
+import { PermissionMetadataController } from './controllers/permission-metadata.controller';
 import { PermissionMetadata } from './entities/permission-metadata.entity';
 import { PermissionMetadataService } from './services/permission-metadata.service';
-import { PermissionMetadataController } from './controllers/permission-metadata.controller';
 
-import { RoleMetadata } from './entities/role-metadata.entity';
-import { RoleMetadataService } from './services/role-metadata.service';
 import { RoleMetadataController } from './controllers/role-metadata.controller';
-import { PermissionMetadataSeederService } from './seeders/permission-metadata-seeder.service';
+import { UserController } from './controllers/user.controller';
+import { RoleMetadata } from './entities/role-metadata.entity';
 import { User } from './entities/user.entity';
+import { PermissionMetadataSeederService } from './seeders/permission-metadata-seeder.service';
+import { RoleMetadataService } from './services/role-metadata.service';
 import { UserService } from './services/user.service';
-import { UserController } from './controllers/user.controller';
 
 
 @Global()
@@ -311,6 +311,8 @@ import { UserController } from './controllers/user.controller';
     AuthenticationService,
     MqMessageQueueService,
     MqMessageService,
+    RefreshModelCommand,
+    RefreshModuleCommand,
   ],
 })
 export class SolidCoreModule { }

package/src/winston.logger.ts

@@ -0,0 +1,70 @@
+
+import { Logger as TypeORMLogger, QueryRunner } from 'typeorm';
+import { Logger } from 'winston';
+import { Inject } from '@nestjs/common';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import * as winston from 'winston';
+
+export const WinstonLoggerConfig = {
+    level: 'debug', // Allow all log levels for debugging
+    format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.errors({ stack: true }),
+        winston.format.printf(({ level, message, timestamp }) => {
+            if (!message) {
+                return `[${timestamp}] ${level.toUpperCase()}: (No message provided)`;
+            }
+            return `[${timestamp}] ${level.toUpperCase()}: ${message}`;
+        }),
+    ),
+    transports: [
+        new winston.transports.Console({
+            format: winston.format.combine(
+                // winston.format.colorize(),
+                // winston.format.timestamp(),
+                winston.format.printf(({ level, message, timestamp }) => {
+                    return `[${timestamp}] ${level.toUpperCase()}: ${message}`;
+                }),
+            ),
+        }),
+        new winston.transports.File({
+            filename: 'logs/application.log',
+            // format: winston.format.json(),
+        }),
+        new winston.transports.File({
+            filename: 'logs/error.log',
+            level: 'error',
+            // format: winston.format.json(),
+        }),
+    ],
+};
+
+export class WinstonTypeORMLogger implements TypeORMLogger {
+    constructor(@Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger) { }
+
+    logQuery(query: string, parameters?: any[], queryRunner?: QueryRunner): void {
+        if (Boolean(process.env.DEFAULT_DATABASE_LOGGING)) {
+            this.logger.info(`Query: ${query} Parameters: ${parameters}`);
+        }
+    }
+
+    logQueryError(error: string, query: string, parameters?: any[], queryRunner?: QueryRunner): void {
+        this.logger.error(`Query failed: ${error} | Query: ${query} | Parameters: ${parameters}`);
+    }
+
+    logQuerySlow(time: number, query: string, parameters?: any[], queryRunner?: QueryRunner): void {
+        this.logger.warn(`Slow query: ${time}ms | Query: ${query} | Parameters: ${parameters}`);
+    }
+
+    logSchemaBuild(message: string, queryRunner?: QueryRunner): void {
+        this.logger.info(`Schema Build: ${message}`);
+    }
+
+    logMigration(message: string, queryRunner?: QueryRunner): void {
+        this.logger.info(`Migration: ${message}`);
+    }
+
+    log(level: 'log' | 'info' | 'warn' | 'error', message: any): void {
+        this.logger[level](message);
+    }
+}