@solidstarters/solid-core 1.2.201 → 1.2.203

package/src/services/crud.service.ts

@@ -1,8 +1,8 @@
-import { BadRequestException, Inject, NotFoundException } from "@nestjs/common";
+import { BadRequestException, NotFoundException } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { isArray } from "class-validator";
-import { CommonEntity, SolidBaseRepository, User } from "src";
+import { CommonEntity, FileService, SolidBaseRepository, User } from "src";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 import { SUCCESS_MESSAGES } from "src/constants/success-messages";
 import { EntityManager, FindOptionsWhere, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
@@ -34,7 +34,6 @@ import { ShortTextFieldCrudManager } from "../helpers/field-crud-managers/ShortT
 import { UUIDFieldCrudManager } from "../helpers/field-crud-managers/UUIDFieldCrudManager";
 import { FieldCrudManager, MediaWithFullUrl } from "../interfaces";
 import { CrudHelperService, FilterCombinator, UserIdFields } from "./crud-helper.service";
-import { FileService } from "./file.service";
 import { HashingService } from "./hashing.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
@@ -45,19 +44,19 @@ import { BasicGroupFilterDto } from "src/dtos/basic-group-filters.dto";
 export class CRUDService<T extends CommonEntity> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
     constructor(
-        readonly modelMetadataService: ModelMetadataService,
-        readonly moduleMetadataService: ModuleMetadataService,
-        readonly configService: ConfigService,
-        readonly fileService: FileService,
-        readonly discoveryService: DiscoveryService,
-        readonly crudHelperService: CrudHelperService,
+        readonly modelMetadataService: ModelMetadataService, // go away
+        readonly moduleMetadataService: ModuleMetadataService, // go away
+        readonly configService: ConfigService, // we don't use it - go away
+        readonly fileService: FileService, // we don't use it - go away
+        readonly discoveryService: DiscoveryService, // go away
+        readonly crudHelperService: CrudHelperService, // go away
         readonly entityManager: EntityManager,
         readonly repo: SolidBaseRepository<T>,
         readonly modelName: string,
         readonly moduleName: string,
         readonly moduleRef: ModuleRef,
-        readonly defaultEntityManager? : EntityManager
-        
+        readonly defaultEntityManager?: EntityManager
+
         //We can just have the Model Entity here
     ) { }
 
@@ -340,7 +339,12 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 //    Use the EntityController to extract uploaded content & pass to the entity service.
                 //    If embedded media, then the media uri will saved in the entity table, else the uri will be saved in the media table
                 //    Plan the media table schema e.g id, uri, storageProvider, entity_id, entity_name, createdAt, updatedAt
-                const options = { ...commonOptions, type: fieldMetadata.type as unknown as SolidMediaType };
+                const options = { 
+                    ...commonOptions, 
+                    mediaMaxSizeKb: fieldMetadata.mediaMaxSizeKb,
+                    mediaTypes: fieldMetadata.mediaTypes,
+                    type: fieldMetadata.type as unknown as SolidMediaType 
+                };
                 return new MediaFieldCrudManager(options);
             }
             case SolidFieldType.relation: {
@@ -435,11 +439,11 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
     }
 
     private isSkipComputation(isPartialUpdate: boolean, computedFieldMetadata: FieldMetadata) {
-       if (isPartialUpdate) return true; // If it is a partial update, then skip computation
-       if (computedFieldMetadata.computedFieldTriggerConfig && computedFieldMetadata.computedFieldTriggerConfig.length > 0) {
-           return true; // computedFieldTriggerConfig is a new field introduced as part of the IEntityComputedFieldProvider new interface, so this computation will be skiipped in crud service & will be called in the subscriber instead
-       }
-       return false; // If it is not a partial update, then do not skip computation
+        if (isPartialUpdate) return true; // If it is a partial update, then skip computation
+        if (computedFieldMetadata.computedFieldTriggerConfig && computedFieldMetadata.computedFieldTriggerConfig.length > 0) {
+            return true; // computedFieldTriggerConfig is a new field introduced as part of the IEntityComputedFieldProvider new interface, so this computation will be skiipped in crud service & will be called in the subscriber instead
+        }
+        return false; // If it is not a partial update, then do not skip computation
     }
 
     async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
@@ -705,7 +709,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return mediaDetails as MediaWithFullUrl[];
     }
 
-    async findOne(id: number, query: any={}, solidRequestContext: any = {}) {
+    async findOne(id: number, query: any = {}, solidRequestContext: any = {}) {
         const { populate = [], fields = [], populateMedia = [] } = query;
 
         // const normalizedFields = this.crudHelperService.normalize(fields);
@@ -1065,7 +1069,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return updatedEntity
     }
 
-    private getDefaultEntityManager(){
+    private getDefaultEntityManager() {
         return this.defaultEntityManager ?? this.entityManager;
     }
 }

package/src/services/excel.service.ts

@@ -1,6 +1,7 @@
 import { Injectable, Logger } from '@nestjs/common';
 import * as ExcelJS from 'exceljs';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { parseFlexibleDate } from 'src/helpers/date.helper';
 import { PassThrough, Readable } from 'stream';
 
 export interface ExcelReadOptions {
@@ -302,4 +303,9 @@ export class ExcelService {
 
     return { headers, rows };
   }
+
+  public parseAndValidateDate(value: string): Date | null {
+    return parseFlexibleDate(value);
+  }
+
 }

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

@@ -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 {
@@ -50,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,
   ) { }
@@ -1291,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/setting.service.ts

@@ -46,49 +46,7 @@ export class SettingService extends CRUDService<Setting> {
   }
 
   async seedDefaultSettings(): Promise<void> {
-    const settingsSeederData = {
-      passwordlessRegistrationValidateWhat: this.iamConfiguration.passwordlessRegistrationValidateWhat,
-      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));
@@ -178,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,
@@ -212,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();
@@ -242,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;
 
@@ -381,8 +341,8 @@ export class SettingService extends CRUDService<Setting> {
 
     const { showHeader, inListView } = getMcpUrlDto;
 
-    if(process.env.MCP_ENABLED === 'false') {
-        throw new ForbiddenException(ERROR_MESSAGES.FORBIDDEN);
+    if (process.env.MCP_ENABLED === 'false') {
+      throw new ForbiddenException(ERROR_MESSAGES.FORBIDDEN);
     }
 
     if (solidRequestContext.activeUser) {

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/solid-introspect.service.ts

@@ -20,6 +20,7 @@ import { CreatedByUpdatedBySubscriber } from 'src/subscribers/created-by-updated
 import { SoftDeleteAwareEventSubscriber } from 'src/subscribers/soft-delete-aware-event.subscriber';
 import { DataSource } from 'typeorm';
 import { CRUDService } from './crud.service';
+import { IS_SMS_PROVIDER } from 'src/decorators/sms-provider.decorator';
 
 export const coreSubscriberClasses = [
   AuditSubscriber,
@@ -153,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()
@@ -352,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/user.service.ts

@@ -18,6 +18,7 @@ import { iamConfig } from 'src/config/iam.config';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { UserRepository } from 'src/repository/user.repository';
 import { RoleMetadataRepository } from 'src/repository/role-metadata.repository';
+import { HashingService } from './hashing.service';
 
 @Injectable()
 export class UserService extends CRUDService<User> {
@@ -29,6 +30,8 @@ export class UserService extends CRUDService<User> {
     readonly fileService: FileService,
     readonly discoveryService: DiscoveryService,
     readonly crudHelperService: CrudHelperService,
+    readonly hashingService: HashingService,
+    
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(User, 'default')
@@ -283,4 +286,20 @@ export class UserService extends CRUDService<User> {
     }
   }
 
+  async hashPassword(password: string): Promise<{
+    password: string;
+    passwordScheme: string;
+    passwordSchemeVersion: number;
+  }> {
+    const hashedPassword = await this.hashingService.hash(password);
+  
+    return {
+      password: hashedPassword,
+      passwordScheme: this.hashingService.name(),
+      passwordSchemeVersion: this.hashingService.currentVersion(),
+    };
+  }
+  
+
 }
+

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()
   ],