@solidstarters/solid-core 1.2.124 → 1.2.127

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

@@ -28,7 +28,7 @@ export class ActionMetadataService extends CRUDService<ActionMetadata> {
     readonly moduleRef: ModuleRef
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'actionMetadata', 'app-builder', moduleRef);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'actionMetadata', 'solid-core', moduleRef);
   }
 
   async findOneByUserKey(name: string, relations = {}) {

package/src/services/computed-fields/entity/concat-entity-computed-field-provider.service.ts

@@ -0,0 +1,52 @@
+import { Injectable } from "@nestjs/common";
+import { kebabCase } from "lodash";
+import { ComputedFieldProvider } from "src/decorators/computed-field-provider.decorator";
+import { CommonEntity } from "src/entities/common.entity";
+import { ComputedFieldMetadata } from "src/helpers/solid-registry";
+import { IEntityPreComputeFieldProvider } from "src/interfaces";
+
+
+export interface ConcatComputedFieldContext {
+    separator: string; // The separator to use between concatenated values
+    fields: string[]; // The fields to concatenate
+    slugify?: boolean; // Optional: if true, slugify each field value before concatenation
+}
+
+@ComputedFieldProvider()
+@Injectable()
+export class ConcatEntityComputedFieldProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, ConcatComputedFieldContext, string> {
+
+    name(): string {
+        return "ConcatEntityComputedFieldProvider";
+    }
+
+    help(): string {
+        return "Computed field provider used to create fields whose value is a concatenation of other fields in the same model.";
+    }
+
+    async preComputeValue(entity: T, computedFieldMetadata: ComputedFieldMetadata<ConcatComputedFieldContext>): Promise<string> {
+        const { computedFieldValueProviderCtxt } = computedFieldMetadata;
+        const separator = computedFieldValueProviderCtxt.separator || ' '; // Default to space if no separator is provided
+        const fields = computedFieldValueProviderCtxt.fields || [];
+        const slugify = computedFieldValueProviderCtxt.slugify || false;
+
+        let concatenatedString = '';
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+
+            // if slugify then each field val to be converted to a slug before concatenation
+            let fieldVal = entity[field];
+            if (slugify && typeof fieldVal === 'string') {
+                fieldVal = kebabCase(fieldVal);
+            }
+
+            if (concatenatedString) {
+                concatenatedString += separator;
+            }
+            concatenatedString += fieldVal;
+        }
+
+        return concatenatedString;
+    }
+
+}

package/src/services/crud.service.ts

@@ -1,5 +1,5 @@
-import { BadRequestException, Optional } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
+import { BadRequestException, Inject, Optional } from "@nestjs/common";
+import { ConfigService, ConfigType } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { EntityManager, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
 import { Repository } from "typeorm/repository/Repository";
@@ -35,6 +35,7 @@ import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
 import { isArray } from "class-validator";
+
 export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
     constructor(
@@ -259,7 +260,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
     }
 
     private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false, isUpdate: boolean = false): FieldCrudManager {
-        const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name, isUpdate};
+        const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name, isUpdate };
         switch (fieldMetadata.type) {
             case SolidFieldType.shortText: {
                 const options = { ...commonOptions, length: fieldMetadata.max, regexPattern: fieldMetadata.regexPattern };
@@ -403,7 +404,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
                 //    The value will be computed by the computed provider
                 //    Invoke the appropriate computed provider, get the value and add to the dto
-                const options = { ...commonOptions, computedFieldProvider: fieldMetadata.computedFieldValueProvider, computedFieldValueProviderCtxt: fieldMetadata.computedFieldValueProviderCtxt, computedFieldValueType: fieldMetadata.computedFieldValueType as ComputedFieldValueType, discoveryService: this.discoveryService, skipComputation: isPartialUpdate };
+                const options = { ...commonOptions, computedFieldProvider: fieldMetadata.computedFieldValueProvider, computedFieldValueProviderCtxt: fieldMetadata.computedFieldValueProviderCtxt, computedFieldValueType: fieldMetadata.computedFieldValueType as ComputedFieldValueType, discoveryService: this.discoveryService, skipComputation: this.isSkipComputation(isPartialUpdate, fieldMetadata) };
                 return new ComputedFieldCrudManager(options);
             }
             default:
@@ -411,6 +412,14 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
+    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
+    }
+
     async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
         const alias = 'entity';
         // Extract the required keys from the input query
@@ -427,8 +436,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
         qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
-        if(internationalisation && draftPublishWorkflow){
-            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias,internationalisation, draftPublishWorkflow,this.moduleRef);
+        if (internationalisation && draftPublishWorkflow) {
+            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef);
         }
 
         if (basicFilterDto.groupBy) {

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

@@ -1,25 +1,25 @@
-import { Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { Injectable, Logger, NotFoundException, OnApplicationBootstrap } 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 { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
-import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ComputedFieldMetadata, SolidRegistry } from 'src/helpers/solid-registry';
+import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { DataSource, Repository, SelectQueryBuilder } from 'typeorm';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
-import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
+import { CascadeType, ComputedFieldTriggerConfig, ComputedFieldTriggerOperation, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
 import { SelectionDynamicQueryDto } from '../dtos/selection-dynamic-query.dto';
 import { UpdateFieldMetaDataDto } from '../dtos/update-field-metadata.dto';
 import { FieldMetadata } from '../entities/field-metadata.entity';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ISelectionProviderValues } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
-import { classify } from '@angular-devkit/core/src/utils/strings';
 
 
 @Injectable()
-export class FieldMetadataService {
+export class FieldMetadataService implements OnApplicationBootstrap {
     constructor(
-        @InjectRepository(FieldMetadata)
-        private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+        private readonly fieldMetadataRepo: FieldMetadataRepository,
         @InjectDataSource()
         private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
@@ -29,6 +29,36 @@ export class FieldMetadataService {
 
     private logger = new Logger(FieldMetadataService.name);
 
+    onApplicationBootstrap() {
+        this.loadAndRegisterComputedFieldsDetails();
+    }
+
+   async loadAndRegisterComputedFieldsDetails() {
+        // Load all the modules and models and within that load all the computed fields
+        const computedFieldsWithModelAndModule =  await this.fieldMetadataRepo.findComputedFieldsPopulatedWithModelAndModule();
+
+        // Convert the computed fields object above to the ComputedFieldMetadata type
+        const computedFieldMetadata: ComputedFieldMetadata[] = computedFieldsWithModelAndModule.map((field) => {
+            // const defaultComputedFieldTriggerConfig: ComputedFieldTriggerConfig = {
+            //     moduleName: field.model.module.name,
+            //     modelName: field.model.singularName,
+            //     operations: [ComputedFieldTriggerOperation.create, ComputedFieldTriggerOperation.update, ComputedFieldTriggerOperation.delete], // Default operations, can be overridden
+            // }
+            return {
+                moduleName: field.model.module.name,
+                modelName: field.model.singularName,
+                fieldName: field.name,
+                computedFieldValueType: field.computedFieldValueType as ComputedFieldValueType,
+                computedFieldTriggerConfig: field.computedFieldTriggerConfig ?? [], // Ensure it's an array, default to empty if not provided
+                computedFieldValueProviderName: field.computedFieldValueProvider,
+                computedFieldValueProviderCtxt: field.computedFieldValueProviderCtxt ? JSON.parse(field.computedFieldValueProviderCtxt) : {}, // Parse the context if it exists, default to empty object
+            };
+        });
+
+        // Register the computed fields in the SolidRegistry. Capture only computed field related info
+        this.solidRegistry.registerComputedFieldMetadata(computedFieldMetadata);
+    }
+
     async updateInverseField(field: FieldMetadata, fieldRepository: Repository<FieldMetadata>, modelRepository: Repository<ModelMetadata>) {
         if (!field.model || !field.model.module) {
             throw new Error('Model and module are required to update inverse field');

package/src/services/file.service.ts

@@ -1,14 +1,12 @@
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import * as fs from 'fs';
 // import * as AWS from 'aws-sdk';
-import { S3Client, PutObjectCommand, DeleteObjectCommand, ObjectCannedACL } from '@aws-sdk/client-s3';
+import { S3Client, PutObjectCommand, DeleteObjectCommand, ObjectCannedACL, GetObjectCommand } from '@aws-sdk/client-s3';
 import { ConfigType } from '@nestjs/config';
 import commonConfig, { AwsS3Config } from '../config/common.config';
 import path from 'path';
 import { Readable } from 'stream';
-
-
-
+import { getSignedUrl as awsGetSignedUrl } from '@aws-sdk/s3-request-presigner';
 
 @Injectable()
 export class FileService {
@@ -166,7 +164,7 @@ export class FileService {
   private isValidS3Config(config: AwsS3Config): boolean {
     return !!config.S3_AWS_ACCESS_KEY && !!config.S3_AWS_SECRET_KEY && !!config.S3_AWS_REGION_NAME;
   }
-  
+
   /**
    * Save a stream to a file
    * @param stream - Readable stream
@@ -198,5 +196,14 @@ export class FileService {
       return false;
     }
   }
-  
+
+  public async getSignedUrl(key: string, expiresIn: number, bucketName: string): Promise<string> {
+    const command = new GetObjectCommand({
+      Bucket: bucketName,
+      Key: key,
+    });
+
+    return awsGetSignedUrl(this.s3Client, command, { expiresIn });
+  }
+
 }

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> {