@solidstarters/solid-core 1.2.193 → 1.2.201

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

@@ -1,19 +1,32 @@
 import { classify } from '@angular-devkit/core/src/utils/strings';
 import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
-import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
+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 { AuditSubscriber } from 'src/subscribers/audit.subscriber';
+import { ComputedEntityFieldSubscriber } from 'src/subscribers/computed-entity-field.subscriber';
+import { CreatedByUpdatedBySubscriber } from 'src/subscribers/created-by-updated-by.subscriber';
+import { SoftDeleteAwareEventSubscriber } from 'src/subscribers/soft-delete-aware-event.subscriber';
+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';
+
+export const coreSubscriberClasses = [
+  AuditSubscriber,
+  ComputedEntityFieldSubscriber,
+  CreatedByUpdatedBySubscriber,
+  SoftDeleteAwareEventSubscriber
+];
 
 @Injectable()
 export class SolidIntrospectService implements OnApplicationBootstrap {
@@ -22,11 +35,12 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     private readonly reflector: Reflector,
     private readonly metadataScanner: MetadataScanner,
     private readonly solidRegistry: SolidRegistry,
+    private readonly moduleRef: ModuleRef,
   ) { }
 
   private readonly logger = new Logger(SolidIntrospectService.name);
-  onApplicationBootstrap() {
-    this.logger.log('Introspecting the application for Solid metadata');
+  async onApplicationBootstrap() {
+    this.logger.debug('Introspecting the application for Solid metadata');
 
     // Register all seeders
     const seeders = this.discoveryService
@@ -147,6 +161,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/solid-ts-morph.service.ts

@@ -47,8 +47,8 @@ export class SolidTsMorphService {
             },
         });
 
-        this.logger.log(`SolidTsMorphService repoRoot = ${this.repoRoot}`);
-        Object.entries(this.workspaceMap).forEach(([k, v]) => this.logger.log(`workspace '${k}' => ${v}`));
+        this.logger.debug(`SolidTsMorphService repoRoot = ${this.repoRoot}`);
+        Object.entries(this.workspaceMap).forEach(([k, v]) => this.logger.debug(`workspace '${k}' => ${v}`));
     }
 
     // ---- repo-root discovery ----

package/src/services/user-activity-history.service.ts

@@ -1,7 +1,7 @@
-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';
+import { EntityManager, In, Repository } from 'typeorm';
 
 import { CRUDService } from 'src/services/crud.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
@@ -19,6 +19,7 @@ import { UserActivityHistoryRepository } from 'src/repository/user-activity-hist
 @Injectable()
 export class UserActivityHistoryService extends CRUDService<UserActivityHistory> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/user-view-metadata.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';
@@ -19,6 +19,7 @@ import { UserViewMetadataRepository } from 'src/repository/user-view-metadata.re
 @Injectable()
 export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -42,13 +43,13 @@ export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
     });
 
     if (existing) {
-      existing.layout = JSON.parse(query.layout);
+      existing.layout = query.layout;
       return await this.repo.save(existing);
     } else {
       const newEntry = this.repo.create({
         user: { id: activeUser?.sub },
         viewMetadata: { id: query.viewMetadataId },
-        layout: JSON.parse(query.layout)
+        layout: query.layout
       });
       return await this.repo.save(newEntry);
     }

package/src/services/user.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable } from '@nestjs/common';
 import { ConfigService, ConfigType } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
@@ -22,6 +22,7 @@ import { RoleMetadataRepository } from 'src/repository/role-metadata.repository'
 @Injectable()
 export class UserService extends CRUDService<User> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

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

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
@@ -7,26 +7,27 @@ 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 { EntityManager } from 'typeorm';
+import { EntityManager, In } from 'typeorm';
 
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
 import { Locale } from 'src/entities/locale.entity';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { SolidRegistry } from 'src/helpers/solid-registry';
-import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
 import { ViewMetadataRepository } from 'src/repository/view-metadata.repository';
 import { UpdateViewMetadataDto } from '../dtos/update-view-metadata.dto';
 import { FieldMetadata } from '../entities/field-metadata.entity';
 import { ViewMetadata } from '../entities/view-metadata.entity';
 import { ActionMetadataService } from './action-metadata.service';
+import { MenuItemMetadataService } from './menu-item-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { UserViewMetadataService } from './user-view-metadata.service';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -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()
@@ -44,6 +46,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
     // @InjectRepository(ModelMetadata)
     // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    @Inject(forwardRef(() => ModelMetadataRepository))
     private readonly modelMetadataRepo: ModelMetadataRepository,
     private readonly modelMetadataHelperService: ModelMetadataHelperService,
     readonly moduleRef: ModuleRef
@@ -55,13 +58,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 +120,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 +165,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 +189,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 +199,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 +238,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 +263,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 +366,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-cli-db.module.ts

@@ -4,7 +4,8 @@ import { join } from 'path';
 import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
 import { WinstonTypeORMLogger } from './winston.logger';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
-
+import { parseBooleanEnv } from './helpers/environment.helper';
+import { Logger } from 'winston';
 @Module({
     imports: [
         TypeOrmModule.forRootAsync({
@@ -47,9 +48,9 @@ import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
                     // autoLoadEntities: true,
                     entities: entities,
                     // your entities will be synced with the database (recommended: disable in prod)
-                    synchronize: Boolean(process.env.DEFAULT_DATABASE_SYNCHRONIZE),
-                    logging: Boolean(process.env.DEFAULT_DATABASE_LOGGING),
-                    // logger: new WinstonTypeORMLogger(logger),  // Pass in the custom WinstonLogger
+                    synchronize: parseBooleanEnv('DEFAULT_DATABASE_SYNCHRONIZE'),
+                    logging: parseBooleanEnv('DEFAULT_DATABASE_LOGGING'),
+                    logger: parseBooleanEnv('DEFAULT_DATABASE_LOGGING') ? new WinstonTypeORMLogger(logger) : undefined,  // Pass in the custom WinstonLogger
                     namingStrategy: new SnakeNamingStrategy(),
                     // subscribers: subscribers
                 }

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,16 @@ 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';
+import { FixturesService } from './services/fixtures.service';
+import { FixturesSetupCommand } from './commands/fixtures/fixtures-setup.command';
+import { FixturesTearDownCommand } from './commands/fixtures/fixtures-tear-down.command';
+import { DatabaseBootstrapService } from './services/database/database-bootstrap.service';
+import { SequenceNumComputedFieldProvider } from './services/computed-fields/entity/sequence-num-computed-field-provider';
+import { ModelSequence } from './entities/model-sequence.entity';
+import { ModelSequenceService } from './services/model-sequence.service';
+import { ModelSequenceController } from './controllers/model-sequence.controller';
+import { ModelSequenceRepository } from './repository/model-sequence.repository';
 
 
 @Global()
@@ -367,6 +378,7 @@ import { MediaStorageProviderMetadataRepository } from './repository/media-stora
       UserActivityHistory,
       UserViewMetadata,
       ViewMetadata,
+      ModelSequence,
     ]),
     ConfigModule.forFeature(appBuilderConfig),
     ConfigModule.forFeature(commonConfig),
@@ -441,6 +453,7 @@ import { MediaStorageProviderMetadataRepository } from './repository/media-stora
     UserController,
     UserViewMetadataController,
     ViewMetadataController,
+    ModelSequenceController,
   ],
   providers: [
     {
@@ -486,6 +499,7 @@ import { MediaStorageProviderMetadataRepository } from './repository/media-stora
     ModuleMetadataSeederService,
     ListOfValuesService,
     ListOfValuesSelectionProvider,
+    PseudoForeignKeySelectionProvider,
     ModelMetadataSubscriber,
     ViewMetadataService,
     ActionMetadataService,
@@ -497,6 +511,7 @@ import { MediaStorageProviderMetadataRepository } from './repository/media-stora
     TextractService,
     SolidRegistry,
     SeedCommand,
+    McpCommand,
     IngestCommand,
     IngestMetadataService,
     SMTPEMailService,
@@ -698,6 +713,13 @@ import { MediaStorageProviderMetadataRepository } from './repository/media-stora
     ModuleMetadataRepository,
     ActionMetadataRepository,
     MediaStorageProviderMetadataRepository,
+    FixturesService,
+    FixturesSetupCommand,
+    FixturesTearDownCommand,
+    DatabaseBootstrapService,
+    SequenceNumComputedFieldProvider,
+    ModelSequenceService,
+    ModelSequenceRepository,
   ],
   exports: [
     AiInteractionService,

package/src/subscribers/audit.subscriber.ts

@@ -1,9 +1,8 @@
-import { Injectable } from '@nestjs/common';
-import { InjectDataSource } from '@nestjs/typeorm';
+import { forwardRef, Inject, 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,25 @@ 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>,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
         private readonly modelMetadataHelperService: ModelMetadataHelperService,
     ) {
+        // this.dataSource.subscribers.push(this);
+    }
+
+    bindToDataSource(dataSource: DataSource) {
+        this.dataSource = dataSource;
         this.dataSource.subscribers.push(this);
     }
 
@@ -57,7 +62,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
         const auditFields = modelFields.filter(field =>
             field.enableAuditTracking &&
-            !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
+            !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
             !(field.type === 'relation' && field.relationType === 'one-to-many')
         );