@solidxai/core 0.1.10-beta.0 → 0.1.10-beta.11

package/src/entities/chatter-message-details.entity.ts

@@ -18,7 +18,6 @@ export class ChatterMessageDetails extends CommonEntity {
     @Column({ type: "varchar", nullable: true })
     oldValueDisplay: string;
 
-    @Index()
     @Column({ type: "varchar", nullable: true })
     newValueDisplay: string;
 
@@ -30,4 +29,4 @@ export class ChatterMessageDetails extends CommonEntity {
 
     @Column({ type: "varchar", nullable: true })
     fieldType: string;
-}
+}

package/src/entities/mcp-audit-log.entity.ts

@@ -0,0 +1,55 @@
+import { Column, Entity, Index } from 'typeorm';
+import { CommonEntity } from 'src/entities/common.entity';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
+
+@Entity({ name: 'ss_mcp_audit_log' })
+export class McpAuditLog extends CommonEntity {
+  @Index()
+  @Column({ nullable: true })
+  userId: number;
+
+  @Column({ nullable: true })
+  apiKeyId: number;
+
+  @Column({ nullable: true, length: 128 })
+  username: string;
+
+  @Column({ length: 32 })
+  transport: string;
+
+  @Index()
+  @Column({ nullable: true, length: 64 })
+  mcpSessionId: string;
+
+  @Column({ nullable: true, length: 64 })
+  clientAddr: string;
+
+  @Index()
+  @Column({ length: 64 })
+  method: string;
+
+  @Column({ nullable: true, length: 64 })
+  requestId: string;
+
+  @Index()
+  @Column({ nullable: true, length: 128 })
+  toolName: string;
+
+  @Column({ nullable: true, ...getColumnType('longText') })
+  requestParams: string;
+
+  @Column({ length: 16 })
+  status: string;
+
+  @Column({ nullable: true, ...getColumnType('longText') })
+  responseResult: string;
+
+  @Column({ nullable: true })
+  errorCode: number;
+
+  @Column({ nullable: true, ...getColumnType('longText') })
+  errorMessage: string;
+
+  @Column({ nullable: true, ...getColumnType('decimal') })
+  durationMs: number;
+}

package/src/entities/user.entity.ts

@@ -177,7 +177,7 @@ export class User extends CommonEntity {
     @Column({ nullable: true })
     rehashedAt: Date;
 
-    // dont send to client
+    @Expose()
     @Column({ type: "int", default: 0 })
     failedLoginAttempts: number = 0;
 

package/src/helpers/bootstrap.helper.ts

@@ -1,5 +1,6 @@
 import { ValidationPipe } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
+import { WsAdapter } from '@nestjs/platform-ws';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import { NextFunction, Request, Response } from 'express';
 import helmet from 'helmet';
@@ -178,6 +179,8 @@ export async function bootstrapSolidApp(
   const types = require('pg').types;
   types.setTypeParser(types.builtins.INT8, (val: string) => parseInt(val));
 
+  app.useWebSocketAdapter(new WsAdapter(app));
+
   await app.listen(port);
 }
 

package/src/helpers/command.service.ts

@@ -4,6 +4,7 @@ import { spawn } from 'child_process';
 export type CommandWithArgs = {
   command: string;
   args: string[];
+  cwd?: string;
 };
 
 @Injectable()
@@ -43,6 +44,7 @@ export class CommandService {
       const child = spawn(command, spawnArgs, {
         shell: isWindows, // Use shell on Windows to handle .cmd files
         stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: commandWithArgs.cwd,
       });
 
       let stdout = '';

package/src/helpers/field-crud-managers/BigIntFieldCrudManager.ts

@@ -20,7 +20,7 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
                 if (typeof fieldValue === 'string' || typeof fieldValue === 'number') {
                     fieldValue = BigInt(fieldValue);
                 }
-            } catch (err) {
+            } catch (err: any) {
                 return [{ field: this.options.fieldName, error: 'Invalid numeric value' }];
             }
         }

package/src/helpers/field-crud-managers/SelectionDynamicFieldCrudManager.ts

@@ -119,7 +119,7 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
             }
             return false;
         }
-        catch (error) {
+        catch (error: any) {
             // Use the values method as a fallback, if the value method is not implemented
             const values = await providerInstance.values('', ctxt);
             const isValid = values.some(v => v.value === fieldValue);

package/src/helpers/module-metadata-helper.service.ts

@@ -23,7 +23,7 @@ export class ModuleMetadataHelperService {
             const fileContent = await fs.readFile(configFilePath, 'utf8');
             return JSON.parse(fileContent);
         }
-        catch (error) {
+        catch (error: any) {
             this.logger.error(`module metadata configuration non existent at: ${configFilePath}`);
         }
 

package/src/index.ts

@@ -49,6 +49,7 @@ export * from './dtos/create-mq-message-queue.dto'
 export * from './dtos/create-mq-message.dto'
 export * from './dtos/create-agent-session.dto'
 export * from './dtos/create-agent-event.dto'
+export * from './dtos/create-mcp-audit-log.dto'
 export * from './dtos/create-scheduled-job.dto'
 export * from './dtos/create-permission-metadata.dto'
 export * from './dtos/create-role-metadata.dto'
@@ -89,6 +90,7 @@ export * from './dtos/update-mq-message-queue.dto'
 export * from './dtos/update-mq-message.dto'
 export * from './dtos/update-agent-session.dto'
 export * from './dtos/update-agent-event.dto'
+export * from './dtos/update-mcp-audit-log.dto'
 export * from './dtos/update-scheduled-job.dto'
 export * from './dtos/update-permission-metadata.dto'
 export * from './dtos/update-role-metadata.dto'
@@ -122,6 +124,7 @@ export * from './entities/mq-message-queue.entity'
 export * from './entities/mq-message.entity'
 export * from './entities/agent-session.entity'
 export * from './entities/agent-event.entity'
+export * from './entities/mcp-audit-log.entity'
 export * from './entities/scheduled-job.entity'
 export * from './entities/permission-metadata.entity'
 export * from './entities/role-metadata.entity'
@@ -297,6 +300,7 @@ export * from './services/mq-message-queue.service'
 export * from './services/mq-message.service'
 export * from './services/agent-session.service'
 export * from './services/agent-event.service'
+export * from './services/mcp-audit-log.service'
 export * from './services/scheduled-job.service'
 export * from './services/pdf.service'
 export * from './services/permission-metadata.service'

package/src/interfaces.ts

@@ -121,8 +121,6 @@ export interface CodeGenerationOptions {
   fieldIdsForRemoval?: number[];
   fieldNamesForRemoval?: string[];
   dryRun?: boolean;
-  fieldIdsForRefresh?: number[];
-  fieldNamesForRefresh?: string[];
 }
 
 export interface TriggerMcpClientOptions {

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/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

@@ -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/permission-metadata-seeder.service.ts

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