@solidstarters/solid-core 1.2.169 → 1.2.170

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.169",
+  "version": "1.2.170",
   "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/filters/http-exception.filter.ts

@@ -33,7 +33,7 @@ export class HttpExceptionFilter implements ExceptionFilter {
         // Canonical code + static message
         const code: ErrorCode = this.errorMapper.mapException(exception);
         const defaultStatus = this.errorMapper.getHttpStatus(code);
-        const message = code === 'unknown-error' ? `${exception?.message}` : this.errorMapper.getMessage(code);
+        const message = code === 'solidx-unknown-error' ? `${exception?.message}` : this.errorMapper.getMessage(code);
 
         const status = explicitStatus ?? defaultStatus ?? 500;
 

package/src/helpers/error-mapper.service.ts

@@ -1,40 +1,6 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ErrorCode, ErrorMeta, ErrorRule, IErrorCodeProvider } from 'src/interfaces';
-
-// export const ERROR_CODES = [
-//     'db-duplicate-key',
-//     'db-foreign-key-error',
-//     'solidx-mcp-server-unavailable',
-//     'unknown-error',
-// ] as const;
-
-// export type ErrorCode = typeof ERROR_CODES[number];
-
-// type ErrorMeta = {
-//     message: string;
-//     httpStatus?: number;
-// };
-
-// const ERROR_MESSAGES: Record<ErrorCode, ErrorMeta> = {
-//     'db-duplicate-key': {
-//         message: 'Duplicate key violation. A record with these values already exists.',
-//         httpStatus: 409,
-//     },
-//     'db-foreign-key-error': {
-//         message: 'Foreign key constraint prevents this operation due to related records.',
-//         httpStatus: 409,
-//     },
-//     'solidx-mcp-server-unavailable': {
-//         message: 'SolidX MCP server is unreachable. Please verify the MCP endpoint.',
-//         httpStatus: 503,
-//     },
-//     'unknown-error': {
-//         message: 'An unexpected error occurred.',
-//         httpStatus: 500,
-//     },
-// };
-
 @Injectable()
 export class ErrorMapperService {
     private readonly logger = new Logger(ErrorMapperService.name);
@@ -76,7 +42,7 @@ export class ErrorMapperService {
                 this.logger.warn(`Error rule threw in match(): code=${rule.code} provider? — ${e}`);
             }
         }
-        return 'unknown-error';
+        return 'solidx-unknown-error';
     }
 
     private lookupMeta(code: ErrorCode): ErrorMeta | undefined {

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

@@ -122,7 +122,7 @@ export class ModelMetadataHelperService {
                 }
             }
         });
-        const fields = [];
+        const fields: any[] = [];
         if (model) {
             // Add the fields of the current model
             fields.push(...model.fields);

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

@@ -29,6 +29,7 @@ import { SolidIntrospectService } from './solid-introspect.service';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 
 const EXPORT_CHUNK_SIZE = 100;
 enum ExportStatus {
@@ -71,20 +72,22 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     @InjectRepository(FieldMetadata, 'default')
     readonly fieldRepo: Repository<FieldMetadata>,
     @InjectRepository(ModelMetadata, 'default')
-    readonly ModelMetadataRepo : Repository<ModelMetadata>,
-    readonly moduleRef: ModuleRef
+    readonly ModelMetadataRepo: Repository<ModelMetadata>,
+    readonly moduleRef: ModuleRef,
+    private readonly modelMetadataHelperService: ModelMetadataHelperService,
+
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'exportTransaction', 'solid-core',moduleRef);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'exportTransaction', 'solid-core', moduleRef);
   }
 
   // Return the export stream
-  async triggerExportSync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto , filters: any): Promise<ExportTransactionFileInfo> {
+  async triggerExportSync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto, filters: any): Promise<ExportTransactionFileInfo> {
     try {
       // 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},
+        where: { id: updateDto?.modelMetadataId },
+        relations: { fields: true },
       })
       const modelName = modeldata?.singularName;
       const modelTemplateName = modelName;
@@ -102,13 +105,13 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
   }
 
   // Store the export stream using the appropriate storage provider
-  async triggerExportAsync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto, filters:any): Promise<void> {
+  async triggerExportAsync(id: number, exportTransactionEntity: any, updateDto: UpdateExportTemplateDto, filters: any): Promise<void> {
     try {
       // 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},
+        where: { id: updateDto?.modelMetadataId },
+        relations: { fields: true },
       })
       const modelName = modeldata?.singularName;
       const modelTemplateName = modelName;
@@ -129,7 +132,7 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
   private async loadExportTransaction(id: number) {
     return await this.repo.findOne({
       where: { id: id },
-      relations: { exportTemplate: { modelMetadata: {fields: true} }},
+      relations: { exportTemplate: { modelMetadata: { fields: true } } },
     }
     );
   }
@@ -138,15 +141,15 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     await this.repo.update(id, { status, error });
   }
 
-  private async getExportStreamDetails(modelName: string, templateName: string, fields:any, modelData:any, templateFormat:string, id:number, exportTransaction: any, filters: any) {
+  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 modelService = this.introspectService.getProvider(`${classify(modelName)}Service`);
     // const templateName = exportTransaction.exportTemplate.templateName;
-     const uuid = String(id); //TODO can be renamed to exportTransactionUUID
+    const uuid = String(id); //TODO can be renamed to exportTransactionUUID
     // const modelData = exportTransaction.exportTemplate.modelMetadata;
 
     // Get the data records function
@@ -208,17 +211,21 @@ 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>, 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);
+  private async getDataRecordsFunc(fields: any, modelService: InstanceWrapper<any>, modelMetadata: any, filters: any): Promise<(chunkIndex: number, chunkSize: number) => Promise<any[]>> {
+    //Load all possible fields for the model
+    const allModelFields = await this.modelMetadataHelperService.loadFieldHierarchy(
+      modelMetadata.singularName,
+    );
+
+    // Filter only the fields requested in the export payload
+    const modelFields = allModelFields.filter((f: any) =>
+      fields.includes(f.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)) {
+    for (const field of modelFields) {
+      if (field.relationType && field.relationCoModelSingularName) {
         const relatedModelMetadata = await this.ModelMetadataRepo.findOne({
           where: { singularName: field.relationCoModelSingularName },
           relations: ['userKeyField'],
@@ -230,12 +237,24 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
       }
     }
 
+    // Build fieldName -> displayName map
+    const fieldNameToDisplayName = new Map<string, string>();
+    for (const field of modelFields || []) {
+      if (field.name) {
+        fieldNameToDisplayName.set(field.name, field.displayName ?? field.name);
+      }
+    }
+
+
     return async (chunkIndex: number, chunkSize: number) => {
       const offset = chunkIndex * chunkSize;
       const recordFilterDto: BasicFilterDto = {
         limit: chunkSize,
         offset,
-        populate: relatedFieldNames
+        //only contains relational fields (so TypeORM includes relations in the result).
+        populate: modelFields
+          .filter((f: any) => f.relationType !== null)
+          .map((f: any) => f.name),
       };
       const cleanedFilters = cleanNullsFromObject(filters);
 
@@ -243,43 +262,87 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
         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 ?? [];
-    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;
+      const cleanedRecords = records.map((record: Record<string, any>) => {
+        const newRecord: Record<string, any> = {};
+
+        // Include non-relational fields
+        for (const field of modelFields) {
+          if (!field.relationType) {
+            // newRecord[field.name] = record[field.name];
+            const displayKey = fieldNameToDisplayName.get(field.name) ?? field.name;
+            const fieldMeta = modelFields.find(f => f.name === field.name);
+
+            if ((fieldMeta?.type === 'datetime' || fieldMeta?.type === 'date') && record[field.name]) {
+              newRecord[displayKey] = new Date(record[field.name]).toISOString();
+            } else {
+              newRecord[displayKey] = record[field.name];
+            }
+          }
         }
-      }
-    
-      return newRecord;
-    });
-    return cleanedRecords
+
+        // Include userKey from each related field
+        for (const [relatedFieldName, userKeyFieldName] of relatedModelsUserKeyMap.entries()) {
+          const relatedData = record[relatedFieldName];
+          const displayKey = fieldNameToDisplayName.get(relatedFieldName) ?? relatedFieldName;
+
+          if (Array.isArray(relatedData)) {
+            // For many-to-many or one-to-many
+            const values = relatedData
+              .map(item => {
+                let val = item?.[userKeyFieldName];
+                const relatedFieldMeta = modelFields.find(f => f.name === relatedFieldName);
+                if ((relatedFieldMeta?.type === 'datetime' || relatedFieldMeta?.type === 'date') && val) {
+                  val = new Date(val).toISOString();
+                }
+                return val;
+              })
+              .filter(Boolean);
+            newRecord[displayKey] = values.join(', ');
+          } else if (relatedData && typeof relatedData === 'object') {
+            // For many-to-one or one-to-one
+            newRecord[relatedFieldName] = relatedData?.[userKeyFieldName] ?? null;
+          } else {
+            newRecord[displayKey] = null;
+          }
+        }
+
+        // Include userKey from each related field (with displayName)
+        for (const [relatedFieldName, userKeyFieldName] of relatedModelsUserKeyMap.entries()) {
+          const relatedData = record[relatedFieldName];
+          const displayKey = fieldNameToDisplayName.get(relatedFieldName) ?? relatedFieldName;
+
+          if (Array.isArray(relatedData)) {
+            // For many-to-many or one-to-many
+            const values = relatedData
+              .map(item => {
+                const val = item?.[userKeyFieldName];
+                // Convert datetime to ISO if needed
+                const relatedFieldMeta = modelFields.find(f => f.name === relatedFieldName);
+                if ((relatedFieldMeta?.type === 'datetime' || relatedFieldMeta?.type === 'date') && val) {
+                  return new Date(val).toISOString();
+                }
+                return val;
+              })
+              .filter(Boolean);
+            newRecord[displayKey] = values.join(', ');
+          } else if (relatedData && typeof relatedData === 'object') {
+            let val = relatedData?.[userKeyFieldName] ?? null;
+            const relatedFieldMeta = modelFields.find(f => f.name === relatedFieldName);
+            if ((relatedFieldMeta?.type === 'datetime' || relatedFieldMeta?.type === 'date') && val) {
+              val = new Date(val).toISOString();
+            }
+            newRecord[displayKey] = val;
+          } else {
+            newRecord[displayKey] = null;
+          }
+        }
+        return newRecord;
+      });
+      return cleanedRecords
+    }
   }
-}
 
   async toDto(data: Partial<CreateExportTransactionDto>): Promise<CreateExportTransactionDto> {
     const dto = new CreateExportTransactionDto(data);