@solidstarters/solid-core 1.2.193 → 1.2.201

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

@@ -7,21 +7,30 @@ import { ComputedFieldMetadata, SolidRegistry } from 'src/helpers/solid-registry
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { DataSource, Repository, SelectQueryBuilder } from 'typeorm';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
-import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
+import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, MSSQLType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
 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()
 export class FieldMetadataService implements OnApplicationBootstrap {
     constructor(
         private readonly fieldMetadataRepo: FieldMetadataRepository,
+        private readonly configService: ConfigService,
+        private readonly fileService: FileService,
+        private readonly mediaStorageProviderMetadataRepository: MediaStorageProviderMetadataRepository,
+
         @InjectDataSource()
         private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
@@ -35,9 +44,9 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         this.loadAndRegisterComputedFieldsDetails();
     }
 
-   async loadAndRegisterComputedFieldsDetails() {
+    async loadAndRegisterComputedFieldsDetails() {
         // Load all the modules and models and within that load all the computed fields
-        const computedFieldsWithModelAndModule =  await this.fieldMetadataRepo.findComputedFieldsPopulatedWithModelAndModule();
+        const computedFieldsWithModelAndModule = await this.fieldMetadataRepo.findComputedFieldsPopulatedWithModelAndModule();
 
         // Convert the computed fields object above to the ComputedFieldMetadata type
         const computedFieldMetadata: ComputedFieldMetadata[] = computedFieldsWithModelAndModule.map((field) => {
@@ -54,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: {}
             };
         });
 
@@ -354,7 +364,71 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         };
 
         // Orm Data type and Solid Dat Type Mapping
-        const ormFieldTypeForSolid = {
+        const ormFieldTypeForSolid = this.getOrmFieldTypes();
+
+        // Fetch Data Source Type 
+        const dataSourceTypes = Object.keys(ormFieldTypeForSolid); // ["psql"]
+
+        const fieldTypes = Object.entries(ormFieldTypeForSolid.postgres).map(([key, value]) => ({
+            type: key,
+            label: key,
+            value: key,
+            fieldType: key,
+            ormTypes: value.ormTypes,
+            fields: this.fetchCurrentFields(key)
+        }));
+
+        const dataSource = this.solidRegistry.getSolidDatabaseModules().map((solidDatabaseModule) => {
+            return {
+                'name': solidDatabaseModule.instance.name(),
+                'type': solidDatabaseModule.instance.type()
+            }
+        });
+
+        // Creating response arrays for each enum
+        // Get all selection providers. 
+        const sps = [];
+        const selectionProviders = this.solidRegistry.getSelectionProviders();
+        for (let i = 0; i < selectionProviders.length; i++) {
+            const selectionProvider = selectionProviders[i];
+            sps.push({
+                provider: selectionProvider.instance.name(),
+                help: selectionProvider.instance.help(),
+            });
+        }
+
+        const cps = [];
+        const computedProviders = this.solidRegistry.getComputedFieldProviders();
+        for (let i = 0; i < computedProviders.length; i++) {
+            const computedProvider = computedProviders[i];
+            cps.push({
+                provider: computedProvider.instance.name(),
+                help: computedProvider.instance.help(),
+            });
+        }
+
+        const r = {
+            // Field Types with ormtypes, available fields  
+            fieldTypes: fieldTypes,
+            encryptionTypes: enumToResponseArray(EncryptionType),
+            ormType: ormFieldTypeForSolid,
+            decryptWhenTypes: enumToResponseArray(DecryptWhenType),
+            mediaTypes: enumToResponseArray(MediaType),
+            relationTypes: enumToResponseArray(RelationType),
+            selectionDynamicProviders: sps,
+            computedProviders: cps,
+            cascadeTypes: enumToResponseArray(CascadeType),
+            selectionValueTypes: enumToResponseArray(SelectionValueType),
+            computedFieldValueTypes: enumToResponseArray(ComputedFieldValueType),
+            dataSourceType: dataSourceTypes,
+            dataSource: dataSource,
+        };
+
+        return r
+    }
+
+    private getOrmFieldTypes() {
+        return {
             "postgres": {
                 // Numeric types
                 "int": {
@@ -379,6 +453,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                 },
                 "json": {
                     "ormTypes": [
+                        // { label: PSQLType.simplejson, description: "Creates DB agnostic column for storing json style data." },
+                        { label: MSSQLType.simplejson, description: "Creates DB agnostic column for storing json style data." },
                         { label: PSQLType.json, description: "Stores JSON data without indexing." },
                         { label: PSQLType.jsonb, description: "Stores JSON data with indexing for faster queries." }
                     ]
@@ -443,69 +519,131 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                 "uuid": {
                     "ormTypes": [{ label: PSQLType.varchar, description: "Stores universally unique identifiers (UUIDs)." }]
                 }
-            }
-        };
+            },
+            "mssql": {
+                // Numeric types
+                "int": {
+                    ormTypes: [
+                        { label: MSSQLType.int, description: "A 4-byte integer for general numeric data." }
+                    ]
+                },
+                "bigint": {
+                    ormTypes: [
+                        { label: MSSQLType.bigint, description: "An 8-byte integer for large numeric values." }
+                    ]
+                },
+                "decimal": {
+                    ormTypes: [
+                        { label: MSSQLType.numeric, description: "A high-precision numeric type for financial or exact values." },
+                        { label: MSSQLType.decimal, description: "A high-precision decimal type for financial or exact values." }
+                    ]
+                },
 
+                // Text types
+                "shortText": {
+                    ormTypes: [
+                        { label: MSSQLType.varchar, description: "A variable-length string for short text." },
+                        { label: MSSQLType.nvarchar, description: "A unicode supported variable-length string for short text." }
+                    ]
+                },
+                "longText": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "A large or unbounded string type." }
+                    ]
+                },
+                "richText": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "A large text field for formatted or long content." }
+                    ]
+                },
+                "json": {
+                    ormTypes: [
+                        { label: MSSQLType.simplejson, description: "Creates DB agnostic column for storing json style data." },
+                        { label: MSSQLType.nvarchar, description: "Stores JSON data as string (MSSQL doesn't have native JSON type)." }
+                    ]
+                },
 
-        // Fetch Data Source Type 
-        const dataSourceTypes = Object.keys(ormFieldTypeForSolid); // ["psql"]
+                // Boolean types
+                "boolean": {
+                    ormTypes: [
+                        { label: MSSQLType.bit, description: "Stores true or false values as 0 or 1." }
+                    ]
+                },
 
-        const fieldTypes = Object.entries(ormFieldTypeForSolid.postgres).map(([key, value]) => ({
-            type: key,
-            label: key,
-            value: key,
-            fieldType: key,
-            ormTypes: value.ormTypes,
-            fields: this.fetchCurrentFields(key)
-        }));
+                // Date and time types
+                "date": {
+                    ormTypes: [
+                        { label: MSSQLType.date, description: "Stores calendar dates (YYYY-MM-DD)." }
+                    ]
+                },
+                "datetime": {
+                    ormTypes: [
+                        { label: MSSQLType.datetime, description: "Stores date and time without timezone." },
+                        { label: MSSQLType.datetime2, description: "High-precision date and time type." }
+                    ]
+                },
+                "time": {
+                    ormTypes: [
+                        { label: MSSQLType.time, description: "Stores time values (HH:MM:SS)." }
+                    ]
+                },
 
-        const dataSource = this.solidRegistry.getSolidDatabaseModules().map((solidDatabaseModule) => {
-            return {
-                'name': solidDatabaseModule.instance.name(),
-                'type': solidDatabaseModule.instance.type()
-            }
-        });
+                // Relation
+                "relation": {
+                    ormTypes: [
+                        { label: MSSQLType.int, description: "Used for foreign keys referencing other entities." }
+                    ]
+                },
 
-        // Creating response arrays for each enum
-        // Get all selection providers. 
-        const sps = [];
-        const selectionProviders = this.solidRegistry.getSelectionProviders();
-        for (let i = 0; i < selectionProviders.length; i++) {
-            const selectionProvider = selectionProviders[i];
-            sps.push({
-                provider: selectionProvider.instance.name(),
-                help: selectionProvider.instance.help(),
-            });
-        }
+                // Media types
+                "mediaSingle": {
+                    ormTypes: [
+                        { label: MSSQLType.varchar, description: "Stores file paths or URLs for single media files." }
+                    ]
+                },
+                "mediaMultiple": {
+                    ormTypes: [
+                        { label: MSSQLType.varchar, description: "Stores file paths or URLs for multiple media files." }
+                    ]
+                },
 
-        const cps = [];
-        const computedProviders = this.solidRegistry.getComputedFieldProviders();
-        for (let i = 0; i < computedProviders.length; i++) {
-            const computedProvider = computedProviders[i];
-            cps.push({
-                provider: computedProvider.instance.name(),
-                help: computedProvider.instance.help(),
-            });
-        }
+                // Email and password
+                "email": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Stores email addresses." }
+                    ]
+                },
+                "password": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Stores hashed or plain-text passwords." }
+                    ]
+                },
 
-        const r = {
-            // Field Types with ormtypes, available fields  
-            fieldTypes: fieldTypes,
-            encryptionTypes: enumToResponseArray(EncryptionType),
-            ormType: ormFieldTypeForSolid,
-            decryptWhenTypes: enumToResponseArray(DecryptWhenType),
-            mediaTypes: enumToResponseArray(MediaType),
-            relationTypes: enumToResponseArray(RelationType),
-            selectionDynamicProviders: sps,
-            computedProviders: cps,
-            cascadeTypes: enumToResponseArray(CascadeType),
-            selectionValueTypes: enumToResponseArray(SelectionValueType),
-            computedFieldValueTypes: enumToResponseArray(ComputedFieldValueType),
-            dataSourceType: dataSourceTypes,
-            dataSource: dataSource,
-        };
+                // Selection types
+                "selectionStatic": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Used for predefined selection options." }
+                    ]
+                },
+                "selectionDynamic": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Used for dynamic selection options." }
+                    ]
+                },
 
-        return r
+                // Computed and external ID
+                "computed": {
+                    ormTypes: [
+                        { label: MSSQLType.nvarchar, description: "Represents computed or derived fields." }
+                    ]
+                },
+                "uuid": {
+                    ormTypes: [
+                        { label: MSSQLType.uniqueidentifier, description: "Stores universally unique identifiers (UUIDs)." }
+                    ]
+                }
+            }
+        };
     }
 
     async fetchCurrentFieldsBasedOnType(type: string) {
@@ -533,7 +671,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             case SolidFieldType.bigint:
@@ -553,7 +692,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             // case SolidFieldType.float:
@@ -616,7 +756,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "decryptWhen",
                     "columnName",
                     "isUserKey",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             case SolidFieldType.longtext:
@@ -639,7 +780,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName"
+                    "columnName",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.richText:
@@ -852,7 +994,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "enableAuditTracking"
+                    "enableAuditTracking",
+                    "isPrimaryKey"
                 ];
 
             case SolidFieldType.password:
@@ -943,7 +1086,8 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "encryptionType",
                     "decryptWhen",
                     "columnName",
-                    "isUserKey"
+                    "isUserKey",
+                    "enableAuditTracking"
                 ];
 
             case SolidFieldType.uuid:
@@ -964,10 +1108,6 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "decryptWhen",
                     "columnName"
                 ];
-
-
-
-
             default:
                 return [
                     "name",
@@ -1145,6 +1285,118 @@ export class FieldMetadataService implements OnApplicationBootstrap {
 
         return fieldObject;
     }
+
+    // async resolveS3Url(resolveS3UrlDto: 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']
+    //     });
+
+    //     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}`
+    //         );
+    //     }
+
+    //     // ------------------------------------------------
+    //     // 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 }
+    //     });
+
+    //     if (!record) {
+    //         throw new NotFoundException(
+    //             `${modelName} record not found for ${fieldName}="${fieldValue}"`
+    //         );
+    //     }
+
+    //     // ------------------------------------------------
+    //     // 5. Extract S3 key from s3KeyFieldName
+    //     // ------------------------------------------------
+    //     const s3Key = record[s3KeyFieldName];
+
+    //     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 }
+    // }
+
+    async resolveS3Url(resolveS3UrlDto: ResolveS3UrlDto) {
+        let url = "";
+        const normalizedKey = this.normalizeS3Key(resolveS3UrlDto.s3Key);
+
+        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(normalizedKey, expiryInSeconds, resolvedBucketName);
+        } else {
+            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,