@solidstarters/solid-core 1.2.203 → 1.2.206

package/src/services/bcrypt.service.ts

@@ -1,22 +1,21 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
 import { compare as bcryptCompare, genSalt, hash as bcryptHash } from 'bcrypt';
-import { iamConfig } from 'src/config/iam.config';
 import { HashingService } from './hashing.service';
+import { SettingService } from './setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 @Injectable()
 export class BcryptService implements HashingService {
     constructor(
-        @Inject(iamConfig.KEY)
-        private readonly iamConfiguration: ConfigType<typeof iamConfig>,
+        readonly settingService: SettingService,
     ) { }
 
     private readonly rounds = 12;
-    private readonly pepper = this.iamConfiguration.passwordPepper ?? '';
 
     async hash(data: string | Buffer): Promise<string> {
         const salt = await genSalt(this.rounds);
-        const normalized = this.normalize(data, this.currentVersion());
+        const normalized = await this.normalize(data, this.currentVersion());
         return bcryptHash(normalized, salt);
     }
 
@@ -25,7 +24,7 @@ export class BcryptService implements HashingService {
         hashed: string,
         hashVersion: number = this.currentVersion()
     ): Promise<boolean> {
-        const normalized = this.normalize(data, hashVersion);
+        const normalized = await this.normalize(data, hashVersion);
         return bcryptCompare(normalized, hashed);
     }
 
@@ -44,10 +43,11 @@ export class BcryptService implements HashingService {
     }
 
     /** Normalize input based on version & pepper policy */
-    private normalize(data: string | Buffer, version: number): string {
+    private async normalize(data: string | Buffer, version: number): Promise<string> {
+        const pepper = this.settingService.getConfigValue<SolidCoreSetting>('passwordPepper')
         const plain = typeof data === 'string' ? data : data.toString('utf8');
-        const usePepper = version >= 2 && this.pepper.length > 0;
-        return usePepper ? plain + this.pepper : plain;
+        const usePepper = version >= 2 && pepper.length > 0;
+        return usePepper ? plain + pepper : plain;
     }
 
 }

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

@@ -1,14 +1,9 @@
-import { forwardRef, Inject, Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { DiscoveryService, ModuleRef  } from "@nestjs/core";
-import { EntityManager, Repository, In } from 'typeorm';
+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 { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from 'src/services/file.service';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 
 import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
 import { ChatterMessageDetailsRepository } from 'src/repository/chatter-message-details.repository';
@@ -16,19 +11,12 @@ import { ChatterMessageDetailsRepository } from 'src/repository/chatter-message-
 @Injectable()
 export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDetails>{
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(ChatterMessageDetails, 'default')
     readonly repo: ChatterMessageDetailsRepository,
     readonly moduleRef: ModuleRef,
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'chatterMessageDetails', 'solid-core', moduleRef);
+    super(entityManager, repo, 'chatterMessageDetails', 'solid-core', moduleRef);
   }
 }

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

@@ -1,10 +1,9 @@
 import { forwardRef, Inject, Injectable } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { Brackets, EntityManager, EntityMetadata } from 'typeorm';
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { ConfigService } from '@nestjs/config';
 import { CHATTER_MESSAGE_SUBTYPE, CHATTER_MESSAGE_TYPE } from 'src/constants/chatter-message.constants';
 import { PostChatterMessageDto } from 'src/dtos/post-chatter-message.dto';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
@@ -13,11 +12,7 @@ import { ChatterMessageDetailsRepository } from 'src/repository/chatter-message-
 import { ChatterMessageRepository } from 'src/repository/chatter-message.repository';
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from 'src/services/file.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
 import { MediaStorageProviderType } from '../dtos/create-media-storage-provider-metadata.dto';
 import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
 import { ChatterMessage } from '../entities/chatter-message.entity';
@@ -26,13 +21,6 @@ import { RequestContextService } from './request-context.service';
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
     constructor(
-        @Inject(forwardRef(() => ModelMetadataService))
-        readonly modelMetadataService: ModelMetadataService,
-        readonly moduleMetadataService: ModuleMetadataService,
-        readonly configService: ConfigService,
-        readonly fileService: FileService,
-        readonly discoveryService: DiscoveryService,
-        readonly crudHelperService: CrudHelperService,
         @InjectEntityManager()
         readonly entityManager: EntityManager,
         // @InjectRepository(ChatterMessage, 'default')
@@ -50,7 +38,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         readonly requestContextService: RequestContextService,
         private readonly modelMetadataHelperService: ModelMetadataHelperService,
     ) {
-        super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'chatterMessage', 'solid-core', moduleRef);
+        super(entityManager, repo, 'chatterMessage', 'solid-core', moduleRef);
     }
 
     async postMessage(postDto: PostChatterMessageDto, files: Express.Multer.File[] = []) {

package/src/services/crud.service.ts

@@ -1,8 +1,7 @@
 import { BadRequestException, NotFoundException } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { isArray } from "class-validator";
-import { CommonEntity, FileService, SolidBaseRepository, User } from "src";
+import { CommonEntity, SettingService, 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";
@@ -37,29 +36,41 @@ import { CrudHelperService, FilterCombinator, UserIdFields } from "./crud-helper
 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
 
+    private _modelMetadataService: ModelMetadataService;
+    private _crudHelperService: CrudHelperService;
+    private _discoveryService: DiscoveryService;
+    private _settingService: SettingService;
+
     constructor(
-        readonly modelMetadataService: ModelMetadataService, // go away
-        readonly moduleMetadataService: ModuleMetadataService, // go away
-        readonly configService: ConfigService, // we don't use it - go away
-        readonly fileService: FileService, // we don't use it - go away
-        readonly discoveryService: DiscoveryService, // go away
-        readonly crudHelperService: CrudHelperService, // go away
         readonly entityManager: EntityManager,
         readonly repo: SolidBaseRepository<T>,
         readonly modelName: string,
         readonly moduleName: string,
         readonly moduleRef: ModuleRef,
-        readonly defaultEntityManager?: EntityManager
-
-        //We can just have the Model Entity here
+        readonly defaultDatasourceEntityManager?: EntityManager
     ) { }
 
+    protected get modelMetadataService(): ModelMetadataService {
+        return this._modelMetadataService ??= this.moduleRef.get(ModelMetadataService, { strict: false });
+    }
+
+    protected get crudHelperService(): CrudHelperService {
+        return this._crudHelperService ??= this.moduleRef.get(CrudHelperService, { strict: false });
+    }
+
+    protected get discoveryService(): DiscoveryService {
+        return this._discoveryService ??= this.moduleRef.get(DiscoveryService, { strict: false });
+    }
+    protected get settingService(): SettingService {
+        return this._settingService ??= this.moduleRef.get(SettingService, { strict: false });
+    }
+
     async create(createDto: any, files: Express.Multer.File[] = [], solidRequestContext: any = {}): Promise<T> {
         // 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
@@ -94,7 +105,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
 
             // 6. Save the media
             if (hasMediaFields) {
-                this.saveMedia(model, files, savedEntity);
+                await this.saveMedia(model, files, savedEntity);
             }
             return savedEntity;
         } catch (error) {
@@ -130,14 +141,13 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return { dto, hasMediaFields };
     }
 
-    //FIXME: Need to make this saving media async. Use queues approach
-    private saveMedia(model: ModelMetadata, files: Express.Multer.File[], savedEntity: T) {
+    private async saveMedia(model: ModelMetadata, files: Express.Multer.File[], savedEntity: T): Promise<void> {
         // Get all the media fields in the dto
-
         const mediaFields = model.fields.filter(field => field.type === 'mediaSingle' || field.type === 'mediaMultiple');
 
         // Depending upon media storage provider configured, get the appropriate storage provider
-        mediaFields.forEach(async (mediaField) => {
+        // Using Promise.all to save all media fields in parallel
+        await Promise.all(mediaFields.map(async (mediaField) => {
             const media = files.filter(multerFile => multerFile.fieldname === mediaField.name);
 
             // If media is present, then save the media
@@ -150,11 +160,9 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 // Get the storage provider implementation
                 const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
 
-                //Commented the below code since we will be direclty images from server on call from ui 
-                // await storageProvider.delete(savedEntity, mediaField);
                 await storageProvider.store(media, savedEntity, mediaField);
             }
-        });
+        }));
     }
 
     //TODO: Will the updates be partial i.e PATCH or full i.e PUT
@@ -214,7 +222,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
 
         // 6. Save the media
         if (hasMediaFields) {
-            this.saveMedia(model, files, savedEntity);
+            await this.saveMedia(model, files, savedEntity);
         }
         return savedEntity;
     }
@@ -339,11 +347,11 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 //    Use the EntityController to extract uploaded content & pass to the entity service.
                 //    If embedded media, then the media uri will saved in the entity table, else the uri will be saved in the media table
                 //    Plan the media table schema e.g id, uri, storageProvider, entity_id, entity_name, createdAt, updatedAt
-                const options = { 
-                    ...commonOptions, 
+                const options = {
+                    ...commonOptions,
                     mediaMaxSizeKb: fieldMetadata.mediaMaxSizeKb,
                     mediaTypes: fieldMetadata.mediaTypes,
-                    type: fieldMetadata.type as unknown as SolidMediaType 
+                    type: fieldMetadata.type as unknown as SolidMediaType
                 };
                 return new MediaFieldCrudManager(options);
             }
@@ -626,7 +634,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
     }
 
     private async handlePopulateMedia(populateMedia: string[], entities: T[]) {
-        const model = await this.getDefaultEntityManager().getRepository(ModelMetadata).findOne({
+        const model = await this.getDatasourceDefaultEntityManager().getRepository(ModelMetadata).findOne({
             where: {
                 singularName: this.modelName,
             },
@@ -965,7 +973,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.getDefaultEntityManager().getRepository(ModelMetadata).findOne({
+        const relationCoModel = await this.getDatasourceDefaultEntityManager().getRepository(ModelMetadata).findOne({
             where: { singularName: field.relationCoModelSingularName },
             relations: ['fields', 'fields.mediaStorageProvider', 'fields.model'],
         });
@@ -1069,7 +1077,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return updatedEntity
     }
 
-    private getDefaultEntityManager() {
-        return this.defaultEntityManager ?? this.entityManager;
+    private getDatasourceDefaultEntityManager() {
+        return this.defaultDatasourceEntityManager ?? this.entityManager;
     }
 }

package/src/services/dashboard-question-sql-dataset-config.service.ts

@@ -1,14 +1,9 @@
 import { Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { DiscoveryService, ModuleRef  } from "@nestjs/core";
-import { EntityManager, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
 
 import { CRUDService } from 'src/services/crud.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from 'src/services/file.service';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 
 
 import { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
@@ -17,12 +12,6 @@ import { DashboardQuestionSqlDatasetConfigRepository } from 'src/repository/dash
 @Injectable()
 export class DashboardQuestionSqlDatasetConfigService extends CRUDService<DashboardQuestionSqlDatasetConfig>{
   constructor(
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(DashboardQuestionSqlDatasetConfig, 'default')
@@ -31,6 +20,6 @@ export class DashboardQuestionSqlDatasetConfigService extends CRUDService<Dashbo
     readonly moduleRef: ModuleRef
 
  ) {
-   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'dashboardQuestionSqlDatasetConfig', 'solid-core', moduleRef);
+   super(entityManager, repo, 'dashboardQuestionSqlDatasetConfig', 'solid-core', moduleRef);
  }
 }

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

@@ -1,22 +1,15 @@
 import { BadRequestException, Injectable, Logger, NotImplementedException } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from 'src/services/file.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
 import { DashboardVariable } from 'src/entities/dashboard-variable.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DashboardQuestion } from '../entities/dashboard-question.entity';
 import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
-import { DashboardService } from './dashboard.service';
-import { Dashboard } from 'src/entities/dashboard.entity';
 import { DashboardQuestionRepository } from 'src/repository/dashboard-question.repository';
 
 enum SOURCE_TYPE {
@@ -32,12 +25,6 @@ const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlData
 export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
   private readonly logger = new Logger(this.constructor.name);
   constructor(
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(DashboardQuestion, 'default')
@@ -46,7 +33,7 @@ export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
     readonly moduleRef: ModuleRef,
     readonly solidRegistry: SolidRegistry, // Assuming solidRegistry is injected for data providers
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'dashboardQuestion', 'solid-core', moduleRef);
+    super(entityManager, repo, 'dashboardQuestion', 'solid-core', moduleRef);
   }
 
   // Get the data for a specific question 

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

@@ -1,30 +1,18 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from 'src/services/file.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
 import { DashboardVariable } from '../entities/dashboard-variable.entity';
-import { Dashboard } from 'src/entities/dashboard.entity';
 import { DashboardVariableRepository } from 'src/repository/dashboard-variable.repository';
 
 @Injectable()
 export class DashboardVariableService extends CRUDService<DashboardVariable> {
   private readonly logger = new Logger(this.constructor.name);
   constructor(
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(DashboardVariable, 'default')
@@ -32,7 +20,7 @@ export class DashboardVariableService extends CRUDService<DashboardVariable> {
     readonly repo: DashboardVariableRepository,
     readonly moduleRef: ModuleRef,
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'dashboardVariable', 'solid-core', moduleRef);
+    super(entityManager, repo, 'dashboardVariable', 'solid-core', moduleRef);
   }
 
 

package/src/services/dashboard.service.ts

@@ -1,14 +1,9 @@
 import { Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from 'src/services/file.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
@@ -27,12 +22,6 @@ export const SQL_DYNAMIC_PROVIDER_NAME = 'DashboardVariableSQLDynamicProvider';
 export class DashboardService extends CRUDService<Dashboard> {
   private readonly logger = new Logger(this.constructor.name);
   constructor(
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     readonly repo: DashboardRepository, // Assuming you have a DashboardRepository for custom queries
@@ -41,7 +30,7 @@ export class DashboardService extends CRUDService<Dashboard> {
     readonly moduleMetadataHelperService: ModuleMetadataHelperService,
     readonly dashboardMapper: DashboardMapper,
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'dashboard', 'solid-core', moduleRef);
+    super(entityManager, repo, 'dashboard', 'solid-core', moduleRef);
   }
 
   async getSelectionDynamicValues(query: DashboardVariableSelectionDynamicQueryDto) {

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

@@ -1,31 +1,19 @@
-import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 
-import { ConfigService } from '@nestjs/config';
-import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { 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 { CrudHelperService } from './crud-helper.service';
 import { CRUDService } from './crud.service';
-import { FileService } from './file.service';
 import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
 import { MediaService } from './media.service';
-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,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
     readonly mediaService: MediaService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(EmailTemplate, 'default')
@@ -33,7 +21,7 @@ export class EmailTemplateService extends CRUDService<EmailTemplate>{
     readonly repo: EmailTemplateRepository,
     readonly moduleRef: ModuleRef,
     ) {
-        super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'emailTemplate', 'app-builder', moduleRef);
+        super(entityManager, repo, 'emailTemplate', 'app-builder', moduleRef);
     }
     async findOneByName(name: string, relations: any = {}) {
         const entity = await this.repo.findOne({

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

@@ -1,21 +1,13 @@
 import { ForbiddenException, Injectable } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from 'src/services/file.service';
-import { MediaStorageProviderMetadataService } from 'src/services/media-storage-provider-metadata.service';
-import { MediaService } from 'src/services/media.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
 import { CreateExportTransactionDto } from 'src/dtos/create-export-transaction.dto';
 import { ExportTransaction } from 'src/entities/export-transaction.entity';
-import { Readable } from 'stream';
 import { ExportTemplate } from '../entities/export-template.entity';
 import { ExportTransactionFileInfo, ExportTransactionService } from './export-transaction.service';
 import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
@@ -71,12 +63,6 @@ export class ExportTemplateService extends CRUDService<ExportTemplate>{
   }
 
   constructor(
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(ExportTemplate, 'default')
@@ -85,6 +71,6 @@ export class ExportTemplateService extends CRUDService<ExportTemplate>{
     readonly exportTransactionService: ExportTransactionService,
     readonly moduleRef: ModuleRef
  ) {
-   super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService,entityManager, repo, 'exportTemplate', 'solid-core',moduleRef);
+   super(entityManager, repo, 'exportTemplate', 'solid-core',moduleRef);
  }
 }

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

@@ -1,16 +1,9 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from 'src/services/file.service';
-import { MediaStorageProviderMetadataService } from 'src/services/media-storage-provider-metadata.service';
-import { MediaService } from 'src/services/media.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
 import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
@@ -26,12 +19,10 @@ import { CsvService } from './csv.service';
 import { ExcelService } from './excel.service';
 import { getMediaStorageProvider } from './mediaStorageProviders';
 import { SolidIntrospectService } from './solid-introspect.service';
-import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { ExportTransactionRepository } from 'src/repository/export-transaction.repository';
-import { Field } from 'mysql2/typings/mysql/lib/parsers/typeCast';
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
 
@@ -59,12 +50,6 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
   private logger = new Logger(ExportTransactionService.name);
 
   constructor(
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(ExportTransaction, 'default')
@@ -84,7 +69,7 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     private readonly modelMetadataHelperService: ModelMetadataHelperService,
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'exportTransaction', 'solid-core', moduleRef);
+    super(entityManager, repo, 'exportTransaction', 'solid-core', moduleRef);
   }
 
   // Return the export stream

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

@@ -225,6 +225,10 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         return { moduleName, modelName };
     }
 
+    async find(basicFilterDto: BasicFilterDto) {
+        return this.findMany(basicFilterDto);
+    }
+
     async findMany(basicFilterDto: BasicFilterDto) {
         const alias = 'fieldMetadata';
         // Extract the required keys from the input query
@@ -1374,7 +1378,7 @@ export class FieldMetadataService implements OnApplicationBootstrap {
             resolvedBucketName = mediaStorageProvider.bucketName;
         }
         this.logger.debug(`INSIDE::resolveS3Url:: resolvedBucketName: ${resolvedBucketName}`)
- 
+
         if (resolveS3UrlDto.isPrivate == "true") {
             const expiryInSeconds = 60 * 60;
             url = await this.fileService.getSignedUrl(normalizedKey, expiryInSeconds, resolvedBucketName);