@solidstarters/solid-core 1.2.149 → 1.2.151

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.149",
+  "version": "1.2.151",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,6 +34,7 @@
   "dependencies": {
     "@angular-devkit/core": "^18.0.3",
     "@aws-sdk/client-s3": "^3.637.0",
+    "@aws-sdk/client-textract": "^3.873.0",
     "@aws-sdk/s3-request-presigner": "^3.828.0",
     "@elasticemail/elasticemail-client": "^4.0.23",
     "@hapi/joi": "^17.1.1",

package/src/dtos/create-scheduled-job.dto.ts

@@ -62,4 +62,7 @@ export class CreateScheduledJobDto {
     @IsString()
     @ApiProperty()
     job: string;
+
+    @IsNotEmpty()
+    moduleId: number;
 }

package/src/dtos/create-user.dto.ts

@@ -23,12 +23,12 @@ export class CreateUserDto {
     @ApiProperty()
     mobile: string;
     @IsOptional()
-    @Matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).*$/)
+    @Matches(/^$|^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).*$/)
     @IsString()
     @ApiProperty()
     password: string;
     @IsOptional()
-    @Matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).*$/)
+    @Matches(/^$|^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).*$/)
     @IsString()
     @ApiProperty()
     passwordConfirm: string;

package/src/dtos/update-scheduled-job.dto.ts

@@ -69,4 +69,7 @@ export class UpdateScheduledJobDto {
     @IsString()
     @ApiProperty()
     job: string;
+    
+    @IsNotEmpty()
+    moduleId: number;
 }

package/src/entities/scheduled-job.entity.ts

@@ -1,8 +1,10 @@
-import { Entity, Column } from 'typeorm';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
 import { CommonEntity } from './common.entity';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
 
 @Entity('ss_scheduled_job')
 export class ScheduledJob extends CommonEntity {
+    @Index({ unique: true })
     @Column({ type: "varchar" })
     scheduleName: string;
     @Column({ type: "boolean", default: false })
@@ -27,4 +29,7 @@ export class ScheduledJob extends CommonEntity {
     dayOfWeek: string;
     @Column({ type: "varchar" })
     job: string;
-}
+    @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE", nullable: false })
+    @JoinColumn({ referencedColumnName: 'id' })
+    module: ModuleMetadata;
+}

package/src/index.ts

@@ -218,6 +218,7 @@ export * from './services/crud.service'
 export * from './services/email-template.service'
 export * from './services/field-metadata.service'
 export * from './services/file.service'
+export * from './services/textract.service'
 export * from './services/hashing.service'
 export * from './services/list-of-values.service'
 export * from './services/mail/elastic-email.service'

package/src/jobs/database/trigger-mcp-client-subscriber-database.service.ts

@@ -46,6 +46,8 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
         const prompt = aiInteraction.message;
 
         // Use this to invoke our mcp client
+        // TODO: try / catch ... 
+        // Handle the rejection gracefully...
         const aiResponse = await this.aiInteractionService.runMcpPrompt(prompt);
         this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
         this.triggerMcpClientSubscriberLogger.log(JSON.stringify(aiResponse));
@@ -75,7 +77,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
         else {
             let nestedResponse = aiResponse.response.trim();
 
-            await this.aiInteractionService.create({
+            const genAiInteraction = await this.aiInteractionService.create({
                 userId: aiInteraction.user.id,
                 threadId: aiInteraction.threadId,
                 parentInteractionId: aiInteraction.id,
@@ -88,6 +90,11 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
                 metadata: JSON.stringify(aiResponse),
                 isApplied: aiInteraction.isApplied
             });
+
+            // If the human interaction was with isAutoApply=true, then we can go ahead and autoApply.
+            if (aiInteraction.isAutoApply) {
+                this.aiInteractionService.applySolidAiInteraction(genAiInteraction.id);
+            }
         }
 
         return aiResponse;

package/src/repository/scheduled-job.repository.ts

@@ -0,0 +1,94 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { ModuleMetadata } from "src/entities/module-metadata.entity";
+import { ScheduledJob } from "src/entities/scheduled-job.entity";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { CrudHelperService } from "src/services/crud-helper.service";
+import { DataSource, Repository } from "typeorm";
+
+// This should match whatever DTO structure you’re using in your seeding logic
+export type CreateScheduledJobDto = {
+  scheduleName: string;
+  isActive?: boolean;
+  frequency: string;
+  startTime?: Date;
+  endTime?: Date;
+  startDate?: Date;
+  endDate?: Date;
+  dayOfMonth?: number;
+  lastRunAt?: Date;
+  nextRunAt?: Date;
+  dayOfWeek?: string;
+  job: string;
+  moduleUserKey: string;
+};
+
+@Injectable()
+export class ScheduledJobRepository extends Repository<ScheduledJob> {
+  private readonly logger = new Logger(ScheduledJobRepository.name);
+
+  constructor(
+    private dataSource: DataSource,
+    private readonly solidRegistry: SolidRegistry,
+    private readonly crudHelperService: CrudHelperService
+  ) {
+    super(ScheduledJob, dataSource.createEntityManager());
+  }
+
+  /**
+   * Converts an entity to a plain DTO object.
+   */
+  async toDto(scheduledJob: ScheduledJob): Promise<CreateScheduledJobDto> {
+    const moduleRepo = this.dataSource.getRepository(ModuleMetadata);
+    const moduleEntity = await moduleRepo.findOne({
+      where: { id: scheduledJob.module?.id },
+    });
+
+    if (!moduleEntity) {
+      throw new Error(`Module with ID ${scheduledJob.module?.id} not found`);
+    }
+    return {
+      scheduleName: scheduledJob.scheduleName,
+      isActive: scheduledJob.isActive,
+      frequency: scheduledJob.frequency,
+      startTime: scheduledJob.startTime,
+      endTime: scheduledJob.endTime,
+      startDate: scheduledJob.startDate,
+      endDate: scheduledJob.endDate,
+      dayOfMonth: scheduledJob.dayOfMonth,
+      lastRunAt: scheduledJob.lastRunAt,
+      nextRunAt: scheduledJob.nextRunAt,
+      dayOfWeek: scheduledJob.dayOfWeek,
+      job: scheduledJob.job,
+      moduleUserKey: moduleEntity.name,
+    };
+  }
+
+  async upsertWithDto(dto: CreateScheduledJobDto): Promise<ScheduledJob> {
+    const moduleRepo = this.dataSource.getRepository(ModuleMetadata);
+
+    const moduleEntity = await moduleRepo.findOne({
+      where: { name: dto.moduleUserKey },
+    });
+
+    if (!moduleEntity) {
+      throw new Error(`Module with ID ${dto.moduleUserKey} not found`);
+    }
+
+    const jobData = {
+      ...dto,
+      module: moduleEntity,
+    };
+    const existing = await this.findOne({
+      where: { scheduleName: dto.scheduleName },
+    });
+
+    if (existing) {
+      const merged = this.merge(existing, jobData);
+      this.logger.debug(`Updating scheduled job: ${dto.scheduleName}`);
+      return this.save(merged);
+    } else {
+      this.logger.debug(`Creating scheduled job: ${dto.scheduleName}`);
+      return this.save(this.create(jobData));
+    }
+  }
+}

package/src/seeders/module-metadata-seeder.service.ts

@@ -39,6 +39,8 @@ import { CreateListOfValuesDto } from 'src/dtos/create-list-of-values.dto';
 import { SystemFieldsSeederService } from './system-fields-seeder.service';
 import { CreateDashboardDto } from 'src/dtos/create-dashboard.dto';
 import { DashboardRepository } from 'src/repository/dashboard.repository';
+// import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
+import { ScheduledJobRepository, CreateScheduledJobDto } from 'src/repository/scheduled-job.repository';
 
 @Injectable()
 export class ModuleMetadataSeederService {
@@ -73,6 +75,7 @@ export class ModuleMetadataSeederService {
         readonly securityRuleRepo: SecurityRuleRepository,
         readonly systemFieldsSeederService: SystemFieldsSeederService,
         readonly dashboardRepo: DashboardRepository,
+        readonly scheduledJobRepository: ScheduledJobRepository,
     ) { }
 
     async seed() {
@@ -221,9 +224,15 @@ export class ModuleMetadataSeederService {
             await this.seedDashboards(dashboards);
             this.logger.log(`[End] Processing dashboards for ${moduleMetadata.name}`);
 
+            // Scheduled Jobs
+            this.logger.debug(`[Start] Processing scheduled jobs for ${moduleMetadata.name}`);
+            const scheduledJobs: CreateScheduledJobDto[] = overallMetadata.scheduledJobs;
+            if (scheduledJobs?.length > 0) {
+                await this.seedScheduledJobs(scheduledJobs);
+            }
+            this.logger.debug(`[End] Processing scheduled jobs for ${moduleMetadata.name}`);
 
             this.logger.debug(`[End] module seed data: ${overallMetadata}`);
-
         }
 
         // Post seed data file processing. 
@@ -588,4 +597,14 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    async seedScheduledJobs(createScheduledJobDto: CreateScheduledJobDto[]) {
+        if (!createScheduledJobDto || createScheduledJobDto.length === 0) {
+            this.logger.debug(`No scheduled jobs found to seed`);
+            return;
+        }
+        for (const dto of createScheduledJobDto) {
+            await this.scheduledJobRepository.upsertWithDto(dto);
+        }
+    }
+
 }

package/src/seeders/seed-data/solid-core-metadata.json

@@ -2548,7 +2548,7 @@
         "userKeyFieldUserKey": "scheduleName",
         "isChild": false,
         "enableAuditTracking": true,
-        "enableSoftDelete": true,
+        "enableSoftDelete": false,
         "draftPublishWorkflow": false,
         "internationalisation": false,
         "fields": [
@@ -2797,6 +2797,22 @@
             "selectionValueType": "string",
             "selectionDynamicProvider": "ListOfScheduledJobsSelectionProvider",
             "selectionDynamicProviderCtxt": "{}"
+          },
+          {
+            "name": "module",
+            "displayName": "Module",
+            "type": "relation",
+            "required": true,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "relationType": "many-to-one",
+            "relationCoModelSingularName": "moduleMetadata",
+            "relationCreateInverse": false,
+            "relationCascade": "cascade",
+            "relationModelModuleName": "solid-core",
+            "isSystem": true
           }
         ]
       },
@@ -10219,6 +10235,13 @@
               "isSearchable": true
             }
           },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "module",
+              "isSearchable": true
+            }
+          },
           {
             "type": "field",
             "attrs": {
@@ -10313,100 +10336,154 @@
             },
             "children": [
               {
-                "type": "row",
+                "type": "notebook",
                 "attrs": {
-                  "name": "sheet-1"
+                  "name": "notebook-1"
                 },
                 "children": [
                   {
-                    "type": "column",
+                    "type": "page",
                     "attrs": {
-                      "name": "group-1",
-                      "label": "Basic",
-                      "className": "col-6"
+                      "name": "page-general",
+                      "label": "General"
                     },
                     "children": [
                       {
-                        "type": "field",
-                        "attrs": {
-                          "name": "scheduleName"
-                        }
-                      },
-                      {
-                        "type": "field",
+                        "type": "row",
                         "attrs": {
-                          "name": "job"
-                        }
+                          "name": "row-general"
+                        },
+                        "children": [
+                          {
+                            "type": "column",
+                            "attrs": {
+                              "name": "group-basic",
+                              "label": "Basic",
+                              "className": "col-6"
+                            },
+                            "children": [
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "scheduleName"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "job"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "module"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "isActive"
+                                }
+                              }
+                            ]
+                          },
+                          {
+                            "type": "column",
+                            "attrs": {
+                              "name": "group-config",
+                              "label": "Configuration",
+                              "className": "col-6"
+                            },
+                            "children": [
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "frequency"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "startTime"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "endTime"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "startDate"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "endDate"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "dayOfWeek"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "dayOfMonth"
+                                }
+                              }
+                            ]
+                          }
+                        ]
                       }
                     ]
                   },
                   {
-                    "type": "column",
+                    "type": "page",
                     "attrs": {
-                      "name": "group-1",
-                      "label": "Configuration",
-                      "className": "col-6"
+                      "name": "page-runtime",
+                      "label": "Runtime"
                     },
                     "children": [
                       {
-                        "type": "field",
-                        "attrs": {
-                          "name": "isActive"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "frequency"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "startTime"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "endTime"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "startDate"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "endDate"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "lastRunAt"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "nextRunAt"
-                        }
-                      },
-                      {
-                        "type": "field",
-                        "attrs": {
-                          "name": "dayOfWeek"
-                        }
-                      },
-                      {
-                        "type": "field",
+                        "type": "row",
                         "attrs": {
-                          "name": "dayOfMonth"
-                        }
+                          "name": "row-runtime"
+                        },
+                        "children": [
+                          {
+                            "type": "column",
+                            "attrs": {
+                              "name": "group-runtime",
+                              "label": "Execution",
+                              "className": "col-12"
+                            },
+                            "children": [
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "lastRunAt",
+                                  "disabled": true,
+                                  "readOnly": true
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "nextRunAt",
+                                  "disabled": true,
+                                  "readOnly": true
+                                }
+                              }
+                            ]
+                          }
+                        ]
                       }
                     ]
                   }
@@ -12279,5 +12356,6 @@
     }
   ],
   "checksums": [],
-  "listOfValues": []
+  "listOfValues": [],
+  "scheduledJobs": []
 }

package/src/services/ai-interaction.service.ts

@@ -43,19 +43,20 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
   }
 
-  async triggerMcpClientJob(prompt: string): Promise<any> {
+  async triggerMcpClientJob(prompt: string, isAutoApply: boolean = false, threadId: string = null): Promise<any> {
     const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
 
     const aiInteraction = await this.create({
       userId: activeUser.sub,
-      threadId: `thread-${activeUser.sub}`,
+      threadId: threadId ? threadId : `thread-${activeUser.sub}`,
       role: 'human',
       message: prompt,
       contentType: '',
       errorMessage: '',
       modelUsed: '',
       responseTimeMs: 0,
-      metadata: ''
+      metadata: '',
+      isAutoApply: isAutoApply
     });
     const m = {
       payload: {

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

@@ -1,5 +1,5 @@
 import { Injectable } from "@nestjs/common";
-import { kebabCase } from "lodash";
+import { kebabCase, get } 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";
@@ -24,28 +24,38 @@ export class ConcatEntityComputedFieldProvider<T extends CommonEntity> implement
         return "Computed field provider used to create fields whose value is a concatenation of other fields in the same model.";
     }
 
-    async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<ConcatComputedFieldContext>){
+    async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<ConcatComputedFieldContext>) {
         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 = triggerEntity[field];
-            if (slugify && typeof fieldVal === 'string') {
-                fieldVal = kebabCase(fieldVal);
+        const separator = computedFieldValueProviderCtxt.separator ?? ' ';
+        const fields: string[] = computedFieldValueProviderCtxt.fields ?? [];
+        const slugify = computedFieldValueProviderCtxt.slugify ?? false;
+
+        const parts: string[] = [];
+
+        for (const fieldExpr of fields) {
+            let val = get(triggerEntity as any, fieldExpr);
+
+            // normalize to string (skip null/undefined)
+            if (val == null) continue;
+
+            if (typeof val !== 'string') {
+                val = String(val);
             }
 
-            if (concatenatedString) {
-                concatenatedString += separator;
+            if (slugify) {
+                val = kebabCase(val);
+            }
+
+            // ignore empty strings so you don't get stray separators
+            if (val.length > 0) {
+                parts.push(val);
             }
-            concatenatedString += fieldVal;
         }
-        triggerEntity[computedFieldMetadata.fieldName] = concatenatedString; //This set the computed value on the entity, since for pre-compute, entity and triggerEntity are the same
+
+        const concatenatedString = parts.join(separator);
+
+        // set the computed field on the entity
+        (triggerEntity as any)[computedFieldMetadata.fieldName] = concatenatedString;
     }
 
 }

package/src/services/media.service.ts

@@ -84,7 +84,6 @@ export class MediaService extends CRUDService<Media> {
     const savedMedias = [];
     for (let i = 0; i < files.length; i++) {
 
-
       createDto['fieldMetadata'] = await this.fieldMetadataRepo.findOne({
         where: {
           id: createDto['fieldMetadataId']
@@ -113,9 +112,9 @@ export class MediaService extends CRUDService<Media> {
           const fileName = this.getFileName(file);
           let awsFileUrl;
           if (createDto.mediaStorageProviderMetadata.isPublic === true) {
-            awsFileUrl = await this.fileService.copyToS3(file.path, file.mimetype, fileName, createDto.mediaStorageProviderMetadata.bucketName,);
-          } else {
             awsFileUrl = await this.fileService.copyToS3WithPublic(file.path, file.mimetype, fileName, createDto.mediaStorageProviderMetadata.bucketName,);
+          } else {
+            awsFileUrl = await this.fileService.copyToS3(file.path, file.mimetype, fileName, createDto.mediaStorageProviderMetadata.bucketName,);
           }
           // createDto['relativeUri'] = this.getAwsS3FullFilePath(awsFileUrl, createDto.mediaStorageProviderMetadata.bucketName, createDto.mediaStorageProviderMetadata.region);
           createDto['relativeUri'] = awsFileUrl

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

@@ -60,7 +60,7 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
             throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
         }
         const result: Media[] = [];
-        files.forEach(async (file) => {
+        for (const file of files) {
             const fileName = this.getFileName(file);
             // Store the file in the configured S3 Bucket
             let awsFileUrl;
@@ -84,7 +84,7 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
             }) as unknown as Media;
             result.push(mediaEntity);
             this.logger.debug(`Stored media with`, mediaEntity);
-        });
+        };
         return result;
     }