Backend aws bedrock

backend/package.json

@@ -26,6 +26,7 @@
   },
   "dependencies": {
     "@amplitude/node": "1.10.2",
+    "@aws-sdk/client-bedrock-runtime": "^3.954.0",
     "@aws-sdk/lib-dynamodb": "^3.953.0",
     "@electric-sql/pglite": "^0.3.14",
     "@faker-js/faker": "^10.1.0",

backend/src/app.module.ts

@@ -84,6 +84,7 @@ import { SignInAuditModule } from './entities/user-sign-in-audit/sign-in-audit.m
     TableCategoriesModule,
     UserSecretModule,
     SignInAuditModule,
+    AIModule,
   ],
   controllers: [AppController],
   providers: [

backend/src/common/data-injection.tokens.ts

@@ -154,6 +154,7 @@ export enum UseCaseType {
   DELETE_API_KEY = 'DELETE_API_KEY',
 
   REQUEST_INFO_FROM_TABLE_WITH_AI_V2 = 'REQUEST_INFO_FROM_TABLE_WITH_AI_V2',
+  REQUEST_AI_SETTINGS_AND_WIDGETS_CREATION = 'REQUEST_AI_SETTINGS_AND_WIDGETS_CREATION',
 
   CREATE_TABLE_FILTERS = 'CREATE_TABLE_FILTERS',
   FIND_TABLE_FILTERS = 'FIND_TABLE_FILTERS',

backend/src/entities/ai/ai-data-entities/types/ai-module-types.ts

@@ -0,0 +1,10 @@
+import { ForeignKeyDS } from '@rocketadmin/shared-code/dist/src/data-access-layer/shared/data-structures/foreign-key.ds.js';
+import { PrimaryKeyDS } from '@rocketadmin/shared-code/dist/src/data-access-layer/shared/data-structures/primary-key.ds.js';
+import { TableStructureDS } from '@rocketadmin/shared-code/dist/src/data-access-layer/shared/data-structures/table-structure.ds.js';
+
+export type TableInformation = {
+  table_name: string;
+  structure: Array<TableStructureDS>;
+  foreignKeys: Array<ForeignKeyDS>;
+  primaryColumns: Array<PrimaryKeyDS>;
+};

backend/src/entities/ai/ai-use-cases.interface.ts

@@ -1,6 +1,11 @@
 import { InTransactionEnum } from '../../enums/in-transaction.enum.js';
+import { FindOneConnectionDs } from '../connection/application/data-structures/find-one-connection.ds.js';
 import { RequestInfoFromTableDSV2 } from './application/data-structures/request-info-from-table.ds.js';
 
 export interface IRequestInfoFromTableV2 {
   execute(inputData: RequestInfoFromTableDSV2, inTransaction: InTransactionEnum): Promise<void>;
 }
+
+export interface IAISettingsAndWidgetsCreation {
+  execute(connectionData: FindOneConnectionDs, inTransaction: InTransactionEnum): Promise<void>;
+}

backend/src/entities/ai/ai.module.ts

@@ -1,13 +1,17 @@
-import { MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common';
+import { Global, MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { AuthMiddleware } from '../../authorization/auth.middleware.js';
 import { GlobalDatabaseContext } from '../../common/application/global-database-context.js';
 import { BaseType, UseCaseType } from '../../common/data-injection.tokens.js';
 import { LogOutEntity } from '../log-out/log-out.entity.js';
 import { UserEntity } from '../user/user.entity.js';
+import { AiService } from './ai.service.js';
+import { AmazonBedrockAiProvider } from './amazon-bedrock/amazon-bedrock.ai.provider.js';
 import { RequestInfoFromTableWithAIUseCaseV4 } from './use-cases/request-info-from-table-with-ai-v4.use.case.js';
 import { UserAIRequestsControllerV2 } from './user-ai-requests-v2.controller.js';
+import { RequestAISettingsAndWidgetsCreationUseCase } from './use-cases/request-ai-settings-and-widgets-creation.use.case.js';
 
+@Global()
 @Module({
   imports: [TypeOrmModule.forFeature([UserEntity, LogOutEntity])],
   providers: [
@@ -19,11 +23,23 @@ import { UserAIRequestsControllerV2 } from './user-ai-requests-v2.controller.js'
       provide: UseCaseType.REQUEST_INFO_FROM_TABLE_WITH_AI_V2,
       useClass: RequestInfoFromTableWithAIUseCaseV4,
     },
+    {
+      provide: UseCaseType.REQUEST_AI_SETTINGS_AND_WIDGETS_CREATION,
+      useClass: RequestAISettingsAndWidgetsCreationUseCase,
+    },
+    AmazonBedrockAiProvider,
+    AiService,
   ],
+  exports: [AiService, AmazonBedrockAiProvider],
   controllers: [UserAIRequestsControllerV2],
 })
 export class AIModule implements NestModule {
   public configure(consumer: MiddlewareConsumer): any {
-    consumer.apply(AuthMiddleware).forRoutes({ path: '/ai/v2/request/:connectionId', method: RequestMethod.POST });
+    consumer
+      .apply(AuthMiddleware)
+      .forRoutes(
+        { path: '/ai/v2/request/:connectionId', method: RequestMethod.POST },
+        { path: '/ai/v2/setup/:connectionId', method: RequestMethod.GET },
+      );
   }
 }

backend/src/entities/ai/ai.service.ts

@@ -0,0 +1,218 @@
+import { Injectable } from '@nestjs/common';
+import { TableSettingsEntity } from '../table-settings/table-settings.entity.js';
+import { TableWidgetEntity } from '../widget/table-widget.entity.js';
+import { TableInformation } from './ai-data-entities/types/ai-module-types.js';
+import { AmazonBedrockAiProvider } from './amazon-bedrock/amazon-bedrock.ai.provider.js';
+import { QueryOrderingEnum } from '../../enums/query-ordering.enum.js';
+import { WidgetTypeEnum } from '../../enums/widget-type.enum.js';
+import { checkFieldAutoincrement } from '../../helpers/check-field-autoincrement.js';
+
+interface AIGeneratedTableSettings {
+  table_name: string;
+  display_name: string;
+  list_fields: string[];
+  ordering_field: string | null;
+  ordering: 'ASC' | 'DESC';
+  search_fields: string[];
+  readonly_fields: string[];
+  columns_view: string[];
+  widgets: Array<{
+    field_name: string;
+    widget_type: string;
+    name: string;
+    description: string;
+  }>;
+}
+
+interface AIResponse {
+  tables: AIGeneratedTableSettings[];
+}
+
+@Injectable()
+export class AiService {
+  constructor(protected readonly aiProvider: AmazonBedrockAiProvider) {}
+
+  public async generateNewTableSettingsWithAI(
+    tablesInformation: Array<TableInformation>,
+  ): Promise<Array<TableSettingsEntity>> {
+    const prompt = this.buildPrompt(tablesInformation);
+    const aiResponse = await this.aiProvider.generateResponse(prompt);
+    const parsedResponse = this.parseAIResponse(aiResponse);
+    return this.buildTableSettingsEntities(parsedResponse, tablesInformation);
+  }
+
+  private buildPrompt(tablesInformation: Array<TableInformation>): string {
+    const widgetTypes = Object.values(WidgetTypeEnum).join(', ');
+
+    const tablesDescription = tablesInformation
+      .map((table) => {
+        const columns = table.structure
+          .map(
+            (col) =>
+              `    - ${col.column_name}: ${col.data_type}${col.allow_null ? ' (nullable)' : ''}${checkFieldAutoincrement(col.column_default, col.extra) ? ' (auto_increment)' : ''}`,
+          )
+          .join('\n');
+        const primaryKeys = table.primaryColumns.map((pk) => pk.column_name).join(', ');
+        const foreignKeys = table.foreignKeys
+          .map((fk) => `    - ${fk.column_name} -> ${fk.referenced_table_name}.${fk.referenced_column_name}`)
+          .join('\n');
+
+        return `
+Table: ${table.table_name}
+  Primary Keys: ${primaryKeys || 'none'}
+  Columns:
+${columns}
+  Foreign Keys:
+${foreignKeys || '    none'}`;
+      })
+      .join('\n\n');
+
+    return `You are a database administration assistant. Analyze the following database tables and generate optimal settings for displaying and managing them in a web admin panel.
+
+For each table, provide:
+1. display_name: A human-readable name for the table
+2. list_fields: Columns to display in the table list view (most important columns first, max 5-7 columns)
+3. ordering_field: The best column to sort by default (usually created_at, id, or a timestamp)
+4. ordering: ASC or DESC
+5. search_fields: Columns that should be searchable
+6. readonly_fields: Columns that should not be editable (like auto_increment, timestamps)
+7. columns_view: All columns in preferred display order
+8. widgets: For each column, suggest the best widget type from: ${widgetTypes}
+
+Available widget types and when to use them:
+- Password: for password fields
+- Boolean: for boolean/bit columns
+- Date: for date columns
+- Time: for time-only columns
+- DateTime: for datetime/timestamp columns
+- JSON: for JSON/JSONB columns
+- Textarea: for long text fields (description, content, etc.)
+- String: for short text fields (name, title, etc.)
+- Readonly: for auto-generated fields
+- Number: for numeric columns
+- Select: for columns with limited options
+- UUID: for UUID columns
+- Enum: for enum columns
+- Foreign_key: for foreign key columns
+- File: for file path columns
+- Image: for image URL columns
+- URL: for URL columns
+- Code: for code snippets
+- Phone: for phone number columns
+- Country: for country columns
+- Color: for color columns (hex values)
+- Range: for range values
+- Timezone: for timezone columns
+
+Database tables to analyze:
+${tablesDescription}
+
+Respond ONLY with valid JSON in this exact format (no markdown, no explanations):
+{
+  "tables": [
+    {
+      "table_name": "table_name",
+      "display_name": "Human Readable Name",
+      "list_fields": ["col1", "col2"],
+      "ordering_field": "created_at",
+      "ordering": "DESC",
+      "search_fields": ["name", "email"],
+      "readonly_fields": ["id", "created_at"],
+      "columns_view": ["id", "name", "email", "created_at"],
+      "widgets": [
+        {
+          "field_name": "column_name",
+          "widget_type": "String",
+          "name": "Column Display Name",
+          "description": "Description of what this column contains"
+        }
+      ]
+    }
+  ]
+}`;
+  }
+
+  private parseAIResponse(aiResponse: string): AIResponse {
+    let cleanedResponse = aiResponse.trim();
+    if (cleanedResponse.startsWith('```json')) {
+      cleanedResponse = cleanedResponse.slice(7);
+    } else if (cleanedResponse.startsWith('```')) {
+      cleanedResponse = cleanedResponse.slice(3);
+    }
+    if (cleanedResponse.endsWith('```')) {
+      cleanedResponse = cleanedResponse.slice(0, -3);
+    }
+    cleanedResponse = cleanedResponse.trim();
+
+    try {
+      return JSON.parse(cleanedResponse) as AIResponse;
+    } catch (error) {
+      throw new Error(`Failed to parse AI response: ${error.message}`);
+    }
+  }
+
+  private buildTableSettingsEntities(
+    aiResponse: AIResponse,
+    tablesInformation: Array<TableInformation>,
+  ): Array<TableSettingsEntity> {
+    return aiResponse.tables.map((tableSettings) => {
+      const tableInfo = tablesInformation.find((t) => t.table_name === tableSettings.table_name);
+      const validColumnNames = tableInfo?.structure.map((col) => col.column_name) || [];
+
+      const settings = new TableSettingsEntity();
+      settings.table_name = tableSettings.table_name;
+      settings.display_name = tableSettings.display_name;
+      settings.list_fields = this.filterValidColumns(tableSettings.list_fields, validColumnNames);
+      settings.ordering_field = tableSettings.ordering_field;
+      settings.ordering = tableSettings.ordering === 'DESC' ? QueryOrderingEnum.DESC : QueryOrderingEnum.ASC;
+      settings.search_fields = this.filterValidColumns(tableSettings.search_fields, validColumnNames);
+      settings.readonly_fields = this.filterValidColumns(tableSettings.readonly_fields, validColumnNames);
+      settings.columns_view = this.filterValidColumns(tableSettings.columns_view, validColumnNames);
+      settings.table_widgets = tableSettings.widgets
+        .filter((w) => validColumnNames.includes(w.field_name))
+        .map((widgetData) => {
+          const widget = new TableWidgetEntity();
+          widget.field_name = widgetData.field_name;
+          widget.widget_type = this.mapWidgetType(widgetData.widget_type);
+          widget.name = widgetData.name;
+          widget.description = widgetData.description;
+          return widget;
+        });
+
+      return settings;
+    });
+  }
+
+  private filterValidColumns(columns: string[], validColumnNames: string[]): string[] {
+    return columns?.filter((col) => validColumnNames.includes(col)) || [];
+  }
+
+  private mapWidgetType(widgetType: string): WidgetTypeEnum | undefined {
+    const widgetTypeMap = new Map<string, WidgetTypeEnum>([
+      ['Password', WidgetTypeEnum.Password],
+      ['Boolean', WidgetTypeEnum.Boolean],
+      ['Date', WidgetTypeEnum.Date],
+      ['Time', WidgetTypeEnum.Time],
+      ['DateTime', WidgetTypeEnum.DateTime],
+      ['JSON', WidgetTypeEnum.JSON],
+      ['Textarea', WidgetTypeEnum.Textarea],
+      ['String', WidgetTypeEnum.String],
+      ['Readonly', WidgetTypeEnum.Readonly],
+      ['Number', WidgetTypeEnum.Number],
+      ['Select', WidgetTypeEnum.Select],
+      ['UUID', WidgetTypeEnum.UUID],
+      ['Enum', WidgetTypeEnum.Enum],
+      ['Foreign_key', WidgetTypeEnum.Foreign_key],
+      ['File', WidgetTypeEnum.File],
+      ['Image', WidgetTypeEnum.Image],
+      ['URL', WidgetTypeEnum.URL],
+      ['Code', WidgetTypeEnum.Code],
+      ['Phone', WidgetTypeEnum.Phone],
+      ['Country', WidgetTypeEnum.Country],
+      ['Color', WidgetTypeEnum.Color],
+      ['Range', WidgetTypeEnum.Range],
+      ['Timezone', WidgetTypeEnum.Timezone],
+    ]);
+    return widgetTypeMap.get(widgetType);
+  }
+}

backend/src/entities/ai/amazon-bedrock/ai-provider.interface.ts

@@ -0,0 +1,3 @@
+export interface IAIProvider {
+  generateResponse(prompt: string): Promise<string>;
+}

backend/src/entities/ai/amazon-bedrock/amazon-bedrock.ai.provider.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@nestjs/common';
+import { BedrockRuntimeClient, ConverseCommand } from '@aws-sdk/client-bedrock-runtime';
+import { IAIProvider } from './ai-provider.interface.js';
+
+@Injectable()
+export class AmazonBedrockAiProvider implements IAIProvider {
+  private readonly bedrockRuntimeClient: BedrockRuntimeClient;
+  private readonly modelId: string = 'global.anthropic.claude-sonnet-4-5-20250929-v1:0';
+  private readonly temperature: number = 0.7;
+  private readonly maxTokens: number = 1024;
+  private readonly region: string = 'us-west-2';
+  private readonly topP: number = 0.9;
+
+  constructor() {
+    this.bedrockRuntimeClient = new BedrockRuntimeClient({
+      region: this.region,
+      credentials: {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      },
+    });
+  }
+  public async generateResponse(prompt: string): Promise<string> {
+    const conversation = [
+      {
+        role: 'user' as const,
+        content: [{ text: prompt }],
+      },
+    ];
+
+    const command = new ConverseCommand({
+      modelId: this.modelId,
+      messages: conversation,
+      inferenceConfig: { maxTokens: this.maxTokens, temperature: this.temperature, topP: this.topP },
+    });
+    try {
+      const response = await this.bedrockRuntimeClient.send(command);
+      const responseText = response.output.message?.content[0].text;
+      return responseText || 'No response generated.';
+    } catch (error) {
+      console.error('Error generating AI response:', error);
+      throw new Error('Failed to generate AI response.');
+    }
+  }
+}

backend/src/entities/ai/use-cases/request-ai-settings-and-widgets-creation.use.case.ts

@@ -0,0 +1,33 @@
+import { BadRequestException, Inject, Injectable, Scope } from '@nestjs/common';
+import { IGlobalDatabaseContext } from '../../../common/application/global-database-context.interface.js';
+import { BaseType } from '../../../common/data-injection.tokens.js';
+import AbstractUseCase from '../../../common/abstract-use.case.js';
+import { IAISettingsAndWidgetsCreation } from '../ai-use-cases.interface.js';
+import { SharedJobsService } from '../../shared-jobs/shared-jobs.service.js';
+import { FindOneConnectionDs } from '../../connection/application/data-structures/find-one-connection.ds.js';
+import { Messages } from '../../../exceptions/text/messages.js';
+
+@Injectable({ scope: Scope.REQUEST })
+export class RequestAISettingsAndWidgetsCreationUseCase
+  extends AbstractUseCase<FindOneConnectionDs, void>
+  implements IAISettingsAndWidgetsCreation
+{
+  constructor(
+    @Inject(BaseType.GLOBAL_DB_CONTEXT)
+    protected _dbContext: IGlobalDatabaseContext,
+    private readonly sharedJobsService: SharedJobsService,
+  ) {
+    super();
+  }
+
+  public async implementation(connectionData: FindOneConnectionDs): Promise<void> {
+    const { connectionId, masterPwd } = connectionData;
+
+    const connection = await this._dbContext.connectionRepository.findAndDecryptConnection(connectionId, masterPwd);
+    if (!connection) {
+      throw new BadRequestException(Messages.CONNECTION_NOT_FOUND);
+    }
+
+    await this.sharedJobsService.scanDatabaseAndCreateSettingsAndWidgetsWithAI(connection);
+  }
+}