@solidxai/core 0.1.10-alpha.1 → 0.1.10-beta.10

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/seeders/module-test-data.service.ts

@@ -24,6 +24,7 @@ import { TestingRoleSpec, TestingUserSpec } from 'src/testing/contracts/testing-
 @Injectable()
 export class ModuleTestDataService {
   private readonly logger = new Logger(ModuleTestDataService.name);
+  private static readonly TEARDOWN_RETRY_ATTEMPTS = 5;
 
   constructor(
     private readonly moduleRef: ModuleRef,
@@ -665,31 +666,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/seed-data/solid-core-metadata.json

@@ -1761,6 +1761,19 @@
             "encrypt": false,
             "isSystem": true
           },
+          {
+            "name": "failedLoginAttempts",
+            "displayName": "Failed Login Attempts",
+            "type": "int",
+            "ormType": "integer",
+            "defaultValue": "0",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
           {
             "name": "profilePicture",
             "displayName": "Profile Picture",
@@ -9841,6 +9854,14 @@
               "name": "active",
               "isSearchable": true
             }
+          },
+          {
+            "type": "field",
+            "attrs": {
+              "label" : "Blocked / Unblocked",
+              "name": "failedLoginAttempts",
+              "viewWidget": "SolidUserBlockedStatusListWidget"
+            }
           }
         ]
       }

package/src/services/chatter-message.service.ts

@@ -47,6 +47,26 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         super(entityManager, repo, 'chatterMessage', 'solid-core', moduleRef);
     }
 
+    private resolveMessageUserId(userId?: number | null): number | null {
+        if (userId) {
+            return userId;
+        }
+
+        return this.requestContextService.getActiveUser()?.sub ?? null;
+    }
+
+    private resolveMessageUser(userId?: number | null) {
+        const resolvedUserId = this.resolveMessageUserId(userId);
+        return resolvedUserId ? ({ id: resolvedUserId } as any) : null;
+    }
+
+    private stampMessageAuditFields(chatterMessage: ChatterMessage, userId?: number | null) {
+        const resolvedUserId = this.resolveMessageUserId(userId);
+        chatterMessage.user = resolvedUserId ? ({ id: resolvedUserId } as any) : null;
+        chatterMessage.createdBy = resolvedUserId;
+        chatterMessage.updatedBy = resolvedUserId;
+    }
+
     async markCompleted(id: number) {
         const activeUser = this.requestContextService.getActiveUser();
         if (!activeUser) {
@@ -78,14 +98,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         });
         chatterMessage.modelDisplayName = model?.displayName ?? null;
 
-        const activeUser = this.requestContextService.getActiveUser();
-
-        if (activeUser) {
-            const userId = activeUser?.sub;
-            chatterMessage.user = { id: userId } as any;
-        } else {
-            chatterMessage.user = null;
-        }
+        this.stampMessageAuditFields(chatterMessage);
 
         const savedMessage = await this.repo.save(chatterMessage);
 
@@ -114,7 +127,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         return savedMessage;
     }
 
-    async postAuditMessageOnInsert(entity: any, modelName: string, messageQueue: boolean = false) {
+    async postAuditMessageOnInsert(entity: any, modelName: string, messageQueue: boolean = false, userId?: number | null) {
         if (!entity) {
             return;
         }
@@ -139,8 +152,6 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             !(field.type === 'relation' && field.relationType === 'one-to-many')
         );
 
-        const activeUser = this.requestContextService.getActiveUser();
-
         const chatterMessage = new ChatterMessage();
         chatterMessage.messageType = CHATTER_MESSAGE_TYPE.AUDIT;
         chatterMessage.messageSubType = CHATTER_MESSAGE_SUBTYPE.AUDIT_INSERT;
@@ -150,13 +161,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.modelDisplayName = model?.displayName;
         chatterMessage.modelUserKey = entity[model?.userKeyField?.name];
         chatterMessage.messageBody = `New ${model?.displayName} created`;
-
-        if (activeUser) {
-            const userId = activeUser?.sub;
-            chatterMessage.user = { id: userId } as any;
-        } else {
-            chatterMessage.user = null;
-        }
+        this.stampMessageAuditFields(chatterMessage, userId);
 
         const savedMessage = await this.repo.save(chatterMessage);
 
@@ -177,7 +182,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }
     }
 
-    async postAuditMessageOnUpdate(entity: any, modelName: string, databaseEntity: any, updatedColumns: any[] = [], messageQueue: boolean = false) {
+    async postAuditMessageOnUpdate(entity: any, modelName: string, databaseEntity: any, updatedColumns: any[] = [], messageQueue: boolean = false, userId?: number | null) {
         if (!databaseEntity || !entity) {
             return;
         }
@@ -259,8 +264,6 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             return;
         }
 
-        const activeUser = this.requestContextService.getActiveUser();
-
         const chatterMessage = new ChatterMessage();
         chatterMessage.messageType = CHATTER_MESSAGE_TYPE.AUDIT;
         chatterMessage.messageSubType = CHATTER_MESSAGE_SUBTYPE.AUDIT_UPDATE;
@@ -270,13 +273,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.modelDisplayName = model.displayName;
         chatterMessage.modelUserKey = entity[model?.userKeyField?.name];
         chatterMessage.messageBody = `${model?.displayName} updated`;
-
-        if (activeUser) {
-            const userId = activeUser?.sub;
-            chatterMessage.user = { id: userId } as any;
-        } else {
-            chatterMessage.user = null;
-        }
+        this.stampMessageAuditFields(chatterMessage, userId);
 
         const savedMessage = await this.repo.save(chatterMessage);
 
@@ -294,7 +291,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }
     }
 
-    async postAuditMessageOnDelete(modelName: string, databaseEntity: any, messageQueue: boolean = false) {
+    async postAuditMessageOnDelete(modelName: string, databaseEntity: any, messageQueue: boolean = false, userId?: number | null) {
         const model = await this.modelMetadataRepo.findOne({
             where: {
                 singularName: lowerFirst(modelName)
@@ -335,14 +332,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.modelUserKey = databaseEntity[model?.userKeyField?.name];
         chatterMessage.messageBody = `${model?.displayName} deleted`;
 
-        const activeUser = this.requestContextService.getActiveUser();
-
-        if (activeUser) {
-            const userId = activeUser?.sub;
-            chatterMessage.user = { id: userId } as any;
-        } else {
-            chatterMessage.user = null;
-        }
+        this.stampMessageAuditFields(chatterMessage, userId);
 
         const savedMessage = await this.repo.save(chatterMessage);
 

package/src/testing/reporter/console-reporter.ts

@@ -146,6 +146,10 @@ function formatStepLabel(step: OpStep): string {
 }
 
 export class ConsoleReporter implements Reporter {
+  private totalScenarios = 0;
+  private passedScenarios = 0;
+  private failedScenarios = 0;
+
   onScenarioStart(scenario: { id: string; name?: string }): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     console.log(`\n▶ Scenario: ${label}`);
@@ -157,6 +161,12 @@ export class ConsoleReporter implements Reporter {
   ): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     const status = result.ok ? "✔" : "✖";
+    this.totalScenarios += 1;
+    if (result.ok) {
+      this.passedScenarios += 1;
+    } else {
+      this.failedScenarios += 1;
+    }
     console.log(`${status} Scenario: ${label} (${result.durationMs}ms)`);
   }
 
@@ -226,4 +236,21 @@ export class ConsoleReporter implements Reporter {
     if (!dataText.length) return;
     console.log(indentLines(dataText, `${STEP_INDENT}${INDENT}${INDENT}`));
   }
+
+  onRunEnd(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void {
+    const durationSeconds = (args.durationMs / 1000).toFixed(2);
+    const finalStatus = args.ok ? "PASSED" : "FAILED";
+
+    console.log("\n════════ Test Run Summary ════════");
+    console.log(`Result: Test run ${finalStatus}`);
+    console.log(`Cases: total=${args.total}, passed=${args.passed}, failed=${args.failed}`);
+    console.log(`Duration: ${durationSeconds}s`);
+    console.log("══════════════════════════════════");
+  }
 }

package/src/testing/reporter/reporter.types.ts

@@ -33,4 +33,11 @@ export interface Reporter {
     contentType: string;
     data: Buffer | string;
   }): void;
+  onRunEnd?(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void;
 }

package/src/testing/runner/run-from-metadata.ts

@@ -44,6 +44,7 @@ export type RunnerOptions = {
 };
 
 export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
+  const startedAt = Date.now();
   const registry = new StepRegistry();
   registerApiSteps(registry);
   registerUiSteps(registry);
@@ -71,15 +72,32 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
   const ui = new PlaywrightAdapter(opts.ui);
   const ctxBase = { resources, reporter, api, ui, specRegistry, testData, options: opts.options };
   const uiStarted = { value: false };
+  let passed = 0;
+  let failed = 0;
+  let runError: unknown;
 
   try {
     for (const scenario of scenarios) {
       if (scenarioNeedsUi(scenario)) {
         await ensureUiStarted(ctxBase, uiStarted);
       }
-      await engine.runScenario(scenario, ctxBase);
+      try {
+        await engine.runScenario(scenario, ctxBase);
+        passed += 1;
+      } catch (error) {
+        failed += 1;
+        runError = error;
+        throw error;
+      }
     }
   } finally {
+    reporter.onRunEnd?.({
+      ok: !runError,
+      total: scenarios.length,
+      passed,
+      failed,
+      durationMs: Date.now() - startedAt,
+    });
     if (uiStarted.value) {
       await ui.stop();
     }