@solidxai/core 0.1.2 → 0.1.5-beta.0

package/src/commands/run-tests.command.ts

@@ -0,0 +1,278 @@
+import { Logger } from '@nestjs/common';
+import { SubCommand, CommandRunner, Option } from 'nest-commander';
+import * as path from 'path';
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
+import { ConsoleReporter } from 'src/testing/reporter/console-reporter';
+import { runFromMetadata } from 'src/testing/runner/run-from-metadata';
+import type { TestingMetadata } from 'src/testing/contracts/testing-metadata.types';
+import { SpecRegistry } from 'src/testing/core/spec-registry';
+
+interface TestRunCommandOptions {
+  module?: string;
+  moduleName?: string;
+  scenarioIds?: string;
+  includeTags?: string;
+  skipScenarioIds?: string;
+  reporter?: string;
+  apiBaseUrl?: string;
+  uiBaseUrl?: string;
+  headless?: boolean;
+  timeoutMs?: number;
+  retries?: number;
+  listSpecs?: boolean;
+  printApiLogs?: boolean;
+}
+
+@SubCommand({
+  name: 'run',
+  description: 'Run testing scenarios from module metadata.',
+})
+export class TestRunCommand extends CommandRunner {
+  private readonly logger = new Logger(TestRunCommand.name);
+
+  constructor(
+    private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+  ) {
+    super();
+  }
+
+  async run(passedParam: string[], options?: TestRunCommandOptions): Promise<void> {
+    try {
+      const moduleName = options?.moduleName ?? options?.module ?? passedParam?.[0];
+      if (!moduleName) {
+        this.logger.error('Module name is required. Use --module or pass it as the first argument.');
+        return;
+      }
+
+      const metadataPath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+      if (!metadataPath) {
+        this.logger.error(`Unable to resolve metadata path for module: ${moduleName}`);
+        return;
+      }
+
+      const metadata = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(metadataPath);
+      if (!metadata?.testing) {
+        this.logger.error(`No testing configuration found in metadata: ${metadataPath}`);
+        return;
+      }
+
+      const listSpecs = options?.listSpecs ?? false;
+      const specEntries = Array.isArray(metadata.testing?.specs)
+        ? metadata.testing.specs
+        : [];
+
+      if (listSpecs) {
+        const registry = new SpecRegistry();
+        if (specEntries.length) {
+          loadSpecRegistrations(specEntries, metadataPath, registry);
+        }
+        printSpecList(registry.list());
+        return;
+      }
+      if (!metadata?.testing?.scenarios || !Array.isArray(metadata.testing.scenarios)) {
+        this.logger.error(`No testing.scenarios found in metadata: ${metadataPath}`);
+        return;
+      }
+
+      const scenarioIds = splitCsv(options?.scenarioIds);
+      const includeTags = splitCsv(options?.includeTags);
+      const skipScenarioIds = splitCsv(options?.skipScenarioIds);
+
+      const reporterName = options?.reporter ?? 'console';
+      if (reporterName !== 'console') {
+        this.logger.error(`Unsupported reporter: ${reporterName}. Use "console".`);
+        return;
+      }
+
+      const apiBaseUrl = options?.apiBaseUrl ?? process.env.BASE_URL;
+      const uiBaseUrl = options?.uiBaseUrl ?? process.env.FRONTEND_BASE_URL;
+      const headless = options?.headless ?? true;
+      const printApiLogs = options?.printApiLogs ?? false;
+
+      await runFromMetadata({
+        metadata: metadata as TestingMetadata,
+        scenarioIds,
+        includeTags,
+        skipScenarioIds,
+        reporter: new ConsoleReporter(),
+        api: apiBaseUrl ? { baseUrl: apiBaseUrl } : undefined,
+        ui: { baseUrl: uiBaseUrl, headless },
+        defaults: {
+          timeoutMs: options?.timeoutMs,
+          retries: options?.retries,
+        },
+        options: { printApiLogs },
+        specs: specEntries.length
+          ? (registry) => loadSpecRegistrations(specEntries, metadataPath, registry)
+          : undefined,
+      });
+    } catch (err: any) {
+      this.logger.error('Run tests command failed');
+      console.error('Run tests command failed');
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  @Option({
+    flags: '-m, --module [module name]',
+    description: 'Module name to load metadata from.',
+    required: false,
+  })
+  parseModule(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--scenario-ids [ids]',
+    description: 'Comma-separated list of scenario ids to run.',
+    required: false,
+  })
+  parseScenarioIds(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--include-tags [tags]',
+    description: 'Comma-separated list of tags; scenario must include all.',
+    required: false,
+  })
+  parseIncludeTags(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--skip-scenario-ids [ids]',
+    description: 'Comma-separated list of scenario ids to skip.',
+    required: false,
+  })
+  parseSkipScenarioIds(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--reporter [name]',
+    description: 'Reporter name (currently only "console").',
+    required: false,
+  })
+  parseReporter(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--list-specs [true|false]',
+    description: 'List registered test specs and exit.',
+    required: false,
+  })
+  parseListSpecs(val?: string): boolean {
+    if (val === undefined) return true;
+    return val === 'false' ? false : true;
+  }
+
+  @Option({
+    flags: '--print-api-logs [true|false]',
+    description: 'Print full API request/response logs for api.request steps.',
+    required: false,
+  })
+  parsePrintApiLogs(val?: string): boolean {
+    if (val === undefined) return true;
+    return val === 'false' ? false : true;
+  }
+
+  @Option({
+    flags: '--api-base-url [url]',
+    description: 'API base URL (defaults to process.env.BASE_URL).',
+    required: false,
+  })
+  parseApiBaseUrl(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--ui-base-url [url]',
+    description: 'UI base URL (defaults to process.env.FRONTEND_BASE_URL).',
+    required: false,
+  })
+  parseUiBaseUrl(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--headless [true|false]',
+    description: 'Run UI browser in headless mode (default: true).',
+    required: false,
+  })
+  parseHeadless(val: string): boolean {
+    return val === 'false' ? false : true;
+  }
+
+  @Option({
+    flags: '--timeout-ms [number]',
+    description: 'Default scenario timeout in milliseconds.',
+    required: false,
+  })
+  parseTimeoutMs(val: string): number {
+    return Number(val);
+  }
+
+  @Option({
+    flags: '--retries [number]',
+    description: 'Default scenario retries.',
+    required: false,
+  })
+  parseRetries(val: string): number {
+    return Number(val);
+  }
+}
+
+function splitCsv(value?: string): string[] | undefined {
+  if (!value) return undefined;
+  const items = value
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return items.length ? items : undefined;
+}
+
+function resolveSpecPath(entry: string, metadataPath: string): string {
+  if (path.isAbsolute(entry)) {
+    return entry;
+  }
+  if (entry.startsWith('.')) {
+    return path.resolve(path.dirname(metadataPath), entry);
+  }
+  return path.resolve(process.cwd(), entry);
+}
+
+function loadSpecRegistrations(entries: string[], metadataPath: string, registry: SpecRegistry): void {
+  for (const entry of entries) {
+    const resolved = resolveSpecPath(entry, metadataPath);
+    let mod: any;
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      mod = require(resolved);
+    } catch (err: any) {
+      const message = err?.message ?? String(err);
+      throw new Error(
+        `Failed to load test spec module "${entry}" resolved to "${resolved}": ${message}`,
+      );
+    }
+    const register = mod?.registerTestSpecs ?? mod?.default ?? mod;
+    if (typeof register !== 'function') {
+      throw new Error(
+        `Test spec module "${entry}" did not export a register function (expected "registerTestSpecs" or default export).`,
+      );
+    }
+    register(registry);
+  }
+}
+function printSpecList(specIds: string[]): void {
+  if (!specIds.length) {
+    console.log('No test specs registered.');
+    return;
+  }
+  console.log('Registered test specs:');
+  for (const id of specIds) {
+    console.log(`- ${id}`);
+  }
+}

package/src/commands/test-data.command.ts

@@ -1,17 +1,17 @@
 import { Logger } from '@nestjs/common';
-import { Command, CommandRunner, Option } from 'nest-commander';
+import { SubCommand, CommandRunner, Option } from 'nest-commander';
 import { ModuleTestDataService } from 'src/seeders/module-test-data.service';
 
 interface TestDataCommandOptions {
-  loadData?: boolean;
+  load?: boolean;
   modulesToTest?: string;
-  createDatasources?: boolean;
-  deleteDatasources?: boolean;
+  setup?: boolean;
+  teardown?: boolean;
 }
 
-@Command({
-  name: 'test-data',
-  description: 'Seed test data from testData sections',
+@SubCommand({
+  name: 'data',
+  description: 'Seed test data from testing.data sections',
 })
 export class TestDataCommand extends CommandRunner {
   private readonly logger = new Logger(TestDataCommand.name);
@@ -22,38 +22,38 @@ export class TestDataCommand extends CommandRunner {
 
   async run(_passedParam: string[], options?: TestDataCommandOptions): Promise<void> {
     try {
-      const loadData = Boolean(options?.loadData);
-      const createDatasources = Boolean(options?.createDatasources);
-      const deleteDatasources = Boolean(options?.deleteDatasources);
+      const load = Boolean(options?.load);
+      const setup = Boolean(options?.setup);
+      const teardown = Boolean(options?.teardown);
 
-      const selectedModes = [loadData, createDatasources, deleteDatasources].filter(Boolean).length;
+      const selectedModes = [load, setup, teardown].filter(Boolean).length;
       if (selectedModes > 1) {
-        this.logger.error('Please specify only one of --load-data, --create-datasources, or --delete-datasources.');
-        console.log('Please specify only one of --load-data, --create-datasources, or --delete-datasources.');
+        this.logger.error('Please specify only one of --load, --setup, or --teardown.');
+        console.log('Please specify only one of --load, --setup, or --teardown.');
         return;
       }
 
-      if (!loadData && !createDatasources && !deleteDatasources) {
-        this.logger.error('Please specify one of --load-data, --create-datasources, or --delete-datasources.');
-        console.log('Please specify one of --load-data, --create-datasources, or --delete-datasources.');
+      if (!load && !setup && !teardown) {
+        this.logger.error('Please specify one of --load, --setup, or --teardown.');
+        console.log('Please specify one of --load, --setup, or --teardown.');
         return;
       }
 
-      if (deleteDatasources) {
+      if (teardown) {
         this.logger.log('Deleting test datasource environment and databases.');
         console.log('Deleting test datasource environment and databases.');
         await this.testDataService.deleteTestDatasources();
         return;
       }
 
-      if (createDatasources) {
+      if (setup) {
         this.logger.log('Creating test datasource environment file and manifest.');
         console.log('Creating test datasource environment file and manifest.');
         await this.testDataService.createTestDatasources();
         return;
       }
 
-      if (loadData) {
+      if (load) {
         const modulesToTest = options?.modulesToTest ? options.modulesToTest.split(',').map((m) => m.trim()).filter(Boolean) : null;
         if (modulesToTest?.length) {
           this.logger.log(`Test data setup for modules: ${modulesToTest.join(', ')}`);
@@ -77,26 +77,26 @@ export class TestDataCommand extends CommandRunner {
   }
 
   @Option({
-    flags: '--load-data',
-    description: 'Seed test data from testData sections',
+    flags: '--load',
+    description: 'Seed test data from testing.data sections',
   })
-  parseLoadData(): boolean {
+  parseLoad(): boolean {
     return true;
   }
 
   @Option({
-    flags: '--create-datasources',
+    flags: '--setup',
     description: 'Create a new .env.<dbRunName> and test datasource manifest',
   })
-  parseCreateDatasources(): boolean {
+  parseSetup(): boolean {
     return true;
   }
 
   @Option({
-    flags: '--delete-datasources',
+    flags: '--teardown',
     description: 'Delete test datasource env/manifest and drop test databases',
   })
-  parseDeleteDatasources(): boolean {
+  parseTeardown(): boolean {
     return true;
   }
 

package/src/commands/test.command.ts

@@ -0,0 +1,14 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { TestDataCommand } from './test-data.command';
+import { TestRunCommand } from './run-tests.command';
+
+@Command({
+  name: 'test',
+  description: 'Testing utilities.',
+  subCommands: [TestRunCommand, TestDataCommand],
+})
+export class TestCommand extends CommandRunner {
+  async run(): Promise<void> {
+    console.log('Usage: solidctl test <run|data> [options]');
+  }
+}

package/src/constants/error-messages.ts

@@ -5,6 +5,7 @@ export const ERROR_MESSAGES = {
     USER_NOT_FOUND: 'User does not exist.',
     USER_NOT_ACTIVE: 'User profile is not activated.',
     USER_INACTIVE: 'User is inactive.',
+    ACCOUNT_BLOCKED: 'Your account has been blocked due to multiple failed login attempts.',
     PASSWORD_INCORRECT: 'Password does not match.',
     PUBLIC_REGISTRATION_DISABLED: 'Public registrations are disabled.',
     UNIQUE_CONSTRAINT_VIOLATION: 'A unique constraint violation occurred.',

package/src/constants.ts

@@ -9,13 +9,13 @@ export const {
 } = new ConfigurableModuleBuilder<QueuesModuleOptions>().build();
 export const REQUEST_USER_KEY = 'user';
 
-export enum RegistrationValidationSource {
+export enum PasswordlessLoginValidateWhatSources {
   EMAIL = 'email',
   MOBILE = 'mobile',
-  TRANSACTIONAL = 'transactional',
+  SELECTABLE = 'selectable',
 }
 
-export enum TransactionalRegistrationValidationSource {
+export enum PasswordlessRegistrationValidateWhatSources {
   EMAIL = 'email',
   MOBILE = 'mobile',
 }

package/src/controllers/role-metadata.controller.ts

@@ -1,4 +1,4 @@
-import { Controller, Post, Body, Param, UploadedFiles, UseInterceptors, Put, Get, Query, Delete } from '@nestjs/common';
+import { Controller, Post, Body, Param, UploadedFiles, UseInterceptors, Put, Get, Query, Delete, Patch } from '@nestjs/common';
 import { AnyFilesInterceptor } from "@nestjs/platform-express";
 import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
 import { RoleMetadataService } from '../services/role-metadata.service';
@@ -7,31 +7,39 @@ import { UpdateRoleMetadataDto } from '../dtos/update-role-metadata.dto';
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
 
-@ApiTags('Solid Core') 
+@ApiTags('Solid Core')
 @Controller('role-metadata') //FIXME: Change this to the model plural name 
 export class RoleMetadataController {
-  constructor(private readonly service: RoleMetadataService) {}
+  constructor(private readonly service: RoleMetadataService) { }
 
   @ApiBearerAuth("jwt")
   @Post()
   @UseInterceptors(AnyFilesInterceptor())
-  create(@Body() createDto: CreateRoleMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
-    return this.service.create(createDto, files,solidRequestContext);
+  create(@Body() createDto: CreateRoleMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
+    return this.service.create(createDto, files, solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")
   @Post('/bulk')
   @UseInterceptors(AnyFilesInterceptor())
-  insertMany(@Body() createDtos: CreateRoleMetadataDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = [],@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
-    return this.service.insertMany(createDtos, filesArray,solidRequestContext);
+  insertMany(@Body() createDtos: CreateRoleMetadataDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = [], @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
+    return this.service.insertMany(createDtos, filesArray, solidRequestContext);
   }
 
 
   @ApiBearerAuth("jwt")
   @Put(':id')
   @UseInterceptors(AnyFilesInterceptor())
-  update(@Param('id') id: number, @Body() updateDto: UpdateRoleMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
-    return this.service.update(id, updateDto, files,false,solidRequestContext);
+  update(@Param('id') id: number, @Body() updateDto: UpdateRoleMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
+    return this.service.update(id, updateDto, files, false, solidRequestContext);
+  }
+
+
+  @ApiBearerAuth("jwt")
+  @Patch(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  partialUpdate(@Param('id') id: number, @Body() updateDto: UpdateRoleMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files, true);
   }
 
   @ApiBearerAuth("jwt")
@@ -40,31 +48,31 @@ export class RoleMetadataController {
   @ApiQuery({ name: 'limit', required: false, type: Number })
   @ApiQuery({ name: 'offset', required: false, type: Number })
   @ApiQuery({ name: 'fields', required: false, type: Array })
-  @ApiQuery({ name: 'sort', required: false, type: Array }) 
+  @ApiQuery({ name: 'sort', required: false, type: Array })
   @ApiQuery({ name: 'groupBy', required: false, type: Array })
   @ApiQuery({ name: 'populate', required: false, type: Array })
   @ApiQuery({ name: 'populateMedia', required: false, type: Array })
   @ApiQuery({ name: 'filters', required: false, type: Array })
   @Get()
-  async findMany(@Query() query: any,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) { 
-    return this.service.find(query,solidRequestContext);  
+  async findMany(@Query() query: any, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
+    return this.service.find(query, solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")
   @Get(':id')
-  async findOne(@Param('id') id: string, @Query() query: any,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
-    return this.service.findOne(+id, query,solidRequestContext);
+  async findOne(@Param('id') id: string, @Query() query: any, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
+    return this.service.findOne(+id, query, solidRequestContext);
   }
 
   @Delete('/bulk')
-  async deleteMany(@Body() ids: number[],@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
-    return this.service.deleteMany(ids,solidRequestContext);
+  async deleteMany(@Body() ids: number[], @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
+    return this.service.deleteMany(ids, solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")
   @Delete(':id')
-  async delete (@Param('id') id: number,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
-    return this.service.delete(id,solidRequestContext);
+  async delete(@Param('id') id: number, @SolidRequestContextDecorator() solidRequestContext: SolidRequestContextDto) {
+    return this.service.delete(id, solidRequestContext);
   }
 
 

package/src/controllers/service.controller.ts

@@ -26,7 +26,6 @@ export class ServiceController {
         private readonly mqMessageService: MqMessageService,
         private readonly errorMapper: ErrorMapperService,
         private readonly ingestMetadataService: IngestMetadataService,
-        
     ) { }
 
     @Public()
@@ -35,64 +34,64 @@ export class ServiceController {
         return { pong: 'v1.0.2' };
     }
 
-    @ApiBearerAuth("jwt")
-    @Get('mcp/ping')
-    async mcpPingPong(@ActiveUser() activeUser: ActiveUserData) {
-        // TODO: do a MCP client invocation, wait for response and return.
-        // If failure then decide shape to return.
-
-        const threadId = `pingPongTxn-${activeUser.sub}`;
-        const dto ={prompt:"Can you do 1 + 1", moduleName:"solidCoreModule"}
-        const { queueMessageId, aiInteractionId } = await this.aiInteractionService.triggerMcpClientJob(
-            dto,
-            activeUser.sub,
-            true,
-            threadId
-        );
-
-        this.logger.debug(`mcp ping pong job triggered: queueMessageId=${queueMessageId}, aiInteractionId=${aiInteractionId}`);
-
-        // Wait up to 2 minutes, start at 500ms poll, back off to max 2s, throw if failed:
-        const result = await this.mqMessageService.waitForTerminalStatus(queueMessageId, {
-            timeoutMs: 2 * 60 * 1000,
-            intervalMs: 500,
-            maxIntervalMs: 2000,
-            throwOnFailure: false,
-        });
-
-        this.logger.debug(`mcp ping pong job finished with stage=${result.stage}`)
-
-        this.logger.debug(`mcp ping pong trying to find genai (child) interaction for aiInteraction for id=${aiInteractionId}`)
-
-        // @ts-ignore
-        const genAiInteractions = await this.aiInteractionService.find({
-            filters: {
-                parentInteraction: {
-                    id: {
-                        $eq: aiInteractionId
-                    }
-                }
-            }
-        });
-
-        const genAiInteraction = genAiInteractions['records'][0];
-        this.logger.debug(genAiInteraction.message);
-
-        this.logger.debug(`identified gen-ai interaction with id=${genAiInteraction.id}`);
-        this.logger.debug(`proceeding with applying the gen-ai interaction`)
-
-        return {
-            mcpPong: 'v1.0.2',
-            genAiInteraction: {
-                status: genAiInteraction.status,
-                errorCode: genAiInteraction.status === 'failed' ? this.errorMapper.mapMessage(genAiInteraction.errorMessage, genAiInteraction.metadata) : '',
-                errorMessage: genAiInteraction.errorMessage,
-            }
-        };
-    }
+    // @ApiBearerAuth("jwt")
+    // @Get('mcp/ping')
+    // async mcpPingPong(@ActiveUser() activeUser: ActiveUserData) {
+    //     // TODO: do a MCP client invocation, wait for response and return.
+    //     // If failure then decide shape to return.
+
+    //     const threadId = `pingPongTxn-${activeUser.sub}`;
+    //     const dto = { prompt: "Can you do 1 + 1", moduleName: "solidCoreModule" }
+    //     const { queueMessageId, aiInteractionId } = await this.aiInteractionService.triggerMcpClientJob(
+    //         dto,
+    //         activeUser.sub,
+    //         true,
+    //         threadId
+    //     );
+
+    //     this.logger.debug(`mcp ping pong job triggered: queueMessageId=${queueMessageId}, aiInteractionId=${aiInteractionId}`);
+
+    //     // Wait up to 2 minutes, start at 500ms poll, back off to max 2s, throw if failed:
+    //     const result = await this.mqMessageService.waitForTerminalStatus(queueMessageId, {
+    //         timeoutMs: 2 * 60 * 1000,
+    //         intervalMs: 500,
+    //         maxIntervalMs: 2000,
+    //         throwOnFailure: false,
+    //     });
+
+    //     this.logger.debug(`mcp ping pong job finished with stage=${result.stage}`)
+
+    //     this.logger.debug(`mcp ping pong trying to find genai (child) interaction for aiInteraction for id=${aiInteractionId}`)
+
+    //     // @ts-ignore
+    //     const genAiInteractions = await this.aiInteractionService.find({
+    //         filters: {
+    //             parentInteraction: {
+    //                 id: {
+    //                     $eq: aiInteractionId
+    //                 }
+    //             }
+    //         }
+    //     });
+
+    //     const genAiInteraction = genAiInteractions['records'][0];
+    //     this.logger.debug(genAiInteraction.message);
+
+    //     this.logger.debug(`identified gen-ai interaction with id=${genAiInteraction.id}`);
+    //     this.logger.debug(`proceeding with applying the gen-ai interaction`)
+
+    //     return {
+    //         mcpPong: 'v1.0.2',
+    //         genAiInteraction: {
+    //             status: genAiInteraction.status,
+    //             errorCode: genAiInteraction.status === 'failed' ? this.errorMapper.mapMessage(genAiInteraction.errorMessage, genAiInteraction.metadata) : '',
+    //             errorMessage: genAiInteraction.errorMessage,
+    //         }
+    //     };
+    // }
 
-    @Public()
     // @SkipThrottle({ short: false, login: true, burst: true, sustained: true }) //Enable the short throttle only
+    @ApiBearerAuth("jwt")
     @Post('seed')
     async seedData(@Body() seedData: any) {
         const seeder = this.solidRegistry
@@ -111,7 +110,7 @@ export class ServiceController {
 
     @ApiBearerAuth("jwt")
     @Post('code-generation/post-process')
-    async postProcessCodeGeneration(@Body() config : PostProcessCodeGenConfig) {
+    async postProcessCodeGeneration(@Body() config: PostProcessCodeGenConfig) {
         // Set defaults if not provided
         config.runModuleMetadataSeeder = config.runModuleMetadataSeeder ?? true;
         config.runSolidIngestion = config.runSolidIngestion ?? true;
@@ -132,7 +131,7 @@ export class ServiceController {
         } else {
             this.logger.debug(`Skipping the Module Metadata Seeder Service as part of post-process code generation`);
         }
-        
+
         // Run the Solid ingestion command
         if (config.runSolidIngestion) {
             this.logger.debug(`Running the Solid ingestion command as part of post-process code generation`);