@solidxai/core 0.1.10-beta.2 → 0.1.10-beta.22

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

@@ -35,7 +35,7 @@ export class ChatterQueueSubscriberDatabase extends DatabaseSubscriber<AuditQueu
 
         switch (p.eventType) {
             case 'insert':
-                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName);
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName, false, p.userId);
                 break;
             case 'update':
                 await this.chatterMessageService.postAuditMessageOnUpdate(
@@ -43,10 +43,12 @@ export class ChatterQueueSubscriberDatabase extends DatabaseSubscriber<AuditQueu
                     p.modelName,
                     p.before,
                     (p.updatedColumnNames ?? []).map(n => ({ propertyName: n })),
+                    false,
+                    p.userId,
                 );
                 break;
             case 'delete':
-                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before);
+                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before, false, p.userId);
                 break;
         }
     }

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

@@ -60,7 +60,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
                 // Fallback
                 nestedResponse = String(raw);
             }
-        } catch (err) {
+        } catch (err: any) {
             this.triggerMcpClientSubscriberLogger.error("Error processing AI response:", err);
             nestedResponse = `Error handling response: ${err?.message || String(err)}`;
         }

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

@@ -33,7 +33,7 @@ export class ChatterQueueSubscriberRabbitmq extends RabbitMqSubscriber<AuditQueu
 
         switch (p.eventType) {
             case 'insert':
-                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName);
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName, false, p.userId);
                 break;
             case 'update':
                 await this.chatterMessageService.postAuditMessageOnUpdate(
@@ -41,10 +41,12 @@ export class ChatterQueueSubscriberRabbitmq extends RabbitMqSubscriber<AuditQueu
                     p.modelName,
                     p.before,
                     (p.updatedColumnNames ?? []).map(n => ({ propertyName: n })),
+                    false,
+                    p.userId,
                 );
                 break;
             case 'delete':
-                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before);
+                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before, false, p.userId);
                 break;
         }
     }

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

@@ -33,13 +33,20 @@ export class ChatterQueueSubscriberRedis extends RedisSubscriber<any> {
 
         switch (p.eventType) {
             case 'insert':
-                await this.chatterMessageService.postAuditMessageOnInsert(p.after, { name: p.modelName } as any);
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName, false, p.userId);
                 break;
             case 'update':
-                await this.chatterMessageService.postAuditMessageOnUpdate(p.after, { name: p.modelName } as any, p.before, (p.updatedColumnNames || []).map(n => ({ propertyName: n })));
+                await this.chatterMessageService.postAuditMessageOnUpdate(
+                    p.after,
+                    p.modelName,
+                    p.before,
+                    (p.updatedColumnNames || []).map(n => ({ propertyName: n })),
+                    false,
+                    p.userId,
+                );
                 break;
             case 'delete':
-                await this.chatterMessageService.postAuditMessageOnDelete(p.before, { name: p.modelName } as any, p.before);
+                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before, false, p.userId);
                 break;
         }
     }

package/src/listeners/user-registration.listener.ts

@@ -1,14 +1,57 @@
-
 import { User } from "../entities/user.entity";
 import { OnEvent } from "@nestjs/event-emitter";
 import { Injectable, Logger } from "@nestjs/common";
 import { EventDetails, EventType } from "../interfaces";
+import { WhatsAppFactory } from "src/factories/whatsapp.factory";
 
 @Injectable()
 export class UserRegistrationListener {
-    private logger = new Logger(UserRegistrationListener.name);
-    @OnEvent(EventType.USER_REGISTERED)
-    handleUserRegistration(event: EventDetails<User>) {
-        this.logger.log(`User registered with details: ${JSON.stringify(event.payload)}`);
+  private readonly logger = new Logger(UserRegistrationListener.name);
+
+  constructor(private readonly whatsAppFactory: WhatsAppFactory) {}
+
+  @OnEvent(EventType.USER_REGISTERED)
+  async handleUserRegistration(event: EventDetails<User>) {
+    this.logger.log(`User registered with details: ${JSON.stringify(event.payload)}`);
+
+    const notifyTo = process.env.WHATSAPP_EVENT_NOTIFY_TO;
+    if (!notifyTo) {
+      this.logger.debug("WHATSAPP_EVENT_NOTIFY_TO not set. Skipping registration WhatsApp notification.");
+      return;
+    }
+
+    try {
+      const whatsappService = this.whatsAppFactory.getWhatsappService();
+      const username = event.payload?.username || "User";
+      const userId = event.payload?.id || "N/A";
+
+      await whatsappService.sendWhatsAppMessage(
+        notifyTo,
+        "registration_event",
+        {
+          payload: {
+            channel: "whatsapp",
+            source: process.env.COMMON_GUPSHUP_WHATSAPP_SOURCE,
+            destination: notifyTo,
+            "src.name": process.env.COMMON_GUPSHUP_APP_NAME || "solidx",
+            message: {
+              type: "text",
+              text: `New user registered: ${username} (id: ${userId})`,
+            },
+          },
+        },
+      );
+
+      this.logger.log(`Sent registration WhatsApp notification to ${notifyTo}`);
+    } catch (error: any) {
+      const status = error?.response?.status;
+      const responseData = error?.response?.data;
+      const errorMessage = error?.message;
+      const stack = error?.stack;
+
+      this.logger.error(
+        `Failed to send registration WhatsApp notification to ${notifyTo}. status=${status ?? "unknown"}, response=${typeof responseData === "object" ? JSON.stringify(responseData) : responseData}, message=${errorMessage}, stack=${stack}`,
+      );
     }
-}
+  }
+}

package/src/repository/mcp-audit-log.repository.ts

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

package/src/repository/security-rule.repository.ts

@@ -56,7 +56,7 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
 
                 evaluatedRules.push(evaluatedRule);
 
-            } catch (error) {
+            } catch (error: any) {
                 this.logger.error(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
                 this.logger.error(error.stack);
                 throw error;

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

@@ -238,7 +238,7 @@ export class ModuleMetadataSeederService {
 
             //FIXME: Handle displaying the created users credentials in a better way.
             // this.logger.log(`Newly created username is: ${usersDetail?.length > 0 ? usersDetail[0]?.username : ''} and password is ${usersDetail?.length > 0 ? usersDetail[0]?.password : ''}`);
-        } catch (error) {
+        } catch (error: any) {
             this.logSeedFailureForCli(error, {
                 moduleName: currentModule,
                 step: currentStep,
@@ -463,7 +463,7 @@ export class ModuleMetadataSeederService {
                     await this.createPermissionIfNotExists(permissionName);
                 }
 
-            } catch (error) {
+            } catch (error: any) {
                 this.logger.error(error);
             }
         }
@@ -544,7 +544,7 @@ export class ModuleMetadataSeederService {
                     moduleRoot = path.dirname(
                         require.resolve('@solidxai/core/package.json'),
                     );
-                } catch (err) {
+                } catch (err: any) {
                     this.logger.debug(
                         'Could not resolve @solidxai/core from node_modules, assuming local execution',
                     );
@@ -610,7 +610,7 @@ export class ModuleMetadataSeederService {
                     moduleRoot = path.dirname(
                         require.resolve('@solidxai/core/package.json'),
                     );
-                } catch (err) {
+                } catch (err: any) {
                     this.logger.debug(
                         'Could not resolve @solidxai/core from node_modules, assuming local execution',
                     );

package/src/seeders/module-test-data.service.ts

@@ -19,11 +19,12 @@ import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { RoleMetadataService } from 'src/services/role-metadata.service';
 import { UserService } from 'src/services/user.service';
 import { getMediaStorageProvider } from 'src/services/mediaStorageProviders';
-import { TestingRoleSpec, TestingUserSpec } from 'src/testing/contracts/testing-metadata.types';
+import { TestingDataRecord, TestingRoleSpec, TestingUserSpec } from 'src/testing/contracts/testing-metadata.types';
 
 @Injectable()
 export class ModuleTestDataService {
   private readonly logger = new Logger(ModuleTestDataService.name);
+  private static readonly TEARDOWN_RETRY_ATTEMPTS = 5;
 
   constructor(
     private readonly moduleRef: ModuleRef,
@@ -50,6 +51,25 @@ export class ModuleTestDataService {
     }
   }
 
+  async removeTestData(modulesToTest?: string[]): Promise<void> {
+    const testDataFiles = this.testDataFiles;
+    const filteredFiles = modulesToTest?.length ? testDataFiles.filter((file) => modulesToTest.includes(file.moduleMetadata?.name)) : testDataFiles;
+
+    if (filteredFiles.length === 0) {
+      this.logger.warn('No modules matched the provided modulesToTest list.');
+      console.log('No modules matched the provided modulesToTest list.');
+      return;
+    }
+
+    for (const overallMetadata of filteredFiles) {
+      const moduleName = overallMetadata?.moduleMetadata?.name ?? 'unknown';
+      this.logger.log(`Removing test data for module: ${moduleName}`);
+      console.log(`Removing test data for module: ${moduleName}`);
+      await this.unlinkTestData(overallMetadata);
+      console.log(`✔ Test data unlink complete for module: ${moduleName}`);
+    }
+  }
+
   async createTestDatasources(): Promise<void> {
     const manifestPath = path.join(process.cwd(), '.solidx-test-manifest');
     if (fs.existsSync(manifestPath)) {
@@ -198,7 +218,7 @@ export class ModuleTestDataService {
 
     const testingRoles: TestingRoleSpec[] = overallMetadata?.testing?.roles ?? [];
     const testingUsers: TestingUserSpec[] = overallMetadata?.testing?.users ?? [];
-    const testingData: Array<{ modelUserKey: string; data: Record<string, any> }> = overallMetadata?.testing?.data ?? [];
+    const testingData: TestingDataRecord[] = overallMetadata?.testing?.data ?? [];
 
     if (testingRoles.length > 0) {
       await this.seedTestRoles(testingRoles);
@@ -289,16 +309,21 @@ export class ModuleTestDataService {
       // Upsert entity, capturing the saved result for post-save steps
       let savedEntity: any;
       const userKeyField = modelDef.userKeyFieldUserKey;
+      const recordUserKeyValue = entry.recUserKeyValue ?? payload[userKeyField];
+      const recordLabel = `${modelUserKey}.${userKeyField}=${recordUserKeyValue}`;
       if (userKeyField && payload[userKeyField] !== undefined) {
         const existing = await entityRepo.findOne({
           where: { [userKeyField]: payload[userKeyField] },
         });
         if (existing) {
+          console.log(`Updating test data record: ${recordLabel}`);
           savedEntity = await entityRepo.save(entityRepo.merge(existing, payload));
         } else {
+          console.log(`Creating test data record: ${recordLabel}`);
           savedEntity = await entityRepo.save(entityRepo.create(payload));
         }
       } else {
+        console.log(`Creating test data record without user key lookup: ${modelUserKey}`);
         savedEntity = await entityRepo.save(entityRepo.create(payload));
       }
 
@@ -312,6 +337,59 @@ export class ModuleTestDataService {
     }
   }
 
+  private async unlinkTestData(overallMetadata: any): Promise<void> {
+    const moduleMetadata: CreateModuleMetadataDto = overallMetadata.moduleMetadata;
+    if (!moduleMetadata) {
+      throw new Error('Module metadata missing from test data payload.');
+    }
+
+    const testingData: TestingDataRecord[] = overallMetadata?.testing?.data ?? [];
+    if (testingData.length === 0) {
+      this.logger.debug(`No test data found for ${moduleMetadata.name}`);
+      return;
+    }
+
+    const modelsByName = new Map<string, CreateModelMetadataDto>(
+      (moduleMetadata.models ?? []).map((m) => [m.singularName, m]),
+    );
+
+    for (const entry of [...testingData].reverse()) {
+      const modelUserKey = entry.modelUserKey;
+      const modelDef = modelsByName.get(modelUserKey);
+      if (!modelDef) {
+        throw new Error(`Test data modelUserKey not found in metadata: ${modelUserKey}`);
+      }
+
+      const userKeyField = modelDef.userKeyFieldUserKey;
+      if (!userKeyField) {
+        throw new Error(`Cannot unlink test data for model ${modelUserKey} because userKeyFieldUserKey is not configured.`);
+      }
+
+      const userKeyValue = entry.data?.[userKeyField];
+      if (userKeyValue === undefined || userKeyValue === null || userKeyValue === '') {
+        throw new Error(
+          `Cannot unlink test data for model ${modelUserKey} because testing.data entry is missing the actual user key field "${userKeyField}" in data.`,
+        );
+      }
+      const recordLabel = `${modelUserKey}.${userKeyField}=${userKeyValue}`;
+
+      const entityRepo = this.resolveRepository(modelUserKey);
+      const existing = typeof entityRepo.findOneByUserKey === 'function'
+        ? await entityRepo.findOneByUserKey(userKeyValue)
+        : await entityRepo.findOne({ where: { [userKeyField]: userKeyValue } });
+
+      if (!existing) {
+        console.log(`Skipping unlink; test data record not found: ${recordLabel}`);
+        this.logger.debug(`Test data record not found for unlink: ${modelUserKey}.${userKeyField}=${userKeyValue}`);
+        continue;
+      }
+
+      console.log(`Deleting test data record: ${recordLabel}`);
+      await entityRepo.remove(existing);
+      this.logger.debug(`Removed test data record: ${modelUserKey}.${userKeyField}=${userKeyValue}`);
+    }
+  }
+
   private async seedTestRoles(roles: TestingRoleSpec[]): Promise<void> {
     const roleService = this.moduleRef.get(RoleMetadataService, { strict: false });
     if (!roleService) {
@@ -665,31 +743,122 @@ export class ModuleTestDataService {
   private async dropTestDatabaseObjects(databases: Record<string, string>): Promise<void> {
     const entries = Object.entries(databases);
     for (const [dsName, dbName] of entries) {
-      const dataSource = this.resolveDataSourceByName(dsName);
-      if (!dataSource.isInitialized) {
-        await dataSource.initialize();
-      }
+      await this.dropTestDatabaseObjectsWithRetry(dsName, dbName);
+    }
+  }
 
-      console.log(`Dropping test database/schema "${dbName}" on datasource "${dsName}"...`);
+  private async dropTestDatabaseObjectsWithRetry(dsName: string, dbName: string): Promise<void> {
+    let lastError: unknown;
+
+    for (let attempt = 1; attempt <= ModuleTestDataService.TEARDOWN_RETRY_ATTEMPTS; attempt += 1) {
+      console.log(`Attempting to tear down "${dbName}" on datasource "${dsName}" (${attempt}/${ModuleTestDataService.TEARDOWN_RETRY_ATTEMPTS})...`);
 
-      const queryRunner = dataSource.createQueryRunner();
       try {
-        const type = dataSource.options.type;
-        if (type === 'postgres') {
-          await queryRunner.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-        } else if (type === 'mssql') {
-          await this.dropMssqlSchema(queryRunner, dbName);
-        } else if (type === 'mysql' || type === 'mariadb') {
-          await queryRunner.query(`DROP DATABASE IF EXISTS \`${dbName}\``);
-        } else {
-          throw new Error(`Unsupported database type for test data deletion: ${type}`);
+        await this.dropSingleTestDatabaseObject(dsName, dbName);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt >= ModuleTestDataService.TEARDOWN_RETRY_ATTEMPTS) {
+          throw error;
         }
+
+        await this.sleep(this.teardownRetryDelayMs(attempt));
+      }
+    }
+
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+
+  private teardownRetryDelayMs(attempt: number): number {
+    const baseMs = 500;
+    const incrementMs = 350;
+    const jitterMs = Math.floor(Math.random() * 250);
+    return baseMs + ((attempt - 1) * incrementMs) + jitterMs;
+  }
+
+  private async sleep(ms: number): Promise<void> {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  private async dropSingleTestDatabaseObject(dsName: string, dbName: string): Promise<void> {
+    const dataSource = this.resolveDataSourceByName(dsName);
+
+    if (dataSource.options.type === 'postgres') {
+      await this.dropPostgresDatabase(dataSource, dbName);
+      return;
+    }
+
+    if (!dataSource.isInitialized) {
+      await dataSource.initialize();
+    }
+
+    const queryRunner = dataSource.createQueryRunner();
+    try {
+      const type = dataSource.options.type;
+      if (type === 'mssql') {
+        await this.dropMssqlSchema(queryRunner, dbName);
+      } else if (type === 'mysql' || type === 'mariadb') {
+        await queryRunner.query(`DROP DATABASE IF EXISTS \`${dbName}\``);
+      } else {
+        throw new Error(`Unsupported database type for test data deletion: ${type}`);
+      }
+    } finally {
+      await queryRunner.release();
+    }
+  }
+
+  private async dropPostgresDatabase(dataSource: DataSource, dbName: string): Promise<void> {
+    if (dataSource.isInitialized) {
+      await dataSource.destroy();
+    }
+
+    const adminDataSource = new DataSource({
+      ...(dataSource.options as any),
+      database: this.resolvePostgresMaintenanceDatabase(dataSource),
+      name: `${String(dataSource.name ?? 'default')}_teardown_admin_${Date.now()}`,
+      synchronize: false,
+      migrationsRun: false,
+      entities: [],
+      subscribers: [],
+      migrations: [],
+    });
+
+    try {
+      await adminDataSource.initialize();
+      const queryRunner = adminDataSource.createQueryRunner();
+      try {
+        await queryRunner.query(
+          `SELECT pg_terminate_backend(pid)
+             FROM pg_stat_activity
+            WHERE datname = $1
+              AND pid <> pg_backend_pid()`,
+          [dbName],
+        );
+        await queryRunner.query(`DROP DATABASE IF EXISTS "${dbName}"`);
       } finally {
         await queryRunner.release();
       }
+    } finally {
+      if (adminDataSource.isInitialized) {
+        await adminDataSource.destroy();
+      }
     }
   }
 
+  private resolvePostgresMaintenanceDatabase(dataSource: DataSource): string {
+    const configured = process.env.POSTGRES_MAINTENANCE_DATABASE?.trim();
+    if (configured) {
+      return configured;
+    }
+
+    const currentDb = String((dataSource.options as any)?.database ?? '').trim();
+    if (currentDb && currentDb !== 'postgres') {
+      return 'postgres';
+    }
+
+    return 'template1';
+  }
+
   private async dropMssqlSchema(queryRunner: ReturnType<DataSource['createQueryRunner']>, schemaName: string): Promise<void> {
     const foreignKeys: Array<{ fk_name: string; table_name: string }> = await queryRunner.query(
       `SELECT fk.name AS fk_name, t.name AS table_name

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

@@ -52,7 +52,7 @@ export class PermissionMetadataSeederService {
           }
         }
 
-      } catch (error) {
+      } catch (error: any) {
         this.logger.error(error);
       }
     }