@solidxai/core 0.1.10-beta.8 → 0.1.10

package/src/controllers/gupshup-webhook.controller.ts

@@ -0,0 +1,91 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Logger,
+  Post,
+  Req,
+} from "@nestjs/common";
+import { ApiTags } from "@nestjs/swagger";
+import { Request } from "express";
+import { Auth } from "src/decorators/auth.decorator";
+import { Public } from "src/decorators/public.decorator";
+import { AuthType } from "src/enums/auth-type.enum";
+
+@Auth(AuthType.None)
+@Controller("webhook/whatsapp/gupshup")
+@ApiTags("Solid Core")
+export class GupshupWebhookController {
+  private readonly logger = new Logger(GupshupWebhookController.name);
+
+  @Public()
+  @Post()
+  @HttpCode(HttpStatus.OK)
+  async receiveWebhook(@Req() req: Request, @Body() body: unknown) {
+    const userAgent = req.headers["user-agent"] ?? null;
+    this.logger.log(
+      `Received Gupshup WhatsApp webhook${userAgent ? ` from ${userAgent}` : ""}`,
+    );
+    this.logger.debug(`Gupshup webhook payload: ${JSON.stringify(body)}`);
+
+    const statusInfo = this.extractStatusInfo(body);
+    if (statusInfo) {
+      this.logger.log(
+        `Gupshup delivery update: status=${statusInfo.status ?? "unknown"}, messageId=${statusInfo.messageId ?? "n/a"}, destination=${statusInfo.destination ?? "n/a"}, reason=${statusInfo.reason ?? "n/a"}`,
+      );
+    }
+
+    return {
+      success: true,
+      message: "Webhook received",
+    };
+  }
+
+  private extractStatusInfo(body: unknown): {
+    status?: string;
+    messageId?: string;
+    destination?: string;
+    reason?: string;
+  } | null {
+    if (!body || typeof body !== "object") {
+      return null;
+    }
+
+    const payload = body as Record<string, unknown>;
+
+    const status =
+      this.asString(payload.status) ||
+      this.asString(payload.messageStatus) ||
+      this.asString((payload.payload as Record<string, unknown>)?.status) ||
+      this.asString((payload.payload as Record<string, unknown>)?.type);
+
+    const messageId =
+      this.asString(payload.messageId) ||
+      this.asString(payload.id) ||
+      this.asString((payload.payload as Record<string, unknown>)?.id) ||
+      this.asString((payload.payload as Record<string, unknown>)?.messageId);
+
+    const destination =
+      this.asString(payload.destination) ||
+      this.asString(payload.phone) ||
+      this.asString((payload.payload as Record<string, unknown>)?.destination) ||
+      this.asString((payload.payload as Record<string, unknown>)?.phone);
+
+    const reason =
+      this.asString(payload.reason) ||
+      this.asString(payload.error) ||
+      this.asString((payload.payload as Record<string, unknown>)?.reason) ||
+      this.asString((payload.payload as Record<string, unknown>)?.error);
+
+    if (!status && !messageId && !destination && !reason) {
+      return null;
+    }
+
+    return { status, messageId, destination, reason };
+  }
+
+  private asString(value: unknown): string | undefined {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+  }
+}

package/src/controllers/mcp-audit-log.controller.ts

@@ -0,0 +1,70 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, UploadedFiles, UseInterceptors } from '@nestjs/common';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { CreateMcpAuditLogDto } from 'src/dtos/create-mcp-audit-log.dto';
+import { UpdateMcpAuditLogDto } from 'src/dtos/update-mcp-audit-log.dto';
+import { McpAuditLogService } from 'src/services/mcp-audit-log.service';
+
+@ApiTags('Solid Core')
+@Controller('mcp-audit-log')
+export class McpAuditLogController {
+  constructor(private readonly service: McpAuditLogService) {}
+
+  @ApiBearerAuth('jwt')
+  @Post()
+  @UseInterceptors(AnyFilesInterceptor())
+  create(@Body() createDto: CreateMcpAuditLogDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.create(createDto, files);
+  }
+
+  @ApiBearerAuth('jwt')
+  @Post('/bulk')
+  @UseInterceptors(AnyFilesInterceptor())
+  insertMany(@Body() createDtos: CreateMcpAuditLogDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = []) {
+    return this.service.insertMany(createDtos, filesArray);
+  }
+
+  @ApiBearerAuth('jwt')
+  @Put(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  update(@Param('id') id: number, @Body() updateDto: UpdateMcpAuditLogDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files);
+  }
+
+  @ApiBearerAuth('jwt')
+  @Patch(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  partialUpdate(@Param('id') id: number, @Body() updateDto: UpdateMcpAuditLogDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files, true);
+  }
+
+  @ApiBearerAuth('jwt')
+  @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: 'populate', required: false, type: Array })
+  @ApiQuery({ name: 'filters', required: false, type: Array })
+  @Get()
+  findMany(@Query() query: any) {
+    return this.service.find(query);
+  }
+
+  @ApiBearerAuth('jwt')
+  @Get(':id')
+  findOne(@Param('id') id: string, @Query() query: any) {
+    return this.service.findOne(+id, query);
+  }
+
+  @ApiBearerAuth('jwt')
+  @Delete('/bulk')
+  deleteMany(@Body() ids: number[]) {
+    return this.service.deleteMany(ids);
+  }
+
+  @ApiBearerAuth('jwt')
+  @Delete(':id')
+  delete(@Param('id') id: number) {
+    return this.service.delete(id);
+  }
+}

package/src/controllers/meta-cloud-whatsapp-webhook.controller.ts

@@ -0,0 +1,155 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Logger,
+  Post,
+  Query,
+  Res,
+} from "@nestjs/common";
+import { ApiTags } from "@nestjs/swagger";
+import { Response } from "express";
+import { Auth } from "src/decorators/auth.decorator";
+import { Public } from "src/decorators/public.decorator";
+import { AuthType } from "src/enums/auth-type.enum";
+import { SettingService } from "src/services/setting.service";
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
+
+@Auth(AuthType.None)
+@Controller("webhook/whatsapp/meta-cloud")
+@ApiTags("Solid Core")
+export class MetaCloudWhatsappWebhookController {
+  private readonly logger = new Logger(MetaCloudWhatsappWebhookController.name);
+
+  constructor(private readonly settingService: SettingService) {}
+
+  @Public()
+  @Get()
+  verifyWebhook(@Query() query: Record<string, unknown>, @Res() res: Response) {
+    const mode = this.resolveQueryValue(query, "hub.mode", "hub_mode", "mode");
+    const verifyToken = this.resolveQueryValue(
+      query,
+      "hub.verify_token",
+      "hub_verify_token",
+      "verify_token",
+    );
+    const challenge = this.resolveQueryValue(
+      query,
+      "hub.challenge",
+      "hub_challenge",
+      "challenge",
+    );
+
+    const configuredVerifyToken =
+      this.settingService.getConfigValue<SolidCoreSetting>(
+        "metaWhatsappWebhookVerifyToken",
+      ) || process.env.COMMON_META_WHATSAPP_WEBHOOK_VERIFY_TOKEN;
+
+    const isVerificationCall = mode === "subscribe";
+    const tokenMatches =
+      !!configuredVerifyToken && verifyToken === configuredVerifyToken;
+
+    if (isVerificationCall && tokenMatches && challenge) {
+      this.logger.log("Meta Cloud WhatsApp webhook verified successfully.");
+      res.writeHead(HttpStatus.OK, {
+        "Content-Type": "text/plain",
+        "Content-Length": Buffer.byteLength(String(challenge)),
+      });
+      res.write(String(challenge));
+      return res.end();
+    }
+
+    this.logger.warn(
+      `Meta Cloud webhook verification failed. mode=${mode ?? "n/a"}, tokenMatch=${tokenMatches}`,
+    );
+
+    res.writeHead(HttpStatus.FORBIDDEN, { "Content-Type": "text/plain" });
+    return res.end("Webhook verification failed");
+  }
+
+  @Public()
+  @Post()
+  @HttpCode(HttpStatus.OK)
+  async receiveWebhook(@Body() body: unknown) {
+    this.logger.log("Received Meta Cloud WhatsApp webhook");
+    this.logger.debug(`Meta Cloud webhook payload: ${JSON.stringify(body)}`);
+
+    const statusInfo = this.extractStatusInfo(body);
+    if (statusInfo) {
+      this.logger.log(
+        `Meta Cloud delivery update: status=${statusInfo.status ?? "unknown"}, messageId=${statusInfo.messageId ?? "n/a"}, destination=${statusInfo.destination ?? "n/a"}, reason=${statusInfo.reason ?? "n/a"}`,
+      );
+    }
+
+    return {
+      success: true,
+      message: "Webhook received",
+    };
+  }
+
+  private extractStatusInfo(body: unknown): {
+    status?: string;
+    messageId?: string;
+    destination?: string;
+    reason?: string;
+  } | null {
+    if (!body || typeof body !== "object") {
+      return null;
+    }
+
+    const payload = body as Record<string, unknown>;
+    const entries = payload.entry as Array<Record<string, unknown>> | undefined;
+    const changes = entries?.[0]?.changes as Array<Record<string, unknown>> | undefined;
+    const value = changes?.[0]?.value as Record<string, unknown> | undefined;
+    const statuses = value?.statuses as Array<Record<string, unknown>> | undefined;
+    const status = statuses?.[0];
+
+    if (!status) {
+      return null;
+    }
+
+    const errors = status.errors as Array<Record<string, unknown>> | undefined;
+
+    return {
+      status: this.asString(status.status),
+      messageId: this.asString(status.id),
+      destination: this.asString(status.recipient_id),
+      reason:
+        this.asString(errors?.[0]?.title) || this.asString(errors?.[0]?.message),
+    };
+  }
+
+  private asString(value: unknown): string | undefined {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+  }
+
+  private resolveQueryValue(
+    query: Record<string, unknown>,
+    ...keys: string[]
+  ): string | undefined {
+    for (const key of keys) {
+      const directValue = this.asString(query[key]);
+      if (directValue) {
+        return directValue;
+      }
+    }
+
+    const hubRaw = query.hub;
+    if (hubRaw && typeof hubRaw === "object" && !Array.isArray(hubRaw)) {
+      const hub = hubRaw as Record<string, unknown>;
+      for (const key of ["mode", "verify_token", "challenge"]) {
+        const value = this.asString(hub[key]);
+        if (
+          value &&
+          keys.some((candidate) => candidate.endsWith(key) || candidate === key)
+        ) {
+          return value;
+        }
+      }
+    }
+
+    return undefined;
+  }
+}

package/src/controllers/microsoft-active-directory-authentication.controller.ts

@@ -0,0 +1,104 @@
+import {
+  Controller,
+  Get,
+  InternalServerErrorException,
+  Query,
+  Req,
+  Res,
+  UseGuards,
+} from "@nestjs/common";
+import { ApiQuery, ApiTags } from "@nestjs/swagger";
+import { Request, Response } from "express";
+import {
+  DEFAULT_MICROSOFT_ACTIVE_DIRECTORY_OAUTH_TENANT,
+  MicrosoftActiveDirectoryAuthConfiguration,
+  isMicrosoftActiveDirectoryOAuthConfigured,
+} from "../helpers/microsoft-active-directory-oauth.helper";
+import { AuthenticationService } from "../services/authentication.service";
+import { SettingService } from "../services/setting.service";
+import { Public } from "src/decorators/public.decorator";
+import { Auth } from "../decorators/auth.decorator";
+import { AuthType } from "../enums/auth-type.enum";
+import { MicrosoftActiveDirectoryOauthGuard } from "../passport-strategies/microsoft-active-directory-oauth.strategy";
+import { UserService } from "../services/user.service";
+import type { SolidCoreSetting } from "../services/settings/default-settings-provider.service";
+
+@Auth(AuthType.None)
+@ApiTags("Solid Core")
+@Controller("iam/microsoft-active-directory")
+export class MicrosoftActiveDirectoryAuthenticationController {
+  constructor(
+    private readonly userService: UserService,
+    private readonly authService: AuthenticationService,
+    private readonly settingService: SettingService,
+  ) {}
+
+  private async getConfiguration(): Promise<MicrosoftActiveDirectoryAuthConfiguration> {
+    return {
+      clientID: this.settingService.getConfigValue<SolidCoreSetting>("MICROSOFT_ACTIVE_DIRECTORY_CLIENT_ID"),
+      clientSecret: this.settingService.getConfigValue<SolidCoreSetting>("MICROSOFT_ACTIVE_DIRECTORY_CLIENT_SECRET"),
+      tenant: this.settingService.getConfigValue<SolidCoreSetting>("MICROSOFT_ACTIVE_DIRECTORY_TENANT_ID" ) ?? DEFAULT_MICROSOFT_ACTIVE_DIRECTORY_OAUTH_TENANT,
+      callbackURL: this.settingService.getConfigValue<SolidCoreSetting>("MICROSOFT_ACTIVE_DIRECTORY_CALLBACK_URL"), 
+      redirectURL: this.settingService.getConfigValue<SolidCoreSetting>("MICROSOFT_ACTIVE_DIRECTORY_REDIRECT_URL"),
+    };
+  }
+
+  private buildFrontendRedirectUrl(redirectURL: string, accessCode: string) {
+    const separator = redirectURL.includes("?") ? "&" : "?";
+    return `${redirectURL}${separator}accessCode=${encodeURIComponent(accessCode)}`;
+  }
+
+  private async validateConfiguration() {
+    const config = await this.getConfiguration();
+    if (!isMicrosoftActiveDirectoryOAuthConfigured(config)) {
+      throw new InternalServerErrorException("Microsoft Active Directory OAuth is not configured");
+    }
+    return config;
+  }
+
+  @Public()
+  @UseGuards(MicrosoftActiveDirectoryOauthGuard)
+  @Get("connect")
+  async connect() {
+    await this.validateConfiguration();
+  }
+
+  @Public()
+  @Get("connect/callback")
+  @UseGuards(MicrosoftActiveDirectoryOauthGuard)
+  async microsoftActiveDirectoryAuthCallback(
+    @Req() req: Request,
+    @Res() res: Response,
+  ) {
+    const config = await this.validateConfiguration();
+    const user = req.user;
+    return res.redirect(
+      this.buildFrontendRedirectUrl(config.redirectURL, user["accessCode"]),
+    );
+  }
+
+  @Public()
+  @Get("dummy-redirect")
+  async dummyMicrosoftActiveDirectoryAuthRedirect(
+    @Query("accessCode") accessCode,
+  ) {
+    await this.validateConfiguration();
+    const user = await this.userService.findOneByAccessCode(accessCode);
+
+    if (user) {
+      delete user["password"];
+    }
+
+    return user;
+  }
+
+  @Public()
+  @Get("authenticate")
+  @ApiQuery({ name: "accessCode", required: true, type: String })
+  async microsoftActiveDirectoryAuth(
+    @Query("accessCode") accessCode: string,
+  ) {
+    await this.validateConfiguration();
+    return this.authService.signInUsingMicrosoftActiveDirectory(accessCode);
+  }
+}

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

@@ -92,7 +92,7 @@ export class ModelMetadataController {
     @ApiBearerAuth("jwt")
     @Post(':id/generate-code')
     generateCode(@Param('id', ParseIntPipe) id: number) {
-        return this.modelMetadataService.handleGenerateCode({ modelId: id });
+        return this.modelMetadataService.generateCodeViaCtl(id);
     }
 
     @ApiBearerAuth("jwt")

package/src/controllers/module-metadata-explorer.controller.ts

@@ -0,0 +1,83 @@
+import { Body, Controller, Get, Param, Post, Put, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { MetadataExplorerReferencesQueryDto } from '../dtos/metadata-explorer-references-query.dto';
+import { MetadataExplorerSearchQueryDto } from '../dtos/metadata-explorer-search-query.dto';
+import { MetadataExplorerWriteDto } from '../dtos/metadata-explorer-write.dto';
+import { ModuleMetadataExplorerService } from '../services/module-metadata-explorer.service';
+
+@ApiTags('Solid Core')
+@ApiBearerAuth('jwt')
+@Controller('module-metadata-explorer')
+export class ModuleMetadataExplorerController {
+    constructor(
+        private readonly moduleMetadataExplorerService: ModuleMetadataExplorerService,
+    ) { }
+
+    @Get(':moduleName/manifest')
+    async getManifest(@Param('moduleName') moduleName: string) {
+        return this.moduleMetadataExplorerService.getManifest(moduleName);
+    }
+
+    @Get(':moduleName/document')
+    async getDocument(@Param('moduleName') moduleName: string) {
+        return this.moduleMetadataExplorerService.getDocument(moduleName);
+    }
+
+    @Put(':moduleName/document')
+    async updateDocument(
+        @Param('moduleName') moduleName: string,
+        @Body() body: MetadataExplorerWriteDto,
+    ) {
+        return this.moduleMetadataExplorerService.updateDocument(moduleName, body);
+    }
+
+    @Post(':moduleName/document/validate')
+    async validateDocument(
+        @Param('moduleName') moduleName: string,
+        @Body() body: MetadataExplorerWriteDto,
+    ) {
+        return this.moduleMetadataExplorerService.validateDocument(moduleName, body);
+    }
+
+    @Get(':moduleName/sections/:sectionKey')
+    async getSection(
+        @Param('moduleName') moduleName: string,
+        @Param('sectionKey') sectionKey: string,
+    ) {
+        return this.moduleMetadataExplorerService.getSection(moduleName, sectionKey);
+    }
+
+    @Put(':moduleName/sections/:sectionKey')
+    async updateSection(
+        @Param('moduleName') moduleName: string,
+        @Param('sectionKey') sectionKey: string,
+        @Body() body: MetadataExplorerWriteDto,
+    ) {
+        return this.moduleMetadataExplorerService.updateSection(moduleName, sectionKey, body);
+    }
+
+    @Post(':moduleName/sections/:sectionKey/validate')
+    async validateSection(
+        @Param('moduleName') moduleName: string,
+        @Param('sectionKey') sectionKey: string,
+        @Body() body: MetadataExplorerWriteDto,
+    ) {
+        return this.moduleMetadataExplorerService.validateSection(moduleName, sectionKey, body);
+    }
+
+    @Get(':moduleName/search')
+    async search(
+        @Param('moduleName') moduleName: string,
+        @Query() query: MetadataExplorerSearchQueryDto,
+    ) {
+        return this.moduleMetadataExplorerService.search(moduleName, query);
+    }
+
+    @Get(':moduleName/references')
+    async findReferences(
+        @Param('moduleName') moduleName: string,
+        @Query() query: MetadataExplorerReferencesQueryDto,
+    ) {
+        return this.moduleMetadataExplorerService.findReferences(moduleName, query);
+    }
+}

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

@@ -62,7 +62,13 @@ export class ModuleMetadataController {
   @ApiBearerAuth("jwt")
   @Post(':id/generate-code')
   generateCode(@Param('id', ParseIntPipe) id: number) {
-    return this.moduleMetadataService.generateCode({ moduleId: id });
+    return this.moduleMetadataService.generateCodeViaCtl(id);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post(':id/seed')
+  seedModule(@Param('id', ParseIntPipe) id: number) {
+    return this.moduleMetadataService.seedModuleFromMetadata(id);
   }
  
 

package/src/controllers/module-package.controller.ts

@@ -0,0 +1,102 @@
+import {
+    Controller,
+    Get,
+    Param,
+    Post,
+    Body,
+    Res,
+    UploadedFiles,
+    UseInterceptors,
+} from '@nestjs/common';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { Response } from 'express';
+import { ConfirmModulePackageImportDto } from 'src/dtos/confirm-module-package-import.dto';
+import { RunModulePackageBuildDto } from 'src/dtos/run-module-package-build.dto';
+import { RunModulePackageSeedDto } from 'src/dtos/run-module-package-seed.dto';
+import { ModulePackageService } from 'src/services/module-package.service';
+
+@Controller('module-packages')
+@ApiTags('Solid Core')
+export class ModulePackageController {
+    constructor(
+        private readonly modulePackageService: ModulePackageService,
+    ) { }
+
+    @ApiBearerAuth('jwt')
+    @Post('import/validate')
+    @UseInterceptors(AnyFilesInterceptor())
+    async validateImportPackage(
+        @UploadedFiles() files: Array<Express.Multer.File>,
+    ) {
+        return this.modulePackageService.validateUpload(files?.[0]);
+    }
+
+    @ApiBearerAuth('jwt')
+    @Get('export/:moduleName')
+    async exportModulePackage(
+        @Param('moduleName') moduleName: string,
+        @Res() res: Response,
+    ) {
+        const archive = await this.modulePackageService.exportModulePackage(moduleName);
+        res.setHeader('Content-Disposition', `attachment; filename="${archive.fileName}"`);
+        res.setHeader('Content-Type', archive.mimeType);
+        res.setHeader('Access-Control-Expose-Headers', 'Content-Disposition, Content-Type');
+        res.sendFile(archive.filePath);
+    }
+
+    @ApiBearerAuth('jwt')
+    @Get('import/resumable/latest')
+    async getLatestResumableImport() {
+        return this.modulePackageService.getLatestResumableImport();
+    }
+
+    @ApiBearerAuth('jwt')
+    @Post('runtime/clear')
+    async clearPackageRuntime() {
+        return this.modulePackageService.clearPackageRuntime();
+    }
+
+    @ApiBearerAuth('jwt')
+    @Post('import/:id/confirm')
+    async confirmImport(
+        @Param('id') id: string,
+        @Body() dto: ConfirmModulePackageImportDto,
+    ) {
+        return this.modulePackageService.confirmImport(id, dto);
+    }
+
+    @ApiBearerAuth('jwt')
+    @Post('import/:id/dismiss')
+    async dismissImport(
+        @Param('id') id: string,
+    ) {
+        return this.modulePackageService.dismissImport(id);
+    }
+
+    @ApiBearerAuth('jwt')
+    @Get('import/:id/status')
+    async getImportStatus(
+        @Param('id') id: string,
+    ) {
+        return this.modulePackageService.getStatus(id);
+    }
+
+    @ApiBearerAuth('jwt')
+    @Post('import/:id/build')
+    async runBuild(
+        @Param('id') id: string,
+        @Body() dto: RunModulePackageBuildDto,
+    ) {
+        return this.modulePackageService.runBuild(id, dto);
+    }
+
+    @ApiBearerAuth('jwt')
+    @Post('import/:id/seed')
+    async runSeed(
+        @Param('id') id: string,
+        @Body() dto: RunModulePackageSeedDto,
+    ) {
+        return this.modulePackageService.runSeed(id, dto);
+    }
+}

package/src/controllers/service.controller.ts

@@ -4,8 +4,6 @@ import { ActiveUser } from 'src/decorators/active-user.decorator';
 import { Public } from 'src/decorators/public.decorator';
 import { ErrorMapperService } from 'src/helpers/error-mapper.service';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
-import { AiInteractionService } from 'src/services/ai-interaction.service';
-import { IngestMetadataService } from 'src/services/genai/ingest-metadata.service';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { SolidRegistry } from '../helpers/solid-registry';
 
@@ -22,10 +20,8 @@ export class ServiceController {
 
     constructor(
         private readonly solidRegistry: SolidRegistry,
-        private readonly aiInteractionService: AiInteractionService,
         private readonly mqMessageService: MqMessageService,
         private readonly errorMapper: ErrorMapperService,
-        private readonly ingestMetadataService: IngestMetadataService,
     ) { }
 
     @Public()
@@ -94,18 +90,19 @@ export class ServiceController {
     @ApiBearerAuth("jwt")
     @Post('seed')
     async seedData(@Body() seedData: any) {
+        const seederName = seedData?.seeder ?? 'ModuleMetadataSeederService';
         const seeder = this.solidRegistry
             .getSeeders()
-            .filter((seeder) => seeder.name === seedData.seeder)
+            .filter((seeder) => seeder.name === seederName)
             .map((seeder) => seeder.instance)
             .pop();
         if (!seeder) {
-            this.logger.error(`Seeder service ${seedData.seeder} not found. Does your service have a seed() method?`);
+            this.logger.error(`Seeder service ${seederName} not found. Does your service have a seed() method?`);
             return;
         }
         this.logger.log(`Running the seed() method for seeder :${seeder.constructor.name}`);
         await seeder.seed();
-        return { message: `seed data for ${seedData.seeder}` };
+        return { message: `seed data for ${seederName}` };
     }
 
     @ApiBearerAuth("jwt")