@solidstarters/solid-core 1.2.200 → 1.2.201

package/src/services/field-metadata.service.ts

@@ -12,13 +12,15 @@ import { SelectionDynamicQueryDto } from '../dtos/selection-dynamic-query.dto';
 import { UpdateFieldMetaDataDto } from '../dtos/update-field-metadata.dto';
 import { FieldMetadata } from '../entities/field-metadata.entity';
 import { ModelMetadata } from '../entities/model-metadata.entity';
-import { ISelectionProviderValues } from '../interfaces';
+import { ISelectionProviderValues, MediaStorageProvider } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import qs from 'qs';
 import { ResolveS3UrlDto } from 'src/dtos/resolve-s3-url.dto';
+import { MediaStorageProviderMetadataRepository } from 'src/repository/media-storage-provider-metadata.repository';
 import { ConfigService } from '@nestjs/config';
 import { FileService } from './file.service';
+import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
 
 
 @Injectable()
@@ -27,6 +29,7 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         private readonly fieldMetadataRepo: FieldMetadataRepository,
         private readonly configService: ConfigService,
         private readonly fileService: FileService,
+        private readonly mediaStorageProviderMetadataRepository: MediaStorageProviderMetadataRepository,
 
         @InjectDataSource()
         private readonly dataSource: DataSource,
@@ -60,6 +63,7 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                 computedFieldTriggerConfig: field.computedFieldTriggerConfig ?? [], // Ensure it's an array, default to empty if not provided
                 computedFieldValueProviderName: field.computedFieldValueProvider,
                 computedFieldValueProviderCtxt: field.computedFieldValueProviderCtxt ? JSON.parse(field.computedFieldValueProviderCtxt) : {}, // Parse the context if it exists, default to empty object
+                eventContext: {}
             };
         });
 
@@ -776,7 +780,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.richText:
@@ -1081,7 +1086,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "isUserKey"
+                    "isUserKey",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.uuid:
@@ -1280,76 +1286,117 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         return fieldObject;
     }
 
-    async resolveS3Url(resolveS3UrlDto: ResolveS3UrlDto) {
+    // async resolveS3Url(resolveS3UrlDto: ResolveS3UrlDto) {
 
-        const { modelName, fieldName, fieldValue, s3KeyFieldName } = resolveS3UrlDto;
+    //     const { modelName, fieldName, fieldValue, s3KeyFieldName } = resolveS3UrlDto;
 
-        // ------------------------------------------------
-        // 1. Load model metadata
-        // ------------------------------------------------
-        const modelRepo = this.dataSource.getRepository(ModelMetadata);
-        const model = await modelRepo.findOne({
-            where: { singularName: modelName },
-            relations: ['fields']
-        });
+    //     // ------------------------------------------------
+    //     // 1. Load model metadata
+    //     // ------------------------------------------------
+    //     const modelRepo = this.dataSource.getRepository(ModelMetadata);
+    //     const model = await modelRepo.findOne({
+    //         where: { singularName: modelName },
+    //         relations: ['fields']
+    //     });
 
-        if (!model) {
-            throw new NotFoundException(`Model ${modelName} not found`);
-        }
+    //     if (!model) {
+    //         throw new NotFoundException(`Model ${modelName} not found`);
+    //     }
 
-        // ------------------------------------------------
-        // 2. Validate the field we are filtering by
-        // ------------------------------------------------
-        const filterFieldMeta = model.fields.find(f => f.name === fieldName);
-        if (!filterFieldMeta) {
-            throw new NotFoundException(
-                `Field ${fieldName} not found in model ${modelName}`
-            );
-        }
+    //     // ------------------------------------------------
+    //     // 2. Validate the field we are filtering by
+    //     // ------------------------------------------------
+    //     const filterFieldMeta = model.fields.find(f => f.name === fieldName);
+    //     if (!filterFieldMeta) {
+    //         throw new NotFoundException(
+    //             `Field ${fieldName} not found in model ${modelName}`
+    //         );
+    //     }
 
-        // ------------------------------------------------
-        // 3. Load the actual entity repository
-        // ------------------------------------------------
-        const entityRepo = this.dataSource.getRepository(model.singularName);
+    //     // ------------------------------------------------
+    //     // 3. Load the actual entity repository
+    //     // ------------------------------------------------
+    //     const entityRepo = this.dataSource.getRepository(model.singularName);
 
-        // ------------------------------------------------
-        // 4. Query using fieldName = fieldValue
-        // ------------------------------------------------
-        const record = await entityRepo.findOne({
-            where: { [fieldName]: fieldValue }
-        });
+    //     // ------------------------------------------------
+    //     // 4. Query using fieldName = fieldValue
+    //     // ------------------------------------------------
+    //     const record = await entityRepo.findOne({
+    //         where: { [fieldName]: fieldValue }
+    //     });
 
-        if (!record) {
-            throw new NotFoundException(
-                `${modelName} record not found for ${fieldName}="${fieldValue}"`
-            );
-        }
+    //     if (!record) {
+    //         throw new NotFoundException(
+    //             `${modelName} record not found for ${fieldName}="${fieldValue}"`
+    //         );
+    //     }
 
-        // ------------------------------------------------
-        // 5. Extract S3 key from s3KeyFieldName
-        // ------------------------------------------------
-        const s3Key = record[s3KeyFieldName];
+    //     // ------------------------------------------------
+    //     // 5. Extract S3 key from s3KeyFieldName
+    //     // ------------------------------------------------
+    //     const s3Key = record[s3KeyFieldName];
 
-        if (!s3Key) {
-            throw new NotFoundException(
-                `Field "${s3KeyFieldName}" has no value in ${modelName}.${fieldName}="${fieldValue}"`
-            );
-        }
+    //     if (!s3Key) {
+    //         throw new NotFoundException(
+    //             `Field "${s3KeyFieldName}" has no value in ${modelName}.${fieldName}="${fieldValue}"`
+    //         );
+    //     }
+
+    //     // ------------------------------------------------
+    //     // 6. Generate signed or public URL
+    //     // ------------------------------------------------
+    //     let url = "";
+
+    //     // TODO  - get 
+    //     if (resolveS3UrlDto.isPrivate == "true") {
+    //         const expiryInSeconds = 60 * 60;
+    //         url = await this.fileService.getSignedUrl(s3Key, expiryInSeconds, resolveS3UrlDto.bucketName);
+    //     } else {
+    //         url = `https://${resolveS3UrlDto.bucketName}.s3.${this.configService.get('S3_AWS_REGION_NAME')}.amazonaws.com/${s3Key}`;
+    //     }
+    //     return { url: url }
+    // }
 
-        // ------------------------------------------------
-        // 6. Generate signed or public URL
-        // ------------------------------------------------
+    async resolveS3Url(resolveS3UrlDto: ResolveS3UrlDto) {
         let url = "";
+        const normalizedKey = this.normalizeS3Key(resolveS3UrlDto.s3Key);
 
-        // TODO  - get 
+        let resolvedBucketName = resolveS3UrlDto.bucketName;
+        if (resolveS3UrlDto.mediaStorageProviderUserKey) {
+            const mediaStorageProvider = await this.mediaStorageProviderMetadataRepository.findOne({
+                where: {
+                    name: resolveS3UrlDto.mediaStorageProviderUserKey
+                }
+            });
+            if (!mediaStorageProvider) {
+                throw new NotFoundException(`MediaStorageProviderMetadata with user key ${resolveS3UrlDto.mediaStorageProviderUserKey} not found`);
+            }
+            resolvedBucketName = mediaStorageProvider.bucketName;
+        }
+        this.logger.debug(`INSIDE::resolveS3Url:: resolvedBucketName: ${resolvedBucketName}`)
+ 
         if (resolveS3UrlDto.isPrivate == "true") {
             const expiryInSeconds = 60 * 60;
-            url = await this.fileService.getSignedUrl(s3Key, expiryInSeconds, resolveS3UrlDto.bucketName);
+            url = await this.fileService.getSignedUrl(normalizedKey, expiryInSeconds, resolvedBucketName);
         } else {
-            url = `https://${resolveS3UrlDto.bucketName}.s3.${this.configService.get('S3_AWS_REGION_NAME')}.amazonaws.com/${s3Key}`;
+            url = `https://${resolvedBucketName}.s3.${this.configService.get(
+                'S3_AWS_REGION_NAME',
+            )}.amazonaws.com/${normalizedKey}`;
         }
         return { url: url }
     }
+
+    private normalizeS3Key(input: string): string {
+        try {
+            const url = new URL(input);
+
+            // remove leading slash from pathname
+            return decodeURIComponent(url.pathname.replace(/^\/+/, ""));
+        } catch {
+            // not a valid URL → treat as raw S3 key
+            return input;
+        }
+    }
 }
 
 

package/src/services/file.service.ts

@@ -175,6 +175,15 @@ export class FileService {
     }
   }
 
+  public async pathExists(targetPath: string): Promise<boolean> {
+    try {
+      await fs.promises.access(targetPath, fs.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   public async getSignedUrl(key: string, expiresIn: number, bucketName: string): Promise<string> {
     const command = new GetObjectCommand({
       Bucket: bucketName,

package/src/services/fixtures.service.ts

@@ -0,0 +1,108 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { SolidIntrospectService } from "./solid-introspect.service";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { classify } from "@angular-devkit/core/src/utils/strings";
+
+interface ScenarioFixture {
+    name: string;
+    models: {
+        singularName: string;
+        data: any;
+    }[];
+}
+
+// This service can contain common logic for fixtures setup and tear down
+@Injectable()
+export class FixturesService {
+    private readonly logger = new Logger(this.constructor.name);
+
+    constructor(
+        private readonly introspectService: SolidIntrospectService,
+        private readonly moduleMetadataHelper: ModuleMetadataHelperService,
+    ) { }
+
+    async setupFixtures(moduleName: string, scenarioName: string) {
+        const scenarioFixture = await this.loadScenario(moduleName, scenarioName);
+        if (!scenarioFixture?.models || scenarioFixture.models.length === 0) {
+            this.logger.warn(`No models found to setup for scenario: ${scenarioName} in module: ${moduleName}`);
+            return;
+        }
+
+        // For each model in the fixtures, use introspectService to get model service
+        for (const modelFixture of scenarioFixture.models) {
+            const modelServiceInstance = await this.loadModelService(modelFixture.singularName);
+            try {
+                // Create the model instance in the database
+                const createdInstance = await modelServiceInstance.create(modelFixture.data);
+                this.logger.log(`Successfully created fixture for model: ${modelFixture.singularName} with ID: ${createdInstance.id}`);
+            } catch (error) {
+                this.logger.error(`Error creating fixture for model: ${modelFixture.singularName} - ${error.message}`);
+            }
+        }
+    }
+
+    async tearDownFixtures(moduleName: string, scenarioName: string) {
+        // Call delete on the modelService to remove the created fixtures, in reverse order
+        const scenarioFixture = await this.loadScenario(moduleName, scenarioName);
+        if (!scenarioFixture?.models || scenarioFixture.models.length === 0) {
+            this.logger.warn(`No models found to tear down for scenario: ${scenarioName} in module: ${moduleName}`);
+            return;
+        }
+
+        // For each model in reverse order
+        for (const modelFixture of scenarioFixture.models.reverse()) {
+            const modelServiceInstance = await this.loadModelService(modelFixture.singularName);
+
+            // Get the user key field for the model to identify the created instances
+            try {
+                // Assuming we have some way to identify the created instances, e.g., by a unique field in data
+                const deleteCriteria = modelFixture.data; // This should be adjusted based on actual criteria
+                await modelServiceInstance.delete(deleteCriteria);
+                this.logger.log(`Successfully deleted fixture for model: ${modelFixture.singularName}`);
+            } catch (error) {
+                this.logger.error(`Error deleting fixture for model: ${modelFixture.singularName} - ${error.message}`);
+            }
+        }
+
+    }
+
+    private async loadScenario(moduleName: string, scenarioName: string): Promise<ScenarioFixture | undefined> {
+        // Read the module metadata file based on module name
+        const moduleMetadataConfiguration = await this.moduleMetadataHelper.getModuleMetadataConfiguration(
+            await this.moduleMetadataHelper.getModuleMetadataFilePath(moduleName)
+        );
+        if (!moduleMetadataConfiguration) {
+            this.logger.error(`No module metadata configuration found for module: ${moduleName}`);
+            return;
+        }
+        this.logger.debug(`Module Metadata Configuration loaded for module: ${moduleName}`);
+
+        // Read the fixtures json from above file
+        const allFixtures = moduleMetadataConfiguration?.fixtures;
+        this.logger.debug(`All Fixtures: ${JSON.stringify(allFixtures)}`);
+        // Check if scenarios exists
+        if (!allFixtures?.scenarios.length || allFixtures?.scenarios.length === 0) {
+            this.logger.error(`No scenarios defined in the module metadata configuration for module: ${moduleName}`);
+            return;
+        }
+
+        // Find the fixtures for the given scenario
+        const scenarioFixture = allFixtures.scenarios.find((scenario: ScenarioFixture) => scenario.name === scenarioName);
+        if (!scenarioFixture) {
+            this.logger.error(`Scenario: ${scenarioName} not found in module metadata configuration for module: ${moduleName}`);
+            return;
+        }
+        this.logger.log(`Scenario: ${scenarioName} found with fixtures to setup.`);
+        return scenarioFixture;
+    }
+
+    private async loadModelService(singularName: string): Promise<any> {
+        const modelServiceProvider = this.introspectService.getProvider(`${classify(singularName)}Service`);
+        if (!modelServiceProvider) {
+            this.logger.error(`Model service provider not found for model: ${singularName}`);
+            return null;
+        }
+        this.logger.debug(`Model service provider found for model: ${singularName}`);
+        return modelServiceProvider.instance;
+    }
+}

package/src/services/genai/ingest-metadata.service.ts

@@ -3,10 +3,10 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 
-import { getDynamicModuleNames } from 'src/helpers/module.helper';
+import { getDynamicModuleNames, getDynamicModuleNamesBasedOnMetadata } from 'src/helpers/module.helper';
 import { CreateModuleMetadataDto } from 'src/dtos/create-module-metadata.dto';
 import { R2RHelperService } from './r2r-helper.service';
-import { CollectionResponse, r2rClient } from 'r2r-js';
+import { r2rClient } from 'r2r-js';
 import { CreateModelMetadataDto } from 'src/dtos/create-model-metadata.dto';
 import { CreateFieldMetadataDto } from 'src/dtos/create-field-metadata.dto';
 
@@ -90,7 +90,8 @@ export class IngestMetadataService {
 
         // const allModuleMetadataJson = [];
         this.logger.debug(`getting dynamics modules`);
-        const enabledModules = getDynamicModuleNames();
+        // const enabledModules = getDynamicModuleNames();
+        const enabledModules = getDynamicModuleNamesBasedOnMetadata();
         this.logger.log(`ingesting metadata`);
 
         for (let i = 0; i < enabledModules.length; i++) {

package/src/services/import-transaction-error-log.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef  } from "@nestjs/core";
 import { EntityManager, Repository } from 'typeorm';
@@ -17,6 +17,7 @@ import { ImportTransactionErrorLogRepository } from 'src/repository/import-trans
 @Injectable()
 export class ImportTransactionErrorLogService extends CRUDService<ImportTransactionErrorLog>{
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

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

@@ -1,4 +1,4 @@
-import { BadRequestException, ForbiddenException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, ForbiddenException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
@@ -94,6 +94,7 @@ interface ImportRecordsResult {
 @Injectable()
 export class ImportTransactionService extends CRUDService<ImportTransaction> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -305,9 +306,12 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       : userPermissions[permissionKey] === true;
 
     if (!hasPermission) {
-      throw new ForbiddenException(
-        `Missing permission: ${permissionKey}`
-      );
+      const action = permissionKey.split('.').pop()!;
+      const message = ERROR_MESSAGES.PERMISSION_MESSAGES[action]?.(modelName) ?? 'You are not allowed to perform this action.';
+      throw new ForbiddenException({
+        message,
+        errorCode: 'permission-denied',
+      });
     }
 
     // Get the import file media object from the import transaction

package/src/services/list-of-values.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
@@ -12,11 +12,10 @@ import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
-import { ListOfValuesRepository } from 'src/repository/list-of-values.repository';
-import { ListOfValues } from '../entities/list-of-values.entity';
-import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
 import { ListOfValuesMapper } from 'src/mappers/list-of-values-mapper';
+import { ListOfValuesRepository } from 'src/repository/list-of-values.repository';
+import { ListOfValues } from '../entities/list-of-values.entity';
 
 
 @Injectable()
@@ -25,6 +24,7 @@ export class ListOfValuesService extends CRUDService<ListOfValues> {
   // moduleMetadataHelperService: any;
   // listOfValuesMapper: any;
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/locale.service.ts

@@ -1,4 +1,4 @@
-import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { forwardRef, Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
@@ -16,6 +16,7 @@ import { RequestContextService } from './request-context.service';
 @Injectable()
 export class LocaleService extends CRUDService<Locale> implements OnApplicationBootstrap{
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/mail/smtp-email.service.ts

@@ -153,7 +153,7 @@ export class SMTPEMailService implements IMail {
             attachments: attachmentsList,
         });
         // this.logger.debug(`Sending email to ${to} with subject ${subject} and body ${body}`);
-        this.logger.debug(`Sending email to ${to} with subject ${subject}`);
+        // this.logger.debug(`Sending email to ${to} with subject ${subject}`);
 
         return r;
     }

package/src/services/media.service.ts

@@ -1,7 +1,7 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager, In } from 'typeorm';
 
 import { ConfigService } from '@nestjs/config';
 import { CrudHelperService } from 'src/services/crud-helper.service';
@@ -11,23 +11,21 @@ import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
-import { FieldMetadata } from 'src/entities/field-metadata.entity';
-import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
 import { Media } from 'src/entities/media.entity';
-import { ModelMetadata } from 'src/entities/model-metadata.entity';
-import { getMediaStorageProvider } from "./mediaStorageProviders";
-import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
-import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
+import { MediaStorageProviderMetadataRepository } from 'src/repository/media-storage-provider-metadata.repository';
 import { MediaRepository } from 'src/repository/media.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
-import { MediaStorageProviderMetadataRepository } from 'src/repository/media-storage-provider-metadata.repository';
-import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
+import { getMediaStorageProvider } from "./mediaStorageProviders";
 
 
 @Injectable()
 export class MediaService extends CRUDService<Media> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -45,6 +43,7 @@ export class MediaService extends CRUDService<Media> {
     // private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
     // @InjectRepository(FieldMetadata)
     // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    @Inject(forwardRef(() => ModelMetadataRepository))
     private readonly modelMetadataRepo: ModelMetadataRepository,
     private readonly mediaStorageProviderMetadataRepo: MediaStorageProviderMetadataRepository,
     private readonly fieldMetadataRepo: FieldMetadataRepository,

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

@@ -2,6 +2,8 @@ import { Inject, Injectable, Logger } from "@nestjs/common";
 import { ConfigService, ConfigType } from "@nestjs/config";
 import { CommonEntity } from "src/entities/common.entity";
 import { FieldMetadata } from "src/entities/field-metadata.entity";
+import { LegacyCommonEntity } from "src/entities/legacy-common.entity";
+import { LegacyCommonWithIdEntity } from "src/entities/legacy-common-with-id.entity";
 import { Media } from "src/entities/media.entity";
 import { MediaStorageProvider } from "src/interfaces";
 import { FileService } from "src/services/file.service";
@@ -28,9 +30,13 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     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
+        const isSupportedEntity = entity instanceof CommonEntity
+            || entity instanceof LegacyCommonEntity
+            || entity instanceof LegacyCommonWithIdEntity;
+        if (!isSupportedEntity) {
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntity or LegacyCommonWithIdEntity"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
+        // @ts-ignore
         const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
 
         // TODO: Check if the mediaStorageProvider (s3 in this case) is configured with a public bucket or not. 
@@ -56,8 +62,11 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async store(files: Express.Multer.File[], 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 isSupportedEntity = entity instanceof CommonEntity
+            || entity instanceof LegacyCommonEntity
+            || entity instanceof LegacyCommonWithIdEntity;
+        if (!isSupportedEntity) {
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntity or LegacyCommonWithIdEntity"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
         const result: Media[] = [];
         for (const file of files) {
@@ -73,6 +82,7 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
 
             // Create an entry in the media table
             const mediaEntity = await this.mediaRepository.createMedia({
+                // @ts-ignore
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: awsFileUrl,
@@ -89,10 +99,15 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     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
+        const isSupportedEntity = entity instanceof CommonEntity
+            || entity instanceof LegacyCommonEntity
+            || entity instanceof LegacyCommonWithIdEntity;
+        if (!isSupportedEntity) {
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntity or LegacyCommonWithIdEntity"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
+        // @ts-ignore
         const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+        // @ts-ignore
         this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         existingMedia.forEach(media => {
             this.fileService.deleteFromS3(media.relativeUri, mediaFieldMetadata.mediaStorageProvider.bucketName); //TODO
@@ -108,4 +123,4 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     private getFileName(file: Express.Multer.File): string {
         return `${file.filename}-${file.originalname}`;
     }
-}
+}