@solidxai/core 0.1.6-beta.9 → 0.1.7

package/src/helpers/typeorm-db-helper.ts

@@ -9,6 +9,29 @@ const LONG_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
     [DatasourceType.oracle]: { type: "clob" },
 };
 
+// For simple-json columns that may contain large payloads: on MySQL/MariaDB the default
+// TEXT backing store is limited to 64 KB, so we override the type to longtext and supply
+// an explicit JSON transformer so TypeORM still serialises/deserialises correctly.
+const SIMPLE_JSON_LARGE_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
+    [DatasourceType.postgres]: {},
+    [DatasourceType.mssql]: {},
+    [DatasourceType.mysql]: {
+        type: "longtext",
+        transformer: {
+            to: (value: any) => (value !== undefined && value !== null ? JSON.stringify(value) : value),
+            from: (value: any) => (value !== null && value !== undefined ? JSON.parse(value) : value),
+        },
+    },
+    [DatasourceType.mariadb]: {
+        type: "longtext",
+        transformer: {
+            to: (value: any) => (value !== undefined && value !== null ? JSON.stringify(value) : value),
+            from: (value: any) => (value !== null && value !== undefined ? JSON.parse(value) : value),
+        },
+    },
+    [DatasourceType.oracle]: { type: "clob" },
+};
+
 const solidCoreDbType: DatasourceType =
     Object.values(DatasourceType).includes(process.env.SOLID_CORE_DB_TYPE as DatasourceType)
         ? (process.env.SOLID_CORE_DB_TYPE as DatasourceType)
@@ -20,6 +43,9 @@ export function getColumnType(solidType: string): ColumnOptions {
         case "richText":
             return LONG_TEXT_MAP[solidCoreDbType];
 
+        case "simpleJsonLargeText":
+            return SIMPLE_JSON_LARGE_TEXT_MAP[solidCoreDbType];
+
         default:
             return {};
     }

package/src/index.ts

@@ -137,6 +137,7 @@ export * from './entities/user-activity-history.entity'
 export * from './entities/dashboard.entity'
 export * from './entities/dashboard-variable.entity'
 export * from './entities/dashboard-question.entity'
+export * from './entities/dashboard-layout.entity'
 export * from './entities/dashboard-question-sql-dataset-config.entity'
 export * from './entities/ai-interaction.entity'
 export * from './entities/model-sequence.entity'
@@ -175,7 +176,9 @@ export * from './helpers/field-crud-managers/SelectionDynamicFieldCrudManager' /
 export * from './helpers/field-crud-managers/SelectionStaticFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/ShortTextFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/UUIDFieldCrudManager' //rename
+export * from './helpers/bootstrap.helper'
 export * from './helpers/environment.helper'
+export * from './helpers/cache.helper'
 export * from './helpers/cors.helper'
 export * from './helpers/security.helper'
 export * from './helpers/model-metadata-helper.service'

package/src/interfaces.ts

@@ -111,6 +111,8 @@ export interface ISelectionProviderContext {
   limit: number;
   offset: number;
   formValues: Record<string, any>;
+  //Attribute to control the validation on creating the record
+  validateOnSave?: boolean;
   // query: string;
 }
 
@@ -269,6 +271,7 @@ export interface QueuesModuleOptions {
   type: BrokerType;
   queueName: string;
   prefetch?: number;
+  persistToDatabase?: boolean;
 }
 
 export type MediaWithFullUrl = Media & {

package/src/jobs/chatter-queue-options.ts

@@ -1,6 +1,6 @@
 import { BrokerType } from "../interfaces";
 
-const QUEUE_NAME = 'solid_chatter_queue';
+const QUEUE_NAME = 'solid_chatter_queue_rabbitmq';
 
 export default {
     name: QUEUE_NAME,

package/src/jobs/chatter-queue-publisher.service.ts

@@ -7,21 +7,21 @@ import { MqMessageService } from '../services/mq-message.service';
 import { QueuesModuleOptions } from "../interfaces";
 
 
-export type ChatterEventType = 'insert' | 'update' | 'delete';
+export type AuditEventType = 'insert' | 'update' | 'delete';
 
-export interface ChatterMessagePayload {
-    eventType: ChatterEventType;
-    model: string;         // entity name
-    entityId: string;      // id string
-    occurredAt: string;    // ISO
-    before?: any;
-    after?: any;
-    diff?: string[];       // changed column names for updates
-    userId?: string | null;
+export interface AuditQueuePayload {
+    eventType: AuditEventType;
+    modelName: string;              // TypeORM entity class name (e.g. 'Order')
+    entityId: string | number | null;
+    occurredAt: string;             // ISO timestamp, captured at event time
+    after?: any;                    // entity state after operation (insert/update)
+    before?: any;                   // entity state before operation (update/delete)
+    updatedColumnNames?: string[];  // propertyNames of changed columns (update only)
+    userId?: number | null;         // active user captured at event time
 }
 
 @Injectable()
-export class ChatterQueuePublisher extends RabbitMqPublisher<any> {
+export class ChatterQueuePublisherRabbitmq extends RabbitMqPublisher<AuditQueuePayload> {
     constructor(
         protected readonly mqMessageService: MqMessageService,
         protected readonly mqMessageQueueService: MqMessageQueueService,

package/src/jobs/chatter-queue-subscriber.service.ts

@@ -6,12 +6,12 @@ import { MqMessageService } from '../services/mq-message.service';
 import { MqMessageQueueService } from '../services/mq-message-queue.service';
 import { QueuesModuleOptions } from "../interfaces";
 import chatterQueueOptions from './chatter-queue-options';
-import { ChatterMessagePayload } from './chatter-queue-publisher.service';
+import { AuditQueuePayload } from './chatter-queue-publisher.service';
 import { ChatterMessageService } from 'src/services/chatter-message.service';
 
 @Injectable()
-export class ChatterQueueSubscriber extends RabbitMqSubscriber<any> {
-    private readonly chatterQueueLogger = new Logger(ChatterQueueSubscriber.name);
+export class ChatterQueueSubscriberRabbitmq extends RabbitMqSubscriber<AuditQueuePayload> {
+    private readonly chatterLogger = new Logger(ChatterQueueSubscriberRabbitmq.name);
 
     constructor(
         readonly mqMessageService: MqMessageService,
@@ -27,19 +27,24 @@ export class ChatterQueueSubscriber extends RabbitMqSubscriber<any> {
         }
     }
 
-    async subscribe(message: QueueMessage<ChatterMessagePayload>) {
+    async subscribe(message: QueueMessage<AuditQueuePayload>) {
         const p = message.payload;
-        this.chatterQueueLogger.debug(`Audit event ${p.eventType} ${p.model}#${p.entityId}`);
+        this.chatterLogger.debug(`Audit event ${p.eventType} ${p.modelName}#${p.entityId}`);
 
         switch (p.eventType) {
             case 'insert':
-                await this.chatterMessageService.postAuditMessageOnInsert(p.after, { name: p.model } as any);
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName);
                 break;
             case 'update':
-                await this.chatterMessageService.postAuditMessageOnUpdate(p.after, { name: p.model } as any, p.before, (p.diff || []).map(n => ({ propertyName: n })));
+                await this.chatterMessageService.postAuditMessageOnUpdate(
+                    p.after,
+                    p.modelName,
+                    p.before,
+                    (p.updatedColumnNames ?? []).map(n => ({ propertyName: n })),
+                );
                 break;
             case 'delete':
-                await this.chatterMessageService.postAuditMessageOnDelete(p.before, { name: p.model } as any, p.before);
+                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before);
                 break;
         }
     }

package/src/jobs/computed-field-evaluation-queue-options.ts

@@ -6,4 +6,6 @@ export default {
     name: QUEUE_NAME,
     type: BrokerType.RabbitMQ,
     queueName: QUEUE_NAME,
+    prefetch: 10,
+    persistToDatabase: false,
 };

package/src/jobs/database/chatter-queue-options-database.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "../../interfaces";
+
+const QUEUE_NAME = 'solid_chatter_queue_database';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Database,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/database/chatter-queue-publisher-database.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import { DatabasePublisher } from 'src/services/queues/database-publisher.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { AuditQueuePayload } from '../chatter-queue-publisher.service';
+import chatterQueueOptionsDatabase from './chatter-queue-options-database';
+
+@Injectable()
+export class ChatterQueuePublisherDatabase extends DatabasePublisher<AuditQueuePayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptionsDatabase
+        };
+    }
+}

package/src/jobs/database/chatter-queue-subscriber-database.service.ts

@@ -0,0 +1,53 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { PollerService } from 'src/services/poller.service';
+import { AuditQueuePayload } from '../chatter-queue-publisher.service';
+import { ChatterMessageService } from 'src/services/chatter-message.service';
+import chatterQueueOptionsDatabase from './chatter-queue-options-database';
+
+@Injectable()
+export class ChatterQueueSubscriberDatabase extends DatabaseSubscriber<AuditQueuePayload> {
+    private readonly chatterLogger = new Logger(ChatterQueueSubscriberDatabase.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        private readonly chatterMessageService: ChatterMessageService,
+    ) {
+        super(mqMessageService, mqMessageQueueService, poller);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptionsDatabase
+        };
+    }
+
+    async subscribe(message: QueueMessage<AuditQueuePayload>) {
+        const p = message.payload;
+        this.chatterLogger.debug(`Audit event ${p.eventType} ${p.modelName}#${p.entityId}`);
+
+        switch (p.eventType) {
+            case 'insert':
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName);
+                break;
+            case 'update':
+                await this.chatterMessageService.postAuditMessageOnUpdate(
+                    p.after,
+                    p.modelName,
+                    p.before,
+                    (p.updatedColumnNames ?? []).map(n => ({ propertyName: n })),
+                );
+                break;
+            case 'delete':
+                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before);
+                break;
+        }
+    }
+}

package/src/repository/dashboard-layout.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+import { DashboardLayout } from 'src/entities/dashboard-layout.entity';
+
+@Injectable()
+export class DashboardLayoutRepository extends SolidBaseRepository<DashboardLayout> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(DashboardLayout, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/model-metadata.repository.ts

@@ -1,5 +1,9 @@
-import { Injectable } from '@nestjs/common';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable } from '@nestjs/common';
+import { Cache } from 'cache-manager';
+import { createHash } from 'crypto';
 import { ModelMetadata } from 'src';
+import { shouldUseCache } from 'src/helpers/cache.helper';
 import { DataSource } from 'typeorm';
 import { SolidBaseRepository } from './solid-base.repository';
 
@@ -7,9 +11,48 @@ import { SolidBaseRepository } from './solid-base.repository';
 export class ModelMetadataRepository extends SolidBaseRepository<ModelMetadata> {
     constructor(
         readonly dataSource: DataSource,
+        @Inject(CACHE_MANAGER) private readonly cacheManager: Cache,
         // readonly requestContextService: RequestContextService,
         // readonly securityRuleRepository: SecurityRuleRepository,
     ) {
         super(ModelMetadata, dataSource, null, null);
     }
-}
+
+    async find(options?: any): Promise<ModelMetadata[]> {
+        if (!shouldUseCache()) {
+            return super.find(options);
+        }
+
+        const cacheKey = this.buildCacheKey('find', options);
+        const cached = await this.cacheManager.get<ModelMetadata[]>(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const result = await super.find(options);
+        await this.cacheManager.set(cacheKey, result);
+        return result;
+    }
+
+    async findOne(options: any): Promise<ModelMetadata | null> {
+        if (!shouldUseCache()) {
+            return super.findOne(options);
+        }
+
+        const cacheKey = this.buildCacheKey('findOne', options);
+        const cached = await this.cacheManager.get<ModelMetadata | null>(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const result = await super.findOne(options);
+        await this.cacheManager.set(cacheKey, result);
+        return result;
+    }
+
+    private buildCacheKey(method: 'find' | 'findOne', options: unknown): string {
+        const serialized = JSON.stringify(options ?? {});
+        const hash = createHash('sha256').update(serialized).digest('hex');
+        return `modelMetadataRepo:${method}:${hash}`;
+    }
+}

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

@@ -140,17 +140,17 @@ export class ModuleMetadataSeederService {
                 console.log(`▶ Seeding Metadata for Module: ${moduleMetadata.name}`);
                 this.logger.log(`Seeding Metadata for Module: ${moduleMetadata.name}`);
 
+                currentStep = 'seedMediaStorageProviders';
+                this.logger.log(`Seeding Media Storage Providers`);
+                const mediaStorageCounts = await this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders);
+                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
+
                 // Process module metadata first.
                 currentStep = 'seedModuleModelFields';
                 this.logger.log(`Seeding Module / Model / Fields`);
                 const moduleModelFieldCounts = await this.seedModuleModelFields(moduleMetadata);
                 console.log(`${this.formatSeedResult(moduleMetadata.name, 'Module/Model/Fields', moduleModelFieldCounts)}`);
 
-                currentStep = 'seedMediaStorageProviders';
-                this.logger.log(`Seeding Media Storage Providers`);
-                const mediaStorageCounts = await this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
-
                 currentStep = 'seedRoles';
                 this.logger.log(`Seeding Roles`);
                 const roleCounts = await this.seedRoles(overallMetadata);