@hexabot-ai/api 3.0.0-alpha.3

package/src/i18n/controllers/i18n.controller.ts

@@ -0,0 +1,37 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Controller, Get } from '@nestjs/common';
+
+import { ChannelService } from '@/channel/channel.service';
+import { HelperService } from '@/helper/helper.service';
+import { PluginService } from '@/plugins/plugins.service';
+
+@Controller('i18n')
+export class I18nController {
+  constructor(
+    private readonly pluginService: PluginService,
+    private readonly helperService: HelperService,
+    private readonly channelService: ChannelService,
+  ) {}
+
+  /**
+   * Retrieves translations of all the installed extensions.
+   * @returns An nested object that holds the translations grouped by language and extension name.
+   */
+  @Get()
+  getTranslations() {
+    const plugins = this.pluginService.getAll();
+    const helpers = this.helperService.getAll();
+    const channels = this.channelService.getAll();
+
+    return [...plugins, ...helpers, ...channels].reduce((acc, curr) => {
+      acc[curr.getNamespace()] = curr.getTranslations();
+
+      return acc;
+    }, {});
+  }
+}

package/src/i18n/controllers/language.controller.ts

@@ -0,0 +1,140 @@
+/*
+ * 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 } 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 {
+  Language,
+  LanguageCreateDto,
+  LanguageDtoConfig,
+  LanguageTransformerDto,
+  LanguageUpdateDto,
+} from '../dto/language.dto';
+import { LanguageOrmEntity } from '../entities/language.entity';
+import { LanguageService } from '../services/language.service';
+
+@Controller('language')
+export class LanguageController extends BaseOrmController<
+  LanguageOrmEntity,
+  LanguageTransformerDto,
+  LanguageDtoConfig
+> {
+  constructor(protected readonly languageService: LanguageService) {
+    super(languageService);
+  }
+
+  /**
+   * Retrieves languages that match the provided filters, pagination, and sorting options.
+   * @param options - Query options applied to the TypeORM repository.
+   * @returns A Promise that resolves to a paginated list of languages.
+   */
+  @Get()
+  async findPage(
+    @Query(
+      new TypeOrmSearchFilterPipe<LanguageOrmEntity>({
+        allowedFields: ['title', 'code'],
+      }),
+    )
+    options: FindManyOptions<LanguageOrmEntity>,
+  ) {
+    return await this.languageService.find(options);
+  }
+
+  /**
+   * Counts the filtered number of languages.
+   * @param options - Query options applied to the TypeORM repository.
+   * @returns A promise that resolves to an object representing the filtered number of languages.
+   */
+  @Get('count')
+  async filterCount(
+    @Query(
+      new TypeOrmSearchFilterPipe<LanguageOrmEntity>({
+        allowedFields: ['title', 'code'],
+      }),
+    )
+    options?: FindManyOptions<LanguageOrmEntity>,
+  ) {
+    return await super.count(options);
+  }
+
+  /**
+   * Finds a language by its ID.
+   * @param id - The ID of the language to find.
+   * @returns A Promise that resolves to the found language.
+   */
+  @Get(':id')
+  async findOne(@Param('id') id: string): Promise<Language> {
+    const language = await this.languageService.findOne(id);
+    if (!language) {
+      this.logger.warn(`Unable to find Language by id ${id}`);
+      throw new NotFoundException(`Language with ID ${id} not found`);
+    }
+
+    return language;
+  }
+
+  /**
+   * Creates a new language.
+   * @param language - The data of the language to be created.
+   * @returns A Promise that resolves to the created language.
+   */
+  @Post()
+  async create(@Body() language: LanguageCreateDto): Promise<Language> {
+    return await this.languageService.create(language);
+  }
+
+  /**
+   * Updates an existing language.
+   * @param id - The ID of the language to be updated.
+   * @param languageUpdate - The updated data for the language.
+   * @returns A Promise that resolves to the updated language.
+   */
+  @Patch(':id')
+  async updateOne(
+    @Param('id') id: string,
+    @Body() languageUpdate: LanguageUpdateDto,
+  ): Promise<Language> {
+    if ('isDefault' in languageUpdate && !languageUpdate.isDefault) {
+      throw new BadRequestException('Should not be able to disable default');
+    }
+
+    return await this.languageService.updateOne(id, languageUpdate);
+  }
+
+  /**
+   * Deletes a language by its ID.
+   * @param id - The ID of the language 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.languageService.deleteOne(id);
+    if (result.deletedCount === 0) {
+      this.logger.warn(`Unable to delete Language by id ${id}`);
+      throw new BadRequestException(`Unable to delete Language with ID ${id}`);
+    }
+
+    return result;
+  }
+}

package/src/i18n/controllers/translation.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, Not } 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 {
+  TranslationDtoConfig,
+  TranslationTransformerDto,
+  TranslationUpdateDto,
+} from '../dto/translation.dto';
+import { TranslationOrmEntity } from '../entities/translation.entity';
+import { LanguageService } from '../services/language.service';
+import { TranslationService } from '../services/translation.service';
+
+@Controller('translation')
+export class TranslationController extends BaseOrmController<
+  TranslationOrmEntity,
+  TranslationTransformerDto,
+  TranslationDtoConfig
+> {
+  constructor(
+    private readonly languageService: LanguageService,
+    protected readonly translationService: TranslationService,
+  ) {
+    super(translationService);
+  }
+
+  @Get()
+  async findPage(
+    @Query(
+      new TypeOrmSearchFilterPipe<TranslationOrmEntity>({
+        allowedFields: ['str'],
+      }),
+    )
+    options: FindManyOptions<TranslationOrmEntity>,
+  ) {
+    return await this.translationService.find(options);
+  }
+
+  /**
+   * Counts the filtered number of translations.
+   * @returns A promise that resolves to an object representing the filtered number of translations.
+   */
+  @Get('count')
+  async filterCount(
+    @Query(
+      new TypeOrmSearchFilterPipe<TranslationOrmEntity>({
+        allowedFields: ['str'],
+      }),
+    )
+    options?: FindManyOptions<TranslationOrmEntity>,
+  ) {
+    return await super.count(options);
+  }
+
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    const translation = await this.translationService.findOne(id);
+    if (!translation) {
+      this.logger.warn(`Unable to find Translation by id ${id}`);
+      throw new NotFoundException(`Translation with ID ${id} not found`);
+    }
+
+    return translation;
+  }
+
+  @Patch(':id')
+  async updateOne(
+    @Param('id') id: string,
+    @Body() translationUpdate: TranslationUpdateDto,
+  ) {
+    return await this.translationService.updateOne(id, translationUpdate);
+  }
+
+  /**
+   * Refresh translations : Add new strings and remove old ones
+   * @returns {Promise<any>}
+   */
+  @Post('refresh')
+  async refresh(): Promise<any> {
+    const defaultLanguage = await this.languageService.getDefaultLanguage();
+    const languages = await this.languageService.getLanguages();
+    const defaultTrans: TranslationOrmEntity['translations'] = Object.keys(
+      languages,
+    )
+      .filter((lang) => lang !== defaultLanguage.code)
+      .reduce(
+        (acc, curr) => {
+          acc[curr] = '';
+
+          return acc;
+        },
+        {} as { [key: string]: string },
+      );
+    // Scan Blocks
+    let strings = await this.translationService.getAllBlockStrings();
+    const settingStrings = await this.translationService.getSettingStrings();
+    // Scan global settings
+    strings = strings.concat(settingStrings);
+    // Filter unique and not empty messages
+    strings = strings.filter((str, pos) => {
+      return str && strings.indexOf(str) == pos;
+    });
+    // Perform refresh
+    const queue = strings.map((str) =>
+      this.translationService.findOneOrCreate(
+        { where: { str } },
+        { str, translations: defaultTrans },
+      ),
+    );
+    await Promise.all(queue);
+    // Purge non existing translations
+    const deleteOptions: FindManyOptions<TranslationOrmEntity> =
+      strings.length > 0 ? { where: { str: Not(In(strings)) } } : {};
+
+    return await this.translationService.deleteMany(deleteOptions);
+  }
+
+  /**
+   * Deletes a translation by its ID.
+   * @param id - The ID of the translation 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.translationService.deleteOne(id);
+    if (result.deletedCount === 0) {
+      this.logger.warn(`Unable to delete Translation by id ${id}`);
+      throw new BadRequestException(
+        `Unable to delete Translation with ID ${id}`,
+      );
+    }
+
+    return result;
+  }
+}

package/src/i18n/dto/language.dto.ts

@@ -0,0 +1,67 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { PartialType } from '@nestjs/mapped-types';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Exclude, Expose } from 'class-transformer';
+import { IsBoolean, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+import {
+  BaseStub,
+  DtoActionConfig,
+  DtoTransformerConfig,
+} from '@/utils/types/dto.types';
+
+@Exclude()
+export class LanguageStub extends BaseStub {
+  @Expose()
+  title!: string;
+
+  @Expose()
+  code!: string;
+
+  @Expose()
+  isDefault!: boolean;
+
+  @Expose()
+  isRTL!: boolean;
+}
+
+@Exclude()
+export class Language extends LanguageStub {}
+
+export class LanguageCreateDto {
+  @ApiProperty({ description: 'Language Title', type: String })
+  @IsNotEmpty()
+  @IsString()
+  title: string;
+
+  @ApiProperty({ description: 'Language Code', type: String })
+  @IsNotEmpty()
+  @IsString()
+  code: string;
+
+  @ApiProperty({ description: 'Whether Language is RTL', type: Boolean })
+  @IsBoolean()
+  isRTL: boolean;
+
+  @ApiPropertyOptional({ description: 'Is Default Language ?', type: Boolean })
+  @IsOptional()
+  @IsBoolean()
+  isDefault?: boolean;
+}
+
+export class LanguageUpdateDto extends PartialType(LanguageCreateDto) {}
+
+export type LanguageTransformerDto = DtoTransformerConfig<{
+  PlainCls: typeof Language;
+  FullCls: typeof Language;
+}>;
+
+export type LanguageDtoConfig = DtoActionConfig<{
+  create: LanguageCreateDto;
+  update: LanguageUpdateDto;
+}>;

package/src/i18n/dto/translation.dto.ts

@@ -0,0 +1,52 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { PartialType } from '@nestjs/mapped-types';
+import { ApiProperty } from '@nestjs/swagger';
+import { Exclude, Expose } from 'class-transformer';
+import { IsNotEmpty, IsObject, IsString } from 'class-validator';
+
+import {
+  BaseStub,
+  DtoActionConfig,
+  DtoTransformerConfig,
+} from '@/utils/types/dto.types';
+
+@Exclude()
+export class TranslationStub extends BaseStub {
+  @Expose()
+  str!: string;
+
+  @Expose()
+  translations!: Record<string, string>;
+}
+
+@Exclude()
+export class Translation extends TranslationStub {}
+
+export class TranslationCreateDto {
+  @ApiProperty({ description: 'Translation str', type: String })
+  @IsNotEmpty()
+  @IsString()
+  str: string;
+
+  @ApiProperty({ description: 'Translations', type: Object })
+  @IsNotEmpty()
+  @IsObject()
+  translations: Record<string, string>;
+}
+
+export class TranslationUpdateDto extends PartialType(TranslationCreateDto) {}
+
+export type TranslationTransformerDto = DtoTransformerConfig<{
+  PlainCls: typeof Translation;
+  FullCls: typeof Translation;
+}>;
+
+export type TranslationDtoConfig = DtoActionConfig<{
+  create: TranslationCreateDto;
+  update: TranslationUpdateDto;
+}>;

package/src/i18n/entities/language.entity.ts

@@ -0,0 +1,61 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  BeforeInsert,
+  BeforeRemove,
+  BeforeUpdate,
+  Column,
+  Entity,
+  Index,
+} from 'typeorm';
+
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+
+@Entity({ name: 'languages' })
+export class LanguageOrmEntity extends BaseOrmEntity {
+  @Column({ unique: true })
+  @Index()
+  title!: string;
+
+  @Column({ unique: true })
+  @Index()
+  code!: string;
+
+  @Column({ default: false })
+  isDefault!: boolean;
+
+  @Column({ default: false })
+  isRTL!: boolean;
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  protected async ensureSingleDefault(): Promise<void> {
+    if (!this.isDefault) {
+      return;
+    }
+
+    const manager = LanguageOrmEntity.getEntityManager();
+    const queryBuilder = manager
+      .createQueryBuilder()
+      .update(LanguageOrmEntity)
+      .set({ isDefault: false })
+      .where('isDefault = :isDefault', { isDefault: true });
+
+    if (this.id) {
+      queryBuilder.andWhere('id != :id', { id: this.id });
+    }
+
+    await queryBuilder.execute();
+  }
+
+  @BeforeRemove()
+  protected preventDefaultRemoval(): void {
+    if (this.isDefault) {
+      throw new Error('Should not be able to delete default');
+    }
+  }
+}

package/src/i18n/entities/translation.entity.ts

@@ -0,0 +1,20 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Column, Entity, Index } from 'typeorm';
+
+import { JsonColumn } from '@/database/decorators/json-column.decorator';
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+
+@Entity({ name: 'translations' })
+export class TranslationOrmEntity extends BaseOrmEntity {
+  @Column({ unique: true })
+  @Index()
+  str!: string;
+
+  @JsonColumn()
+  translations!: Record<string, string>;
+}

package/src/i18n/i18n.module.ts

@@ -0,0 +1,84 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  InternalServerErrorException,
+  Module,
+} from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import {
+  I18N_OPTIONS,
+  I18N_TRANSLATIONS,
+  I18nOptions,
+  I18nTranslation,
+  I18nModule as NativeI18nModule,
+} from 'nestjs-i18n';
+import { Observable } from 'rxjs';
+
+import { ChatModule } from '@/chat/chat.module';
+
+import { I18nController } from './controllers/i18n.controller';
+import { LanguageController } from './controllers/language.controller';
+import { TranslationController } from './controllers/translation.controller';
+import { LanguageOrmEntity } from './entities/language.entity';
+import { TranslationOrmEntity } from './entities/translation.entity';
+import { LanguageRepository } from './repositories/language.repository';
+import { TranslationRepository } from './repositories/translation.repository';
+import { LanguageSeeder } from './seeds/language.seed';
+import { TranslationSeeder } from './seeds/translation.seed';
+import { I18nService } from './services/i18n.service';
+import { LanguageService } from './services/language.service';
+import { TranslationService } from './services/translation.service';
+
+@Global()
+@Module({})
+export class I18nModule extends NativeI18nModule {
+  constructor(
+    i18n: I18nService,
+    @Inject(I18N_TRANSLATIONS)
+    translations: Observable<I18nTranslation>,
+    @Inject(I18N_OPTIONS) i18nOptions: I18nOptions,
+    adapter: HttpAdapterHost,
+  ) {
+    super(i18n, translations, i18nOptions, adapter);
+  }
+
+  static forRoot(options: I18nOptions): DynamicModule {
+    const { imports, providers, controllers, exports } = super.forRoot(options);
+    if (!providers || !exports) {
+      throw new InternalServerErrorException(
+        'I18n: Unable to find providers and/or exports forRoot()',
+      );
+    }
+
+    return {
+      module: I18nModule,
+      imports: (imports || []).concat([
+        TypeOrmModule.forFeature([LanguageOrmEntity, TranslationOrmEntity]),
+        ChatModule,
+      ]),
+      controllers: (controllers || []).concat([
+        LanguageController,
+        TranslationController,
+        I18nController,
+      ]),
+      providers: providers.concat([
+        I18nService,
+        LanguageRepository,
+        LanguageService,
+        LanguageSeeder,
+        TranslationRepository,
+        TranslationService,
+        TranslationSeeder,
+      ]),
+      exports: exports.concat(I18nService, LanguageService),
+    };
+  }
+}

package/src/i18n/index.ts

@@ -0,0 +1,39 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export * from './controllers/i18n.controller';
+
+export * from './controllers/language.controller';
+
+export * from './controllers/translation.controller';
+
+export * from './dto/language.dto';
+
+export * from './dto/translation.dto';
+
+export * from './entities/language.entity';
+
+export * from './entities/translation.entity';
+
+export * from './i18n.module';
+
+export * from './repositories/language.repository';
+
+export * from './repositories/translation.repository';
+
+export * from './seeds/language.seed-model';
+
+export * from './seeds/language.seed';
+
+export * from './seeds/translation.seed-model';
+
+export * from './seeds/translation.seed';
+
+export * from './services/i18n.service';
+
+export * from './services/language.service';
+
+export * from './services/translation.service';

package/src/i18n/repositories/language.repository.ts

@@ -0,0 +1,35 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { BaseOrmRepository } from '@/utils/generics/base-orm.repository';
+
+import {
+  Language,
+  LanguageDtoConfig,
+  LanguageTransformerDto,
+} from '../dto/language.dto';
+import { LanguageOrmEntity } from '../entities/language.entity';
+
+@Injectable()
+export class LanguageRepository extends BaseOrmRepository<
+  LanguageOrmEntity,
+  LanguageTransformerDto,
+  LanguageDtoConfig
+> {
+  constructor(
+    @InjectRepository(LanguageOrmEntity)
+    repository: Repository<LanguageOrmEntity>,
+  ) {
+    super(repository, [], {
+      PlainCls: Language,
+      FullCls: Language,
+    });
+  }
+}