@solidstarters/solid-core 1.2.73 → 1.2.76

package/src/services/excel.service.ts

@@ -0,0 +1,105 @@
+import { Injectable, Logger } from '@nestjs/common';
+import * as ExcelJS from 'exceljs';
+import { PassThrough, Readable } from 'stream';
+
+
+@Injectable()
+export class ExcelService {
+  private logger = new Logger(ExcelService.name);
+  // Sample JSON data
+  // const jsonData = [
+  //   { id: 1, name: 'John Doe', age: 25, email: 'john@example.com' },
+  //   { id: 2, name: 'Jane Doe', age: 28, email: 'jane@example.com' },
+  //   { id: 3, name: 'Alice Smith', age: 30, email: 'alice@example.com' }
+  // ];
+
+  // public async createExcelFromJson(data: any[], fileName: string) {
+  //   const workbook = new ExcelJS.Workbook();
+  //   const worksheet = workbook.addWorksheet('Data');
+
+  //   // Define Columns (Header)
+  //   worksheet.columns = Object.keys(data[0]).map((key) => ({
+  //     header: key.toUpperCase(), // Convert header names to uppercase
+  //     key: key,
+  //     width: 20, // Set column width
+  //   }));
+
+  //   // Add Data Rows
+  //   data.forEach((item) => {
+  //     worksheet.addRow(item);
+  //   });
+
+  //   // Apply basic formatting
+  //   worksheet.getRow(1).font = { bold: true }; // Make headers bold
+
+  //   // Save file
+  //   await workbook.xlsx.writeFile(fileName);
+  //   this.logger.log(`✅ Excel file "${fileName}" created successfully!`);
+  //   // console.log(`✅ Excel file "${fileName}" created successfully!`);
+  // }
+
+  // public async createExcelStreamFromJson(data: any[]): Promise<Readable> {
+  //   const passThrough = new PassThrough(); // Stream to pipe data
+  //   const workbook = new ExcelJS.stream.xlsx.WorkbookWriter({ stream: passThrough });
+  //   const worksheet = workbook.addWorksheet('Data');
+  //   worksheet.columns = Object.keys(data[0]).map((key) => ({
+  //     header: key.toUpperCase(),
+  //     key: key,
+  //     width: 20,
+  //   }));
+
+  //   data.forEach((item) => {
+  //     worksheet.addRow(item);
+  //   });
+
+  //   worksheet.getRow(1).font = { bold: true };
+
+  //   await workbook.commit();
+  //   return passThrough;
+  // }
+
+
+  public async createExcelStream(
+    getDataRecords: (chunkIndex: number, chunkSize: number) => Promise<any[]>,
+    chunkSize: number
+  ): Promise<Readable> {
+    const passThrough = new PassThrough(); // Create streaming pipe
+    try {
+      const workbook = new ExcelJS.stream.xlsx.WorkbookWriter({ stream: passThrough });
+      const worksheet = workbook.addWorksheet('Data');
+
+      let chunkIndex = 0;
+      let isHeaderWritten = false;
+
+      while (true) {
+        const records = await getDataRecords(chunkIndex, chunkSize); // Fetch chunked data
+        if (records.length === 0) break; // Stop if no more records
+
+        if (!isHeaderWritten) {
+          worksheet.columns = Object.keys(records[0]).map((key) => ({
+            header: key.toUpperCase(),
+            key: key,
+            width: 20,
+          }));
+          isHeaderWritten = true;
+        }
+
+        records.forEach((item) => {
+          worksheet.addRow(item).commit(); // Commit each row immediately
+        });
+
+        chunkIndex++; // Fetch next chunk
+        this.logger.debug(`✅ Chunk ${chunkIndex} written to Excel`);
+      }
+
+      await workbook.commit();
+      // passThrough.end(); // ✅ Properly close the stream
+    } catch (error) {
+      this.logger.error(`❌ Error writing Excel: ${error.message}`);
+      passThrough.destroy(error); // Destroy stream
+      throw error;
+    }
+    return passThrough; // Return streaming response
+  }
+
+}

package/src/services/export-template.service.ts

@@ -0,0 +1,71 @@
+import { Injectable } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } from 'typeorm';
+
+import { ConfigService } from '@nestjs/config';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { CRUDService } from 'src/services/crud.service';
+import { FileService } from 'src/services/file.service';
+import { MediaStorageProviderMetadataService } from 'src/services/media-storage-provider-metadata.service';
+import { MediaService } from 'src/services/media.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+
+
+import { CreateExportTransactionDto } from 'src/dtos/create-export-transaction.dto';
+import { ExportTransaction } from 'src/entities/export-transaction.entity';
+import { Readable } from 'stream';
+import { ExportTemplate } from '../entities/export-template.entity';
+import { ExportTransactionFileInfo, ExportTransactionService } from './export-transaction.service';
+
+@Injectable()
+export class ExportTemplateService extends CRUDService<ExportTemplate>{
+  async startExportSync(id: number): Promise<ExportTransactionFileInfo> {
+    // Create the export transaction entry, with status 'started'
+    const exportTransaction: CreateExportTransactionDto =  await this.exportTransactionService.toDto({
+      datetime: new Date(),
+      status: 'started',
+      exportTemplateId: id,
+    });
+    const exportTransactionEntity = await this.exportTransactionService.create(exportTransaction);
+
+    // Trigger the export process
+    const exportFileInfo = await this.exportTransactionService.triggerExportSync(exportTransactionEntity.id);
+    // It should return the export transaction id
+    return exportFileInfo;
+  }
+
+  async startExportAsync(id: number): Promise<ExportTransaction>{
+    // Create the export transaction entry, with status 'started'
+    const exportTransaction: CreateExportTransactionDto =  await this.exportTransactionService.toDto({
+      datetime: new Date(),
+      status: 'started',
+      exportTemplateId: id,
+    });
+    const exportTransactionEntity = await this.exportTransactionService.create(exportTransaction);
+
+    // Trigger the export process
+    this.exportTransactionService.triggerExportAsync(exportTransactionEntity.id);
+
+    // It should return the export transaction id, so client can use this to check the status
+    return exportTransactionEntity;
+  }
+
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ExportTemplate, 'default')
+    readonly repo: Repository<ExportTemplate>,
+    readonly exportTransactionService: ExportTransactionService,
+    readonly moduleRef: ModuleRef
+ ) {
+   super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService,entityManager, repo, 'exportTemplate', 'solid-core',moduleRef);
+ }
+}

package/src/services/export-transaction.service.ts

@@ -0,0 +1,208 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } from 'typeorm';
+
+import { ConfigService } from '@nestjs/config';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { CRUDService } from 'src/services/crud.service';
+import { FileService } from 'src/services/file.service';
+import { MediaStorageProviderMetadataService } from 'src/services/media-storage-provider-metadata.service';
+import { MediaService } from 'src/services/media.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+
+
+import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { validate } from 'class-validator';
+import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
+import { CreateExportTransactionDto } from 'src/dtos/create-export-transaction.dto';
+import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { Readable } from 'stream';
+import { ExportTransaction } from '../entities/export-transaction.entity';
+import { CsvService } from './csv.service';
+import { ExcelService } from './excel.service';
+import { getMediaStorageProvider } from './mediaStorageProviders';
+import { SolidIntrospectService } from './solid-introspect.service';
+
+const EXPORT_CHUNK_SIZE = 100;
+enum ExportStatus {
+  STARTED = 'started',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+}
+
+enum ExportFormat {
+  CSV = 'csv',
+  EXCEL = 'excel',
+}
+
+export interface ExportTransactionFileInfo {
+  exportStream: Readable;
+  fileName: string;
+  mimeType: string;
+  exportTransaction: ExportTransaction;
+}
+
+@Injectable()
+export class ExportTransactionService extends CRUDService<ExportTransaction> {
+  private logger = new Logger(ExportTransactionService.name);
+
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ExportTransaction, 'default')
+    readonly repo: Repository<ExportTransaction>,
+    readonly introspectService: SolidIntrospectService,
+    readonly excelService: ExcelService,
+    readonly csvService: CsvService,
+    // readonly fieldMetadataService: FieldMetadataService,
+    @InjectRepository(FieldMetadata, 'default')
+    readonly fieldRepo: Repository<FieldMetadata>,
+    readonly moduleRef: ModuleRef
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'exportTransaction', 'solid-core',moduleRef);
+  }
+
+  // Return the export stream
+  async triggerExportSync(id: number): Promise<ExportTransactionFileInfo> {
+    try {
+      const loadedExportTransaction = await this.loadExportTransaction(id);
+      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(loadedExportTransaction);
+      this.updateExportTransaction(id, ExportStatus.COMPLETED);
+      const fileName = this.getFileName(templateName, uuid, loadedExportTransaction.exportTemplate.templateFormat);
+      const mimeType = this.getMimeType(loadedExportTransaction.exportTemplate.templateFormat);
+      return { exportStream, fileName, mimeType, exportTransaction };
+    } catch (error) {
+      this.updateExportTransaction(id, ExportStatus.FAILED, error.message);
+      throw error;
+    }
+  }
+
+  // Store the export stream using the appropriate storage provider
+  async triggerExportAsync(id: number): Promise<void> {
+    try {
+      const loadedExportTransaction = await this.loadExportTransaction(id)
+      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(loadedExportTransaction);
+      const fileFormat = loadedExportTransaction.exportTemplate.templateFormat;
+      // Store the file using the appropriate storage provider
+      await this.storeExportStream(exportStream, exportTransaction, this.getFileName(templateName, uuid, fileFormat));
+      this.updateExportTransaction(id, ExportStatus.COMPLETED);
+    } catch (error) {
+      this.updateExportTransaction(id, ExportStatus.FAILED, error.message);
+      throw error;
+
+    }
+  }
+
+  private async loadExportTransaction(id: number) {
+    return await this.repo.findOne({
+      where: { id: id },
+      relations: { exportTemplate: { modelMetadata: true } },
+    }
+    );
+  }
+
+  private async updateExportTransaction(id: number, status: string, error?: string) {
+    await this.repo.update(id, { status, error });
+  }
+
+  private async getExportStreamDetails(exportTransaction: ExportTransaction) {
+    // Get the columns which need to be exported & the model id
+    const fields = JSON.parse(exportTransaction.exportTemplate.fields);
+
+    // Get the appropriate service for the model by trying to fetch a model service matching a particular name
+    const modelName = exportTransaction.exportTemplate.modelMetadata.singularName;
+    const modelService = this.introspectService.getProvider(`${classify(modelName)}Service`);
+    const templateName = exportTransaction.exportTemplate.templateName;
+    const uuid = exportTransaction.exportTransactionId; //TODO can be renamed to exportTransactionUUID
+
+
+    // Get the data records function
+    const dataRecordsFunc = await this.getDataRecordsFunc(fields, modelService);
+
+    // Get the export passthru stream (since it is a passthru stream, nothing is stored in memory & it is streamed directly when the stream is read)
+    let exportStream = await this.getExportStream(exportTransaction.exportTemplate.templateFormat, dataRecordsFunc);
+    return { exportStream, templateName, uuid, exportTransaction };
+  }
+
+  private async getExportStream(templateFormat: string, dataRecordsFunc: (chunkIndex: number, chunkSize: number) => Promise<any[]>) {
+    let exportStream = null;
+    switch (templateFormat) {
+      case ExportFormat.EXCEL:
+        exportStream = await this.excelService.createExcelStream(dataRecordsFunc, EXPORT_CHUNK_SIZE);
+        break;
+      case ExportFormat.CSV:
+        exportStream = await await this.csvService.createCsvStream(dataRecordsFunc, EXPORT_CHUNK_SIZE);
+        break;
+      default:
+        throw new Error('Invalid export format');
+    }
+    return exportStream;
+  }
+
+  private async storeExportStream(exportStream: Readable, exportTransaction: ExportTransaction, fileName: string) {
+    const exportedFileMediaField = await this.fieldRepo.findOne({
+      where: {
+        name: 'exportedFile',
+        model: {
+          singularName: 'exportTransaction'
+        },
+      },
+      relations: ['model', 'mediaStorageProvider'],
+    });
+    // const storageProvider = new FileStorageProvider<ExportTransaction>(this.configService, this.fileService, this.mediaService);
+    const storageProviderMetadata = exportedFileMediaField.mediaStorageProvider;
+
+    // // Use the storage provider metadata to get the appropriate storage provider implementation
+    const storageProviderType = storageProviderMetadata.type as MediaStorageProviderType;
+
+    // // Get the storage provider implementation
+    const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
+
+    //Commented the below code since we will be direclty images from server on call from ui 
+    await storageProvider.storeStreams([[exportStream, fileName]], exportTransaction, exportedFileMediaField)
+  }
+
+  private getFileName(templateName: string, exportTransactionUUID: string, fileFormat: string): string {
+    const extension = (fileFormat === ExportFormat.EXCEL) ? 'xlsx' : 'csv';
+    return `${dasherize(templateName)}-${exportTransactionUUID}.${extension}`;
+  }
+
+  private getMimeType(fileFormat: string): string {
+    return (fileFormat === ExportFormat.EXCEL) ? 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' : 'text/csv';
+  }
+
+  private async getDataRecordsFunc(fields: any, modelService: InstanceWrapper<any>): Promise<(chunkIndex: number, chunkSize: number) => Promise<any[]>> {
+    // Return a function which will take the chunkIndex & chunkSize and return the data
+    return async (chunkIndex: number, chunkSize: number) => {
+      const offset = chunkIndex * chunkSize;
+      const recordFilterDto: BasicFilterDto = {
+        fields,
+        limit: chunkSize,
+        offset,
+      };
+      const data = await modelService.instance.find(recordFilterDto);
+      const records = data.records ?? [];
+      return records;
+    }
+  }
+
+  async toDto(data: Partial<CreateExportTransactionDto>): Promise<CreateExportTransactionDto> {
+    const dto = new CreateExportTransactionDto(data);
+    const errors = await validate(dto);
+    if (errors.length > 0) {
+      console.error("Validation failed:", errors);
+      return null;
+    }
+    return dto;
+  }
+}

package/src/services/export_issues.txt

@@ -0,0 +1,6 @@
+1. Do i need to create a storeStreams method for aws service too?
+    - Handle later
+2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
+    - startExport should either return the data or return the transaction id
+3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
+    - show the userKey

package/src/services/file.service.ts

@@ -1,10 +1,11 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { Inject, Injectable, Logger } from '@nestjs/common';
 import * as fs from 'fs';
 // import * as AWS from 'aws-sdk';
 import { S3Client, PutObjectCommand, DeleteObjectCommand, ObjectCannedACL } from '@aws-sdk/client-s3';
 import { ConfigType } from '@nestjs/config';
 import commonConfig, { AwsS3Config } from '../config/common.config';
 import path from 'path';
+import { Readable } from 'stream';
 
 
 
@@ -13,6 +14,7 @@ import path from 'path';
 export class FileService {
 
   private readonly s3Client: S3Client;
+  private readonly logger = new Logger(FileService.name);
 
   constructor(
     @Inject(commonConfig.KEY)
@@ -164,4 +166,27 @@ export class FileService {
   private isValidS3Config(config: AwsS3Config): boolean {
     return !!config.S3_AWS_ACCESS_KEY && !!config.S3_AWS_SECRET_KEY && !!config.S3_AWS_REGION_NAME;
   }
+  
+  /**
+   * Save a stream to a file
+   * @param stream - Readable stream
+   * @param filePath - Destination file path
+   * @returns Promise<void>
+   */
+  public async writeStreamToFile(stream: Readable, filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const writeStream = fs.createWriteStream(filePath);
+      stream.pipe(writeStream);
+
+      writeStream.on('finish', () => {
+        this.logger.debug(`✅ File saved: ${filePath}`);
+        resolve();
+      });
+
+      writeStream.on('error', (err) => {
+        this.logger.debug(`❌ Error saving file: ${filePath}`, err);
+        reject(err);
+      });
+    });
+  }
 }

package/src/services/mediaStorageProviders/file-s3-storage-provider.ts

@@ -1,11 +1,11 @@
-import { Inject, Injectable, Logger } from "@nestjs/common";
-import { ConfigService, ConfigType } from "@nestjs/config";
-import { MediaStorageProvider } from "src/interfaces";
-import { FileService } from "src/services/file.service";
-import { Media } from "src/entities/media.entity";
+import { Injectable, Logger } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
 import { CommonEntity } from "src/entities/common.entity";
 import { FieldMetadata } from "src/entities/field-metadata.entity";
-import appBuilderConfig from "src/config/app-builder.config";
+import { Media } from "src/entities/media.entity";
+import { MediaStorageProvider } from "src/interfaces";
+import { FileService } from "src/services/file.service";
+import { Readable } from "stream";
 import { MediaRepository } from "src/repository/media.repository";
 
 @Injectable()
@@ -19,6 +19,9 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         readonly fileService: FileService,
         readonly mediaRepository: MediaRepository
     ) { }
+    storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
+        throw new Error("Method not implemented.");
+    }
     async retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
         if (!(entity instanceof CommonEntity)) {
             throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity

package/src/services/mediaStorageProviders/file-storage-provider.ts

@@ -1,11 +1,12 @@
-import { Inject, Injectable, Logger } from "@nestjs/common";
-import { ConfigService, ConfigType } from "@nestjs/config";
-import { MediaStorageProvider } from "src/interfaces";
-import { FileService } from "src/services/file.service";
-import { Media } from "src/entities/media.entity";
+import { Injectable, Logger } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
 import { CommonEntity } from "src/entities/common.entity";
 import { FieldMetadata } from "src/entities/field-metadata.entity";
+import { Media } from "src/entities/media.entity";
+import { MediaStorageProvider } from "src/interfaces";
 import { MediaRepository } from "src/repository/media.repository";
+import { FileService } from "src/services/file.service";
+import { Readable } from "stream";
 
 @Injectable()
 export class FileStorageProvider<T> implements MediaStorageProvider<T> {
@@ -40,8 +41,8 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
         files.forEach(async (file) => {
             // Store the file in the configured file storage directory
             const fileStoragePath = this.getFullFilePath(this.getFileName(file));
-            this.fileService.copyFile(file.path, fileStoragePath);
-            this.fileService.deleteFile(file.path);
+            await this.fileService.copyFile(file.path, fileStoragePath);
+            await this.fileService.deleteFile(file.path);
 
             // Create an entry in the media table
             const mediaEntity = await this.mediaRepository.createMedia({
@@ -60,6 +61,27 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
         return result;
     }
 
+    async storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
+        if (!(entity instanceof CommonEntity)) {
+            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        }
+        const result: Media[] = [];
+        streamPairs.forEach(async (pair) => {
+            const stream = pair[0];
+            const fileName = pair[1];
+            this.fileService.writeStreamToFile(stream, fileName);
+            const mediaEntity = await this.mediaRepository.createMedia({
+                entityId: entity.id,
+                modelMetadataId: mediaFieldMetadata.model.id,
+                relativeUri: fileName,
+                mediaStorageProviderMetadataId: mediaFieldMetadata.mediaStorageProvider.id,
+                fieldMetadataId: mediaFieldMetadata.id
+            }) as unknown as Media;
+            this.logger.debug(`Stored media with`, mediaEntity);
+        });
+        return result;
+    }
+
     async delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void> {
         if (!(entity instanceof CommonEntity)) {
             throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity

package/src/services/solid-introspect.service.ts

@@ -80,6 +80,7 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
       .getProviders()
       .filter((provider) => this.isModule(provider));
     this.solidRegistry.registerModules(allModules);
+
   }
 
   // This method identifies a provider as a seeder if it has a seed method i.e duck typing

package/src/solid-core.module.ts

@@ -161,8 +161,17 @@ import { ChatterMessageDetails } from './entities/chatter-message-details.entity
 import { ChatterMessageDetailsService } from './services/chatter-message-details.service';
 import { ChatterMessageDetailsController } from './controllers/chatter-message-details.controller';
 import { AuditSubscriber } from './subscribers/audit.subscriber';
+import { ExportTemplate } from './entities/export-template.entity';
+import { ExportTemplateService } from './services/export-template.service';
+import { ExportTemplateController } from './controllers/export-template.controller';
+import { ExportTransaction } from './entities/export-transaction.entity';
+import { ExportTransactionService } from './services/export-transaction.service';
+import { ExportTransactionController } from './controllers/export-transaction.controller';
+import { ExcelService } from './services/excel.service';
+import { CsvService } from './services/csv.service';
 import { ClsModule } from 'nestjs-cls';
 
+
 @Global()
 @Module({
   imports: [
@@ -212,6 +221,8 @@ import { ClsModule } from 'nestjs-cls';
     TypeOrmModule.forFeature([ListOfValues]),
     TypeOrmModule.forFeature([ChatterMessage]),
     TypeOrmModule.forFeature([ChatterMessageDetails]),
+    TypeOrmModule.forFeature([ExportTemplate]),
+    TypeOrmModule.forFeature([ExportTransaction]),
     // TypeOrmModule.forFeature([User]),
     ClsModule.forRoot({
       middleware: {
@@ -247,7 +258,9 @@ import { ClsModule } from 'nestjs-cls';
     SavedFiltersController,
     ListOfValuesController,
     ChatterMessageController,
-    ChatterMessageDetailsController
+    ChatterMessageDetailsController,
+    ExportTemplateController,
+    ExportTransactionController,
   ],
   providers: [
     {
@@ -352,6 +365,10 @@ import { ClsModule } from 'nestjs-cls';
     ChatterMessageService,
     ChatterMessageDetailsService,
     AuditSubscriber,
+    ExportTemplateService,
+    ExportTransactionService,
+    ExcelService,
+    CsvService,
   ],
   exports: [
     ModuleMetadataService,