@solidstarters/solid-core 1.2.193 → 1.2.201

package/src/services/crud.service.ts

@@ -1,8 +1,8 @@
-import { BadRequestException, NotFoundException } from "@nestjs/common";
+import { BadRequestException, Inject, NotFoundException } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { isArray } from "class-validator";
-import { CommonEntity, SolidBaseRepository } from "src";
+import { CommonEntity, SolidBaseRepository, User } from "src";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 import { SUCCESS_MESSAGES } from "src/constants/success-messages";
 import { EntityManager, FindOptionsWhere, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
@@ -33,13 +33,14 @@ import { SelectionStaticFieldCrudManager } from "../helpers/field-crud-managers/
 import { ShortTextFieldCrudManager } from "../helpers/field-crud-managers/ShortTextFieldCrudManager";
 import { UUIDFieldCrudManager } from "../helpers/field-crud-managers/UUIDFieldCrudManager";
 import { FieldCrudManager, MediaWithFullUrl } from "../interfaces";
-import { CrudHelperService } from "./crud-helper.service";
+import { CrudHelperService, FilterCombinator, UserIdFields } from "./crud-helper.service";
 import { FileService } from "./file.service";
 import { HashingService } from "./hashing.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
 import { RequestContextService } from "./request-context.service";
+import { BasicGroupFilterDto } from "src/dtos/basic-group-filters.dto";
 
 export class CRUDService<T extends CommonEntity> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
@@ -55,6 +56,8 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         readonly modelName: string,
         readonly moduleName: string,
         readonly moduleRef: ModuleRef,
+        readonly defaultEntityManager? : EntityManager
+        
         //We can just have the Model Entity here
     ) { }
 
@@ -178,7 +181,16 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
 
-        updateDto.id = id;
+        if (model.draftPublishWorkflow === true && entity.publishedAt) {
+            throw new BadRequestException(`Cannot update a published record for model ${this.modelName}. Unpublish it first.`
+            );
+        }
+
+        // // In some instances for legacy tables sometimes id is mapped as a bigint. 
+        // // in these cases the update method ends up attempting to insert records due to some type orm type mismatch issue.
+        // const idFieldMetadata = model.fields.find(f => f.name === 'id');
+        // updateDto.id = idFieldMetadata?.type === 'bigint' ? BigInt(id) : id;
+
         // This class will be extended by the generated service class i.e PersonService
         // The data required to identify the model and module name will be passed from the generate CrudService subclass
         //TODO: Algorithm to create the entity
@@ -239,6 +251,10 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
 
+        if (model.draftPublishWorkflow === true && entity.publishedAt) {
+            throw new BadRequestException(`Cannot update a published record for model ${this.modelName}, Unpublish it first.`);
+        }
+
         // If the model has internationalisation enabled, delete children with defaultEntityLocaleId === this entity's id
         if (model.internationalisation) {
             // Find all child entities where defaultEntityLocaleId === this entity's id
@@ -430,6 +446,8 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         const alias = 'entity';
         // Extract the required keys from the input query
         let { limit, offset, populateMedia, populateGroup, groupFilter } = basicFilterDto;
+        const populateUserIdFields = this.crudHelperService.extractUserIdFieldsFromPopulate(basicFilterDto.populate);
+
         const { singularName, internationalisation, draftPublishWorkflow } = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
@@ -445,16 +463,34 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
 
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = await this.repo.createSecurityRuleAwareQueryBuilder(alias)
-        qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
-        if (internationalisation && draftPublishWorkflow) {
-            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef);
-        }
 
         if (basicFilterDto.groupBy) {
-            // Get the records and the count
-            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia);
-            const totalGroups = await this.crudHelperService.countGroupedRecords(qb, basicFilterDto, alias);
-            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+            const groupFilterQb = (internationalisation && draftPublishWorkflow)
+                ? this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef, FilterCombinator.AND, false, false)
+                : this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, undefined, undefined, undefined, FilterCombinator.AND, false, false);
+
+            const groupByFields = this.crudHelperService.normalize(basicFilterDto.groupBy);
+            if (!groupByFields.length) {
+                throw new BadRequestException(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
+            }
+
+            if (basicFilterDto.populateGroup) {
+                const hasRelationGroup = groupByFields.some(field => field.includes('.'));
+                if (hasRelationGroup) {
+                    throw new BadRequestException('populateGroup is not supported when grouping on relation fields. Fetch group metadata first and retrieve records in a separate call.');
+                }
+            }
+
+            const { aliasMap: groupAliasMap, formatMap: groupFormatMap, expressionMap: groupExpressionMap } = this.crudHelperService.applyGroupBySelections(groupFilterQb, groupByFields, alias);
+            const aggregateAliasMap = this.crudHelperService.applyAggregates(groupFilterQb, basicFilterDto.aggregates, alias);
+            const sortAliasMap = { ...groupAliasMap, ...aggregateAliasMap };
+            this.crudHelperService.applyGroupSortingAndPagination(groupFilterQb, basicFilterDto.sort, sortAliasMap, limit, offset);
+
+            const groupByResult = await groupFilterQb.getRawMany();
+            const totalGroups = await this.crudHelperService.countGroups(groupFilterQb);
+
+            const groupByFieldsOrdered = this.crudHelperService.normalize(basicFilterDto.groupBy || []);
+            const { groupMeta, groupRecords } = await this.handleGroupFind(groupByResult, groupFilter, populateGroup, alias, populateUserIdFields, populateMedia, basicFilterDto, groupAliasMap, aggregateAliasMap, groupByFieldsOrdered, groupFormatMap, groupExpressionMap);
 
             return {
                 meta: {
@@ -465,8 +501,10 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             }
         }
         else {
-            // Get the records and the count
-            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias);
+            qb = (internationalisation && draftPublishWorkflow)
+                ? this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef)
+                : this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+            const { meta, records } = await this.handleNonGroupFind(qb, populateUserIdFields, populateMedia, offset, limit, alias);
             return {
                 meta,
                 records,
@@ -474,9 +512,14 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         }
     }
 
-    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number, alias: string) {
+    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateUserIdFields: UserIdFields[], populateMedia: string[], offset: number, limit: number, alias: string) {
         const [entities, count] = await qb.getManyAndCount();
 
+        // Populate the entity with the userId fields
+        if (populateUserIdFields && populateUserIdFields.length > 0) {
+            await this.handlePopulateUserIdFields(populateUserIdFields, entities);
+        }
+
         // Populate the entity with the media
         if (populateMedia && populateMedia.length > 0) {
             await this.handlePopulateMedia(populateMedia, entities);
@@ -485,37 +528,65 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return this.wrapFindResponse(offset, limit, count, entities);
     }
 
-    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[]) {
-        const groupByResult = await qb.getRawMany();
-
+    private async handleGroupFind(
+        groupByResult: any[],
+        groupFilter: BasicGroupFilterDto | undefined,
+        populateGroup: boolean,
+        alias: string,
+        populateUserIdFields: UserIdFields[],
+        populateMedia: string[],
+        baseFilterDto: BasicFilterDto,
+        groupAliasMap: Record<string, string>,
+        aggregateAliasMap: Record<string, string>,
+        groupByFieldsOrdered: string[],
+        groupFormatMap: Record<string, string | undefined>,
+        groupExpressionMap: Record<string, string>
+    ) {
         const groupMeta = [];
         const groupRecords = [];
+        const aggregateAliasSet = new Set(Object.values(aggregateAliasMap));
         // For each group, get the records and the count
         for (const group of groupByResult) {
             if (populateGroup) {
                 let groupByQb: SelectQueryBuilder<T> = await this.repo.createSecurityRuleAwareQueryBuilder(alias);
-                groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias);
-                groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
+                const groupFilterDto: BasicFilterDto = {
+                    ...baseFilterDto,
+                    ...groupFilter,
+                    groupBy: undefined,
+                    aggregates: undefined,
+                    // Only use explicit groupFilter.sort for record ordering; group-level sorts can contain
+                    // group expressions (e.g. createdAt:day) that are invalid on record queries.
+                    sort: groupFilter?.sort,
+                };
+                groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilterDto, alias);
+                groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias, groupAliasMap, aggregateAliasMap, groupExpressionMap);
                 const [entities, count] = await groupByQb.getManyAndCount();
 
+                // Populate the entity with the userId fields
+                if (populateUserIdFields && populateUserIdFields.length > 0) {
+                    await this.handlePopulateUserIdFields(populateUserIdFields, entities);
+                }
+
                 // Populate the entity with the media
                 if (populateMedia && populateMedia.length > 0) {
                     await this.handlePopulateMedia(populateMedia, entities);
                 }
-                const groupData = this.wrapFindResponse(groupFilter.offset, groupFilter.limit, count, entities);
-                groupRecords.push(this.crudHelperService.createGroupRecords(group, alias, groupData));
+                const groupData = this.wrapFindResponse(groupFilter?.offset, groupFilter?.limit, count, entities);
+                groupRecords.push(this.crudHelperService.createGroupRecords(group, aggregateAliasSet, groupData, groupByFieldsOrdered, groupAliasMap, groupFormatMap));
             }
-            groupMeta.push(this.crudHelperService.createGroupMeta(group, alias));
+            groupMeta.push(this.crudHelperService.createGroupMeta(group, aggregateAliasSet, groupByFieldsOrdered, groupAliasMap, groupFormatMap));
         }
         return { groupMeta, groupRecords };
     }
 
-    private wrapFindResponse(offset: number, limit: number, count: number, entities: T[]) {
-        const currentPage = Math.floor(offset / limit) + 1;
-        const totalPages = Math.ceil(count / limit);
+    private wrapFindResponse(offset: number | undefined, limit: number | undefined, count: number, entities: T[]) {
+        const safeLimit = limit ?? count ?? 0;
+        const safeOffset = offset ?? 0;
+        const currentPage = safeLimit ? Math.floor(safeOffset / safeLimit) + 1 : 1;
+        const totalPages = safeLimit ? Math.ceil(count / safeLimit) : 1;
 
-        const nextPage = currentPage < totalPages ? currentPage + 1 : null;
-        const prevPage = currentPage > 1 ? currentPage - 1 : null;
+        const nextPage = safeLimit && currentPage < totalPages ? currentPage + 1 : null;
+        const prevPage = safeLimit && currentPage > 1 ? currentPage - 1 : null;
 
         const r = {
             meta: {
@@ -524,15 +595,34 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 nextPage: nextPage,
                 prevPage: prevPage,
                 totalPages: totalPages,
-                perPage: +limit,
+                perPage: safeLimit ? +safeLimit : 0,
             },
             records: entities
         };
         return r;
     }
 
+    // entities is an array of T
+    // T can contain createdBy and updatedBy fields
+    // We need to populate the createdBy and updatedBy fields with the User entity
+    private async handlePopulateUserIdFields(userIdFields: UserIdFields[], entities: T[]) {
+        const userRepository = this.entityManager.getRepository(User);
+        for (const entity of entities) {
+            for (const userFieldPath of userIdFields) {
+                const userId = entity[userFieldPath as keyof T] as unknown as number;
+                if (userId) {
+                    const user = await userRepository.findOne({
+                        where: { id: userId },
+                    });
+                    // @ts-ignore
+                    entity[userFieldPath] = user;
+                }
+            }
+        }
+    }
+
     private async handlePopulateMedia(populateMedia: string[], entities: T[]) {
-        const model = await this.entityManager.getRepository(ModelMetadata).findOne({
+        const model = await this.getDefaultEntityManager().getRepository(ModelMetadata).findOne({
             where: {
                 singularName: this.modelName,
             },
@@ -615,7 +705,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return mediaDetails as MediaWithFullUrl[];
     }
 
-    async findOne(id: number, query: any, solidRequestContext: any = {}) {
+    async findOne(id: number, query: any={}, solidRequestContext: any = {}) {
         const { populate = [], fields = [], populateMedia = [] } = query;
 
         // const normalizedFields = this.crudHelperService.normalize(fields);
@@ -731,8 +821,30 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                     id: id,
                 } as unknown as FindOptionsWhere<T>,
             });
+
             removedEntities.push(entity);
         }
+
+
+        // entity-level flag
+        const isDraftPublishEnabled = model?.draftPublishWorkflow === true;
+
+        let publishedEntitiesExists: T[] = [];
+
+        if (isDraftPublishEnabled) {
+            publishedEntitiesExists = removedEntities.filter(
+                (x) => !!x?.publishedAt
+            );
+        }
+
+        if (publishedEntitiesExists.length > 0) {
+            const publishedEntitiesExistsID = publishedEntitiesExists.map(x => x.id);
+
+            throw new BadRequestException(
+                `Cannot delete published record(s) for model ${this.modelName} with Ids ${publishedEntitiesExistsID.join(', ')}. Unpublish them first.`
+            );
+        }
+
         if (model.enableSoftDelete === true) {
             await this.repo.softRemove(removedEntities);
             return this.repo.save(removedEntities);
@@ -767,7 +879,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             await this.repo.update(id, {
                 deletedAt: null, deletedTracker: "not-deleted"
             } as unknown as QueryDeepPartialEntity<T>
-         );
+            );
 
             return { message: SUCCESS_MESSAGES.RECORD_RECOVERED, data: softDeletedRows };
         } catch (error) {
@@ -849,7 +961,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             throw new BadRequestException(`Field ${field.name} does not define a relationCoModelSingularName`);
         }
 
-        const relationCoModel = await this.entityManager.getRepository(ModelMetadata).findOne({
+        const relationCoModel = await this.getDefaultEntityManager().getRepository(ModelMetadata).findOne({
             where: { singularName: field.relationCoModelSingularName },
             relations: ['fields', 'fields.mediaStorageProvider', 'fields.model'],
         });
@@ -868,5 +980,92 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         }
         return model.userKeyField?.name || '';
     }
-}
 
+    /* Publish a record - sets publishedAt timestamp */
+    async publishRecord(id: number, solidRequestContext: any = {}): Promise<T> {
+
+        const model = await this.loadModel();
+
+        // Check if publish workflow is enabled for this model
+        if (!model.draftPublishWorkflow) {
+            throw new BadRequestException(
+                `Publish workflow is not enabled for ${this.modelName}`
+            );
+        }
+
+        // Check user permissions
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasPublishPermissionOnModel(
+                solidRequestContext.activeUser,
+                model.singularName
+            );
+            if (!hasPermission) {
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
+            }
+        }
+
+        // Find the entity
+        const entity = await this.repo.findOne({ where: { id } as any });
+        if (!entity) {
+            throw new NotFoundException(`${this.modelName} with id ${id} not found`);
+        }
+
+        // Check if already published
+        if (entity.publishedAt) {
+            throw new BadRequestException(
+                `${this.modelName} with id ${id} is already published`
+            );
+        }
+
+        // Update publish status
+        const updatedEntity = await this.repo.save({ ...entity, publishedAt: new Date() });
+
+        return updatedEntity
+    }
+
+    /* Unpublish a record - clears publishedAt timestamp */
+    async unpublishRecord(id: number, solidRequestContext: any = {}): Promise<T> {
+
+        const model = await this.loadModel();
+
+        // Check if publish workflow is enabled for this model
+        if (!model.draftPublishWorkflow) {
+            throw new BadRequestException(
+                `Publish workflow is not enabled for ${this.modelName}`
+            );
+        }
+
+        // Check user permissions
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasUnpublishPermissionOnModel(
+                solidRequestContext.activeUser,
+                model.singularName
+            );
+            if (!hasPermission) {
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
+            }
+        }
+
+        // Find the entity
+        const entity = await this.repo.findOne({ where: { id } as any });
+        if (!entity) {
+            throw new NotFoundException(`${this.modelName} with id ${id} not found`);
+        }
+
+        // Check if already unpublished
+        if (!entity.publishedAt) {
+            throw new BadRequestException(
+                `${this.modelName} with id ${id} is already unpublished`
+            );
+        }
+
+        // Update unpublish status
+        const updatedEntity = await this.repo.save({ ...entity, publishedAt: null });
+
+        return updatedEntity
+    }
+
+    private getDefaultEntityManager(){
+        return this.defaultEntityManager ?? this.entityManager;
+    }
+}

package/src/services/database/database-bootstrap.service.ts

@@ -0,0 +1,91 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { readdir, readFile } from 'fs/promises';
+import * as path from 'path';
+import { InjectDataSource } from '@nestjs/typeorm';
+
+@Injectable()
+export class DatabaseBootstrapService implements OnModuleInit {
+  private readonly logger = new Logger(DatabaseBootstrapService.name);
+
+  constructor(
+    @InjectDataSource()
+    private readonly dataSource: DataSource,
+  ) { }
+
+  async onModuleInit() {
+    if (!this.dataSource.isInitialized) {
+      this.logger.warn(`[${this.dataSource.name}] DataSource not initialized. Skipping SQL bootstrap.`);
+      return;
+    }
+
+    this.logger.debug(`[${this.dataSource.name}] Bootstrapping stored procedures...`);
+
+    await this.applyAllSqlFiles();
+
+    this.logger.debug(`[${this.dataSource.name}] SQL bootstrap completed`);
+  }
+
+  private resolveSqlDirectory(): string {
+    const datasourceName = this.dataSource.name || 'default';
+    const dbType = this.dataSource.options.type;
+
+    const sqlFilePath = path.resolve(__dirname, `../../../sql/${datasourceName}/${dbType}`);
+
+    return sqlFilePath
+  }
+
+  private async applyAllSqlFiles() {
+    const sqlDir = this.resolveSqlDirectory();
+
+    this.logger.debug(`[${this.dataSource.name}] SQL directory: ${sqlDir}`);
+
+    let files: string[];
+    try {
+      files = await readdir(sqlDir);
+    } catch {
+      this.logger.warn(
+        `[${this.dataSource.name}] No SQL directory found. Skipping.`,
+      );
+      return;
+    }
+
+    const sqlFiles = files
+      .filter(file => file.endsWith('.sql'))
+      .sort();
+
+    if (!sqlFiles.length) {
+      this.logger.warn(
+        `[${this.dataSource.name}] No SQL files found`,
+      );
+      return;
+    }
+
+    for (const file of sqlFiles) {
+      await this.applySqlFileSafely(
+        path.join(sqlDir, file),
+        file,
+      );
+    }
+  }
+
+  private async applySqlFileSafely(
+    filePath: string,
+    fileName: string,
+  ) {
+    this.logger.debug(`[${this.dataSource.name}] Applying ${fileName}`);
+
+    try {
+      const sql = await readFile(filePath, 'utf8');
+      await this.dataSource.query(sql);
+
+      this.logger.debug(`[${this.dataSource.name}] Applied ${fileName}`);
+    } catch (error) {
+      // DO NOT THROW — continue with next file
+      this.logger.error(
+        `[${this.dataSource.name}] Failed ${fileName}`,
+        error instanceof Error ? error.stack : String(error),
+      );
+    }
+  }
+}

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

@@ -1,25 +1,23 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
-import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { ConfigService } from '@nestjs/config';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EmailTemplateRepository } from 'src/repository/email-template.repository';
+import { EntityManager } from 'typeorm';
 import { EmailTemplate } from '../entities/email-template.entity';
-import { CreateEmailTemplateDto } from '../dtos/create-email-template.dto';
-import { UpdateEmailTemplateDto } from '../dtos/update-email-template.dto';
+import { CrudHelperService } from './crud-helper.service';
 import { CRUDService } from './crud.service';
-import { ModelMetadataService } from './model-metadata.service';
-import { ModuleMetadataService } from './module-metadata.service';
-import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
-import { ConfigService } from '@nestjs/config';
 import { FileService } from './file.service';
+import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
 import { MediaService } from './media.service';
-import { DiscoveryService, ModuleRef } from '@nestjs/core';
-import { CrudHelperService } from './crud-helper.service';
-import { EmailTemplateRepository } from 'src/repository/email-template.repository';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
 
 @Injectable()
 export class EmailTemplateService extends CRUDService<EmailTemplate>{
     constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly mediaStorageProviderService: MediaStorageProviderMetadataService,