@solidxai/core 0.1.6 → 0.1.7

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);