@solidstarters/solid-core 1.2.192 → 1.2.200

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

@@ -70,17 +70,17 @@ export class MqMessageService extends CRUDService<MqMessage> {
     });
   }
 
-/**
- * Wait until a queue message reaches a terminal status (succeeded/failed).
- *
- * @param messageId string – the external message id you store in `ss_mq_message.messageId`
- * @param opts.timeoutMs total time to wait before giving up (default 60s)
- * @param opts.intervalMs initial poll interval (default 500ms)
- * @param opts.maxIntervalMs cap for exponential backoff (default 2000ms)
- * @param opts.throwOnFailure if true, throws when stage === 'failed' (default false)
- * @param opts.parseJson try JSON.parse on `output` and `error` (default true)
- * @returns resolves with the final MqMessage row when terminal, rejects on timeout (or failure if throwOnFailure)
- */
+  /**
+   * Wait until a queue message reaches a terminal status (succeeded/failed).
+   *
+   * @param messageId string – the external message id you store in `ss_mq_message.messageId`
+   * @param opts.timeoutMs total time to wait before giving up (default 60s)
+   * @param opts.intervalMs initial poll interval (default 500ms)
+   * @param opts.maxIntervalMs cap for exponential backoff (default 2000ms)
+   * @param opts.throwOnFailure if true, throws when stage === 'failed' (default false)
+   * @param opts.parseJson try JSON.parse on `output` and `error` (default true)
+   * @returns resolves with the final MqMessage row when terminal, rejects on timeout (or failure if throwOnFailure)
+   */
   async waitForTerminalStatus(
     messageId: string,
     opts?: {
@@ -139,14 +139,15 @@ export class MqMessageService extends CRUDService<MqMessage> {
       } else if (rec.stage === 'succeeded' || rec.stage === 'failed') {
         // Optionally parse output/error if they contain JSON strings
         if (parseJson) {
-          rec.output = this.safeJsonParse(rec.output);
-          rec.error = this.safeJsonParse(rec.error);
+          // rec.output = this.safeJsonParse(rec.output);
+          rec.output = rec.output;
+          // rec.error = this.safeJsonParse(rec.error);
+          rec.error = rec.error;
         }
 
         if (rec.stage === 'failed' && throwOnFailure) {
           throw new Error(
-            `Queue message ${messageId} failed` +
-            (rec.error ? `: ${JSON.stringify(rec.error).slice(0, 500)}` : '')
+            `Queue message ${messageId} failed` + (rec.error ? `: ${JSON.stringify(rec.error).slice(0, 500)}` : '')
           );
         }
         return rec;

package/src/services/queues/publisher-factory.service.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@nestjs/common';
+import { forwardRef, Inject, Logger } from '@nestjs/common';
 import { Injectable } from '@nestjs/common';
 
 import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
@@ -11,6 +11,7 @@ export class PublisherFactory<T> {
     private readonly logger = new Logger(PublisherFactory.name);
 
     constructor(
+        @Inject(forwardRef(() => SolidIntrospectService))
         private readonly solidIntrospectionService: SolidIntrospectService
     ) {
     }

package/src/{providers → services/selection-providers}/list-of-values-selection-providers.service.ts

@@ -1,9 +1,9 @@
 
-import { ListOfValuesService } from "../services/list-of-values.service";
+import { ListOfValuesService } from "../list-of-values.service";
 import { PaginationQueryDto } from "src/dtos/pagination-query.dto";
 import { SelectionProvider } from "src/decorators/selection-provider.decorator";
 import { Injectable } from "@nestjs/common";
-import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../interfaces";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
 import { filter } from "rxjs";
 import { BasicFilterDto } from "src/dtos/basic-filters.dto";
 

package/src/services/selection-providers/pseudo-foreign-key-selection-provider.service.ts

@@ -0,0 +1,94 @@
+import { ListOfValuesService } from "../list-of-values.service";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { BadRequestException, Injectable } from "@nestjs/common";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
+import { BasicFilterDto } from "src/dtos/basic-filters.dto";
+import { SolidIntrospectService } from "../solid-introspect.service";
+import { classify } from "@angular-devkit/core/src/utils/strings";
+import { CRUDService } from "../crud.service";
+
+interface PseudoForeignKeySelectionProviderContext extends ISelectionProviderContext {
+    modelName: string;
+    // ['countryName', 'countryCode'] - IN|INR
+    whereClauseFields: string[];
+    labelFieldName: string;
+    valueFieldName: string;
+}
+
+const DEFAULT_LIMIT = 100;
+
+@SelectionProvider()
+@Injectable()
+export class PseudoForeignKeySelectionProvider implements ISelectionProvider<PseudoForeignKeySelectionProviderContext> {
+    constructor(
+        private readonly listOfValuesService: ListOfValuesService,
+        readonly introspectService: SolidIntrospectService,
+    ) { }
+
+    name(): string {
+        return 'PseudoForeignKeySelectionProvider';
+    }
+
+    help(): string {
+        return "# Use this provider to implement pseudo foreign key style relationships.";
+    }
+
+    async value(optionValue: string, ctxt: PseudoForeignKeySelectionProviderContext): Promise<ISelectionProviderValues | any> {
+        const basicFilterQuery = new BasicFilterDto(DEFAULT_LIMIT, 0);
+        basicFilterQuery.filters = {
+            [ctxt.valueFieldName]: {
+                $eq: optionValue
+            }
+        };
+
+        const modelServiceInstanceWrapper = this.introspectService.getProvider(`${classify(ctxt.modelName)}Service`);
+        if (!modelServiceInstanceWrapper) {
+            throw new BadRequestException(`Invalid model name (${ctxt.modelName}) specified in PseudoForeignKeySelectionProvider context.`);
+        }
+
+        const modelService: CRUDService<any> = modelServiceInstanceWrapper.instance;
+        const recs = await modelService.find(basicFilterQuery);
+        if (!recs.records || recs.records.length == 0) {
+            throw new Error(`Invalid optionValue=${optionValue}, for PseudoForeignKeySelectionProvider with context: ${JSON.stringify(ctxt)}`)
+            // return null;
+        }
+
+        return {
+            label: recs.records[0][ctxt.labelFieldName],
+            value: recs.records[0][ctxt.valueFieldName]
+        }
+    }
+
+    async values(query: string, ctxt: PseudoForeignKeySelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+        const basicFilterQuery = new BasicFilterDto(ctxt.limit, ctxt.offset);
+
+        // Next we get hold of the userkey field in the parent model.
+        if (query) {
+            basicFilterQuery.filters = {
+                $or: ctxt.whereClauseFields.map((whereClauseField) => {
+                    return {
+                        [whereClauseField]: {
+                            $containsi: `%${query}%`
+                        }
+                    }
+                })
+            };
+        }
+
+        const modelServiceInstanceWrapper = this.introspectService.getProvider(`${classify(ctxt.modelName)}Service`);
+        if (!modelServiceInstanceWrapper) {
+            throw new BadRequestException(`Invalid model name (${ctxt.modelName}) specified in PseudoForeignKeySelectionProvider context.`);
+        }
+
+        const modelService: CRUDService<any> = modelServiceInstanceWrapper.instance;
+
+        const recs = await modelService.find(basicFilterQuery);
+        const selectionValues = recs.records.map(rec => {
+            return {
+                label: rec[ctxt.labelFieldName],
+                value: rec[ctxt.valueFieldName]
+            }
+        });
+        return selectionValues;
+    }
+}

package/src/services/setting.service.ts

@@ -79,10 +79,10 @@ export class SettingService extends CRUDService<Setting> {
       authenticationPasswordRegexErrorMessage: this.iamConfiguration.PASSWORD_REGEX_ERROR_MESSAGE,
       authenticationPasswordComplexityDescription: this.iamConfiguration.PASSWORD_COMPLEXITY_DESC,
       solidXGenAiCodeBuilderConfig: JSON.stringify({
-            defaultProvider: "",
-            availableProviders: []
-        }),
-      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration,
+        defaultProvider: "",
+        availableProviders: []
+      }),
+      showNameFieldsForRegistration: this.iamConfiguration.showNameFieldsForRegistration,
       forceChangePasswordOnFirstLogin: this.iamConfiguration.forceChangePasswordOnFirstLogin
     };
 
@@ -199,11 +199,11 @@ export class SettingService extends CRUDService<Setting> {
       authenticationPasswordRegexErrorMessage: this.iamConfiguration.PASSWORD_REGEX_ERROR_MESSAGE,
       authenticationPasswordComplexityDescription: this.iamConfiguration.PASSWORD_COMPLEXITY_DESC,
       solidXGenAiCodeBuilderConfig: JSON.stringify({
-            defaultProvider: "",
-            availableProviders: []
-        }),
-      iamAutoGeneratedPassword:this.iamConfiguration.iamAutoGeneratedPassword,
-      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration
+        defaultProvider: "",
+        availableProviders: []
+      }),
+      iamAutoGeneratedPassword: this.iamConfiguration.iamAutoGeneratedPassword,
+      showNameFieldsForRegistration: this.iamConfiguration.showNameFieldsForRegistration
     };
   }
 
@@ -297,7 +297,10 @@ export class SettingService extends CRUDService<Setting> {
       }
 
       const key = settingDto.key;
-      const value = settingDto.value ?? '';
+      // const value = settingDto.value ?? '';
+      const rawValue = settingDto.value;
+      const value = rawValue === null || rawValue === undefined ? null : String(rawValue);
+
       const settingType = settingDto.type ?? 'system';
 
       const existingSetting = existingSettings.find(s => s.key === key);

package/src/services/solid-introspect.service.ts

@@ -1,19 +1,36 @@
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
-import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
+import { forwardRef, Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner, ModuleRef, Reflector } from '@nestjs/core';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { getDataSourceToken } from '@nestjs/typeorm';
 import { IS_COMPUTED_FIELD_PROVIDER } from 'src/decorators/computed-field-provider.decorator';
+import { IS_DASHBOARD_QUESTION_DATA_PROVIDER } from 'src/decorators/dashboard-question-data-provider.decorator';
+import { IS_DASHBOARD_VARIABLE_SELECTION_PROVIDER } from 'src/decorators/dashboard-selection-provider.decorator';
+import { IS_ERROR_CODE_PROVIDER } from 'src/decorators/error-codes-provider.decorator';
+import { IS_MAIL_PROVIDER } from 'src/decorators/mail-provider.decorator';
+import { IS_SCHEDULED_JOB_PROVIDER } from 'src/decorators/scheduled-job-provider.decorator';
+import { IS_SECURITY_RULE_CONFIG_PROVIDER } from 'src/decorators/security-rule-config-provider.decorator';
 import { IS_SELECTION_PROVIDER } from 'src/decorators/selection-provider.decorator';
 import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.decorator';
+import { IS_WA_PROVIDER } from 'src/decorators/whatsapp-provider.decorator';
 import { SolidRegistry } from 'src/helpers/solid-registry';
+import { DataSource } from 'typeorm';
 import { CRUDService } from './crud.service';
-import { IS_SCHEDULED_JOB_PROVIDER } from 'src/decorators/scheduled-job-provider.decorator';
-import { IS_DASHBOARD_VARIABLE_SELECTION_PROVIDER } from 'src/decorators/dashboard-selection-provider.decorator';
-import { IS_DASHBOARD_QUESTION_DATA_PROVIDER } from 'src/decorators/dashboard-question-data-provider.decorator';
-import { IS_MAIL_PROVIDER } from 'src/decorators/mail-provider.decorator';
-import { IS_WA_PROVIDER } from 'src/decorators/whatsapp-provider.decorator';
-import { IS_ERROR_CODE_PROVIDER } from 'src/decorators/error-codes-provider.decorator';
-import { IS_SECURITY_RULE_CONFIG_PROVIDER } from 'src/decorators/security-rule-config-provider.decorator';
+import { RequestContextService } from './request-context.service';
+import { CreatedByUpdatedBySubscriber } from 'src/subscribers/created-by-updated-by.subscriber';
+import { AuditSubscriber } from 'src/subscribers/audit.subscriber';
+import { ComputedEntityFieldSubscriber, ComputedFieldEvaluationPayload } from 'src/subscribers/computed-entity-field.subscriber';
+import { SoftDeleteAwareEventSubscriber } from 'src/subscribers/soft-delete-aware-event.subscriber';
+import { ChatterMessageService } from './chatter-message.service';
+import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
+import { ModelMetadataHelperService, PublisherFactory } from 'src';
+
+export const coreSubscriberClasses = [
+  AuditSubscriber,
+  ComputedEntityFieldSubscriber,
+  CreatedByUpdatedBySubscriber,
+  SoftDeleteAwareEventSubscriber
+];
 
 @Injectable()
 export class SolidIntrospectService implements OnApplicationBootstrap {
@@ -22,10 +39,20 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     private readonly reflector: Reflector,
     private readonly metadataScanner: MetadataScanner,
     private readonly solidRegistry: SolidRegistry,
+    private readonly moduleRef: ModuleRef,
+    private readonly requestContextService: RequestContextService,
+    // AuditSubscribe related dependencies
+    private readonly chatterMessageService: ChatterMessageService,
+    private readonly modelMetadataHelperService: ModelMetadataHelperService,
+    private readonly modelMetadataRepo: ModelMetadataRepository,
+    // ComputedEntityFieldSubscriber related dependencies
+   @Inject(forwardRef(() => PublisherFactory))
+    private readonly publisherFactory: PublisherFactory<any>,
+    
   ) { }
 
   private readonly logger = new Logger(SolidIntrospectService.name);
-  onApplicationBootstrap() {
+  async onApplicationBootstrap() {
     this.logger.log('Introspecting the application for Solid metadata');
 
     // Register all seeders
@@ -147,6 +174,79 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     securityRuleConfigProviders.forEach((securityRuleConfigProvider) => {
       this.solidRegistry.registerSecurityRuleConfigProvider(securityRuleConfigProvider);
     });
+
+    // Register the core subscribers against all the configured database modules / datasources
+    await this.bootstrapCoreTypeOrmSubscribers(solidDatabaseModules)
+  }
+
+  async bootstrapCoreTypeOrmSubscribers(dbModules: Array<InstanceWrapper<any>>): Promise<void> {
+    // Register core subscribers for each Solid database module
+    for (const wrapper of dbModules) {
+      // Get the Database Module instance
+      const instance = (wrapper as InstanceWrapper).instance as any;
+      if (!instance || typeof instance.name !== 'function') {
+        this.logger.warn('Skipping a solid DB module wrapper with no instance or name() method');
+        continue;
+      }
+
+      // Get the DataSource for this module
+      const dsName: string | undefined = instance.name();
+      // getDataSourceToken() without name = default; pass dsName if non-default
+      const token = dsName ? getDataSourceToken(dsName) : getDataSourceToken();
+      let ds: DataSource | undefined;
+      try {
+        ds = this.moduleRef.get<DataSource>(token, { strict: false });
+      } catch (err) {
+        this.logger.warn(`DataSource token for "${dsName ?? 'default'}" not found: ${err?.message ?? err}`);
+      }
+      if (!ds) {
+        this.logger.warn(`No DataSource found for module "${dsName}". Skipping subscriber registration.`);
+        continue;
+      }
+
+      // Ensure DataSource is initialized (optional)
+      if (!ds.isInitialized) {
+        try {
+          await ds.initialize(); // only if you need to initialize here; in many apps datasources are created earlier
+        } catch (err) {
+          this.logger.error(`Failed to initialize DataSource "${dsName}": ${err}`);
+          continue;
+        }
+      }
+
+      // Register each subscriber class for this DataSource
+      // const auditSubscriberInstance = new AuditSubscriber(this.chatterMessageService, this.modelMetadataRepo, this.modelMetadataHelperService);
+      // auditSubscriberInstance.bindToDataSource(ds);
+
+      // const computedEntityFieldSubscriberInstance = new ComputedEntityFieldSubscriber(this.solidRegistry, this.publisherFactory);
+      // computedEntityFieldSubscriberInstance.bindToDataSource(ds);
+
+      // const createdByUpdatedBySubscriberInstance = new CreatedByUpdatedBySubscriber(this.requestContextService);
+      // createdByUpdatedBySubscriberInstance.bindToDataSource(ds);
+
+      // const softDeleteAwareEventSubscriberInstance = new SoftDeleteAwareEventSubscriber();
+      // softDeleteAwareEventSubscriberInstance.bindToDataSource(ds);
+      for (const SubClass of coreSubscriberClasses) {
+        const alreadyRegistered = ds.subscribers.some(
+          (s) => (s as any).constructor?.name === SubClass.name,
+        );
+        if (alreadyRegistered) {
+          this.logger.debug(`Subscriber ${SubClass.name} already registered on datasource ${dsName ?? 'default'}`);
+          continue;
+        }
+
+        // Resolve subscriber from NestJS moduleRef to ensure dependencies are injected
+        const subscriberInstance = await this.moduleRef.resolve(SubClass, undefined, { strict: false });
+        subscriberInstance.bindToDataSource(ds);
+
+        // instantiate subscriber bound to this DataSource
+        // NOTE: constructor signature must be (dataSource: DataSource, requestContextService: RequestContextService, ...)
+        // const subscriberInstance = new (SubClass as any)(ds, this.requestContextService);
+
+        // ds.subscribers.push(subscriberInstance);
+        // this.logger.log(`Registered subscriber ${SubClass.name} on datasource ${dsName ?? 'default'}`);
+      }
+    }
   }
 
   isDashboardQuestionDataProvider(providerWrapper: InstanceWrapper<any>) {

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

@@ -23,6 +23,7 @@ import { ViewMetadata } from '../entities/view-metadata.entity';
 import { ActionMetadataService } from './action-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { UserViewMetadataService } from './user-view-metadata.service';
+import { MenuItemMetadataService } from './menu-item-metadata.service';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -34,6 +35,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     readonly discoveryService: DiscoveryService,
     readonly crudHelperService: CrudHelperService,
     readonly actionMetadataService: ActionMetadataService,
+    readonly menuItemMetadataService: MenuItemMetadataService,
     readonly introspectService: SolidIntrospectService,
     readonly userViewMetadataService: UserViewMetadataService,
     @InjectEntityManager()
@@ -55,13 +57,13 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
 
   //for locales 
   private async getEntityRecordsInAllLocales(
-  modelName: string,
-  id: string,
-  defaultEntityLocaleIdFromQuery?: string
-): Promise<{ records: any[], defaultEntityLocaleId: string | null }> {
-  const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
-  // const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
-  const currentEntityRepository = this.entityManager.getRepository(classify(modelName));
+    modelName: string,
+    id: string,
+    defaultEntityLocaleIdFromQuery?: string
+  ): Promise<{ records: any[], defaultEntityLocaleId: string | null }> {
+    const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
+    // const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
+    const currentEntityRepository = this.entityManager.getRepository(classify(modelName));
 
     // Case 1: Creating a new record with no defaultEntityLocaleId to clone
     if (id === 'new' && !defaultEntityLocaleIdFromQuery) {
@@ -117,16 +119,35 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
 
   // START: Custom Service Methods
   async getLayout(query, activeUser) {
-    let { modelName, moduleName, viewType, id, populate } = query;
+    let { modelName, moduleName, viewType, id, populate, menuItemId, menuItemName, actionId, actionName } = query;
 
-    // modelName = camelize(modelName);
 
-    // 1. Fetch the view based on module, model & view name.
+    // 1. Fetch the action based on actionId.
+    const solidRequestContext = {
+      activeUser: activeUser
+    }
+    const actionQuery = {
+      populate: ["view"]
+    }
+    let action = null;
+    if (actionId) {
+      action = await this.actionMetadataService.findOne(actionId, actionQuery, solidRequestContext);
+    }
+
+    // 2. Fetch the menu based on menuItemId.
+    const menuItemQuery = {
+    }
+    let menuItem = null;
+    if (menuItemId) {
+      menuItem = await this.menuItemMetadataService.findOne(menuItemId, menuItemQuery, solidRequestContext);
+    }
+    const viewId = action?.view?.id
+    // 3. Fetch the view based on module, model & view name.
     const entity = await this.repo.findOne({
       where: {
         model: { singularName: modelName },
         module: { name: moduleName },
-        type: viewType,
+        ...(actionId && viewId ? { id: action.view.id } : { type: viewType })
       },
       relations: {
         model: {
@@ -143,7 +164,16 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       throw new BadRequestException(`Unable to identify user for module: ${moduleName}, model: ${modelName} and viewType: ${viewType}`);
     }
 
-    // 2. See if we have a user specific layout for this view.
+    // 4. add action and menuItem to Entity which is our solid View
+    if (actionId) {
+      delete action.view;
+      entity['action'] = action
+    }
+    if (menuItemId) {
+      entity['menu'] = menuItem
+    }
+
+    // 5. See if we have a user specific layout for this view.
     const userLayout = await this.userViewMetadataService.repo.findOne({
       where: {
         user: { id: activeUser?.sub },
@@ -158,7 +188,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     }
 
 
-    // 3. We are resolving the create & edit actions if specified in the layout.
+    // 6. We are resolving the create & edit actions if specified in the layout.
     if (entity?.layout?.attrs?.createAction) {
       const actionName: string = entity.layout.attrs.createAction;
       entity.layout.attrs.createAction = await this.actionMetadataService.findOneByUserKey(actionName)
@@ -168,14 +198,14 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       entity.layout.attrs.editAction = await this.actionMetadataService.findOneByUserKey(actionName)
     }
 
-    // 4. For form views we need to fetch the workflow field metadata if specified.
+    // 7. For form views we need to fetch the workflow field metadata if specified.
     let workflowFieldName = null;
     let workflowField = null;
     if (viewType === 'form') {
       workflowFieldName = entity.layout?.attrs?.workflowField;
     }
 
-    // 5. Create an easy to use map of field metadata, rather than sending an array of fields it becomes easier to use in the frontend.
+    // 8. Create an easy to use map of field metadata, rather than sending an array of fields it becomes easier to use in the frontend.
     const fields = await this.modelMetadataHelperService.loadFieldHierarchy(modelName);
     const fieldsMap = new Map<string, FieldMetadata>();
     for (let i = 0; i < fields.length; i++) {
@@ -207,7 +237,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       }
     }
 
-    // 6. Use the resolved workflowField to populate workflow specific metadata.
+    // 9. Use the resolved workflowField to populate workflow specific metadata.
     // Check if we were able to resolve an actual workflowField.
     let solidFormViewWorkflowData = [];
     if (viewType === 'form' && workflowField) {
@@ -232,7 +262,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       }
     }
 
-    // 7. If this model supports internationalisation, we need to load the locales applicable with the id of an actual record for each locale if present.
+    // 10. If this model supports internationalisation, we need to load the locales applicable with the id of an actual record for each locale if present.
     // This is the shape of locales that will be returned 
     /**
      * [
@@ -335,7 +365,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       'solidView': entity,
       'solidFieldsMetadata': Object.fromEntries(fieldsMap),
       'solidFormViewWorkflowData': solidFormViewWorkflowData,
-      'applicableLocales': applicableLocales
+      'applicableLocales': applicableLocales,
     }
 
     return r;

package/src/solid-core.module.ts

@@ -25,7 +25,8 @@ import { ModelMetadata } from './entities/model-metadata.entity';
 import { ModuleMetadata } from './entities/module-metadata.entity';
 import { CommandService } from './helpers/command.service';
 import { SchematicService } from './helpers/schematic.service';
-import { ListOfValuesSelectionProvider } from './providers/list-of-values-selection-providers.service';
+import { ListOfValuesSelectionProvider } from './services/selection-providers/list-of-values-selection-providers.service';
+import { PseudoForeignKeySelectionProvider } from './services/selection-providers/pseudo-foreign-key-selection-provider.service'
 import { ModuleMetadataSeederService } from './seeders/module-metadata-seeder.service';
 import { CrudHelperService } from './services/crud-helper.service';
 import { FieldMetadataService } from './services/field-metadata.service';
@@ -326,6 +327,7 @@ import { ScheduledJobSubscriber } from './subscribers/scheduled-job.subscriber';
 import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
 import { MediaStorageProviderMetadataRepository } from './repository/media-storage-provider-metadata.repository';
+import { McpCommand } from './commands/mcp.command';
 
 
 @Global()
@@ -486,6 +488,7 @@ import { MediaStorageProviderMetadataRepository } from './repository/media-stora
     ModuleMetadataSeederService,
     ListOfValuesService,
     ListOfValuesSelectionProvider,
+    PseudoForeignKeySelectionProvider,
     ModelMetadataSubscriber,
     ViewMetadataService,
     ActionMetadataService,
@@ -497,6 +500,7 @@ import { MediaStorageProviderMetadataRepository } from './repository/media-stora
     TextractService,
     SolidRegistry,
     SeedCommand,
+    McpCommand,
     IngestCommand,
     IngestMetadataService,
     SMTPEMailService,

package/src/subscribers/audit.subscriber.ts

@@ -1,9 +1,8 @@
-import { Injectable } from '@nestjs/common';
-import { InjectDataSource } from '@nestjs/typeorm';
+import { Injectable, Scope } from '@nestjs/common';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { lowerFirst } from 'src/helpers/string.helper';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
-import { DataSource, EntityMetadata, EntitySubscriberInterface, EventSubscriber, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
+import { DataSource, EntityMetadata, EntitySubscriberInterface, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
 import { ChatterMessageService } from '../services/chatter-message.service';
 
 
@@ -12,19 +11,24 @@ type DeferredCall =
     | { kind: 'update'; args: Parameters<ChatterMessageService['postAuditMessageOnUpdate']> }
     | { kind: 'delete'; args: Parameters<ChatterMessageService['postAuditMessageOnDelete']> };
 
-@Injectable()
-@EventSubscriber()
+@Injectable({scope: Scope.TRANSIENT})
+// @EventSubscriber()
 export class AuditSubscriber implements EntitySubscriberInterface {
-
+    private dataSource: DataSource;
     constructor(
-        @InjectDataSource()
-        private readonly dataSource: DataSource,
+        // @InjectDataSource()
+        // private readonly dataSource: DataSource,
         private readonly chatterMessageService: ChatterMessageService,
         // @InjectRepository(ModelMetadata)
         // private readonly modelMetadataRepo: Repository<ModelMetadata>,
         private readonly modelMetadataRepo: ModelMetadataRepository,
         private readonly modelMetadataHelperService: ModelMetadataHelperService,
     ) {
+        // this.dataSource.subscribers.push(this);
+    }
+
+    bindToDataSource(dataSource: DataSource) {
+        this.dataSource = dataSource;
         this.dataSource.subscribers.push(this);
     }
 

package/src/subscribers/computed-entity-field.subscriber.ts

@@ -1,28 +1,34 @@
 import { camelize } from "@angular-devkit/core/src/utils/strings";
-import { Injectable, InternalServerErrorException, Logger } from "@nestjs/common";
-import { InjectDataSource } from "@nestjs/typeorm";
+import { forwardRef, Inject, Injectable, InternalServerErrorException, Logger, Scope } from "@nestjs/common";
 import { ComputedFieldTriggerOperation } from "src/dtos/create-field-metadata.dto";
 import { ComputedFieldMetadata, SolidRegistry } from "src/helpers/solid-registry";
 import { IEntityPreComputeFieldProvider } from "src/interfaces";
 import { PublisherFactory } from "src/services/queues/publisher-factory.service";
-import { DataSource, EntitySubscriberInterface, EventSubscriber, InsertEvent, UpdateEvent } from "typeorm";
+import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
 
 // Create an interface i.e ComputedFieldEvaluationPayload which has same fields as the ComputedFieldMetadata and an additional field for the database entity
 export interface ComputedFieldEvaluationPayload extends ComputedFieldMetadata {
     databaseEntity: any;
 }
 
-@Injectable()
-@EventSubscriber()
+@Injectable({scope: Scope.TRANSIENT})
+// @EventSubscriber()
 export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface {
     private readonly logger = new Logger(this.constructor.name);
+    private dataSource: DataSource;
     constructor(
-        @InjectDataSource()
-        private readonly dataSource: DataSource,
+        // @InjectDataSource()
+        // private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
+        @Inject(forwardRef(() => PublisherFactory))
         private readonly publisherFactory: PublisherFactory<ComputedFieldEvaluationPayload>
         // private readonly computedFieldPublisher: ComputedFieldEvaluationPublisherDatabase,
     ) {
+        // this.dataSource.subscribers.push(this);
+    }
+
+    bindToDataSource(dataSource: DataSource) {
+        this.dataSource = dataSource;
         this.dataSource.subscribers.push(this);
     }