@solidxai/core 0.1.10-beta.9 → 0.1.10

package/src/services/dashboard-runtime.service.ts

@@ -0,0 +1,488 @@
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+import qs from 'qs';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { DashboardVariableOptionsQueryDto } from 'src/dtos/dashboard-variable-options-query.dto';
+import { DashboardBatchDataRequestDto, DashboardSaveLayoutDto, DashboardWidgetDataRequestDto } from 'src/dtos/dashboard-widget-data-request.dto';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+import { IDashboardWidgetDataProviderContext } from 'src/interfaces';
+import { DashboardUserLayoutService } from './dashboard-user-layout.service';
+
+@Injectable()
+export class DashboardRuntimeService {
+    private readonly logger = new Logger(DashboardRuntimeService.name);
+
+    constructor(
+        private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        private readonly solidRegistry: SolidRegistry,
+        private readonly dashboardUserLayoutService: DashboardUserLayoutService,
+    ) { }
+
+    async getDashboardDefinition(moduleName: string, dashboardName: string): Promise<any> {
+        const moduleMetadata = await this.getModuleMetadata(moduleName);
+        const dashboards = this.getDashboards(moduleMetadata);
+        const dashboard = dashboards.find((d) => d?.name === dashboardName || d?.routeName === dashboardName);
+
+        if (!dashboard) {
+            throw new NotFoundException(`Dashboard ${dashboardName} not found for module ${moduleName}.`);
+        }
+
+        return dashboard;
+    }
+
+    async getWidgetData(
+        moduleName: string,
+        dashboardName: string,
+        widgetName: string,
+        request: DashboardWidgetDataRequestDto = {},
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        return this.getWidgetDataFromDefinition(dashboardDefinition, moduleName, dashboardName, widgetName, request, activeUser);
+    }
+
+    async getDashboardData(
+        moduleName: string,
+        dashboardName: string,
+        request: DashboardBatchDataRequestDto = {},
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const allWidgets = Array.isArray(dashboardDefinition.widgets) ? dashboardDefinition.widgets : [];
+
+        const targetWidgets = request.widgetNames?.length
+            ? allWidgets.filter((widget) => request.widgetNames.includes(widget.id) || request.widgetNames.includes(widget.name))
+            : allWidgets;
+
+        const widgets = await Promise.all(
+            targetWidgets.map((widget) => this.getWidgetDataFromDefinition(
+                dashboardDefinition,
+                moduleName,
+                dashboardName,
+                widget.id ?? widget.name,
+                request,
+                activeUser
+            ))
+        );
+
+        return {
+            moduleName,
+            dashboardName: dashboardDefinition.name,
+            variables: request.variables ?? {},
+            widgets,
+        };
+    }
+
+    async getVariableOptions(
+        moduleName: string,
+        dashboardName: string,
+        variableName: string,
+        query: DashboardVariableOptionsQueryDto,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const variable = (dashboardDefinition.variables ?? []).find((v) => v.name === variableName);
+
+        if (!variable) {
+            throw new NotFoundException(`Variable ${variableName} not found in dashboard ${dashboardName}.`);
+        }
+
+        if (variable.type === 'selectionStatic') {
+            const values = Array.isArray(variable.selectionStaticValues) ? variable.selectionStaticValues : [];
+            return values.map((entry: string) => {
+                const [value, label] = `${entry}`.split(':');
+                return { label: label ?? value, value };
+            });
+        }
+
+        if (variable.type !== 'selectionDynamic') {
+            return [];
+        }
+
+        const providerName = variable?.selectionConfig?.providerName;
+        if (!providerName) {
+            throw new NotFoundException(`Variable ${variableName} does not define a dynamic selection provider.`);
+        }
+
+        const selectionProvider = this.solidRegistry.getSelectionProviderInstance(providerName);
+        if (!selectionProvider) {
+            throw new NotFoundException(ERROR_MESSAGES.PROVIDER_NOT_FOUND(providerName));
+        }
+
+        const providerContext = {
+            ...(variable?.selectionConfig?.providerContext ?? {}),
+            limit: query?.limit ?? 10,
+            offset: query?.offset ?? 0,
+            formValues: this.parseFormValues(query?.formValues),
+        };
+
+        if (query.optionValue) {
+            return selectionProvider.value(query.optionValue, providerContext as any);
+        }
+
+        return selectionProvider.values(query?.query ?? '', providerContext as any);
+    }
+
+    async getLayout(moduleName: string, dashboardName: string, activeUser?: ActiveUserData): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const defaultLayout = dashboardDefinition.defaultLayout ?? {};
+        const userId = activeUser?.sub ?? null;
+        let userLayoutRecord = null;
+        try {
+            userLayoutRecord = userId
+                ? await this.dashboardUserLayoutService.repo.findOne({
+                    where: {
+                        user: { id: userId },
+                        module: { name: moduleName },
+                        dashboardName: dashboardDefinition.name,
+                    } as any,
+                })
+                : null;
+        } catch (err: any) {
+            const isEntityMetadataMissing = `${err?.message ?? ''}`.includes('No metadata for "DashboardUserLayout" was found');
+            if (!isEntityMetadataMissing) throw err;
+            this.logger.warn('DashboardUserLayout entity metadata is not registered yet. Returning default layout fallback.');
+        }
+        const userLayout = this.parseLayoutJson(userLayoutRecord?.layoutJson);
+        const effectiveLayout = this.mergeLayouts(defaultLayout, userLayout);
+
+        return {
+            moduleName,
+            dashboardName: dashboardDefinition.name,
+            userId,
+            defaultLayout,
+            userLayout,
+            effectiveLayout,
+            persisted: !!userLayoutRecord,
+        };
+    }
+
+    async saveLayout(
+        moduleName: string,
+        dashboardName: string,
+        dto: DashboardSaveLayoutDto,
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const resolvedDashboardName = dashboardDefinition?.name ?? dashboardName;
+        const resolvedLayoutJson = this.resolveLayoutPayload(dto);
+        const userId = activeUser?.sub;
+        if (!userId) {
+            return {
+                moduleName,
+                dashboardName: resolvedDashboardName,
+                userId: null,
+                persisted: false,
+                message: 'Unable to persist layout without active user context.',
+                layoutJson: resolvedLayoutJson,
+            };
+        }
+        const layoutJsonAsString = typeof resolvedLayoutJson === 'string'
+            ? resolvedLayoutJson
+            : JSON.stringify(resolvedLayoutJson ?? {});
+        let savedLayout: any = null;
+        try {
+            const layoutRepo = this.dashboardUserLayoutService.repo;
+            const existing = await layoutRepo.findOne({
+                where: {
+                    user: { id: userId },
+                    module: { name: moduleName },
+                    dashboardName: resolvedDashboardName,
+                } as any,
+            });
+
+            const moduleRepo = this.dashboardUserLayoutService.entityManager.getRepository(ModuleMetadata);
+            const moduleEntity = await moduleRepo.findOne({ where: { name: moduleName } as any });
+
+            if (!moduleEntity) {
+                throw new NotFoundException(`Module ${moduleName} not found.`);
+            }
+
+            const toSave = layoutRepo.create({
+                ...(existing ? { id: existing.id } : {}),
+                user: { id: userId } as any,
+                module: { id: moduleEntity.id } as any,
+                dashboardName: resolvedDashboardName,
+                layoutJson: layoutJsonAsString,
+                version: (existing?.version ?? 0) + 1,
+            } as any);
+
+            savedLayout = await layoutRepo.save(toSave);
+        } catch (err: any) {
+            const isEntityMetadataMissing = `${err?.message ?? ''}`.includes('No metadata for "DashboardUserLayout" was found');
+            if (!isEntityMetadataMissing) throw err;
+            this.logger.warn('DashboardUserLayout entity metadata is not registered yet. Returning non-persistent save fallback.');
+            return {
+                moduleName,
+                dashboardName: resolvedDashboardName,
+                userId,
+                persisted: false,
+                message: 'Layout model generated but entity is not registered in TypeORM yet. Please add DashboardUserLayout to module TypeOrm entities and restart.',
+                layoutJson: resolvedLayoutJson,
+            };
+        }
+
+        return {
+            moduleName,
+            dashboardName: resolvedDashboardName,
+            userId,
+            persisted: true,
+            message: 'Layout saved successfully.',
+            layoutJson: this.parseLayoutJson(savedLayout.layoutJson),
+        };
+    }
+
+    private async getModuleMetadata(moduleName: string): Promise<any> {
+        const configPath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        const moduleMetadata = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(configPath);
+
+        if (!moduleMetadata) {
+            throw new NotFoundException(ERROR_MESSAGES.MODULE_NOT_FOUND(moduleName));
+        }
+
+        return moduleMetadata;
+    }
+
+    private getDashboards(moduleMetadata: any): any[] {
+        return Array.isArray(moduleMetadata?.dashboards) ? moduleMetadata.dashboards : [];
+    }
+
+    private findWidgetDefinition(dashboardDefinition: any, widgetName: string): any {
+        const widgets = Array.isArray(dashboardDefinition.widgets) ? dashboardDefinition.widgets : [];
+        const widgetDefinition = widgets.find((widget) => widget?.id === widgetName || widget?.name === widgetName);
+
+        if (!widgetDefinition) {
+            throw new NotFoundException(`Widget ${widgetName} not found in dashboard ${dashboardDefinition?.name ?? ''}.`);
+        }
+
+        return widgetDefinition;
+    }
+
+    private async getWidgetDataFromDefinition(
+        dashboardDefinition: any,
+        moduleName: string,
+        dashboardName: string,
+        widgetName: string,
+        request: DashboardWidgetDataRequestDto = {},
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const widgetDefinition = this.findWidgetDefinition(dashboardDefinition, widgetName);
+        const resolvedWidgetName = widgetDefinition.id ?? widgetDefinition.name ?? widgetName;
+        const providerName = widgetDefinition.dataProvider;
+
+        if (!this.hasDashboardWidgetPermission(activeUser, dashboardDefinition?.name ?? dashboardName, resolvedWidgetName)) {
+            return this.buildUnauthorizedWidgetResponse(
+                dashboardDefinition?.name ?? dashboardName,
+                resolvedWidgetName,
+                providerName,
+            );
+        }
+
+        if (!providerName) {
+            throw new NotFoundException(`Widget ${widgetName} is missing dataProvider definition.`);
+        }
+
+        const provider = this.solidRegistry.getDashboardWidgetDataProviderInstance(providerName);
+        if (!provider) {
+            throw new NotFoundException(ERROR_MESSAGES.PROVIDER_NOT_FOUND(providerName));
+        }
+
+        const providerContext = {
+            ...(widgetDefinition.providerContext ?? {}),
+            ...(request.providerContext ?? {}),
+        };
+
+        const runtimeContext: IDashboardWidgetDataProviderContext = {
+            moduleName,
+            dashboardName,
+            widgetName: resolvedWidgetName,
+            variables: request.variables ?? {},
+            providerContext,
+            activeUser,
+        };
+
+        const startTime = Date.now();
+        const providerResponse = await provider.getData(widgetDefinition, runtimeContext);
+        const durationMs = Date.now() - startTime;
+
+        if (providerResponse && typeof providerResponse === 'object' && providerResponse.data !== undefined) {
+            const nextMeta = {
+                ...(providerResponse.meta ?? {}),
+                providerName,
+                widgetName: runtimeContext.widgetName,
+                durationMs: providerResponse?.meta?.durationMs ?? durationMs,
+                generatedAt: providerResponse?.meta?.generatedAt ?? new Date().toISOString(),
+            };
+
+            return {
+                ...providerResponse,
+                meta: nextMeta,
+            };
+        }
+
+        this.logger.debug(`Widget provider ${providerName} returned a non-envelope payload for ${runtimeContext.widgetName}. Normalizing response.`);
+        return {
+            meta: {
+                providerName,
+                widgetName: runtimeContext.widgetName,
+                durationMs,
+                generatedAt: new Date().toISOString(),
+            },
+            data: providerResponse,
+        };
+    }
+
+    private parseFormValues(formValues?: Record<string, any> | string): Record<string, any> {
+        if (!formValues) {
+            return {};
+        }
+        if (typeof formValues === 'object') {
+            return formValues;
+        }
+
+        try {
+            const parsedFromQueryString = qs.parse(formValues);
+            if (parsedFromQueryString && typeof parsedFromQueryString === 'object') {
+                if (parsedFromQueryString['formValues'] && typeof parsedFromQueryString['formValues'] === 'object') {
+                    return parsedFromQueryString['formValues'] as Record<string, any>;
+                }
+                return parsedFromQueryString as Record<string, any>;
+            }
+        } catch (err) {
+            // ignore parse errors and try JSON
+        }
+
+        try {
+            return JSON.parse(formValues);
+        } catch (err) {
+            return {};
+        }
+    }
+
+    private hasDashboardWidgetPermission(
+        activeUser: ActiveUserData | undefined,
+        dashboardName: string,
+        widgetName: string,
+    ): boolean {
+        const permissions = Array.isArray(activeUser?.permissions) ? activeUser.permissions : [];
+        if (!dashboardName || !widgetName || permissions.length === 0) {
+            return false;
+        }
+
+        return permissions.some((permission) => this.matchesDashboardWidgetPermission(permission, dashboardName, widgetName));
+    }
+
+    private matchesDashboardWidgetPermission(permission: string, dashboardName: string, widgetName: string): boolean {
+        const match = /^dashboard:([^:]+):(.+)$/.exec(`${permission ?? ''}`.trim());
+        if (!match) {
+            return false;
+        }
+
+        const [, permissionDashboardName, widgetPattern] = match;
+        if (permissionDashboardName !== dashboardName || !widgetPattern) {
+            return false;
+        }
+
+        if (widgetPattern === '*') {
+            return true;
+        }
+
+        if (widgetPattern === widgetName) {
+            return true;
+        }
+
+        try {
+            return new RegExp(widgetPattern).test(widgetName);
+        } catch {
+            return false;
+        }
+    }
+
+    private buildUnauthorizedWidgetResponse(
+        dashboardName: string,
+        widgetName: string,
+        providerName?: string,
+    ): any {
+        return {
+            meta: {
+                providerName: providerName ?? null,
+                widgetName,
+                durationMs: 0,
+                generatedAt: new Date().toISOString(),
+                unauthorized: true,
+                permissionExpression: `dashboard:${dashboardName}:${widgetName}`,
+            },
+            data: null,
+            uiHints: {
+                state: 'unauthorized',
+                message: 'Unauthorized',
+            },
+        };
+    }
+
+    private parseLayoutJson(layoutJson: any): any {
+        if (layoutJson === null || layoutJson === undefined) return null;
+        if (typeof layoutJson !== 'string') return layoutJson;
+        try {
+            return JSON.parse(layoutJson);
+        } catch {
+            return layoutJson;
+        }
+    }
+
+    private resolveLayoutPayload(dto: DashboardSaveLayoutDto | Record<string, any> | null | undefined): any {
+        if (!dto) return {};
+        if (dto.layoutJson !== undefined) return dto.layoutJson;
+        if ((dto as any).layout !== undefined) return (dto as any).layout;
+        return dto;
+    }
+
+    private mergeLayouts(defaultLayout: any, userLayout: any): any {
+        if (!defaultLayout && !userLayout) return {};
+        if (!defaultLayout) return userLayout ?? {};
+        if (!userLayout) return defaultLayout ?? {};
+
+        const defaultItems = Array.isArray(defaultLayout?.items) ? defaultLayout.items : [];
+        const userItems = Array.isArray(userLayout?.items) ? userLayout.items : [];
+
+        if (!defaultItems.length) {
+            return {
+                ...defaultLayout,
+                ...userLayout,
+                items: userItems,
+            };
+        }
+
+        const userByWidget = new Map<string, any>();
+        userItems.forEach((item: any) => {
+            const key = item?.widgetId ?? item?.id;
+            if (key) userByWidget.set(key, item);
+        });
+
+        const mergedDefaultItems = defaultItems.map((baseItem: any) => {
+            const key = baseItem?.widgetId ?? baseItem?.id;
+            if (!key) return baseItem;
+            const override = userByWidget.get(key);
+            return override ? { ...baseItem, ...override, widgetId: key } : baseItem;
+        });
+
+        const defaultKeys = new Set(
+            defaultItems
+                .map((item: any) => item?.widgetId ?? item?.id)
+                .filter((value: any) => !!value)
+        );
+
+        const userOnlyItems = userItems.filter((item: any) => {
+            const key = item?.widgetId ?? item?.id;
+            return !!key && !defaultKeys.has(key);
+        });
+
+        return {
+            ...defaultLayout,
+            ...userLayout,
+            columns: userLayout?.columns ?? defaultLayout?.columns ?? 12,
+            items: [...mergedDefaultItems, ...userOnlyItems],
+        };
+    }
+}

package/src/services/dashboard-user-layout.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { DashboardUserLayout } from '../entities/dashboard-user-layout.entity';
+import { DashboardUserLayoutRepository } from '../repositories/dashboard-user-layout.repository';
+
+@Injectable()
+export class DashboardUserLayoutService extends CRUDService<DashboardUserLayout>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: DashboardUserLayoutRepository,
+    readonly moduleRef: ModuleRef,
+      
+ ) {
+   super(entityManager, repo, 'dashboardUserLayout', 'solid-core', moduleRef);
+ }
+}

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

@@ -27,6 +27,7 @@ import { getUserExcludedFields } from 'src/helpers/user-helper';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { upperFirst, camelCase } from 'lodash';
 import { classify } from '../helpers/string.helper';
+import type { SolidCoreSetting } from './settings/default-settings-provider.service';
 
 interface ImportTemplateFileInfo {
   stream: NodeJS.ReadableStream;
@@ -180,11 +181,20 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     // Replace modelMetadata.fields with combined (child + parent) fields
     // modelMetadata.fields = allFields;
 
+    const dateFieldFormat =
+      (this.settingService.getConfigValue<SolidCoreSetting>('dateFormat') as string | null) ??
+      'YYYY-MM-DD';
+    const dateTimeFieldFormat =
+      (this.settingService.getConfigValue<SolidCoreSetting>('dateTimeFormat') as string | null) ??
+      'YYYY-MM-DD HH:mm:ss';
+
     // Create the standard import instructions
     const standardInstructions: StandardImportInstructionsResponseDto = {
       requiredFields: [],
       dateFields: [],
+      dateFieldFormat,
       dateTimeFields: [],
+      dateTimeFieldFormat,
       numberFields: [],
       emailFields: [],
       regexFields: [],
@@ -792,4 +802,4 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     const relatedRecordsIds = relatedRecordsResult.records.map(record => record.id);
     return relatedRecordsIds;
   }
-}
+}

package/src/services/mcp-audit-log.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { McpAuditLog } from 'src/entities/mcp-audit-log.entity';
+import { McpAuditLogRepository } from 'src/repository/mcp-audit-log.repository';
+import { EntityManager } from 'typeorm';
+import { CRUDService } from './crud.service';
+
+@Injectable()
+export class McpAuditLogService extends CRUDService<McpAuditLog> {
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    readonly repo: McpAuditLogRepository,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(entityManager, repo, 'mcpAuditLog', 'solid-core', moduleRef);
+  }
+}

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

@@ -2,8 +2,8 @@ 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 { LegacyCommonEntity } from "src/entities/legacy-common.entity";
-import { LegacyCommonWithIdEntity } from "src/entities/legacy-common-with-id.entity";
+import { LegacyCommonEntityWithExistingId } from "src/entities/legacy-common.entity";
+import { LegacyCommonEntityWithGeneratedId } from "src/entities/legacy-common-with-id.entity";
 import { Media } from "src/entities/media.entity";
 import { MediaStorageProvider } from "src/interfaces";
 import { DiskFileService, S3FileService } from "src/services/file";
@@ -21,16 +21,51 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         readonly mediaRepository: MediaRepository,
     ) { }
 
-    storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        throw new Error("Method not implemented.");
+    async storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
+        const isSupportedEntity = entity instanceof CommonEntity
+            || entity instanceof LegacyCommonEntityWithExistingId
+            || entity instanceof LegacyCommonEntityWithGeneratedId;
+        if (!isSupportedEntity) {
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId");
+        }
+        const result: Media[] = [];
+        const storageProvider = mediaFieldMetadata.mediaStorageProvider;
+        const region = this.getEffectiveRegion(storageProvider.region);
+
+        for (const [stream, fileName] of streamPairs) {
+            const bucketName = storageProvider.bucketName;
+
+            // Buffer the stream so we can get the byte count and upload in one pass
+            const chunks: Buffer[] = [];
+            for await (const chunk of stream) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            const fileData = Buffer.concat(chunks);
+            const fileSize = fileData.length;
+
+            await this.s3FileService.write(`${bucketName}:${fileName}`, fileData, { region });
+
+            const mediaEntity = await this.mediaRepository.createMedia({
+                // @ts-ignore
+                entityId: entity.id,
+                modelMetadataId: mediaFieldMetadata.model.id,
+                relativeUri: fileName,
+                fileSize,
+                mediaStorageProviderMetadataId: mediaFieldMetadata.mediaStorageProvider.id,
+                fieldMetadataId: mediaFieldMetadata.id
+            }) as unknown as Media;
+            result.push(mediaEntity);
+            this.logger.debug(`Stored media with`, mediaEntity);
+        }
+        return result;
     }
 
     async retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
         const isSupportedEntity = entity instanceof CommonEntity
-            || entity instanceof LegacyCommonEntity
-            || entity instanceof LegacyCommonWithIdEntity;
+            || entity instanceof LegacyCommonEntityWithExistingId
+            || entity instanceof LegacyCommonEntityWithGeneratedId;
         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
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId"); // 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']);
@@ -60,10 +95,10 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
 
     async store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
         const isSupportedEntity = entity instanceof CommonEntity
-            || entity instanceof LegacyCommonEntity
-            || entity instanceof LegacyCommonWithIdEntity;
+            || entity instanceof LegacyCommonEntityWithExistingId
+            || entity instanceof LegacyCommonEntityWithGeneratedId;
         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
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
         const result: Media[] = [];
         const storageProvider = mediaFieldMetadata.mediaStorageProvider;
@@ -102,10 +137,10 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
 
     async delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void> {
         const isSupportedEntity = entity instanceof CommonEntity
-            || entity instanceof LegacyCommonEntity
-            || entity instanceof LegacyCommonWithIdEntity;
+            || entity instanceof LegacyCommonEntityWithExistingId
+            || entity instanceof LegacyCommonEntityWithGeneratedId;
         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
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
         const storageProvider = mediaFieldMetadata.mediaStorageProvider;
         const region = this.getEffectiveRegion(storageProvider.region);
@@ -120,6 +155,18 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         }
     }
 
+    async deleteByMediaRecord(media: Media): Promise<void> {
+        const storageProvider = media?.mediaStorageProviderMetadata;
+        if (!storageProvider) {
+            throw new Error(`mediaStorageProviderMetadata is not populated for media id ${media?.id ?? 'unknown'}`);
+        }
+        if (!storageProvider?.bucketName || !media?.relativeUri) {
+            return;
+        }
+        const region = this.getEffectiveRegion(storageProvider.region);
+        await this.s3FileService.delete(`${storageProvider.bucketName}:${media.relativeUri}`, { region });
+    }
+
     /**
      * Get the effective region to use for S3 operations.
      * Uses the provider-specific region if configured, otherwise falls back to env variable.