feat: Create prompt breakthrough (Circular dependency)

Author: Benny Burkert

backend/src/app.module.ts

@@ -14,6 +14,7 @@ import { ExtensionsController } from './controllers/extensions/extensions.contro
 import { FilesController } from './controllers/files/files.controller';
 import { UserFilesController } from './controllers/files/user-files.controller';
 import { HealthController } from './controllers/health/health.controller';
+import { PromptController } from './controllers/prompts/prompts.controller';
 import { SettingsController } from './controllers/settings/settings.controller';
 import { UsagesController } from './controllers/usages/usages.controller';
 import { UserGroupsController } from './controllers/users/user-groups.controller';
@@ -24,6 +25,7 @@ import { UserEntity } from './domain/database';
 import { initSchemaIfNotExistsAndMoveMigrations, schema } from './domain/database/typeorm.helper';
 import { ExtensionModule } from './domain/extensions';
 import { FilesModule } from './domain/files';
+import { PromptModule } from './domain/prompt/module';
 import { SettingsModule } from './domain/settings';
 import { UsersModule } from './domain/users/module';
 import { ExtensionLibraryModule } from './extensions';
@@ -47,6 +49,7 @@ import { PrometheusModule } from './metrics/prometheus.module';
       },
     }),
     PrometheusModule.forRoot(),
+    PromptModule,
     SettingsModule,
     UsersModule,
     TerminusModule,
@@ -82,6 +85,7 @@ import { PrometheusModule } from './metrics/prometheus.module';
     ConfigurationsController,
     ExtensionsController,
     FilesController,
+    PromptController,
     SettingsController,
     UsagesController,
     UserFilesController,

backend/src/controllers/prompts/dtos/index.ts

@@ -73,7 +73,7 @@ export class CreatePromptDto {
   })
   @IsOptional()
   @IsArray()
-  categories?: [number];
+  categories?: string[];
 
   @ApiProperty({
     description: 'The visibility of the prompt (e.g., public, private).',

backend/src/controllers/prompts/prompts.controller.ts

@@ -1,9 +1,13 @@
 import { Body, Controller, Get, Param, Post } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
 import { ApiOperation, ApiResponse } from '@nestjs/swagger';
+import { CreatePrompt, CreatePromptResponse } from 'src/domain/prompt/use-cases/create-prompt';
 import { CreatePromptCategoryDto, CreatePromptDto, PromptCategoryDto, PromptDto } from './dtos/index';
 
 @Controller('prompt')
 export class PromptController {
+  constructor(private readonly commandBus: CommandBus) {}
+
   @Post('categories')
   @ApiOperation({ operationId: 'postPromptCategory', summary: 'Create a new prompt category' })
   @ApiResponse({ status: 201, description: 'Category created successfully' })
@@ -22,7 +26,28 @@ export class PromptController {
   @ApiOperation({ operationId: 'postPrompt', summary: 'Create a new prompt' })
   @ApiResponse({ status: 201, description: 'Prompt created successfully' })
   async createPrompt(@Body() createPromptDto: CreatePromptDto): Promise<PromptDto> {
-    return Promise.resolve(undefined as unknown as PromptDto);
+    const response: CreatePromptResponse = await this.commandBus.execute(
+      new CreatePrompt({
+        title: createPromptDto.title,
+        description: createPromptDto.description,
+        content: createPromptDto.content,
+        visibility: createPromptDto.visibility,
+        categoryLabels: createPromptDto.categories,
+      }),
+    );
+
+    // Map entity to DTO
+    const promptDto: PromptDto = {
+      id: response.prompt.id.toString(),
+      title: response.prompt.title,
+      description: response.prompt.description,
+      content: response.prompt.content,
+      visibility: response.prompt.visibility,
+      categories: response.prompt.categories?.map(cat => cat.label) || [],
+      rating: response.prompt.rating,
+    };
+
+    return promptDto;
   }
 
   @Get()

backend/src/controllers/prompts/prompts.e2e.spec.ts

@@ -0,0 +1,146 @@
+import { Server } from 'net';
+import { HttpStatus, INestApplication } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import * as request from 'supertest';
+import { DataSource, Repository } from 'typeorm';
+import { AppModule } from '../../app.module';
+import { PromptCategoryEntity } from '../../domain/database';
+import { VisibilityType } from '../../domain/prompt';
+import { initAppWithDataBaseAndValidUser } from '../../utils/testUtils';
+import { CreatePromptDto, PromptDto } from './dtos';
+
+describe('Prompts', () => {
+  let app: INestApplication<Server>;
+  let dataSource: DataSource;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    const initialized = await initAppWithDataBaseAndValidUser(dataSource, module, app);
+    dataSource = initialized.dataSource;
+    app = initialized.app;
+    await seedTestData(dataSource);
+  });
+
+  afterAll(async () => {
+    await dataSource.destroy();
+    await app.close();
+  });
+
+  it('should create a prompt without categories', async () => {
+    const newPrompt: CreatePromptDto = {
+      title: 'Test Prompt',
+      description: 'A test prompt for e2e testing',
+      content: 'This is the prompt content for testing purposes.',
+      visibility: VisibilityType.PUBLIC,
+    };
+
+    const response = await request(app.getHttpServer()).post('/prompt').send(newPrompt).expect(HttpStatus.CREATED);
+
+    const typedBody = response.body as PromptDto;
+    expect(typedBody.id).toBeDefined();
+    expect(typedBody.title).toBe(newPrompt.title);
+    expect(typedBody.description).toBe(newPrompt.description);
+    expect(typedBody.content).toBe(newPrompt.content);
+    expect(typedBody.visibility).toBe(newPrompt.visibility);
+    expect(typedBody.categories).toEqual([]);
+  });
+
+  it('should create a prompt with categories', async () => {
+    const newPrompt: CreatePromptDto = {
+      title: 'Categorized Prompt',
+      content: 'This prompt has categories.',
+      visibility: VisibilityType.PRIVATE,
+      categories: ['technical', 'creative'],
+    };
+
+    const response = await request(app.getHttpServer()).post('/prompt').send(newPrompt).expect(HttpStatus.CREATED);
+
+    const typedBody = response.body as PromptDto;
+    expect(typedBody.id).toBeDefined();
+    expect(typedBody.title).toBe(newPrompt.title);
+    expect(typedBody.content).toBe(newPrompt.content);
+    expect(typedBody.visibility).toBe(newPrompt.visibility);
+    expect(typedBody.categories).toHaveLength(2);
+    expect(typedBody.categories).toEqual(
+      expect.arrayContaining([expect.objectContaining({ label: 'technical' }), expect.objectContaining({ label: 'creative' })]),
+    );
+  });
+
+  it('should create a prompt with only required fields', async () => {
+    const newPrompt: CreatePromptDto = {
+      title: 'Minimal Prompt',
+      content: 'This is a minimal prompt with only required fields.',
+      visibility: VisibilityType.PRIVATE,
+    };
+
+    const response = await request(app.getHttpServer()).post('/prompt').send(newPrompt).expect(HttpStatus.CREATED);
+
+    const typedBody = response.body as PromptDto;
+    expect(typedBody.id).toBeDefined();
+    expect(typedBody.title).toBe(newPrompt.title);
+    expect(typedBody.content).toBe(newPrompt.content);
+    expect(typedBody.visibility).toBe(newPrompt.visibility);
+    expect(typedBody.description).toBeUndefined();
+    expect(typedBody.rating).toBeUndefined();
+    expect(typedBody.categories).toEqual([]);
+  });
+
+  it('should create a prompt with non-existent categories', async () => {
+    const newPrompt: CreatePromptDto = {
+      title: 'Prompt with Non-existent Categories',
+      content: 'This prompt references categories that do not exist.',
+      visibility: VisibilityType.PUBLIC,
+      categories: ['nonexistent1', 'technical', 'nonexistent2'],
+    };
+
+    const response = await request(app.getHttpServer()).post('/prompt').send(newPrompt).expect(HttpStatus.CREATED);
+
+    const typedBody = response.body as PromptDto;
+    expect(typedBody.categories).toHaveLength(1); // Only 'technical' exists
+    expect(typedBody.categories).toEqual([expect.objectContaining({ label: 'technical' })]);
+  });
+
+  it('should fail to create a prompt without required fields', async () => {
+    const invalidPrompt = {
+      description: 'Missing title and content',
+      visibility: VisibilityType.PUBLIC,
+    };
+
+    await request(app.getHttpServer()).post('/prompt').send(invalidPrompt).expect(HttpStatus.BAD_REQUEST);
+  });
+
+  it('should fail to create a prompt with invalid visibility', async () => {
+    const invalidPrompt = {
+      title: 'Invalid Prompt',
+      content: 'This prompt has invalid visibility.',
+      visibility: 'invalid_visibility',
+    };
+
+    await request(app.getHttpServer()).post('/prompt').send(invalidPrompt).expect(HttpStatus.BAD_REQUEST);
+  });
+});
+
+async function seedTestData(dataSource: DataSource) {
+  const promptCategoryRepository = dataSource.getRepository(PromptCategoryEntity);
+
+  // Create test categories
+  await createPromptCategory('technical', 'Technical prompts', promptCategoryRepository);
+  await createPromptCategory('creative', 'Creative writing prompts', promptCategoryRepository);
+  await createPromptCategory('business', 'Business and professional prompts', promptCategoryRepository);
+}
+
+async function createPromptCategory(
+  label: string,
+  description: string,
+  promptCategoryRepository: Repository<PromptCategoryEntity>,
+): Promise<PromptCategoryEntity> {
+  const categoryEntity = new PromptCategoryEntity();
+  categoryEntity.label = label;
+  categoryEntity.description = description;
+  categoryEntity.creationDate = new Date();
+  categoryEntity.visibility = VisibilityType.PUBLIC;
+  return promptCategoryRepository.save(categoryEntity);
+}

backend/src/domain/database/entities/prompt-category.ts

@@ -1,5 +1,5 @@
-import { Column, Entity, PrimaryColumn } from 'typeorm';
-import { VisibilityType } from '../../prompt';
+import { Column, CreateDateColumn, Entity, PrimaryColumn, UpdateDateColumn } from 'typeorm';
+import { VisibilityType } from '../../prompt/interfaces';
 import { schema } from '../typeorm.helper';
 
 @Entity({ name: 'prompt-categories', schema })
@@ -15,4 +15,10 @@ export class PromptCategoryEntity {
 
   @Column()
   visibility!: VisibilityType;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
 }

backend/src/domain/database/entities/prompt.ts

@@ -1,14 +1,14 @@
-import { Column, Entity, JoinTable, ManyToMany, PrimaryGeneratedColumn } from 'typeorm';
-import { VisibilityType } from '../../prompt';
+import { Column, CreateDateColumn, Entity, JoinTable, ManyToMany, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { VisibilityType } from '../../prompt/interfaces';
 import { schema } from '../typeorm.helper';
 import { PromptCategoryEntity } from './prompt-category';
 
 @Entity({ name: 'prompts', schema })
 export class PromptEntity {
   @PrimaryGeneratedColumn()
-  id!: string;
+  id!: number;
 
-  @Column({ nullable: true })
+  @Column({ nullable: false })
   title!: string;
 
   @Column({ nullable: true })
@@ -25,5 +25,11 @@ export class PromptEntity {
   visibility!: VisibilityType;
 
   @Column({ nullable: true })
-  raiting!: number;
+  rating!: number;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
 }

backend/src/domain/prompt/index.ts

@@ -1 +1,2 @@
 export * from './interfaces';
+export * from './module';

backend/src/domain/prompt/interfaces.ts

@@ -2,3 +2,52 @@ export enum VisibilityType {
   PRIVATE = 'private',
   PUBLIC = 'public',
 }
+
+export interface Prompt {
+  // The prompt ID.
+  id: number;
+
+  // The prompt title.
+  title: string;
+
+  // Optional description of the prompt.
+  description?: string;
+
+  // The actual prompt content.
+  content: string;
+
+  // Visibility setting for the prompt.
+  visibility: VisibilityType;
+
+  // Optional rating for the prompt.
+  rating?: number;
+
+  // Associated categories.
+  categories?: PromptCategory[];
+
+  // Creation timestamp.
+  createdAt: Date;
+
+  // Last update timestamp.
+  updatedAt: Date;
+}
+
+export interface PromptCategory {
+  // The category label (primary key).
+  label: string;
+
+  // Optional description of the category.
+  description?: string;
+
+  // Manual creation date field.
+  creationDate: Date;
+
+  // Visibility setting for the category.
+  visibility: VisibilityType;
+
+  // Creation timestamp.
+  createdAt: Date;
+
+  // Last update timestamp.
+  updatedAt: Date;
+}

backend/src/domain/prompt/module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { CqrsModule } from '@nestjs/cqrs';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { PromptCategoryEntity } from '../database/entities/prompt-category';
+import { PromptEntity } from '../database/entities/prompt';
+import { CreatePromptHandler } from './use-cases/create-prompt';
+
+@Module({
+  imports: [CqrsModule, TypeOrmModule.forFeature([PromptEntity, PromptCategoryEntity])],
+  providers: [CreatePromptHandler],
+  exports: [CreatePromptHandler],
+})
+export class PromptModule {}