@solidstarters/solid-core 1.2.200 → 1.2.202

package/src/services/mediaStorageProviders/file-storage-provider.ts

@@ -22,9 +22,10 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     ) { }
 
     async retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
+        //@ts-ignore
         const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
         // Add the full URL to the media
         media.forEach(m => {
@@ -34,9 +35,9 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
         const result: Media[] = [];
         for (const file of files) {
             // Store the file in the configured file storage directory
@@ -46,7 +47,8 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
 
             // Create an entry in the media table
             const mediaEntity = await this.mediaRepository.createMedia({
-                entityId: entity.id,
+                //@ts-ignore
+                entityId: entity.id, 
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: this.getFileName(file),
                 mimeType: file.mimetype,
@@ -62,15 +64,16 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
         const result: Media[] = [];
         for (const pair of streamPairs) {
             const stream = pair[0];
             const fileName = pair[1];
             this.fileService.writeStreamToFile(stream, this.getFullFilePath(fileName));
             const mediaEntity = await this.mediaRepository.createMedia({
+                //@ts-ignore
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: fileName,
@@ -83,10 +86,12 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
+        //@ts-ignore
         const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+        //@ts-ignore
         this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         existingMedia.forEach(media => {
             this.fileService.deleteFile(this.getFullFilePath(media.relativeUri));

package/src/services/menu-item-metadata.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';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
@@ -21,6 +21,7 @@ import { SavedFiltersRepository } from 'src/repository/saved-filters.repository'
 @Injectable()
 export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -165,6 +166,9 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
           if (!i.parentMenuItem) {
             return true
           } else {
+            if(i.action.type === 'custom'){
+              return true;
+            }
             return this.crudHelperService.hasReadPermissionOnModel(activeUser, i.action.model.singularName)
           }
         });

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

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
 import { DataSource, EntityManager, In, Repository, SelectQueryBuilder } from 'typeorm';
@@ -30,6 +30,9 @@ import { CrudHelperService } from './crud-helper.service';
 import { FieldMetadataService } from './field-metadata.service';
 import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
 import { RoleMetadataService } from './role-metadata.service';
+import { NavigationDto } from 'src/dtos/navigation.dto';
+import { SolidIntrospectService } from './solid-introspect.service';
+import { CRUDService } from './crud.service';
 
 @Injectable()
 export class ModelMetadataService {
@@ -39,6 +42,7 @@ export class ModelMetadataService {
     // private readonly modelMetadataRepo: Repository<ModelMetadata>,
     // @InjectRepository(FieldMetadata)
     // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    @Inject(forwardRef(() => ModelMetadataRepository))
     private readonly modelMetadataRepo: ModelMetadataRepository,
     private readonly fieldMetadataRepo: FieldMetadataRepository,
     private readonly schematicService: SchematicService,
@@ -49,6 +53,8 @@ export class ModelMetadataService {
     private readonly fieldMetadataService: FieldMetadataService,
     private readonly roleService: RoleMetadataService,
     private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+    readonly introspectService: SolidIntrospectService,
+
     // No longer used. 
     // private readonly generateCodePublihser: GenerateCodePublisherDatabase,
   ) { }
@@ -610,57 +616,62 @@ export class ModelMetadataService {
       }
     }
 
+    await this.dataSource.query(
+      `CALL cleanup_model_metadata($1, $2)`,
+      [modelEntity.singularName, true],
+    );
+
     // Delete the permissions, menu, actions & views related to this model.
-    const controllerName = `${classify(modelEntity.singularName)}Controller`;
-    const permissionNames = [
-      `${controllerName}.delete`,
-      `${controllerName}.deleteMany`,
-      `${controllerName}.findOne`,
-      `${controllerName}.findMany`,
-      `${controllerName}.recover`,
-      `${controllerName}.recoverMany`,
-      `${controllerName}.partialUpdate`,
-      `${controllerName}.update`,
-      `${controllerName}.insertMany`,
-      `${controllerName}.create`,
-    ];
-    const permissionsRepo = this.dataSource.getRepository(PermissionMetadata);
-    const permissionsToDelete = await permissionsRepo.find({
-      where: { name: In(permissionNames) },
-      relations: ['roles'],
-    });
+    // const controllerName = `${classify(modelEntity.singularName)}Controller`;
+    // const permissionNames = [
+    //   `${controllerName}.delete`,
+    //   `${controllerName}.deleteMany`,
+    //   `${controllerName}.findOne`,
+    //   `${controllerName}.findMany`,
+    //   `${controllerName}.recover`,
+    //   `${controllerName}.recoverMany`,
+    //   `${controllerName}.partialUpdate`,
+    //   `${controllerName}.update`,
+    //   `${controllerName}.insertMany`,
+    //   `${controllerName}.create`,
+    // ];
+    // const permissionsRepo = this.dataSource.getRepository(PermissionMetadata);
+    // const permissionsToDelete = await permissionsRepo.find({
+    //   where: { name: In(permissionNames) },
+    //   relations: ['roles'],
+    // });
 
     // Remove role associations first
-    for (const permission of permissionsToDelete) {
-      if (permission.roles?.length) {
-        await this.dataSource
-          .createQueryBuilder()
-          .relation(PermissionMetadata, 'roles')
-          .of(permission) // permission instance or its ID
-          .remove(permission.roles); // remove all linked roles
-      }
-    }
+    // for (const permission of permissionsToDelete) {
+    //   if (permission.roles?.length) {
+    //     await this.dataSource
+    //       .createQueryBuilder()
+    //       .relation(PermissionMetadata, 'roles')
+    //       .of(permission) // permission instance or its ID
+    //       .remove(permission.roles); // remove all linked roles
+    //   }
+    // }
 
-    await permissionsRepo.remove(permissionsToDelete);
+    // await permissionsRepo.remove(permissionsToDelete);
 
     // Delete actions
-    const actionRepo = this.dataSource.getRepository(ActionMetadata);
-    const action = await actionRepo.findOne({ where: { model: { id: modelEntity.id } } });
-    await actionRepo.delete({ model: { id: modelEntity.id } });
-
-    // Delete menu items
-    const menuItemRepo = this.dataSource.getRepository(MenuItemMetadata);
-    if (action) {
-      const menuItems = await menuItemRepo.find({ where: { action: { id: action.id } } });
-      for (let i = 0; i < menuItems.length; i++) {
-        const menuItem = menuItems[i];
-        await menuItemRepo.remove(menuItem);
-      }
-    }
+    // const actionRepo = this.dataSource.getRepository(ActionMetadata);
+    // const action = await actionRepo.findOne({ where: { model: { id: modelEntity.id } } });
+    // await actionRepo.delete({ model: { id: modelEntity.id } });
+
+    // // Delete menu items
+    // const menuItemRepo = this.dataSource.getRepository(MenuItemMetadata);
+    // if (action) {
+    //   const menuItems = await menuItemRepo.find({ where: { action: { id: action.id } } });
+    //   for (let i = 0; i < menuItems.length; i++) {
+    //     const menuItem = menuItems[i];
+    //     await menuItemRepo.remove(menuItem);
+    //   }
+    // }
 
     // Delete view 
-    const viewRepo = this.dataSource.getRepository(ViewMetadata);
-    await viewRepo.delete({ model: { id: modelEntity.id } })
+    // const viewRepo = this.dataSource.getRepository(ViewMetadata);
+    // await viewRepo.delete({ model: { id: modelEntity.id } })
 
     // <moduleName>-metadata.json | Remove references to this model in the model metadata, menu, action & view sections. | Automatic
     const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(modelEntity.module?.name);
@@ -1285,4 +1296,150 @@ export class ModelMetadataService {
     });
   }
 
+  async navigation(navigationDto: NavigationDto) {
+    const { recordId, modelName, ...basicFilterDto } = navigationDto;
+
+    const modelServiceInstanceWrapper =
+      this.introspectService.getProvider(`${classify(modelName)}Service`);
+
+    if (!modelServiceInstanceWrapper) {
+      throw new BadRequestException(
+        `Invalid model name (${modelName}) specified in Navigation.`,
+      );
+    }
+
+    const modelService: CRUDService<any> = modelServiceInstanceWrapper.instance;
+
+    const recs = await modelService.find(basicFilterDto);
+
+    // navigation only works for paginated results
+    if (!('records' in recs) || !('currentPage' in recs.meta)) {
+      return {
+        prev: null,
+        next: null,
+        meta: null,
+      };
+    }
+
+    const { records, meta } = recs;
+
+    // --------------------
+    // Find record index in page
+    // --------------------
+    const index = records.findIndex(r => String(r.id) === String(recordId));
+
+    if (index === -1) {
+      throw new BadRequestException(`Record not found in current page`);
+    }
+
+    // --------------------
+    // Pagination calculations
+    // --------------------
+    const limit = meta.perPage;
+    const currentOffset = (meta.currentPage - 1) * meta.perPage;
+    const currentIndexGlobal = currentOffset + index + 1;
+
+
+    let prev: { record: any; offset: number; limit: number } | null = null;
+    let next: { record: any; offset: number; limit: number } | null = null;
+
+    // --------------------
+    // PREV
+    // --------------------
+    if (index > 0) {
+      prev = {
+        record: records[index - 1],
+        offset: currentOffset,
+        limit,
+      };
+    } else if (meta.prevPage !== null) {
+      const prevOffset = (meta.prevPage - 1) * meta.perPage;
+
+      const prevPage = await modelService.find({
+        ...basicFilterDto,
+        offset: prevOffset,
+        limit,
+      });
+
+      if ('records' in prevPage) {
+        const record = prevPage.records.at(-1) ?? null;
+        if (record) {
+          prev = {
+            record,
+            offset: prevOffset,
+            limit,
+          };
+        }
+      }
+    }
+
+    // --------------------
+    // NEXT
+    // --------------------
+    if (index < records.length - 1) {
+      next = {
+        record: records[index + 1],
+        offset: currentOffset,
+        limit,
+      };
+    } else if (meta.nextPage !== null) {
+      const nextOffset = (meta.nextPage - 1) * meta.perPage;
+
+      const nextPage = await modelService.find({
+        ...basicFilterDto,
+        offset: nextOffset,
+        limit,
+      });
+
+      if ('records' in nextPage) {
+        const record = nextPage.records[0] ?? null;
+        if (record) {
+          next = {
+            record,
+            offset: nextOffset,
+            limit,
+          };
+        }
+      }
+    }
+
+    // --------------------
+    // RESPONSE
+    // --------------------
+    return {
+      prev: prev
+        ? {
+          recordId: prev.record.id,
+          offset: prev.offset,
+          limit: prev.limit,
+        }
+        : null,
+
+      next: next
+        ? {
+          recordId: next.record.id,
+          offset: next.offset,
+          limit: next.limit,
+        }
+        : null,
+      meta: {
+        totalRecords: meta.totalRecords,
+        perPage: meta.perPage,
+        currentPage: meta.currentPage,
+        totalPages: meta.totalPages,
+
+        currentIndexInPage: index,
+        currentIndexGlobal,
+
+        hasPrev: !!prev,
+        hasNext: !!next,
+
+        prevPage: meta.prevPage,
+        nextPage: meta.nextPage,
+      },
+
+    };
+  }
+
+
 }

package/src/services/model-sequence.service.ts

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef  } from "@nestjs/core";
+import { EntityManager, Repository } 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 { ModelSequence } from '../entities/model-sequence.entity';
+import { ModelSequenceRepository } from '../repository/model-sequence.repository';
+
+@Injectable()
+export class ModelSequenceService extends CRUDService<ModelSequence>{
+  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: ModelSequenceRepository,
+    readonly moduleRef: ModuleRef
+
+ ) {
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'modelSequence', 'solid-core', moduleRef);
+ }
+}

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

@@ -4,7 +4,7 @@ import { DataSource, EntityManager, Repository, SelectQueryBuilder } from 'typeo
 import { CreateModuleMetadataDto } from '../dtos/create-module-metadata.dto';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 
-import { classify } from '@angular-devkit/core/src/utils/strings';
+import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
 import { ConfigService } from '@nestjs/config';
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
 import * as path from 'path'; // To handle file paths
@@ -320,7 +320,54 @@ export class ModuleMetadataService {
 
   async remove(id: number) {
     const entity = await this.findOne(id);
-    return this.moduleMetadataRepo.remove(entity);
+    await this.cleanupOnDelete(entity.id);
+    const r = await this.moduleMetadataRepo.remove(entity);
+    return r
+
+  }
+
+
+  async cleanupOnDelete(moduleEntityId: number) {
+    const moduleEntity = await this.moduleMetadataRepo.findOne({
+      where: {
+        // @ts-ignore
+        id: moduleEntityId,
+      }
+    });
+
+    if (!moduleEntity) {
+      this.logger.log(`Invalid moduleEntityId: ${moduleEntityId} unable to resolve model metadata`);
+      return;
+    }
+    if (moduleEntity.id !== moduleEntityId) {
+      this.logger.log(`Invalid moduleEntityId: ${moduleEntityId} unable to resolve model metadata id ${moduleEntity.id} not matching with the one passed as argument ${moduleEntityId}`);
+      return;
+    }
+
+    this.logger.log(`Cleaning up for module: ${moduleEntity.name}.`);
+
+    const modulePath = await this.moduleMetadataHelperService.getModulePath(moduleEntity.name);
+    if (modulePath) {
+
+      this.logger.log(`Module path: ${modulePath}`);
+
+      // Metadata file to be deleted
+      const moduleMetadataPAth = await this.moduleMetadataHelperService.getModuleMetadataFolderPath(moduleEntity.name)
+      this.logger.log(`About to delete module metadata path: ${moduleMetadataPAth}`);
+
+      try {
+        await fs.rm(modulePath, { recursive: true, force: true });
+        await fs.rm(moduleMetadataPAth, { recursive: true, force: true });
+        this.logger.log(`Deleted file: ${moduleMetadataPAth}`);
+      } catch (error) {
+        this.logger.error(`Error deleting file: ${moduleMetadataPAth}`, error);
+        throw new Error(ERROR_MESSAGES.FILE_DELETE_FAILED); // Trigger rollback
+      }
+    }
+    await this.dataSource.query(
+      `CALL cleanup_module_metadata($1, $2)`,
+      [moduleEntity.name, true],
+    );
   }
 
   async deleteMany(ids: number[]): Promise<any> {

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

@@ -1,23 +1,22 @@
-import { Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, In, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
+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 { ConfigService } from '@nestjs/config';
-import { FileService } from "src/services/file.service";
-import { CrudHelperService } from "src/services/crud-helper.service";
+import { EntityManager, In } from 'typeorm';
 
 
-import { PermissionMetadata } from '../entities/permission-metadata.entity';
-import { ActiveUserData } from '../interfaces/active-user-data.interface';
-import { classify } from '@angular-devkit/core/src/utils/strings';
 import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
+import { PermissionMetadata } from '../entities/permission-metadata.entity';
 
 @Injectable()
 export class PermissionMetadataService extends CRUDService<PermissionMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/queues/database-subscriber.service.ts

@@ -99,8 +99,10 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
 
     async onModuleInit(): Promise<void> {
         const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'database';
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+
         // we will start subscriber only if the current service role is subscriber. 
-        if (['both', 'subscriber'].includes(this.serviceRole) && defaultBroker === 'database') {
+        if (['both', 'subscriber'].includes(this.serviceRole) && defaultBroker === 'database' && solidCliRunning === "false") {
 
             const options = this.options();
 

package/src/services/queues/rabbitmq-subscriber.service.ts

@@ -52,8 +52,10 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     }
 
     async onModuleInit(): Promise<void> {
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+
         // we will start subscriber only if the current service role is subscriber. 
-        if (this.url && ['both', 'subscriber'].includes(this.serviceRole)) {
+        if (this.url && ['both', 'subscriber'].includes(this.serviceRole) && solidCliRunning === "false") {
 
             // this.logger.debug(`RabbitMqSubscriber instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
             // const connection = await amqp.connect(this.url);
@@ -92,7 +94,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
                 async (rawMessage) => {
                     if (rawMessage) {
                         const messageContentString = rawMessage.content.toString();
-                        this.logger.debug(`RabbitMqSubscriber Received raw message: ${messageContentString}`);
+                        // this.logger.debug(`RabbitMqSubscriber Received raw message: ${messageContentString}`);
 
                         let message: QueueMessage<T> = null;
 

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

@@ -23,6 +23,7 @@ export class RoleMetadataService extends CRUDService<RoleMetadata> {
   constructor(
     @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
+    @Inject(forwardRef(() => ModuleMetadataService))
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
     readonly fileService: FileService,

package/src/services/scheduled-job.service.ts

@@ -1,22 +1,22 @@
-import { Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
 import { ScheduledJob } from 'src/entities/scheduled-job.entity';
-import { ModelMetadataService } from './model-metadata.service';
-import { ModuleMetadataService } from './module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from './file.service';
+import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
+import { EntityManager } from 'typeorm';
 import { CrudHelperService } from './crud-helper.service';
 import { CRUDService } from './crud.service';
-import { Logger } from '@nestjs/common';
-import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
+import { FileService } from './file.service';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
 
 @Injectable()
 export class ScheduledJobService extends CRUDService<ScheduledJob> {
   private readonly logger = new Logger(ScheduledJobService.name);
 
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/scheduled-jobs/scheduler.service.ts

@@ -20,6 +20,11 @@ export class SchedulerServiceImpl implements ISchedulerService {
 
     @Cron(CronExpression.EVERY_MINUTE)
     async runScheduledJobs(): Promise<void> {
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+        if (solidCliRunning === "true") {
+            return;
+        }
+
         const now = new Date();
 
         // this.logger.log(`[${now.getTime()}]: scheduler service started run...`);

package/src/services/security-rule.service.ts

@@ -18,6 +18,7 @@ import { SecurityRuleRepository } from 'src';
 @Injectable()
 export class SecurityRuleService extends CRUDService<SecurityRule> implements OnApplicationBootstrap {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/selection-providers/list-of-models-selection-provider.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from "@nestjs/common";
+import { forwardRef, Inject, Injectable } from "@nestjs/common";
 import { ModelMetadataService } from "src/services/model-metadata.service";
 import { SelectionProvider } from "src/decorators/selection-provider.decorator";
 import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
@@ -8,7 +8,10 @@ import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues
 @Injectable()
 export class ListOfModelsSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
     private readonly modelMetadataService: ModelMetadataService;
-    constructor(modelMetadataService: ModelMetadataService) {
+    constructor(
+        @Inject(forwardRef(() => ModelMetadataService))
+        modelMetadataService: ModelMetadataService
+    ) {
         this.modelMetadataService = modelMetadataService;
     }
     help(): string {