@solidstarters/solid-core 1.2.88 → 1.2.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.88",
+  "version": "1.2.89",
   "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/export-template.controller.ts

@@ -5,6 +5,7 @@ import { ExportTemplateService } from '../services/export-template.service';
 import { CreateExportTemplateDto } from '../dtos/create-export-template.dto';
 import { UpdateExportTemplateDto } from '../dtos/update-export-template.dto';
 import { Response } from 'express';
+import { StartExportSyncDto } from 'src/dtos/export.dto';
 
 @ApiTags('Solid') 
 @Controller('export-template') //FIXME: Change this to the model plural name 
@@ -74,13 +75,19 @@ export class ExportTemplateController {
   }
 
   @ApiBearerAuth("jwt")
-  @Post(':id/startExport/sync')
-  async startExportSync(@Param('id') id: number, @Res() res: Response) {
-    const exportFileInfo = await this.service.startExportSync(+id);
+  @Post('/startExport/sync')
+  async startExportSync(@Body() dto: StartExportSyncDto, @Res() res: Response) {
+    const { filters, ...rest } = dto;
+    let updateDto = { ...rest };
+    // Check if templateName is present → create template
+    if (updateDto?.templateName) {
+      const newTemplate = await this.service.create(updateDto, []);
+      updateDto = { ...updateDto, id: newTemplate.id };
+    }
+    const exportFileInfo = await this.service.startExportSync(updateDto, filters);
     if (exportFileInfo.exportStream === null) {
       throw new InternalServerErrorException("Export stream is null");
     }
-
     // ✅ Set response headers for streaming
     res.setHeader('Content-Disposition', `attachment; filename="${exportFileInfo.fileName}"`);
     res.setHeader('Content-Type', exportFileInfo.mimeType);
@@ -90,9 +97,15 @@ export class ExportTemplateController {
   }
 
   @ApiBearerAuth("jwt")
-  @Post(':id/startExport/async')
-  async startExportAsync(@Param('id') id: number) {
-    return this.service.startExportAsync(+id);
+  @Post('/startExport/async')
+  async startExportAsync(@Body() dto: StartExportSyncDto) {
+    const { filters, ...rest } = dto;
+    let updateDto = { ...rest };
+    if (updateDto.templateName) {
+      const newTemplate = await this.service.create(updateDto, []);
+      updateDto = { ...updateDto, id: newTemplate.id };
+    }
+    return this.service.startExportAsync(updateDto, filters);
   }
 
 }

package/src/dtos/export.dto.ts

@@ -0,0 +1,5 @@
+import { UpdateExportTemplateDto } from "./update-export-template.dto";
+
+export class StartExportSyncDto extends UpdateExportTemplateDto {
+    filters?: any;
+  }

package/src/entities/export-transaction.entity.ts

@@ -17,6 +17,6 @@ export class ExportTransaction extends CommonEntity {
     @Column({ type: "text", nullable: true })
     error: string;
     @Index()
-    @ManyToOne(() => ExportTemplate, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ExportTemplate, { onDelete: "CASCADE", nullable: true })
     exportTemplate: ExportTemplate;
 }

package/src/seeders/seed-data/solid-core-metadata.json

@@ -3564,7 +3564,7 @@
             "displayName": "Related Export Template",
             "type": "relation",
             "ormType": "int",
-            "required": true,
+            "required": false,
             "unique": false,
             "index": true,
             "private": false,

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

@@ -18,35 +18,36 @@ 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';
+import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
 
 @Injectable()
 export class ExportTemplateService extends CRUDService<ExportTemplate>{
-  async startExportSync(id: number): Promise<ExportTransactionFileInfo> {
+  async startExportSync(updateDto: UpdateExportTemplateDto, filters:any): Promise<ExportTransactionFileInfo> {
     // Create the export transaction entry, with status 'started'
     const exportTransaction: CreateExportTransactionDto =  await this.exportTransactionService.toDto({
       datetime: new Date(),
       status: 'started',
-      exportTemplateId: id,
+      exportTemplateId: updateDto?.id ? updateDto?.id : null,
     });
     const exportTransactionEntity = await this.exportTransactionService.create(exportTransaction);
 
     // Trigger the export process
-    const exportFileInfo = await this.exportTransactionService.triggerExportSync(exportTransactionEntity.id);
+    const exportFileInfo = await this.exportTransactionService.triggerExportSync(exportTransactionEntity.id, exportTransactionEntity, updateDto, filters);
     // It should return the export transaction id
     return exportFileInfo;
   }
 
-  async startExportAsync(id: number): Promise<ExportTransaction>{
+  async startExportAsync(updateDto: UpdateExportTemplateDto,  filters:any): Promise<ExportTransaction>{
     // Create the export transaction entry, with status 'started'
     const exportTransaction: CreateExportTransactionDto =  await this.exportTransactionService.toDto({
       datetime: new Date(),
       status: 'started',
-      exportTemplateId: id,
+      exportTemplateId: updateDto?.id ? updateDto?.id : null,
     });
     const exportTransactionEntity = await this.exportTransactionService.create(exportTransaction);
 
     // Trigger the export process
-    this.exportTransactionService.triggerExportAsync(exportTransactionEntity.id);
+    this.exportTransactionService.triggerExportAsync(exportTransactionEntity.id, exportTransactionEntity, updateDto, filters);
 
     // It should return the export transaction id, so client can use this to check the status
     return exportTransactionEntity;

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

@@ -26,6 +26,8 @@ import { CsvService } from './csv.service';
 import { ExcelService } from './excel.service';
 import { getMediaStorageProvider } from './mediaStorageProviders';
 import { SolidIntrospectService } from './solid-introspect.service';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
 
 const EXPORT_CHUNK_SIZE = 100;
 enum ExportStatus {
@@ -67,19 +69,30 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     // readonly fieldMetadataService: FieldMetadataService,
     @InjectRepository(FieldMetadata, 'default')
     readonly fieldRepo: Repository<FieldMetadata>,
+    @InjectRepository(ModelMetadata, 'default')
+    readonly ModelMetadataRepo : Repository<ModelMetadata>,
     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> {
+  async triggerExportSync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto , filters: any): Promise<ExportTransactionFileInfo> {
     try {
-      const loadedExportTransaction = await this.loadExportTransaction(id);
-      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(loadedExportTransaction);
+      // const loadedExportTransaction = await this.loadExportTransaction(id);
+      // from updateDto, get modelId and get modelMetadata
+      const modeldata = await this.ModelMetadataRepo.findOne({
+        where: { id:  updateDto?.modelMetadataId},
+        relations: { fields: true},
+      })
+      const modelName = modeldata?.singularName;
+      const modelTemplateName = modelName;
+      const fields = JSON.parse(updateDto?.fields);
+      const templateFormat = updateDto?.templateFormat;
+      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(modelName, modelTemplateName, fields, modeldata, templateFormat, id, exportTransactionEntity, filters);
       this.updateExportTransaction(id, ExportStatus.COMPLETED);
-      const fileName = this.getFileName(templateName, uuid, loadedExportTransaction.exportTemplate.templateFormat);
-      const mimeType = this.getMimeType(loadedExportTransaction.exportTemplate.templateFormat);
+      const fileName = this.getFileName(templateName, uuid, templateFormat);
+      const mimeType = this.getMimeType(templateFormat);
       return { exportStream, fileName, mimeType, exportTransaction };
     } catch (error) {
       this.updateExportTransaction(id, ExportStatus.FAILED, error.message);
@@ -88,13 +101,22 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
   }
 
   // Store the export stream using the appropriate storage provider
-  async triggerExportAsync(id: number): Promise<void> {
+  async triggerExportAsync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto, filters:any): Promise<void> {
     try {
-      const loadedExportTransaction = await this.loadExportTransaction(id)
-      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(loadedExportTransaction);
-      const fileFormat = loadedExportTransaction.exportTemplate.templateFormat;
+      // const loadedExportTransaction = await this.loadExportTransaction(id)
+      // from updateDto, get modelId and get modelMetadata
+      const modeldata = await this.ModelMetadataRepo.findOne({
+        where: { id:  updateDto?.modelMetadataId},
+        relations: { fields: true},
+      })
+      const modelName = modeldata?.singularName;
+      const modelTemplateName = modelName;
+      const fields = JSON.parse(updateDto?.fields);
+      const templateFormat = updateDto?.templateFormat;
+      const { exportStream, templateName, uuid, exportTransaction } = await this.getExportStreamDetails(modelName, modelTemplateName, fields, modeldata, templateFormat, id, exportTransactionEntity, filters);
+      // const fileFormat = loadedExportTransaction.exportTemplate.templateFormat;
       // Store the file using the appropriate storage provider
-      await this.storeExportStream(exportStream, exportTransaction, this.getFileName(templateName, uuid, fileFormat));
+      await this.storeExportStream(exportStream, exportTransaction, this.getFileName(templateName, uuid, templateFormat));
       this.updateExportTransaction(id, ExportStatus.COMPLETED);
     } catch (error) {
       this.updateExportTransaction(id, ExportStatus.FAILED, error.message);
@@ -106,7 +128,7 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
   private async loadExportTransaction(id: number) {
     return await this.repo.findOne({
       where: { id: id },
-      relations: { exportTemplate: { modelMetadata: true } },
+      relations: { exportTemplate: { modelMetadata: {fields: true} }},
     }
     );
   }
@@ -115,22 +137,26 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     await this.repo.update(id, { status, error });
   }
 
-  private async getExportStreamDetails(exportTransaction: ExportTransaction) {
+  private async getExportStreamDetails(modelName: string, templateName: string, fields:any, modelData:any, templateFormat:string, id:number, exportTransaction: any, filters: any) {
     // 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
+    // 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 = String(id); //TODO can be renamed to exportTransactionUUID
+    // const modelData = exportTransaction.exportTemplate.modelMetadata;
 
     // Get the data records function
-    const dataRecordsFunc = await this.getDataRecordsFunc(fields, modelService);
+    //const dataRecordsFunc = await this.getDataRecordsFunc(fields, modelService,modelData, filters);
+    const dataRecordsFunc = await this.getDataRecordsFunc(fields, modelService, modelData, filters);
 
     // 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);
+    // let exportStream = await this.getExportStream(exportTransaction.exportTemplate.templateFormat, dataRecordsFunc);
+    // return { exportStream, templateName, uuid, exportTransaction };
+
+    let exportStream = await this.getExportStream(templateFormat, dataRecordsFunc);
     return { exportStream, templateName, uuid, exportTransaction };
   }
 
@@ -181,20 +207,78 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     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[]>> {
+  private async getDataRecordsFunc(fields: any, modelService: InstanceWrapper<any>, modelMetadata: any, filters:any): Promise<(chunkIndex: number, chunkSize: number) => Promise<any[]>> {
     // Return a function which will take the chunkIndex & chunkSize and return the data
+    // Get the relation fields to populate
+    const relatedFieldNames = modelMetadata?.fields
+    .filter((field: { relationType: any; }) => field.relationType !== null)
+    .map((field: { name: any; }) => field.name);
+
+    //Get the model metadata of relation field with userKey details
+    const relatedModelsUserKeyMap = new Map<string, string>();
+    for (const field of modelMetadata?.fields || []) {
+      if (field.relationType && field.relationCoModelSingularName && fields.includes(field.name)) {
+        const relatedModelMetadata = await this.ModelMetadataRepo.findOne({
+          where: { singularName: field.relationCoModelSingularName },
+          relations: ['userKeyField'],
+        });
+
+        if (relatedModelMetadata?.userKeyField?.name) {
+          relatedModelsUserKeyMap.set(field.name, relatedModelMetadata.userKeyField.name);
+        }
+      }
+    }
+
     return async (chunkIndex: number, chunkSize: number) => {
       const offset = chunkIndex * chunkSize;
       const recordFilterDto: BasicFilterDto = {
-        fields,
         limit: chunkSize,
         offset,
+        populate: relatedFieldNames
       };
+      const cleanedFilters = cleanNullsFromObject(filters);
+
+      if (cleanedFilters && Object.keys(cleanedFilters).length > 0) {
+        recordFilterDto.filters = cleanedFilters;
+      }
+
+      //Get the non relation fields which are in fields array passed to this function
+      const nonRelationalFieldSet = new Set(
+        modelMetadata?.fields
+          .filter((field: { name: any; relationType: any; }) => fields.includes(field.name) && field.relationType === null)
+          .map((field: { name: any; }) => field.name)
+      );
       const data = await modelService.instance.find(recordFilterDto);
       const records = data.records ?? [];
-      return records;
-    }
+    const cleanedRecords = records.map((record: Record<string, any>) => {
+      const newRecord: Record<string, any> = {};
+    
+      // Include non-relational fields
+      for (const key of nonRelationalFieldSet as Set<string>) {
+        newRecord[key] = record[key];
+      }
+    
+      // Include userKey from each related field
+      for (const [relatedFieldName, userKeyFieldName] of relatedModelsUserKeyMap.entries()) {
+        const relatedData = record[relatedFieldName];
+    
+        if (Array.isArray(relatedData)) {
+          // For many-to-many or one-to-many
+          const values = relatedData.map(item => item?.[userKeyFieldName]).filter(Boolean);
+          newRecord[relatedFieldName] = values.join(', ');
+        } else if (relatedData && typeof relatedData === 'object') {
+          // For many-to-one or one-to-one
+          newRecord[relatedFieldName] = relatedData?.[userKeyFieldName] ?? null;
+        } else {
+          newRecord[relatedFieldName] = null;
+        }
+      }
+    
+      return newRecord;
+    });
+    return cleanedRecords
   }
+}
 
   async toDto(data: Partial<CreateExportTransactionDto>): Promise<CreateExportTransactionDto> {
     const dto = new CreateExportTransactionDto(data);
@@ -206,3 +290,30 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     return dto;
   }
 }
+
+function cleanNullsFromObject(obj: any): any {
+  if (Array.isArray(obj)) {
+    return obj
+      .filter(item => item !== null && item !== undefined)
+      .map(cleanNullsFromObject);
+  } else if (typeof obj === 'object' && obj !== null) {
+    const newObj: any = {};
+    for (const key in obj) {
+      const value = obj[key];
+      if (value !== null && value !== undefined) {
+        const cleanedValue = cleanNullsFromObject(value);
+        // Only assign non-empty objects/arrays or non-null primitives
+        if (
+          (typeof cleanedValue === 'object' && Object.keys(cleanedValue).length > 0) ||
+          (Array.isArray(cleanedValue) && cleanedValue.length > 0) ||
+          typeof cleanedValue !== 'object'
+        ) {
+          newObj[key] = cleanedValue;
+        }
+      }
+    }
+    return newObj;
+  }
+  return obj;
+}
+