@hexabot-ai/api 3.0.0-alpha.3

package/src/chat/controllers/category.controller.ts

@@ -0,0 +1,162 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  NotFoundException,
+  Param,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { FindManyOptions, In } from 'typeorm';
+
+import { BaseOrmController } from '@/utils/generics/base-orm.controller';
+import { DeleteResult } from '@/utils/generics/base-orm.repository';
+import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';
+
+import {
+  Category,
+  CategoryCreateDto,
+  CategoryDtoConfig,
+  CategoryTransformerDto,
+  CategoryUpdateDto,
+} from '../dto/category.dto';
+import { CategoryOrmEntity } from '../entities/category.entity';
+import { CategoryService } from '../services/category.service';
+
+@Controller('category')
+export class CategoryController extends BaseOrmController<
+  CategoryOrmEntity,
+  CategoryTransformerDto,
+  CategoryDtoConfig
+> {
+  constructor(private readonly categoryService: CategoryService) {
+    super(categoryService);
+  }
+
+  /**
+   * Retrieves a paginated list of categories based on provided filters and pagination settings.
+   * @param pageQuery - The pagination settings.
+   * @param filters - The filters to apply to the category search.
+   * @returns A Promise that resolves to a paginated list of categories.
+   */
+  @Get()
+  async findPage(
+    @Query(
+      new TypeOrmSearchFilterPipe<CategoryOrmEntity>({
+        allowedFields: ['label', 'builtin'],
+        defaultSort: ['createdAt', 'desc'],
+      }),
+    )
+    options: FindManyOptions<CategoryOrmEntity>,
+  ) {
+    return await this.categoryService.find(options ?? {});
+  }
+
+  /**
+   * Counts the filtered number of categories.
+   * @returns A promise that resolves to an object representing the filtered number of categories.
+   */
+  @Get('count')
+  async filterCount(
+    @Query(
+      new TypeOrmSearchFilterPipe<CategoryOrmEntity>({
+        allowedFields: ['label', 'builtin'],
+      }),
+    )
+    options?: FindManyOptions<CategoryOrmEntity>,
+  ) {
+    return await this.count(options ?? {});
+  }
+
+  /**
+   * Finds a category by its ID.
+   * @param id - The ID of the category to find.
+   * @returns A Promise that resolves to the found category.
+   */
+  @Get(':id')
+  async findOne(@Param('id') id: string): Promise<Category> {
+    const record = await this.categoryService.findOne(id);
+    if (!record) {
+      this.logger.warn(`Unable to find Category by id ${id}`);
+      throw new NotFoundException(`Category with ID ${id} not found`);
+    }
+
+    return record;
+  }
+
+  /**
+   * Creates a new category.
+   * @param category - The data of the category to be created.
+   * @returns A Promise that resolves to the created category.
+   */
+  @Post()
+  async create(@Body() category: CategoryCreateDto): Promise<Category> {
+    return await this.categoryService.create(category);
+  }
+
+  /**
+   * Updates an existing category.
+   * @param id - The ID of the category to be updated.
+   * @param categoryUpdate - The updated data for the category.
+   * @returns A Promise that resolves to the updated category.
+   */
+  @Patch(':id')
+  async updateOne(
+    @Param('id') id: string,
+    @Body() categoryUpdate: CategoryUpdateDto,
+  ): Promise<Category> {
+    return await this.categoryService.updateOne(id, categoryUpdate);
+  }
+
+  /**
+   * Deletes a category by its ID.
+   * @param id - The ID of the category to be deleted.
+   * @returns A Promise that resolves to the deletion result.
+   */
+  @Delete(':id')
+  @HttpCode(204)
+  async deleteOne(@Param('id') id: string): Promise<DeleteResult> {
+    const result = await this.categoryService.deleteOne(id);
+    if (result.deletedCount === 0) {
+      this.logger.warn(`Unable to delete Category by id ${id}`);
+      throw new NotFoundException(`Category with ID ${id} not found`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Deletes multiple categories by their IDs.
+   * @param ids - IDs of categories to be deleted.
+   * @returns A Promise that resolves to the deletion result.
+   */
+  @Delete('')
+  @HttpCode(204)
+  async deleteMany(@Body('ids') ids?: string[]): Promise<DeleteResult> {
+    if (!ids?.length) {
+      throw new BadRequestException('No IDs provided for deletion.');
+    }
+    const deleteResult = await this.categoryService.deleteMany({
+      where: { id: In(ids) },
+    });
+
+    if (deleteResult.deletedCount === 0) {
+      this.logger.warn(`Unable to delete categories with provided IDs: ${ids}`);
+      throw new NotFoundException('Categories with provided IDs not found');
+    }
+
+    this.logger.log(`Successfully deleted categories with IDs: ${ids}`);
+
+    return deleteResult;
+  }
+}

package/src/chat/controllers/context-var.controller.ts

@@ -0,0 +1,157 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  NotFoundException,
+  Param,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { FindManyOptions, In } from 'typeorm';
+
+import { BaseOrmController } from '@/utils/generics/base-orm.controller';
+import { DeleteResult } from '@/utils/generics/base-orm.repository';
+import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';
+
+import {
+  ContextVar,
+  ContextVarCreateDto,
+  ContextVarDtoConfig,
+  ContextVarTransformerDto,
+  ContextVarUpdateDto,
+} from '../dto/context-var.dto';
+import { ContextVarOrmEntity } from '../entities/context-var.entity';
+import { ContextVarService } from '../services/context-var.service';
+
+@Controller('contextvar')
+export class ContextVarController extends BaseOrmController<
+  ContextVarOrmEntity,
+  ContextVarTransformerDto,
+  ContextVarDtoConfig
+> {
+  constructor(private readonly contextVarService: ContextVarService) {
+    super(contextVarService);
+  }
+
+  /** Finds context vars based on TypeORM filters and pagination options. */
+  @Get()
+  async findPage(
+    @Query(
+      new TypeOrmSearchFilterPipe<ContextVarOrmEntity>({
+        allowedFields: ['label', 'name', 'permanent'],
+        defaultSort: ['createdAt', 'desc'],
+      }),
+    )
+    options: FindManyOptions<ContextVarOrmEntity>,
+  ): Promise<ContextVar[]> {
+    return await this.contextVarService.find(options ?? {});
+  }
+
+  /** Counts context vars matching the provided TypeORM options. */
+  @Get('count')
+  async filterCount(
+    @Query(
+      new TypeOrmSearchFilterPipe<ContextVarOrmEntity>({
+        allowedFields: ['label', 'name', 'permanent'],
+      }),
+    )
+    options?: FindManyOptions<ContextVarOrmEntity>,
+  ) {
+    return await this.count(options ?? {});
+  }
+
+  /**
+   * Retrieves a contextVar by its ID.
+   * @param id - The ID of the contextVar to retrieve.
+   * @returns A Promise that resolves to the retrieved contextVar.
+   */
+
+  @Get(':id')
+  async findOne(@Param('id') id: string): Promise<ContextVar> {
+    const record = await this.contextVarService.findOne(id);
+    if (!record) {
+      this.logger.warn(`Unable to find ContextVar by id ${id}`);
+      throw new NotFoundException(`ContextVar with ID ${id} not found`);
+    }
+
+    return record;
+  }
+
+  /**
+   * Creates a new contextVar.
+   * @param contextVar - The data of the contextVar to create.
+   * @returns A Promise that resolves to the created contextVar.
+   */
+  @Post()
+  async create(@Body() contextVar: ContextVarCreateDto): Promise<ContextVar> {
+    return await this.contextVarService.create(contextVar);
+  }
+
+  /**
+   * Updates an existing contextVar.
+   * @param id - The ID of the contextVar to update.
+   * @param contextVarUpdate - The updated data for the contextVar.
+   * @returns A Promise that resolves to the updated contextVar.
+   */
+  @Patch(':id')
+  async updateOne(
+    @Param('id') id: string,
+    @Body() contextVarUpdate: ContextVarUpdateDto,
+  ): Promise<ContextVar> {
+    return await this.contextVarService.updateOne(id, contextVarUpdate);
+  }
+
+  /**
+   * Deletes a contextVar.
+   * @param id - The ID of the contextVar to delete.
+   * @returns A Promise that resolves to a DeleteResult.
+   */
+  @Delete(':id')
+  @HttpCode(204)
+  async deleteOne(@Param('id') id: string): Promise<DeleteResult> {
+    const result = await this.contextVarService.deleteOne(id);
+    if (result.deletedCount === 0) {
+      this.logger.warn(`Unable to delete ContextVar by id ${id}`);
+      throw new NotFoundException(`ContextVar with ID ${id} not found`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Deletes multiple context variables by their IDs.
+   * @param ids - IDs of context variables to be deleted.
+   * @returns A Promise that resolves to the deletion result.
+   */
+  @Delete('')
+  @HttpCode(204)
+  async deleteMany(@Body('ids') ids?: string[]): Promise<DeleteResult> {
+    if (!ids?.length) {
+      throw new BadRequestException('No IDs provided for deletion.');
+    }
+    const deleteResult = await this.contextVarService.deleteMany({
+      where: { id: In(ids) },
+    });
+
+    if (deleteResult.deletedCount === 0) {
+      this.logger.warn(
+        `Unable to delete context vars with provided IDs: ${ids}`,
+      );
+      throw new NotFoundException('Context vars with provided IDs not found');
+    }
+
+    this.logger.log(`Successfully deleted context vars with IDs: ${ids}`);
+
+    return deleteResult;
+  }
+}

package/src/chat/controllers/label-group.controller.ts

@@ -0,0 +1,171 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  NotFoundException,
+  Param,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { FindManyOptions, In } from 'typeorm';
+
+import { BaseOrmController } from '@/utils/generics/base-orm.controller';
+import { DeleteResult } from '@/utils/generics/base-orm.repository';
+import { PopulatePipe } from '@/utils/pipes/populate.pipe';
+import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';
+
+import {
+  LabelGroup,
+  LabelGroupCreateDto,
+  LabelGroupDtoConfig,
+  LabelGroupFull,
+  LabelGroupTransformerDto,
+  LabelGroupUpdateDto,
+} from '../dto/label-group.dto';
+import { LabelGroupOrmEntity } from '../entities/label-group.entity';
+import { LabelGroupService } from '../services/label-group.service';
+
+@Controller('labelgroup')
+export class LabelGroupController extends BaseOrmController<
+  LabelGroupOrmEntity,
+  LabelGroupTransformerDto,
+  LabelGroupDtoConfig
+> {
+  constructor(private readonly labelGroupService: LabelGroupService) {
+    super(labelGroupService);
+  }
+
+  /**
+   * Returns the paginated and filtered label groups.
+   * @returns A promise that resolves to an array of label groups.
+   */
+  @Get()
+  async findPage(
+    @Query(PopulatePipe)
+    populate: string[],
+    @Query(
+      new TypeOrmSearchFilterPipe<LabelGroupOrmEntity>({
+        allowedFields: ['name'],
+        defaultSort: ['createdAt', 'desc'],
+      }),
+    )
+    options: FindManyOptions<LabelGroupOrmEntity>,
+  ): Promise<LabelGroup[] | LabelGroupFull[]> {
+    const queryOptions = options ?? {};
+
+    return this.canPopulate(populate)
+      ? await this.labelGroupService.findAndPopulate(queryOptions)
+      : await this.labelGroupService.find(queryOptions);
+  }
+
+  /**
+   * Counts the filtered number of label groups.
+   * @returns A promise that resolves to an object representing the filtered number of labels.
+   */
+  @Get('count')
+  async filterCount(
+    @Query(
+      new TypeOrmSearchFilterPipe<LabelGroupOrmEntity>({
+        allowedFields: ['name'],
+      }),
+    )
+    options?: FindManyOptions<LabelGroupOrmEntity>,
+  ): Promise<{ count: number }> {
+    return await this.count(options ?? {});
+  }
+
+  /**
+   * Returns the label group by ID
+   * @returns A promise that resolves to a label group.
+   */
+  @Get(':id')
+  async findOne(
+    @Param('id') id: string,
+    @Query(PopulatePipe)
+    populate: string[],
+  ): Promise<LabelGroup | LabelGroupFull> {
+    const record = this.canPopulate(populate)
+      ? await this.labelGroupService.findOneAndPopulate(id)
+      : await this.labelGroupService.findOne(id);
+    if (!record) {
+      this.logger.warn(`Unable to find Label Group by id ${id}`);
+      throw new NotFoundException(`Label Group with ID ${id} not found`);
+    }
+
+    return record;
+  }
+
+  /**
+   * Creates a new label group
+   * @returns A promise that resolves to the created label group.
+   */
+  @Post()
+  async create(@Body() labelGroup: LabelGroupCreateDto): Promise<LabelGroup> {
+    return await this.labelGroupService.create(labelGroup);
+  }
+
+  /**
+   * Updates a label group by ID
+   * @returns A promise that resolves to the created label group.
+   */
+  @Patch(':id')
+  async updateOne(
+    @Param('id') id: string,
+    @Body() labelGroupUpdate: LabelGroupUpdateDto,
+  ): Promise<LabelGroup> {
+    return await this.labelGroupService.updateOne(id, labelGroupUpdate);
+  }
+
+  /**
+   * Deletes a label group by ID
+   * @returns A promise that resolves to the label group deletion result.
+   */
+  @Delete(':id')
+  @HttpCode(204)
+  async deleteOne(@Param('id') id: string): Promise<DeleteResult> {
+    const result = await this.labelGroupService.deleteOne(id);
+    if (result.deletedCount === 0) {
+      this.logger.warn(`Unable to delete Label Group by id ${id}`);
+      throw new NotFoundException(`Label Group with ID ${id} not found`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Deletes multiple label groups by their IDs.
+   * @param ids - IDs of label groups to be deleted.
+   * @returns A Promise that resolves to the deletion result.
+   */
+  @Delete('')
+  @HttpCode(204)
+  async deleteMany(@Body('ids') ids?: string[]): Promise<DeleteResult> {
+    if (!ids?.length) {
+      throw new BadRequestException('No IDs provided for deletion.');
+    }
+    const deleteResult = await this.labelGroupService.deleteMany({
+      where: { id: In(ids) },
+    });
+
+    if (deleteResult.deletedCount === 0) {
+      this.logger.warn(
+        `Unable to delete Label Groups with provided IDs: ${ids}`,
+      );
+      throw new NotFoundException('Label Groups with provided IDs not found');
+    }
+
+    this.logger.log(`Successfully deleted Label Groups with IDs: ${ids}`);
+
+    return deleteResult;
+  }
+}

package/src/chat/controllers/label.controller.ts

@@ -0,0 +1,149 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  NotFoundException,
+  Param,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { FindManyOptions, In } from 'typeorm';
+
+import { BaseOrmController } from '@/utils/generics/base-orm.controller';
+import { DeleteResult } from '@/utils/generics/base-orm.repository';
+import { PopulatePipe } from '@/utils/pipes/populate.pipe';
+import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';
+
+import {
+  Label,
+  LabelCreateDto,
+  LabelDtoConfig,
+  LabelFull,
+  LabelTransformerDto,
+  LabelUpdateDto,
+} from '../dto/label.dto';
+import { LabelOrmEntity } from '../entities/label.entity';
+import { LabelService } from '../services/label.service';
+
+@Controller('label')
+export class LabelController extends BaseOrmController<
+  LabelOrmEntity,
+  LabelTransformerDto,
+  LabelDtoConfig
+> {
+  constructor(private readonly labelService: LabelService) {
+    super(labelService);
+  }
+
+  @Get()
+  async findPage(
+    @Query(PopulatePipe)
+    populate: string[],
+    @Query(
+      new TypeOrmSearchFilterPipe<LabelOrmEntity>({
+        allowedFields: ['name', 'title', 'builtin'],
+        defaultSort: ['createdAt', 'desc'],
+      }),
+    )
+    options: FindManyOptions<LabelOrmEntity>,
+  ): Promise<Label[] | LabelFull[]> {
+    const queryOptions = options ?? {};
+
+    return this.canPopulate(populate)
+      ? await this.labelService.findAndPopulate(queryOptions)
+      : await this.labelService.find(queryOptions);
+  }
+
+  /**
+   * Counts the filtered number of labels.
+   * @returns A promise that resolves to an object representing the filtered number of labels.
+   */
+  @Get('count')
+  async filterCount(
+    @Query(
+      new TypeOrmSearchFilterPipe<LabelOrmEntity>({
+        allowedFields: ['name', 'title', 'builtin', 'group.id'],
+      }),
+    )
+    options?: FindManyOptions<LabelOrmEntity>,
+  ): Promise<{ count: number }> {
+    return await this.count(options ?? {});
+  }
+
+  @Get(':id')
+  async findOne(
+    @Param('id') id: string,
+    @Query(PopulatePipe)
+    populate: string[],
+  ): Promise<Label | LabelFull> {
+    const record = this.canPopulate(populate)
+      ? await this.labelService.findOneAndPopulate(id)
+      : await this.labelService.findOne(id);
+    if (!record) {
+      this.logger.warn(`Unable to find Label by id ${id}`);
+      throw new NotFoundException(`Label with ID ${id} not found`);
+    }
+
+    return record;
+  }
+
+  @Post()
+  async create(@Body() label: LabelCreateDto): Promise<Label> {
+    return await this.labelService.create(label);
+  }
+
+  @Patch(':id')
+  async updateOne(
+    @Param('id') id: string,
+    @Body() labelUpdate: LabelUpdateDto,
+  ): Promise<Label> {
+    return await this.labelService.updateOne(id, labelUpdate);
+  }
+
+  @Delete(':id')
+  @HttpCode(204)
+  async deleteOne(@Param('id') id: string): Promise<DeleteResult> {
+    const result = await this.labelService.deleteOne(id);
+    if (result.deletedCount === 0) {
+      this.logger.warn(`Unable to delete Label by id ${id}`);
+      throw new NotFoundException(`Label with ID ${id} not found`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Deletes multiple Labels by their IDs.
+   * @param ids - IDs of Labels to be deleted.
+   * @returns A Promise that resolves to the deletion result.
+   */
+  @Delete('')
+  @HttpCode(204)
+  async deleteMany(@Body('ids') ids?: string[]): Promise<DeleteResult> {
+    if (!ids?.length) {
+      throw new BadRequestException('No IDs provided for deletion.');
+    }
+    const deleteResult = await this.labelService.deleteMany({
+      where: { id: In(ids) },
+    });
+
+    if (deleteResult.deletedCount === 0) {
+      this.logger.warn(`Unable to delete Labels with provided IDs: ${ids}`);
+      throw new NotFoundException('Labels with provided IDs not found');
+    }
+
+    this.logger.log(`Successfully deleted Labels with IDs: ${ids}`);
+
+    return deleteResult;
+  }
+}