@solidxai/core 0.1.8-beta.2 → 0.1.8-beta.4

package/src/seeders/module-test-data.service.ts

@@ -2,15 +2,19 @@ import { Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from '@nestjs/core';
 import { getDataSourceToken } from '@nestjs/typeorm';
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { DataSource } from 'typeorm';
+import { DataSource, EntityManager } from 'typeorm';
 import * as fs from 'fs';
 import * as path from 'path';
 
 import solidCoreMetadata from './seed-data/solid-core-metadata.json';
 import { CreateModuleMetadataDto } from 'src/dtos/create-module-metadata.dto';
 import { CreateModelMetadataDto } from 'src/dtos/create-model-metadata.dto';
+import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
 import { getDynamicModuleNamesBasedOnMetadata } from 'src/helpers/module.helper';
 import { SolidRegistry } from 'src/helpers/solid-registry';
+import { MediaRepository } from 'src/repository/media.repository';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { getMediaStorageProvider } from 'src/services/mediaStorageProviders';
 
 @Injectable()
 export class ModuleTestDataService {
@@ -185,7 +189,7 @@ export class ModuleTestDataService {
       throw new Error('Module metadata missing from test data payload.');
     }
 
-    // console.log(JSON.stringify(moduleMetadata, null, 2));    
+    // console.log(JSON.stringify(moduleMetadata, null, 2));
 
     const testingData: Array<{ modelUserKey: string; data: Record<string, any> }> = overallMetadata?.testing?.data ?? [];
     if (testingData.length === 0) {
@@ -243,19 +247,174 @@ export class ModuleTestDataService {
         }
       }
 
+      // Strip media fields from entity payload — file paths cannot be saved as columns
+      const mediaPayload: Record<string, string> = {};
+      for (const field of modelDef.fields ?? []) {
+        if ((field.type === 'mediaSingle' || field.type === 'mediaMultiple') && payload[field.name] !== undefined) {
+          mediaPayload[field.name] = payload[field.name] as string;
+          delete payload[field.name];
+        }
+      }
+
+      // Strip many-to-many and one-to-many fields — these are resolved post-save via the relation builder
+      const multiRelationPayload: Array<{ field: any; userKeys: string[] }> = [];
+      for (const field of modelDef.fields ?? []) {
+        if (field.type !== 'relation') continue;
+        if (field.relationType !== 'many-to-many' && field.relationType !== 'one-to-many') continue;
+
+        const userKeysProp = `${field.name}UserKeys`;
+        if (userKeysProp in payload && Array.isArray(payload[userKeysProp])) {
+          multiRelationPayload.push({ field, userKeys: payload[userKeysProp] });
+          delete payload[userKeysProp];
+        }
+        // Remove raw field value if accidentally present
+        delete payload[field.name];
+      }
+
+      // Upsert entity, capturing the saved result for post-save steps
+      let savedEntity: any;
       const userKeyField = modelDef.userKeyFieldUserKey;
       if (userKeyField && payload[userKeyField] !== undefined) {
         const existing = await entityRepo.findOne({
           where: { [userKeyField]: payload[userKeyField] },
         });
         if (existing) {
-          await entityRepo.save(entityRepo.merge(existing, payload));
-          continue;
+          savedEntity = await entityRepo.save(entityRepo.merge(existing, payload));
+        } else {
+          savedEntity = await entityRepo.save(entityRepo.create(payload));
         }
+      } else {
+        savedEntity = await entityRepo.save(entityRepo.create(payload));
+      }
+
+      if (multiRelationPayload.length > 0) {
+        await this.seedMultiRelations(savedEntity.id, modelUserKey, multiRelationPayload, modelsByName);
+      }
+
+      if (Object.keys(mediaPayload).length > 0) {
+        await this.seedEntityMedia(savedEntity.id, modelUserKey, mediaPayload);
+      }
+    }
+  }
+
+  private async seedMultiRelations(
+    entityId: number,
+    modelUserKey: string,
+    relations: Array<{ field: any; userKeys: string[] }>,
+    modelsByName: Map<string, CreateModelMetadataDto>,
+  ): Promise<void> {
+    for (const { field, userKeys } of relations) {
+      if (!userKeys.length) continue;
+
+      const coModelName = field.relationCoModelSingularName;
+      const coModelDef = modelsByName.get(coModelName);
+      if (!coModelDef) {
+        throw new Error(`Relation model "${coModelName}" not found in metadata for field ${modelUserKey}.${field.name}`);
+      }
+      const coUserKeyField = coModelDef.userKeyFieldUserKey;
+      if (!coUserKeyField) {
+        throw new Error(`Relation model "${coModelName}" is missing userKeyFieldUserKey, needed to resolve ${modelUserKey}.${field.name}`);
+      }
+
+      const coRepo = this.resolveRepository(coModelName);
+      const resolvedIds: number[] = [];
+      for (const uk of userKeys) {
+        const related = typeof coRepo.findOneByUserKey === 'function'
+          ? await coRepo.findOneByUserKey(uk)
+          : await coRepo.findOne({ where: { [coUserKeyField]: uk } });
+        if (!related) {
+          throw new Error(`Related entity not found: ${coModelName}.${coUserKeyField}=${uk}`);
+        }
+        resolvedIds.push(related.id);
+      }
+
+      // Load currently associated entities to diff (set semantics — idempotent)
+      const existingRelated: any[] = await this.entityManager
+        .createQueryBuilder()
+        .relation(classify(modelUserKey), field.name)
+        .of(entityId)
+        .loadMany();
+      const existingIds: number[] = existingRelated.map((e) => e.id);
+
+      const toAdd = resolvedIds.filter((id) => !existingIds.includes(id));
+      const toRemove = existingIds.filter((id) => !resolvedIds.includes(id));
+
+      if (toAdd.length > 0 || toRemove.length > 0) {
+        await this.entityManager
+          .createQueryBuilder()
+          .relation(classify(modelUserKey), field.name)
+          .of(entityId)
+          .addAndRemove(toAdd, toRemove);
       }
 
-      await entityRepo.save(entityRepo.create(payload));
+      this.logger.debug(`Seeded ${field.relationType} relation ${modelUserKey}.${field.name} entityId=${entityId}: +${toAdd.length} -${toRemove.length}`);
+    }
+  }
+
+  private async seedEntityMedia(
+    entityId: number,
+    modelUserKey: string,
+    mediaPayload: Record<string, string>,
+  ): Promise<void> {
+    const mediaBasePath = process.env.TEST_UPLOADS_MEDIA_FILE_PATH;
+    if (!mediaBasePath) {
+      throw new Error('TEST_UPLOADS_MEDIA_FILE_PATH is not set. Cannot seed test media.');
     }
+
+    const modelMetadata = await this.modelMetadataService.findOneBySingularName(modelUserKey, {
+      fields: {
+        model: { userKeyField: true },
+        mediaStorageProvider: true,
+      },
+    });
+
+    for (const [fieldName, fileName] of Object.entries(mediaPayload)) {
+      if (!fileName) continue;
+
+      const fieldMetadata = modelMetadata.fields.find((f) => f.name === fieldName);
+      if (!fieldMetadata) {
+        throw new Error(`Media field "${fieldName}" not found in loaded metadata for model ${modelUserKey}`);
+      }
+      if (!fieldMetadata.mediaStorageProvider) {
+        throw new Error(`Media field "${fieldName}" in model ${modelUserKey} has no storage provider configured`);
+      }
+
+      const storageProviderType = fieldMetadata.mediaStorageProvider.type as MediaStorageProviderType;
+      if (storageProviderType !== MediaStorageProviderType.Filesystem) {
+        throw new Error(`Test media seeding supports filesystem storage only. Field "${fieldName}" uses "${storageProviderType}".`);
+      }
+
+      // Idempotency: skip if media already exists for this entity + field
+      const existing = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(
+        entityId, fieldMetadata.id, fieldMetadata.model.id,
+      );
+      if (existing.length > 0) {
+        this.logger.debug(`Media already seeded for ${modelUserKey}.${fieldName} entityId=${entityId}, skipping`);
+        continue;
+      }
+
+      const sourcePath = path.join(mediaBasePath, fileName);
+      if (!fs.existsSync(sourcePath)) {
+        throw new Error(`Test media file not found: ${sourcePath}`);
+      }
+
+      const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
+      const stream = fs.createReadStream(sourcePath);
+      await storageProvider.storeStreams([[stream, fileName]], { id: entityId }, fieldMetadata);
+      this.logger.debug(`Seeded media for ${modelUserKey}.${fieldName} entityId=${entityId} file=${fileName}`);
+    }
+  }
+
+  private get entityManager(): EntityManager {
+    return this.moduleRef.get(EntityManager, { strict: false });
+  }
+
+  private get modelMetadataService(): ModelMetadataService {
+    return this.moduleRef.get(ModelMetadataService, { strict: false });
+  }
+
+  private get mediaRepository(): MediaRepository {
+    return this.moduleRef.get(MediaRepository, { strict: false });
   }
 
   private resolveRepository(modelUserKey: string): any {
@@ -308,7 +467,7 @@ export class ModuleTestDataService {
         if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) {
           return line;
         }
-        const [rawKey, ...rest] = line.split('=');
+        const [rawKey] = line.split('=');
         const key = rawKey.trim();
         if (!key.endsWith('_DATABASE_NAME')) {
           return line;

package/src/services/chatter-message.service.ts

@@ -53,6 +53,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.messageBody = postDto.messageBody;
         chatterMessage.coModelEntityId = postDto.coModelEntityId;
         chatterMessage.coModelName = postDto.coModelName;
+        chatterMessage.modelUserKey = postDto.modelUserKey ?? null;
+
+        const model = await this.modelMetadataRepo.findOne({
+            where: { singularName: lowerFirst(postDto.coModelName) },
+            relations: { userKeyField: true }
+        });
+        chatterMessage.modelDisplayName = model?.displayName ?? null;
 
         const activeUser = this.requestContextService.getActiveUser();
 

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

@@ -274,32 +274,6 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
           }
         }
 
-        // 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];