@solidstarters/solid-core 1.2.125 → 1.2.128

package/src/services/mail/ElasticEmailService.ts

@@ -1,14 +1,14 @@
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
-import Handlebars, { template } from "handlebars";
+import Handlebars from "handlebars";
 import commonConfig from 'src/config/common.config';
 import { EmailAttachment } from 'src/entities/email-attachment.entity';
-import { ApiEmailQueuePublisher } from 'src/jobs/api-email-publisher.service';
 import { QueueMessage } from 'src/interfaces/mq';
 import { EmailTemplateService } from '../email-template.service';
 import { PdfService } from '../pdf.service';
 import { FileService } from '../file.service';
 import { IMail, MailAttachment, MailAttachmentWrapper } from "../../interfaces";
+import { PublisherFactory } from '../queues/publisher-factory.service';
 
 const ElasticEmail = require('@elasticemail/elasticemail-client');
 
@@ -20,7 +20,8 @@ export class ElasticEmailService implements IMail {
     constructor(
         @Inject(commonConfig.KEY)
         private readonly commonConfiguration: ConfigType<typeof commonConfig>,
-        private readonly emailPublisher: ApiEmailQueuePublisher,
+        // private readonly emailPublisher: ApiEmailQueuePublisher,
+        private readonly publisherFactory: PublisherFactory<any>,
         private readonly emailTemplateService: EmailTemplateService,
         private readonly pdfService: PdfService,
         private readonly fileService: FileService,
@@ -88,7 +89,8 @@ export class ElasticEmailService implements IMail {
     async sendEmailAsynchronously(message: QueueMessage<any>) {
         const { to, subject, body } = message.payload;
         // this.notificationPublisherService.publish(message);
-        this.emailPublisher.publish(message);
+        // this.emailPublisher.publish(message);
+        this.publisherFactory.publish(message, 'ApiEmailQueuePublisher');
         this.logger.debug(`Queueing email to ${to} with subject ${subject} and body ${body}`);
     }
 

package/src/services/mail/SMTPEmailService.ts

@@ -1,11 +1,11 @@
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
 import { QueueMessage } from 'src/interfaces/mq';
-import { EmailQueuePublisher } from 'src/jobs/email-publisher.service';
 import commonConfig from 'src/config/common.config';
 import { EmailTemplateService } from '../email-template.service';
 import Handlebars from "handlebars";
 import { IMail, MailAttachment } from "../../interfaces";
+import { PublisherFactory } from '../queues/publisher-factory.service';
 
 const nodemailer = require("nodemailer");
 
@@ -17,7 +17,9 @@ export class SMTPEMailService implements IMail {
     constructor(
         @Inject(commonConfig.KEY)
         private readonly commonConfiguration: ConfigType<typeof commonConfig>,
-        private readonly emailPublisher: EmailQueuePublisher,
+        // private readonly emailPublisher: EmailQueuePublisher,
+        // private readonly emailDbPublisher: EmailQueueDbPublisher,
+        private readonly publisherFactory: PublisherFactory<any>,
         private readonly emailTemplateService: EmailTemplateService,
     ) {
         this.transporter = nodemailer.createTransport({
@@ -50,7 +52,7 @@ export class SMTPEMailService implements IMail {
         await this.sendEmail(to, subject, body, shouldQueueEmails, parentEntity, parentEntityId, attachments);
     }
 
-    async sendEmail(to: string, subject: string, body: string, shouldQueueEmails = false, parentEntity = null, parentEntityId = null, attachments: MailAttachment[] = [], cc: string[]=[]): Promise<void> {
+    async sendEmail(to: string, subject: string, body: string, shouldQueueEmails = false, parentEntity = null, parentEntityId = null, attachments: MailAttachment[] = [], cc: string[] = []): Promise<void> {
         const message = {
             payload: {
                 from: this.commonConfiguration.smtpMail.from,
@@ -81,7 +83,11 @@ export class SMTPEMailService implements IMail {
     async sendEmailAsynchronously(message) {
         const { to, subject, body } = message.payload;
         // this.notificationPublisherService.publish(message);
-        this.emailPublisher.publish(message);
+        // this.emailPublisher.publish(message);
+        // this.emailDbPublisher.publish(message);
+
+        this.publisherFactory.publish(message, 'EmailQueuePublisher');
+
         this.logger.debug(`Queueing email to ${to} with subject ${subject} and body ${body}`);
     }
 
@@ -92,7 +98,7 @@ export class SMTPEMailService implements IMail {
             const attachmentEntry = {
                 filename: attachment.filename,
                 contentType: attachment.contentType,
-            } 
+            }
             if (attachment.path) {
                 attachmentEntry['path'] = attachment.path;
             }

package/src/services/media.service.ts

@@ -40,12 +40,10 @@ export class MediaService extends CRUDService<Media> {
     @InjectRepository(FieldMetadata)
     private readonly fieldMetadataRepo: Repository<FieldMetadata>,
     readonly moduleRef: ModuleRef,
-
-
-
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'media', 'solid-core', moduleRef);
   }
+
   async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
     const data = await super.find(basicFilterDto, solidRequestContext);
     if (data.records) {
@@ -64,17 +62,18 @@ export class MediaService extends CRUDService<Media> {
     if (data.groupRecords) {
       data.groupRecords.forEach((group) => {
         group.groupData.records.forEach((media) => {
-            if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
-                media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
-            }
-            else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
-                media.relativeUri = this.getAwsS3FullFilePath(media.relativeUri, media.mediaStorageProviderMetadata.bucketName, media.mediaStorageProviderMetadata.region);
-            }
+          if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
+            media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
+          }
+          else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
+            media.relativeUri = this.getAwsS3FullFilePath(media.relativeUri, media.mediaStorageProviderMetadata.bucketName, media.mediaStorageProviderMetadata.region);
+          }
         });
-    });
+      });
     }
     return data
   }
+
   async upload(createDto: any, files: Array<Express.Multer.File>) {
 
     if (!files) {

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

@@ -1,5 +1,5 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
+import { Inject, Injectable, Logger } from "@nestjs/common";
+import { ConfigService, ConfigType } from "@nestjs/config";
 import { CommonEntity } from "src/entities/common.entity";
 import { FieldMetadata } from "src/entities/field-metadata.entity";
 import { Media } from "src/entities/media.entity";
@@ -7,6 +7,7 @@ import { MediaStorageProvider } from "src/interfaces";
 import { FileService } from "src/services/file.service";
 import { Readable } from "stream";
 import { MediaRepository } from "src/repository/media.repository";
+import commonConfig from "src/config/common.config";
 
 @Injectable()
 export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
@@ -17,21 +18,41 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         // private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
         private readonly configService: ConfigService,
         readonly fileService: FileService,
-        readonly mediaRepository: MediaRepository
+        readonly mediaRepository: MediaRepository,
+        @Inject(commonConfig.KEY)
+        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
     ) { }
+
     storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
         throw new Error("Method not implemented.");
     }
+
     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
         }
         const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+
+        // TODO: Check if the mediaStorageProvider (s3 in this case) is configured with a public bucket or not. 
+        // If private bucket then we need to return a "signed-url", the timeout for the signed url can be configured in the media storage provider entity and modified using the CRUD interface.
         // Add the full URL to the media
-        media.forEach(m => {
-            m['_full_url'] = this.getFullFilePath(m);
-        });
+        for (const m of media) {
+            const storageMeta = m.mediaStorageProviderMetadata;
+            if (storageMeta.isPublic === false) {
+                // Generate signed URL
+                const expiryInSeconds = (storageMeta.signedUrlExpiry ?? 60) * 60; // default 5 min
+                m['_full_url'] = await this.fileService.getSignedUrl(m.relativeUri, expiryInSeconds, storageMeta?.bucketName);
+            } else {
+                // Public S3 or local filesystem: use normal URL
+                m['_full_url'] = this.getFullFilePath(m);
+            }
+        }
+
         return media;
+        // media.forEach(m => {
+        //     m['_full_url'] = this.getFullFilePath(m);
+        // });
+        // return media;
     }
 
     async store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
@@ -44,9 +65,9 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
             // Store the file in the configured S3 Bucket
             let awsFileUrl;
             if (mediaFieldMetadata.mediaStorageProvider.isPublic === true) {
-                awsFileUrl = await this.fileService.copyToS3(file.path, file.mimetype, fileName, mediaFieldMetadata.mediaStorageProvider.bucketName,);
-            } else {
                 awsFileUrl = await this.fileService.copyToS3WithPublic(file.path, file.mimetype, fileName, mediaFieldMetadata.mediaStorageProvider.bucketName,);
+            } else {
+                awsFileUrl = await this.fileService.copyToS3(file.path, file.mimetype, fileName, mediaFieldMetadata.mediaStorageProvider.bucketName,);
             }
             await this.fileService.deleteFile(file.path);
 
@@ -71,7 +92,7 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         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 existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id,['mediaStorageProviderMetadata']);
+        const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
         this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         existingMedia.forEach(media => {
             this.fileService.deleteFromS3(media.relativeUri, mediaFieldMetadata.mediaStorageProvider.bucketName); //TODO

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

@@ -15,12 +15,12 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     constructor(
         // @Inject(appBuilderConfig.KEY)
         // private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
-        private readonly configService: ConfigService, 
+        private readonly configService: ConfigService,
         readonly fileService: FileService,
         readonly mediaRepository: MediaRepository
-    
+
     ) { }
-    
+
     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
@@ -45,7 +45,7 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
             await this.fileService.deleteFile(file.path);
 
             // Create an entry in the media table
-        const mediaEntity = await this.mediaRepository.createMedia({
+            const mediaEntity = await this.mediaRepository.createMedia({
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: this.getFileName(file),
@@ -86,7 +86,7 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
         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 existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id,['mediaStorageProviderMetadata']);
+        const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
         this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         existingMedia.forEach(media => {
             this.fileService.deleteFile(this.getFullFilePath(media.relativeUri));

package/src/services/mediaStorageProviders/index.ts

@@ -6,11 +6,11 @@ import { FileStorageProvider } from "./file-storage-provider";
 export async function getMediaStorageProvider<T>(
     moduleRef: ModuleRef,
     type: MediaStorageProviderType): Promise<any> {
-    switch(type) {
+    switch (type) {
         case MediaStorageProviderType.Filesystem:
-            return await moduleRef.get(FileStorageProvider,{ strict: false });
+            return await moduleRef.get(FileStorageProvider, { strict: false });
         case MediaStorageProviderType.AwsS3:
-            return await moduleRef.get(FileS3StorageProvider,{ strict: false });
+            return await moduleRef.get(FileS3StorageProvider, { strict: false });
         default:
             throw new Error(`Unknown media storage provider type ${type}`);
     }

package/src/services/menu-item-metadata.service.ts

@@ -32,7 +32,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
     readonly moduleRef: ModuleRef
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService,  discoveryService, crudHelperService, entityManager, repo, 'menuItemMetadata', 'app-builder',moduleRef);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'menuItemMetadata', 'solid-core', moduleRef);
   }
 
 
@@ -178,7 +178,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
         title: rootItem.displayName || rootItem.name,
         path: path,
         key: rootItem.name.toLowerCase().replace(/\s+/g, '-'),
-        icon : rootItem.iconName,
+        icon: rootItem.iconName,
         // iconVariant : rootItem.iconVariant
       }
       if (children.length > 0) {

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

@@ -24,7 +24,6 @@ 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 { GenerateCodePublisher } from 'src/jobs/database/generate-code-publisher.service';
 import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
 import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
 import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
@@ -45,7 +44,8 @@ export class ModelMetadataService {
     private readonly fieldMetadataService: FieldMetadataService,
     private readonly roleService: RoleMetadataService,
     private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
-    private readonly generateCodePublihser: GenerateCodePublisher,
+    // No longer used. 
+    // private readonly generateCodePublihser: GenerateCodePublisherDatabase,
   ) { }
 
   async findMany(basicFilterDto: BasicFilterDto) {
@@ -228,7 +228,7 @@ export class ModelMetadataService {
       if (fieldMetadata.isUserKey) {
         userKeyField = affectedField;
       }
-      listViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}`, sortable: true, filterable: true } })
+      listViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}` } })
       formViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}` } })
 
     }
@@ -779,13 +779,13 @@ export class ModelMetadataService {
       const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(model.module.name);
       const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
 
-      const listViewLayoutFields = [{ type: "field", attrs: { name: `id`, sortable: true, filterable: true } }];
+      const listViewLayoutFields = [{ type: "field", attrs: { name: `id` } }];
       const formViewLayoutFields = [];
 
       for (let i = 0; i < model.fields.length; i++) {
         const field = model.fields[i];
         if (field.isSystem) continue;
-        listViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}`, sortable: true, filterable: true } })
+        listViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
         formViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
       }
       this.populateVAMConfigInFileInternal(formViewLayoutFields, model, listViewLayoutFields, metaData);
@@ -801,7 +801,7 @@ export class ModelMetadataService {
   }
 
   // Populate the View, Actions and Menus in the config file
-  private populateVAMConfigInFileInternal(formViewLayoutFields: any[], model: ModelMetadata, listViewLayoutFields: { type: string; attrs: { name: string; sortable: boolean; filterable: boolean; }; }[], metaData: any) {
+  private populateVAMConfigInFileInternal(formViewLayoutFields: any[], model: ModelMetadata, listViewLayoutFields: { type: string; attrs: { name: string;  }; }[], metaData: any) {
     const column1Fields = [];
     const column2Fields = [];
 
@@ -813,35 +813,36 @@ export class ModelMetadataService {
         column2Fields.push(formViewLayoutFields[i]);
       }
     }
+    const actionName = `${model.singularName}-list-action`;
     const viewName = `${model.singularName}-list-view`;
     const formViewName = `${model.singularName}-form-view`;
     const menuName = `${model.singularName}-menu-item`;
 
     const action = {
-      displayName: `${model.displayName} List View`,
-      name: `${model.singularName}-list-view`,
+      displayName: `${model.displayName} List Action`,
+      name: actionName,
       type: "solid",
       domain: "",
       context: "",
       customComponent: `/admin/address-master/${model.singularName}/all`,
       customIsModal: true,
       serverEndpoint: "",
-      viewUserKey: `${model.singularName}-list-view`,
+      viewUserKey: viewName,
       moduleUserKey: `${model.module.name}`,
       modelUserKey: `${model.singularName}`
     };
 
     const menu = {
       displayName: `${model.displayName}`,
-      name: `${model.singularName}-menu-item`,
+      name: menuName,
       sequenceNumber: 1,
-      actionUserKey: `${model.singularName}-list-view`,
+      actionUserKey: actionName,
       moduleUserKey: `${model.module.name}`,
       parentMenuItemUserKey: ""
     };
 
     const modelListview = {
-      name: `${model.singularName}-list-view`,
+      name: viewName,
       displayName: `${model.displayName}`,
       type: "list",
       context: "{}",
@@ -867,7 +868,7 @@ export class ModelMetadataService {
 
 
     const modelFormView = {
-      name: `${model.singularName}-form-view`,
+      name: formViewName,
       displayName: `${model.displayName}`,
       type: "form",
       context: "{}",

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

@@ -29,7 +29,7 @@ export class MqMessageQueueService extends CRUDService<MqMessageQueue> {
     readonly moduleRef: ModuleRef
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'mqMessageQueue', 'queues',moduleRef);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'mqMessageQueue', 'solid-core', moduleRef);
   }
 
   async resolveQueue(queueName: string): Promise<MqMessageQueue> {

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

@@ -29,7 +29,7 @@ export class MqMessageService extends CRUDService<MqMessage> {
     readonly repo: Repository<MqMessage>,
     readonly moduleRef: ModuleRef
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'mqMessage', 'queues', moduleRef);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'mqMessage', 'solid-core', moduleRef);
   }
 
   async lockNextPendingMessage(queueName: string): Promise<MqMessage | null> {

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

@@ -1,5 +1,4 @@
 import { Logger, OnModuleInit } from '@nestjs/common';
-import * as amqp from 'amqplib';
 import { QueuesModuleOptions } from "../../interfaces";
 import { QueueMessage, QueueSubscriber } from '../../interfaces/mq';
 import { MqMessageQueueService } from '../mq-message-queue.service';
@@ -92,7 +91,7 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
             // start the loop
             poll();
 
-            this.logger.debug(`DatabaseSubscriber ready to consume messages: ${JSON.stringify(this.options())}`);
+            this.logger.log(`DatabaseSubscriber ready to consume messages: ${JSON.stringify(this.options())}`);
         }
     }
 

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

@@ -0,0 +1,41 @@
+import { Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
+
+import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { SolidIntrospectService } from '../solid-introspect.service';
+
+
+@Injectable()
+export class PublisherFactory<T> {
+    private readonly logger = new Logger(PublisherFactory.name);
+
+    constructor(
+        private readonly solidIntrospectionService: SolidIntrospectService
+    ) {
+    }
+
+    async publish(message: QueueMessage<T>, publisherName: string, brokerToUse?: string): Promise<string> {
+        let defaultBrokerToUse = brokerToUse || process.env.QUEUES_DEFAULT_BROKER;
+        let resolvedPublisherName = `${publisherName}${classify(defaultBrokerToUse)}`;
+
+        // Register all ISolidDatabaseModules implementations
+        let actualPublisherToUse = this.solidIntrospectionService.getProvider(resolvedPublisherName);
+        if (!actualPublisherToUse) {
+
+            // Extra check in place to make sure we do not have to refactor old publishers which have been created earlier. 
+            if (defaultBrokerToUse === 'rabbitmq') {
+                actualPublisherToUse = this.solidIntrospectionService.getProvider(publisherName);
+                if (!actualPublisherToUse) {
+                    throw new Error(`Unable to locate publisher with name ${resolvedPublisherName}`);
+                }
+            }
+        }
+
+        // type safe
+        const typedActualPublisher: QueuePublisher<T> = actualPublisherToUse.instance;
+        this.logger.error(`Resolved publisher with name ${actualPublisherToUse.name}, and with options ${typedActualPublisher.options()}`);
+
+        return typedActualPublisher.publish(message);
+    }
+}

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

@@ -121,7 +121,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
                 {},
             );
 
-            this.logger.debug(`RabbitMqSubscriber ready to consume messages: ${JSON.stringify(this.options())} and url: ${this.url}`);
+            this.logger.log(`RabbitMqSubscriber ready to consume messages: ${JSON.stringify(this.options())} and url: ${this.url}`);
         }
     }
 

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { EntityManager, Repository } from '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 { CrudHelperService } from './crud-helper.service';
+import { CRUDService } from './crud.service';
+import { Logger } from '@nestjs/common';
+
+@Injectable()
+export class ScheduledJobService extends CRUDService<ScheduledJob> {
+  private readonly logger = new Logger(ScheduledJobService.name);
+
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ScheduledJob)
+    readonly repo: Repository<ScheduledJob>,
+    readonly moduleRef: ModuleRef
+
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'scheduledJob', 'solid-core', moduleRef);
+  }
+}

package/src/services/scheduled-jobs/scheduled-job.interface.ts

@@ -0,0 +1,5 @@
+import { ScheduledJob } from "src/entities/scheduled-job.entity";
+
+export interface IScheduledJob {
+    executeReminder(reminder: ScheduledJob): Promise<void>;
+}

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

@@ -0,0 +1,3 @@
+export interface ISchedulerService {
+    runScheduledJobs(): Promise<void>;
+}