@solidstarters/solid-core 1.2.200 → 1.2.202

package/src/services/setting.service.ts

@@ -1,25 +1,28 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, ForbiddenException, forwardRef, Inject, Injectable } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { EntityManager, Repository } from 'typeorm';
 
 import { ConfigService, ConfigType } from '@nestjs/config';
+import commonConfig from 'src/config/common.config';
+import { iamConfig } from 'src/config/iam.config';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { CreateSettingDto } from 'src/dtos/create-setting.dto';
+import { GetMcpUrlDto } from 'src/dtos/get-mcp-url.dto';
+import { User } from 'src/entities/user.entity';
+import { SettingRepository } from 'src/repository/setting.repository';
 import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
 import { FileService } from 'src/services/file.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import commonConfig from 'src/config/common.config';
-import { iamConfig } from 'src/config/iam.config';
 import { Setting } from '../entities/setting.entity';
 import { RequestContextService } from './request-context.service';
-import { User } from 'src/entities/user.entity';
-import { CreateSettingDto } from 'src/dtos/create-setting.dto';
-import { SettingRepository } from 'src/repository/setting.repository';
 
 @Injectable()
 export class SettingService extends CRUDService<Setting> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -43,48 +46,7 @@ export class SettingService extends CRUDService<Setting> {
   }
 
   async seedDefaultSettings(): Promise<void> {
-    const settingsSeederData = {
-      allowPublicRegistration: this.iamConfiguration.allowPublicRegistration,
-      passwordBasedAuth: this.iamConfiguration.passwordBasedAuth,
-      passwordLessAuth: this.iamConfiguration.passwordLessAuth,
-      activateUserOnRegistration: this.iamConfiguration.activateUserOnRegistration,
-      iamGoogleOAuthEnabled: false,
-      authPagesLayout: "center",
-      authPagesTheme: "light",
-      appLogo: null,
-      companylogo: null,
-      favicon: null,
-      appLogoPosition: "in_form_view",
-      showAuthContent: false,
-      appTitle: process.env.SOLID_APP_NAME || "Solid App",
-      appSubtitle: process.env.SOLID_APP_SUBTITLE || "Lorem Ipsum",
-      appDescription: process.env.SOLID_APP_DESCRIPTION || "lorem ipsum",
-      showLegalLinks: false,
-      appTnc: null,
-      appPrivacyPolicy: null,
-      defaultRole: this.iamConfiguration.defaultRole,
-      shouldQueueEmails: this.commonConfiguration.shouldQueueEmails,
-      shouldQueueSms: this.commonConfiguration.shouldQueueSms,
-      enableDarkMode: true,
-      copyright: null,
-      enableUsername: true,
-      enabledNotification: true,
-      contactSupportEmail: null,
-      contactSupportDisplayName: null,
-      contactSupportIcon: null,
-      authScreenRightBackgroundImage: null,
-      authScreenLeftBackgroundImage: null,
-      authScreenCenterBackgroundImage: null,
-      authenticationPasswordRegex: this.iamConfiguration.PASSWORD_REGEX,
-      authenticationPasswordRegexErrorMessage: this.iamConfiguration.PASSWORD_REGEX_ERROR_MESSAGE,
-      authenticationPasswordComplexityDescription: this.iamConfiguration.PASSWORD_COMPLEXITY_DESC,
-      solidXGenAiCodeBuilderConfig: JSON.stringify({
-        defaultProvider: "",
-        availableProviders: []
-      }),
-      showNameFieldsForRegistration: this.iamConfiguration.showNameFieldsForRegistration,
-      forceChangePasswordOnFirstLogin: this.iamConfiguration.forceChangePasswordOnFirstLogin
-    };
+    const settingsSeederData = this.getDefaultSettings();
 
     const existingSettings = await this.repo.find();
     const existingKeys = new Set(existingSettings.map(s => s.key));
@@ -163,6 +125,7 @@ export class SettingService extends CRUDService<Setting> {
 
   private getDefaultSettings(): Record<string, any> {
     return {
+      passwordlessRegistrationValidateWhat: this.iamConfiguration.passwordlessRegistrationValidateWhat,
       allowPublicRegistration: this.iamConfiguration.allowPublicRegistration,
       passwordBasedAuth: this.iamConfiguration.passwordBasedAuth,
       passwordLessAuth: this.iamConfiguration.passwordLessAuth,
@@ -173,11 +136,12 @@ export class SettingService extends CRUDService<Setting> {
       appLogo: null,
       companylogo: null,
       favicon: null,
-      appLogoPosition: "in_form_view", //in_form_view | in_image_view
+      // in_form_view | in_image_view
+      appLogoPosition: "in_form_view",
       showAuthContent: false,
       appTitle: process.env.SOLID_APP_NAME || "Solid App",
-      appSubtitle: null,
-      appDescription: null,
+      appSubtitle: process.env.SOLID_APP_SUBTITLE || "",
+      appDescription: process.env.SOLID_APP_DESCRIPTION || "",
       showLegalLinks: false,
       appTnc: null,
       appPrivacyPolicy: null,
@@ -207,6 +171,10 @@ export class SettingService extends CRUDService<Setting> {
     };
   }
 
+  // private async getSettingsFromRepo(): Promise<Setting[]> {
+  //   const cachedSettings = await this.cacheManager.get('cached-system-settings');
+  // }
+
   async getConfigValue(settingKey: string) {
     try {
       const settingsArray: Setting[] = await this.repo.find();
@@ -237,10 +205,7 @@ export class SettingService extends CRUDService<Setting> {
     }
   }
 
-  async updateSettings(
-    settings: CreateSettingDto[] = [],
-    uploadedFiles: Array<Express.Multer.File> = []
-  ): Promise<Setting[]> {
+  async updateSettings(settings: CreateSettingDto[] = [], uploadedFiles: Array<Express.Multer.File> = []): Promise<Setting[]> {
     const activeUser = this.requestContextService.getActiveUser();
     const userId = activeUser?.sub;
 
@@ -372,4 +337,26 @@ export class SettingService extends CRUDService<Setting> {
     return { system, user };
   }
 
+  async getMcpUrl(getMcpUrlDto: GetMcpUrlDto, solidRequestContext: any = {}): Promise<any> {
+
+    const { showHeader, inListView } = getMcpUrlDto;
+
+    if (process.env.MCP_ENABLED === 'false') {
+      throw new ForbiddenException(ERROR_MESSAGES.FORBIDDEN);
+    }
+
+    if (solidRequestContext.activeUser) {
+      const permissionNames = ["SettingController.getMcpUrl"];
+      const matchingPermssions = solidRequestContext.activeUser.permissions.filter((p: any) => permissionNames.includes(p));
+      const hasPermission = matchingPermssions.length > 0;
+      if (!hasPermission) {
+        throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
+      }
+    }
+    const apiKey = process.env.MCP_API_KEY;
+    const userId = solidRequestContext.activeUser.sub;
+    const mcpServerUrl = process.env.MCP_SERVER_URL;
+    return { mcpUrl: `${mcpServerUrl}/static/frontend.html?solidx-mcp-api-key=${apiKey}&solidx-user-id=${userId}&solidx-show-header=${showHeader}&solidx-in-list-view=${inListView}` };
+  }
+
 }

package/src/services/sms/Msg91BaseSMSService.ts

@@ -22,8 +22,8 @@ export abstract class Msg91BaseSMSService implements ISMS {
 
     async sendSMSUsingTemplate(to: string, templateName: string, templateParams: any, shouldQueueSms = false): Promise<any> {
         // Load template and evaluate it. 
-        const emailTemplate = await this.smsTemplateService.findOneByName(templateName);
-        if (!emailTemplate) {
+        const smsTemplate = await this.smsTemplateService.findOneByName(templateName);
+        if (!smsTemplate) {
             throw new Error(`Invalid template name ${templateName}`);
         }
 
@@ -33,12 +33,12 @@ export abstract class Msg91BaseSMSService implements ISMS {
 
         // The below code is only for reference, msh91 maintains the SMS templates in their database, and we need to only specify the templateId. 
         // The below was designed assuming that there are certain sms gateways who do not work this way.
-        if (emailTemplate.body) {
-            const bodyTemplate = Handlebars.compile(emailTemplate.body);
+        if (smsTemplate.body) {
+            const bodyTemplate = Handlebars.compile(smsTemplate.body);
             body = bodyTemplate(templateParams);
         }
-        if (emailTemplate.smsProviderTemplateId) {
-            templateId = emailTemplate.smsProviderTemplateId;
+        if (smsTemplate.smsProviderTemplateId) {
+            templateId = smsTemplate.smsProviderTemplateId;
         }
         if (!body && !templateId) {
             throw new Error(`Invalid template, neither body nor templateId specified on template with name ${templateName}`);

package/src/services/sms/Msg91OTPService.ts

@@ -7,6 +7,7 @@ import { SmsTemplateService } from "../sms-template.service";
 import { Msg91BaseSMSService } from "./Msg91BaseSMSService";
 import { ISMS } from "../../interfaces";
 import { PublisherFactory } from "../queues/publisher-factory.service";
+import { SmsProvider } from "src/decorators/sms-provider.decorator";
 
 interface OtpParams {
     otp: string,
@@ -16,16 +17,16 @@ interface OtpParams {
 }
 
 @Injectable()
+@SmsProvider()
 export class Msg91OTPService extends Msg91BaseSMSService implements ISMS {
     constructor(
         @Inject(commonConfig.KEY)
         commonConfiguration: ConfigType<typeof commonConfig>,
-        // smsPublisher: OTPQueuePublisher,
         publisherFactory: PublisherFactory<any>,
         smsTemplateService: SmsTemplateService,
         private readonly httpService: HttpService,
     ) {
-        super(commonConfiguration, 'OTPQueuePublisher', publisherFactory, smsTemplateService);
+        super(commonConfiguration, 'Msg91OTPQueuePublisher', publisherFactory, smsTemplateService);
     }
 
     async sendSMSSynchronously(message: QueueMessage<any>): Promise<any> {

package/src/services/sms/Msg91SMSService.ts

@@ -7,8 +7,10 @@ import { SmsTemplateService } from "../sms-template.service";
 import { Msg91BaseSMSService } from "./Msg91BaseSMSService";
 import { ISMS } from "../../interfaces";
 import { PublisherFactory } from "../queues/publisher-factory.service";
+import { SmsProvider } from "src/decorators/sms-provider.decorator";
 
 @Injectable()
+@SmsProvider()
 export class Msg91SMSService extends Msg91BaseSMSService implements ISMS {
     constructor(
         @Inject(commonConfig.KEY)
@@ -18,7 +20,7 @@ export class Msg91SMSService extends Msg91BaseSMSService implements ISMS {
         smsTemplateService: SmsTemplateService,
         private readonly httpService: HttpService,
     ) {
-        super(commonConfiguration, 'SmsQueuePublisher', publisherFactory, smsTemplateService)
+        super(commonConfiguration, 'Msg91SmsQueuePublisher', publisherFactory, smsTemplateService)
     }
 
     async sendSMSSynchronously(message: QueueMessage<any>): Promise<any> {

package/src/services/sms/TwilioSMSService.ts

@@ -7,9 +7,11 @@ import { ISMS } from "../../interfaces";
 import { PublisherFactory } from "../queues/publisher-factory.service";
 import twilio from 'twilio';
 import { QueueMessage } from "src/interfaces/mq";
+import { SmsProvider } from "src/decorators/sms-provider.decorator";
 
 
 @Injectable()
+@SmsProvider()
 export class TwilioSMSService implements ISMS {
     private readonly logger = new Logger(TwilioSMSService.name);
 
@@ -18,9 +20,7 @@ export class TwilioSMSService implements ISMS {
         private commonConfiguration: ConfigType<typeof commonConfig>,
         private publisherFactory: PublisherFactory<any>,
         private smsTemplateService: SmsTemplateService,
-    ) {
-        // super(commonConfiguration, 'OTPQueuePublisher', publisherFactory, smsTemplateService);
-    }
+    ) { }
 
     async sendSMS(to: string, body: string, shouldQueueSms: boolean): Promise<any> {
         const accountSid = this.commonConfiguration.twilio.accountSid;

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

@@ -1,25 +1,23 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
-import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { ConfigService } from '@nestjs/config';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { SmsTemplateRepository } from 'src/repository/sms-template.repository';
+import { EntityManager } from 'typeorm';
 import { SmsTemplate } from '../entities/sms-template.entity';
-import { CreateSmsTemplateDto } from '../dtos/create-sms-template.dto';
-import { UpdateSmsTemplateDto } from '../dtos/update-sms-template.dto';
+import { CrudHelperService } from './crud-helper.service';
 import { CRUDService } from './crud.service';
-import { ModelMetadataService } from './model-metadata.service';
-import { ModuleMetadataService } from './module-metadata.service';
-import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
-import { ConfigService } from '@nestjs/config';
 import { FileService } from './file.service';
+import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
 import { MediaService } from './media.service';
-import { DiscoveryService, ModuleRef } from '@nestjs/core';
-import { CrudHelperService } from './crud-helper.service';
-import { SmsTemplateRepository } from 'src/repository/sms-template.repository';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
 
 @Injectable()
 export class SmsTemplateService extends CRUDService<SmsTemplate>{
     constructor(
+        @Inject(forwardRef(() => ModelMetadataService))
         readonly modelMetadataService: ModelMetadataService,
             readonly moduleMetadataService: ModuleMetadataService,
             readonly mediaStorageProviderService: MediaStorageProviderMetadataService,

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

@@ -1,5 +1,5 @@
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { forwardRef, Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { 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';
@@ -14,16 +14,13 @@ import { IS_SELECTION_PROVIDER } from 'src/decorators/selection-provider.decorat
 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 { 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 { 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 { ChatterMessageService } from './chatter-message.service';
-import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
-import { ModelMetadataHelperService, PublisherFactory } from 'src';
+import { DataSource } from 'typeorm';
+import { CRUDService } from './crud.service';
+import { IS_SMS_PROVIDER } from 'src/decorators/sms-provider.decorator';
 
 export const coreSubscriberClasses = [
   AuditSubscriber,
@@ -40,20 +37,11 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     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);
   async onApplicationBootstrap() {
-    this.logger.log('Introspecting the application for Solid metadata');
+    this.logger.debug('Introspecting the application for Solid metadata');
 
     // Register all seeders
     const seeders = this.discoveryService
@@ -166,6 +154,15 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
       this.solidRegistry.registerWhatsappProvider(whatsappProvider);
     });
 
+    // Register all IWhatsappTransport implementations
+    const smsProviders = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isSmsProvider(provider));
+
+    smsProviders.forEach((smsProvider) => {
+      this.solidRegistry.registerSmsProvider(smsProvider);
+    });
+
     // Register all ISecurityRuleConfigProvider implementations
     const securityRuleConfigProviders = this.discoveryService
       .getProviders()
@@ -365,6 +362,18 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isWhatsappProvider;
   }
 
+  private isSmsProvider(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const isSmsProvider = this.reflector.get<boolean>(
+      IS_SMS_PROVIDER,
+      instance.constructor,
+    );
+
+    return !!isSmsProvider;
+  }
+
   private isSecurityRuleConfigProvider(provider: InstanceWrapper) {
     const { instance } = provider;
     if (!instance) return false;

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,27 +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';
-import { MenuItemMetadataService } from './menu-item-metadata.service';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -46,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

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-cli.module.ts

@@ -5,7 +5,7 @@ import { WinstonLoggerConfig } from './winston.logger';
 import { WinstonModule } from 'nest-winston';
 import { CacheModule } from '@nestjs/cache-manager';
 import { EventEmitterModule } from '@nestjs/event-emitter';
-import { RedisOptions } from './config/cache.options';
+import { CacheManagerOptions } from './config/cache.options';
 import { ConfigModule } from '@nestjs/config';
 import Joi from '@hapi/joi';
 
@@ -31,7 +31,7 @@ import Joi from '@hapi/joi';
     }),
 
     SolidCoreCliDBModule,
-    CacheModule.registerAsync(RedisOptions),
+    CacheModule.registerAsync(CacheManagerOptions),
     EventEmitterModule.forRoot(),
     SolidCoreModule, // Import main module without exposing forRoot()
   ],