@solidxai/core 0.0.2

package/src/commands/remove-fields.command.ts

@@ -0,0 +1,67 @@
+import { BadRequestException, Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { CodeGenerationOptions } from '../interfaces';
+
+interface CommandOptions {
+  fieldIds: number[];
+  modelId: number;
+  dryRun: boolean;
+}
+
+@Command({
+  name: 'remove-fields',
+  description: 'Removes fields from a model',
+})
+export class RemoveFieldsCommand extends CommandRunner {
+  constructor(
+    private readonly modelMetadataService: ModelMetadataService,
+  ) {
+    super();
+  }
+  private readonly logger = new Logger(RemoveFieldsCommand.name);
+
+  async run(_passedParam: string[], options?: CommandOptions): Promise<void> {
+
+    const codeGenerationOptions: CodeGenerationOptions = {
+      modelId: options.modelId,
+      fieldIdsForRemoval: options.fieldIds,
+      dryRun: options.dryRun,
+    };
+
+    await this.modelMetadataService.generateRemoveFieldsCode(codeGenerationOptions);
+  }
+
+  @Option({
+    flags: '-fids, --fieldIds [Array of field IDs]',
+    description: 'Json array of Field IDs from the ss_field_metadata table',
+    required: true,
+  })
+  parseFieldIds(val: string): number[] {
+    //Check if the value is a json array
+    if (!val.startsWith('[') || !val.endsWith(']')) {
+      throw new BadRequestException('Field IDs should be a json array');
+    }
+    return JSON.parse(val).map((id: string) => parseInt(id));
+  }
+
+  @Option({
+    flags: '-mid, --modelId [model ID]',
+    description: 'Model id from the ss_model_metadata table',
+    required: true,
+  })
+  parseModelId(val: string): number {
+    return +val;
+  }
+
+  @Option({
+    flags: '-d, --dryRun [dry run]',
+    description: 'Dry run the command',
+  })
+  parseDryRun(val: string): boolean {
+    this.logger.debug(`Dry run : ${val}`);
+    return (val === 'false') ? false : true;
+  }
+
+
+}

package/src/commands/seed.command.ts

@@ -0,0 +1,68 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+
+interface SeedCommandOptions {
+  seeder?: string;
+  modulesToSeed?: string;
+  prune?: boolean;
+}
+
+@Command({ name: 'seed', description: 'Install seed data for a given module' })
+export class SeedCommand extends CommandRunner {
+  private readonly logger = new Logger(SeedCommand.name);
+
+  constructor(private readonly solidRegistry: SolidRegistry) {
+    super();
+  }
+
+  async run(passedParam: string[], options?: SeedCommandOptions): Promise<void> {
+    let parsedConf: any = null;
+    if (options?.modulesToSeed) {
+      const modulesToSeed = options.modulesToSeed
+        .split(',')
+        .map((m) => m.trim())
+        .filter(Boolean);
+      parsedConf = { modulesToSeed };
+      this.logger.log(`Modules to seed: ${modulesToSeed.join(', ')}`);
+    } else {
+      this.logger.log('No --modules-to-seed flag provided. Running with default seeder behavior.');
+    }
+
+    if (options?.prune) {
+      parsedConf = parsedConf ?? {};
+      parsedConf.pruneMetadata = true;
+    }
+
+    const seeder = this.solidRegistry
+      .getSeeders()
+      .filter((seeder) => seeder.name === options.seeder)
+      .map((seeder) => seeder.instance)
+      .pop();
+    if (!seeder) {
+      this.logger.error(`Seeder service ${options.seeder} 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(parsedConf);
+  }
+
+  /**
+   * This parameter will be useful, to support seeders with the same name in different modules
+   * Currently the seeder service won't support seeder with same classname within a module
+   **/
+  @Option({ flags: '-m, --modules-to-seed [module names]', description: 'Comma-separated list of module names to seed.', required: false })
+  parseModulesToSeed(val: string): string {
+    return val;
+  }
+
+  @Option({ flags: '-s, --seeder [seeder name]', description: 'The seeder to run.', required: true, defaultValue: 'ModuleMetadataSeederService' })
+  parseString(val: string): string {
+    return val;
+  }
+
+  @Option({ flags: '--prune', description: 'Prune metadata not present in JSON.' })
+  parsePrune(): boolean {
+    return true;
+  }
+}

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

@@ -0,0 +1,112 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { ModuleTestDataService } from 'src/seeders/module-test-data.service';
+
+interface TestDataCommandOptions {
+  loadData?: boolean;
+  modulesToTest?: string;
+  createDatasources?: boolean;
+  deleteDatasources?: boolean;
+}
+
+@Command({
+  name: 'test-data',
+  description: 'Seed test data from testData sections',
+})
+export class TestDataCommand extends CommandRunner {
+  private readonly logger = new Logger(TestDataCommand.name);
+
+  constructor(private readonly testDataService: ModuleTestDataService) {
+    super();
+  }
+
+  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 selectedModes = [loadData, createDatasources, deleteDatasources].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.');
+        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.');
+        return;
+      }
+
+      if (deleteDatasources) {
+        this.logger.log('Deleting test datasource environment and databases.');
+        console.log('Deleting test datasource environment and databases.');
+        await this.testDataService.deleteTestDatasources();
+        return;
+      }
+
+      if (createDatasources) {
+        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) {
+        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(', ')}`);
+          console.log(`Test data setup for modules: ${modulesToTest.join(', ')}`);
+        } else {
+          this.logger.log('Test data setup for all modules.');
+          console.log('Test data setup for all modules.');
+        }
+        await this.testDataService.setupTestData(modulesToTest ?? undefined);
+        return;
+      }
+    } catch (err: any) {
+      const message = err?.message ?? String(err);
+      this.logger.error(message);
+      console.error(`Test data command failed: ${message}`);
+      if (err?.stack) {
+        console.error(err.stack);
+      }
+      throw err;
+    }
+  }
+
+  @Option({
+    flags: '--load-data',
+    description: 'Seed test data from testData sections',
+  })
+  parseLoadData(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--create-datasources',
+    description: 'Create a new .env.<dbRunName> and test datasource manifest',
+  })
+  parseCreateDatasources(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--delete-datasources',
+    description: 'Delete test datasource env/manifest and drop test databases',
+  })
+  parseDeleteDatasources(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--modules-to-test [module names]',
+    description: 'Comma-separated list of module names to test (defaults to all modules).',
+    required: false,
+  })
+  parseModulesToTest(val: string): string {
+    return val;
+  }
+
+}

package/src/config/cache.options.ts

@@ -0,0 +1,34 @@
+import { CacheModuleAsyncOptions } from '@nestjs/cache-manager';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { redisStore } from 'cache-manager-redis-store';
+import { isRedisConfigured } from 'src/helpers/environment.helper';
+
+export const CacheManagerOptions: CacheModuleAsyncOptions = {
+    isGlobal: true,
+    imports: [ConfigModule],
+    useFactory: async (configService: ConfigService) => {
+
+        // This defaults to in-memory cache
+        if (!isRedisConfigured(configService)) {
+            return {
+                ttl: 0
+            }
+        }
+
+        // If redis is configured we use that...
+        const store = await createRedisStore(configService);
+        return {
+            store: () => store,
+        };
+    },
+    inject: [ConfigService],
+};
+
+async function createRedisStore(configService: ConfigService<Record<string, unknown>, false>) {
+    return await redisStore({
+        socket: {
+            host: configService.get<string>('REDIS_HOST'),
+            port: parseInt(configService.get<string>('REDIS_PORT')!),
+        },
+    });
+}

package/src/constants/chatter-message.constants.ts

@@ -0,0 +1,11 @@
+export const CHATTER_MESSAGE_TYPE = {
+    AUDIT: 'audit',
+    CUSTOM: 'custom',
+} as const;
+
+export const CHATTER_MESSAGE_SUBTYPE = {
+    AUDIT_INSERT: 'audit_insert',
+    AUDIT_UPDATE: 'audit_update',
+    AUDIT_DELETE: 'audit_delete',
+    CUSTOM: 'custom',
+} as const;

package/src/constants/error-messages.ts

@@ -0,0 +1,132 @@
+// backend/common/constants/error-messages.ts
+
+export const ERROR_MESSAGES = {
+    //authentication errors
+    USER_NOT_FOUND: 'User does not exist.',
+    USER_NOT_ACTIVE: 'User profile is not activated.',
+    USER_INACTIVE: 'User is inactive.',
+    PASSWORD_INCORRECT: 'Password does not match.',
+    PUBLIC_REGISTRATION_DISABLED: 'Public registrations are disabled.',
+    UNIQUE_CONSTRAINT_VIOLATION: 'A unique constraint violation occurred.',
+    PASSWORDLESS_REGISTRATION_DISABLED: 'Passwordless registration is not enabled.',
+    REGISTRATION_REQUIRES_CONTACT: 'Either mobile or email is required for initiating registration.',
+    EMAIL_REQUIRED_FOR_VALIDATION: 'Email is required for email validation source.',
+    MOBILE_REQUIRED_FOR_VALIDATION: 'Mobile is required for mobile validation source.',
+    USER_ALREADY_EXISTS: 'User already exists. Please sign in.',
+    VALIDATION_SOURCE_REQUIRED: 'At least one validation source is required.',
+    INVALID_OTP: 'Invalid OTP.',
+    OTP_EXPIRED: 'OTP has expired.',
+    INVALID_VERIFICATION_TYPE: 'Invalid type. Must be either email or mobile.',
+    NON_LOCAL_PROVIDER: 'User seems to have used a passwordless mode to authenticate.',
+    USER_ID_MISMATCH: "User ID's do not match.",
+    USERNAME_MISMATCH: "User username's do not match.",
+    INCORRECT_CURRENT_PASSWORD: 'Incorrect current password specified.',
+    PASSWORD_REUSED: 'Try a different password',
+    INVALID_VERIFICATION_TOKEN: 'Invalid verification token',
+    INVALID_REFRESH_TOKEN: 'Invalid refresh token',
+    ACCESS_DENIED: 'Access denied',
+    INVALID_USER_PROFILE: 'Invalid user profile',
+    GOOGLE_OAUTH_PROFILE_FETCH_FAILED: 'Failed to fetch user profile from Google OAuth service',
+    LOGOUT_FAILED: 'Logout failed due to an unexpected error.',
+
+    INVALID_CREDENTIALS: 'Invalid credentials',
+    LOGIN_FAILED: 'Login Failed',
+    OLD_PASSWORD_INCORRECT: 'You have specified an incorrect old password.',
+    INVALID_NEW_PASSWORD: 'Invalid new password.',
+    PASSWORDS_DO_NOT_MATCH: 'New passwords are not matching.',
+
+    // user management errors
+    DELETE_SELF_NOT_ALLOWED: 'Deleting logged-in user is not allowed.',
+    DELETE_IDS_REQUIRED: 'At least one ID is required for deletion.',
+    USER_MISSING_ID: 'User must exist before initializing roles.',
+    ROLES_NOT_FOUND: (roles: string[]) => `The following roles were not found: ${roles.join(', ')}`,
+    USER_NOT_FOUND_BY_USERNAME: (username: string) => `User with username '${username}' not found.`,
+    ROLE_NOT_FOUND: (roleName: string) => `Role '${roleName}' not found.`,
+    PERMISSION_NOT_EXIST: (permission: string) => `Permission '${permission}' does not exist.`,
+
+    // session errors
+    SESSION_INVALID: 'Your session is no longer valid. Please log in again.',
+    SESSION_EXPIRED: 'Your session has expired. Please log in again.',
+
+    // filter errors
+    GROUP_BY_LIMIT: 'buildFilterQuery: Only 1 Group by field is supported currently.',
+    INVALID_GROUP_BY_COUNT: 'Exactly one groupBy field is required to count grouped records.',
+
+    // general errors
+    FORBIDDEN: 'Forbidden',
+
+
+    // database errors
+    DUPLICATE_ENTRY: 'Duplicate entry. A record with similar unique fields already exists.',
+
+    // validation errors
+    ID_REQUIRED_FOR_UPDATE: 'Id is required for update.',
+    ID_REQUIRED_FOR_DELETE: 'Id is required for deletion.',
+
+    // CRUD service errors
+    RELATION_TYPE_NOT_SUPPORTED: 'Relation type not supported in CRUD service.',
+    NO_SOFT_DELETED_RECORD_FOUND: 'No soft-deleted record found with the given ID.',
+    CONFLICTING_RECORD_ON_UNARCHIVE: 'Another record is conflicting with the record you are attempting to Un-Archive, either delete or change the other record so as to avoid this conflict.',
+    NO_SOFT_DELETED_RECORDS_FOUND: 'No matching soft-deleted records found.',
+    EMPTY_PATH_PARTS: 'Path parts cannot be empty',
+
+
+    // CSV/Excel service errors
+    MISSING_HEADERS_OR_FUNCTION: 'Either headers or data records function must be provided.',
+    INVALID_CHUNK_SIZE: 'Chunk size must be greater than 0 when data records function is provided.',
+    INVALID_FORMAT: (format: string) => `Invalid ${format} format`,
+
+
+    //field errors
+    INVALID_INVERSE_FIELD_TYPE: 'Only relation fields can have inverse fields.',
+    MODEL_AND_MODULE_REQUIRED_TO_UPDATE_INVERSE_FIELD: 'Model and module are required to update inverse field.',
+    MODEL_NAME_AND_MODULE_NAME_REQUIRED_TO_CREATE_INVERSE_FIELD: 'Model name and module name are required to create inverse field.',
+    FIELD_NOT_FOUND: (id: number | string) => `No field with id #${id} exists`,
+    PROVIDER_NOT_FOUND: (provider: string) => `Field incorrectly configured. No provider with name ${provider} registered in backend.`,
+    FILE_WRITE_FAILED: 'File creation failed, rolling back transaction',
+    FILE_DELETE_FAILED: 'File deletion failed, rolling back transaction',
+    // file service errors
+    FILE_NOT_FOUND: 'File not found',
+    FILE_COPY_ERROR: 'Error copying file',
+    S3_CLIENT_NOT_INITIALIZED: 'S3 Client not initialized. Please check the S3 configuration.',
+
+    // model errors
+    MODEL_METADATA_NOT_FOUND: (id: string | number) => `Model metadata with ID ${id} not found.`,
+    MODEL_SERVICE_NOT_FOUND: (model: string) => `Model service for ${model} not found.`,
+    RELATION_CO_MODEL_NOT_DEFINED_FOR_FIELD: (fieldName: string) => `Relation coModelSingularName is not defined for relation field ${fieldName}`,
+    MODEL_NOT_FOUND: (singularName?: string) => `Model${singularName ? ` with singular name "${singularName}"` : ''} not found.`,
+    MODEL_REQUIRED_FOR_CODE_GENERATION: 'Model ID or Model Name is required for generating code.',
+
+    //module errors
+    MODULE_NOT_FOUND: (moduleName: string) => `Module with name ${moduleName} not found.`,
+    MODULE_ID_NOT_FOUND: (id: string | number) => `Module with ID ${id} not found.`,
+
+    //entity errors
+    ENTITY_NOT_FOUND: (entity?: string | number) => `Entity${entity ? ' ' + entity : ''} not found.`,
+    ENTITY_NAME_REQUIRED: 'Entity name is required to find the entity.',
+    ENTITY_ID_REQUIRED: 'Entity ID is required to find the entity.',
+
+    // import errors
+    NO_ERROR_LOG_FOR_IMPORT: (id: string | number) => `No error log entries found for import transaction ID ${id}.`,
+    FILE_READ_FAILED_FROM_URL: (url: string) => `Failed to read file from URL: ${url}`,
+
+    // media storage provider errors
+    MEDIA_STORAGE_PROVIDER_ID_NOT_FOUND: (id: number | string) => `Media Storage Provider with #${id} not found.`,
+    MEDIA_STORAGE_PROVIDER_NOT_FOUND: 'Media Storage Provider not found',
+
+    // SQL errors
+    UNSUPPORTED_SQL_OPERATOR: (operator: string) => `Unsupported SQL operator: ${operator}`,
+
+    // AI interaction errors
+    PYTHON_EXECUTABLE_NOT_CONFIGURED: 'SolidX AI MCP python executable or client path not configured.',
+    UNABLE_TO_RESOLVE_SOLID_COMMAND: 'Unable to resolve a solid_ command that was used to come up with this response.',
+    UNABLE_TO_RESOLVE_MCP_HANDLER: 'Unable to resolve a mcp tool handler.',
+
+    DEFAULT_REGEX_PATTERN_NOT_MATCHING_ERROR_MSG: 'Invalid regex pattern.',
+
+    PERMISSION_MESSAGES: {
+    insertMany: (model?: string) =>
+      `You do not have permission to import ${model ?? 'these'} records.`,
+    } as Record<string, (model?: string) => string>,
+
+};

package/src/constants/success-messages.ts

@@ -0,0 +1,13 @@
+export const SUCCESS_MESSAGES = {
+    OTP_SENT_SUCCESS_REGISTRATION: 'User registration initiated. OTP sent to the user.',
+    OTP_SENT_SUCCESS_LOGIN: 'User login initiated. OTP sent to the user.',
+    FORGOT_PASSWORD_TOKEN_SENT: 'Forgot password - token generated and sent.',
+    FORGOT_PASSWORD_CONFIRMED: 'Forgot password confirmed.',
+    LOGOUT_SUCCESS: 'Logged out successfully',
+    USER_REGISTERED: 'User registered successfully.',
+
+    // CRUD service messages
+    RECORD_RECOVERED: 'Record successfully recovered',
+    SELECTED_RECORDS_RECOVERED: 'Selected records successfully recovered',
+
+};

package/src/constants.ts

@@ -0,0 +1,28 @@
+import { ConfigurableModuleBuilder } from '@nestjs/common';
+import { QueuesModuleOptions } from './interfaces';
+
+export const {
+  ConfigurableModuleClass,
+  MODULE_OPTIONS_TOKEN: QUEUES_MODULE_OPTION_TOKEN,
+  OPTIONS_TYPE,
+  ASYNC_OPTIONS_TYPE,
+} = new ConfigurableModuleBuilder<QueuesModuleOptions>().build();
+export const REQUEST_USER_KEY = 'user';
+
+export enum RegistrationValidationSource {
+  EMAIL = 'email',
+  MOBILE = 'mobile',
+  TRANSACTIONAL = 'transactional',
+}
+
+export enum TransactionalRegistrationValidationSource {
+  EMAIL = 'email',
+  MOBILE = 'mobile',
+}
+
+export enum ForgotPasswordSendVerificationTokenOn {
+  EMAIL = 'email',
+  MOBILE = 'mobile',
+}
+
+export const SOLID_CORE_MODULE_NAME = 'solid-core';

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

@@ -0,0 +1,68 @@
+import { Controller, Post, Body, Param, UploadedFiles, UseInterceptors, Put, Get, Query, Delete } from '@nestjs/common';
+import { AnyFilesInterceptor } from "@nestjs/platform-express";
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { ActionMetadataService } from '../services/action-metadata.service';
+import { CreateActionMetadataDto } from '../dtos/create-action-metadata.dto';
+import { UpdateActionMetadataDto } from '../dtos/update-action-metadata.dto';
+import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
+import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
+
+@ApiTags('App Builder')
+@Controller('action-metadata') //FIXME: Change this to the model plural name 
+export class ActionMetadataController {
+  constructor(private readonly service: ActionMetadataService) { }
+
+  @ApiBearerAuth("jwt")
+  @Post()
+  @UseInterceptors(AnyFilesInterceptor())
+  create(@Body() createDto: CreateActionMetadataDto, @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: CreateActionMetadataDto[], @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: UpdateActionMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.update(id, updateDto, files,false,solidRequestContext);
+  }
+
+  @ApiBearerAuth("jwt")
+  @ApiQuery({ name: 'showSoftDeleted', required: false, type: Boolean })
+  @ApiQuery({ name: 'showOnlySoftDeleted', required: false, type: Boolean })
+  @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: '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);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get(':id')
+  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);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete(':id')
+  async delete(@Param('id') id: number,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.delete(id,solidRequestContext);
+  }
+}

package/src/controllers/ai-interaction.controller.ts

@@ -0,0 +1,112 @@
+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 { AiInteractionService } from '../services/ai-interaction.service';
+import { CreateAiInteractionDto } from '../dtos/create-ai-interaction.dto';
+import { UpdateAiInteractionDto } from '../dtos/update-ai-interaction.dto';
+import { InvokeAiPromptDto } from '../dtos/invoke-ai-prompt.dto';
+import { ActiveUser } from 'src/decorators/active-user.decorator';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+
+enum ShowSoftDeleted {
+  INCLUSIVE = "inclusive",
+  EXCLUSIVE = "exclusive",
+}
+
+@ApiTags('Solid Core')
+@Controller('ai-interaction')
+export class AiInteractionController {
+  constructor(private readonly service: AiInteractionService) { }
+
+  @ApiBearerAuth("jwt")
+  @Post()
+  @UseInterceptors(AnyFilesInterceptor())
+  create(@Body() createDto: CreateAiInteractionDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.create(createDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/bulk')
+  @UseInterceptors(AnyFilesInterceptor())
+  insertMany(@Body() createDtos: CreateAiInteractionDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = []) {
+    return this.service.insertMany(createDtos, filesArray);
+  }
+
+
+  @ApiBearerAuth("jwt")
+  @Put(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  update(@Param('id') id: number, @Body() updateDto: UpdateAiInteractionDto, @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: UpdateAiInteractionDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files, true);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/bulk-recover')
+  async recoverMany(@Body() ids: number[]) {
+    return this.service.recoverMany(ids);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get('/recover/:id')
+  async recover(@Param('id') id: number) {
+    return this.service.recover(id);
+  }
+
+  @ApiBearerAuth("jwt")
+  @ApiQuery({ name: 'showSoftDeleted', required: false, enum: ShowSoftDeleted })
+  @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: '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) {
+    return this.service.find(query);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get(':id')
+  async findOne(@Param('id') id: string, @Query() query: any) {
+    return this.service.findOne(+id, query);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete('/bulk')
+  async deleteMany(@Body() ids: number[]) {
+    return this.service.deleteMany(ids);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete(':id')
+  async delete(@Param('id') id: number) {
+    return this.service.delete(id);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/trigger-mcp-client-job')
+  async triggerMcpClientJob(@Body() dto: InvokeAiPromptDto, @ActiveUser() activeUser: ActiveUserData) {
+    return this.service.triggerMcpClientJob(dto, activeUser.sub);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post(':id/apply-solid-ai-interaction')
+  async applySolidAiInteraction(@Param('id') id: number) {
+    return this.service.applySolidAiInteraction(+id);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/run-mcp-prompt')
+  async runMcpPrompt(@Body() dto: InvokeAiPromptDto) {
+    return this.service.runMcpPrompt(dto.prompt);
+  }
+}