@hexabot-ai/api 3.0.0-alpha.3

package/src/utils/test/fixtures/nlpentity.ts

@@ -0,0 +1,61 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource, DeepPartial } from 'typeorm';
+
+import { NlpEntityCreateDto } from '@/nlp/dto/nlp-entity.dto';
+import { NlpEntityOrmEntity } from '@/nlp/entities/nlp-entity.entity';
+
+export const nlpEntityFixtures: NlpEntityCreateDto[] = [
+  {
+    name: 'intent',
+    lookups: ['trait'],
+    doc: '',
+    builtin: false,
+    weight: 1,
+  },
+  {
+    name: 'firstname',
+    lookups: ['keywords'],
+    doc: '',
+    builtin: false,
+    weight: 0.85,
+  },
+  {
+    name: 'built_in',
+    lookups: ['trait'],
+    doc: '',
+    builtin: true,
+    weight: 1,
+  },
+  {
+    name: 'subject',
+    lookups: ['trait'],
+    doc: '',
+    builtin: false,
+    weight: 0.95,
+  },
+];
+
+export const nlpEntityOrmFixtures: DeepPartial<NlpEntityOrmEntity>[] =
+  nlpEntityFixtures.map((fixture) => ({
+    ...fixture,
+    foreignId: null,
+  }));
+
+export const installNlpEntityFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const repository = dataSource.getRepository(NlpEntityOrmEntity);
+  const existing = await repository.find();
+  if (existing.length) {
+    return existing;
+  }
+
+  const entities = repository.create(nlpEntityOrmFixtures);
+
+  return await repository.save(entities);
+};

package/src/utils/test/fixtures/nlpsample.ts

@@ -0,0 +1,91 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource, DeepPartial } from 'typeorm';
+
+import { LanguageOrmEntity } from '@/i18n/entities/language.entity';
+import { NlpSample, NlpSampleCreateDto } from '@/nlp/dto/nlp-sample.dto';
+import { NlpSampleOrmEntity } from '@/nlp/entities/nlp-sample.entity';
+import { NlpSampleState } from '@/nlp/types';
+
+import { getFixturesWithDefaultValues } from '../defaultValues';
+import { FixturesTypeBuilder } from '../types';
+
+import { installLanguageFixturesTypeOrm } from './language';
+
+type TNlpSampleFixtures = FixturesTypeBuilder<NlpSample, NlpSampleCreateDto>;
+
+export const nlpSampleDefaultValues: TNlpSampleFixtures['defaultValues'] = {
+  type: NlpSampleState.train,
+  trained: false,
+};
+
+const nlpSamples: TNlpSampleFixtures['values'][] = [
+  {
+    text: 'yess',
+    language: '0',
+  },
+  {
+    text: 'No',
+    language: '0',
+  },
+  {
+    text: 'Hello',
+    trained: true,
+    language: '0',
+  },
+  {
+    text: 'Bye Jhon',
+    trained: true,
+    language: '0',
+  },
+];
+
+export const nlpSampleFixtures = getFixturesWithDefaultValues<
+  TNlpSampleFixtures['values']
+>({
+  fixtures: nlpSamples,
+  defaultValues: nlpSampleDefaultValues,
+});
+
+export const installNlpSampleFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const languageRepository = dataSource.getRepository(LanguageOrmEntity);
+  let languages = await languageRepository.find();
+  if (!languages.length) {
+    languages = await installLanguageFixturesTypeOrm(dataSource);
+  }
+
+  const repository = dataSource.getRepository(NlpSampleOrmEntity);
+  const existing = await repository.find();
+  if (existing.length) {
+    return existing;
+  }
+
+  const samples: DeepPartial<NlpSampleOrmEntity>[] = nlpSampleFixtures.map(
+    (fixture) => {
+      const languageIndex =
+        typeof fixture.language === 'number'
+          ? fixture.language
+          : parseInt(String(fixture.language), 10);
+      const language =
+        Number.isNaN(languageIndex) || !languages[languageIndex]
+          ? null
+          : languages[languageIndex];
+
+      return {
+        text: fixture.text,
+        trained: fixture.trained ?? false,
+        type: (fixture.type ?? NlpSampleState.train) as NlpSampleState,
+        language: language ? { id: language?.id } : null,
+      };
+    },
+  );
+  const records = repository.create(samples);
+
+  return await repository.save(records);
+};

package/src/utils/test/fixtures/nlpsampleentity.ts

@@ -0,0 +1,99 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource, DeepPartial } from 'typeorm';
+
+import { NlpSampleEntityCreateDto } from '@/nlp/dto/nlp-sample-entity.dto';
+import type { NlpEntityOrmEntity } from '@/nlp/entities/nlp-entity.entity';
+import { NlpSampleEntityOrmEntity } from '@/nlp/entities/nlp-sample-entity.entity';
+import type { NlpSampleOrmEntity } from '@/nlp/entities/nlp-sample.entity';
+import type { NlpValueOrmEntity } from '@/nlp/entities/nlp-value.entity';
+
+import { installNlpEntityFixturesTypeOrm } from './nlpentity';
+import { installNlpSampleFixturesTypeOrm } from './nlpsample';
+import { installNlpValueFixturesTypeOrm, nlpValueFixtures } from './nlpvalue';
+
+export const nlpSampleEntityFixtures: NlpSampleEntityCreateDto[] = [
+  {
+    sample: '0',
+    entity: '0',
+    value: '0',
+  },
+  {
+    sample: '1',
+    entity: '0',
+    value: '1',
+  },
+  {
+    sample: '2',
+    entity: '0',
+    value: '3',
+  },
+  {
+    sample: '3',
+    entity: '0',
+    value: '3',
+  },
+  {
+    sample: '3',
+    entity: '1',
+    value: '4',
+  },
+];
+
+export const installNlpSampleEntityFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const repository = dataSource.getRepository(NlpSampleEntityOrmEntity);
+  const entities = await installNlpEntityFixturesTypeOrm(dataSource);
+  const [samples, values] = await Promise.all([
+    installNlpSampleFixturesTypeOrm(dataSource),
+    installNlpValueFixturesTypeOrm(dataSource),
+  ]);
+  const valueMap = values.reduce<Record<string, NlpValueOrmEntity>>(
+    (acc, value) => {
+      acc[value.value] = value;
+
+      return acc;
+    },
+    {},
+  );
+  const sampleRecords: Record<number, NlpSampleOrmEntity> = {};
+  samples.forEach((sample, index) => (sampleRecords[index] = sample));
+
+  const entityRecords: Record<number, NlpEntityOrmEntity> = {};
+  entities.forEach((entity, index) => (entityRecords[index] = entity));
+
+  const existing = await repository.find();
+  if (existing.length) {
+    return existing;
+  }
+
+  const records: DeepPartial<NlpSampleEntityOrmEntity>[] =
+    nlpSampleEntityFixtures.map((fixture) => {
+      const sample = sampleRecords[parseInt(fixture.sample, 10)];
+      const entity = entityRecords[parseInt(fixture.entity, 10)];
+      const valueFixture = nlpValueFixtures[parseInt(fixture.value, 10)];
+      const value = valueFixture ? valueMap[valueFixture.value] : undefined;
+
+      if (!sample || !entity || !value) {
+        throw new Error(
+          `Unable to resolve sample entity fixture dependencies (sample=${sample?.id ?? 'undefined'}, entity=${entity?.id ?? 'undefined'}, value=${valueFixture?.value ?? 'undefined'})`,
+        );
+      }
+
+      return {
+        sample: { id: sample.id },
+        entity: { id: entity.id },
+        value: { id: value.id },
+        start: fixture.start ?? null,
+        end: fixture.end ?? null,
+      };
+    });
+  const created = repository.create(records);
+
+  return await repository.save(created);
+};

package/src/utils/test/fixtures/nlpvalue.ts

@@ -0,0 +1,115 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource, DeepPartial } from 'typeorm';
+
+import { NlpValueCreateDto } from '@/nlp/dto/nlp-value.dto';
+import { NlpEntityOrmEntity } from '@/nlp/entities/nlp-entity.entity';
+import { NlpValueOrmEntity } from '@/nlp/entities/nlp-value.entity';
+
+import {
+  installNlpEntityFixturesTypeOrm,
+  nlpEntityFixtures,
+} from './nlpentity';
+
+export const nlpValueFixtures: NlpValueCreateDto[] = [
+  {
+    entity: '0',
+    value: 'positive',
+    expressions: [],
+    builtin: false,
+    doc: '',
+  },
+  {
+    entity: '0',
+    value: 'negative',
+    expressions: [],
+    builtin: false,
+    doc: '',
+  },
+  {
+    entity: '1',
+    value: 'jhon',
+    expressions: ['john', 'joohn', 'jhonny'],
+    builtin: false,
+    doc: '',
+  },
+  {
+    entity: '0',
+    value: 'greeting',
+    expressions: ['heello', 'Hello', 'hi', 'heyy'],
+    builtin: false,
+    doc: '',
+  },
+  {
+    entity: '0',
+    value: 'goodbye',
+    expressions: ['bye', 'bye bye'],
+    builtin: false,
+    doc: '',
+  },
+  {
+    entity: '0',
+    value: 'affirmation',
+    expressions: ['yes', 'oui', 'yeah'],
+    builtin: false,
+    doc: '',
+  },
+  {
+    entity: '3',
+    value: 'product',
+    expressions: [],
+    builtin: false,
+    doc: '',
+  },
+  {
+    entity: '3',
+    value: 'claim',
+    expressions: [],
+    builtin: false,
+    doc: '',
+  },
+];
+
+export const installNlpValueFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const nlpEntities = await installNlpEntityFixturesTypeOrm(dataSource);
+  const repository = dataSource.getRepository(NlpValueOrmEntity);
+  const existing = await repository.find();
+  if (existing.length) {
+    return existing;
+  }
+
+  const entitiesByName = nlpEntities.reduce<Record<string, NlpEntityOrmEntity>>(
+    (acc, entity) => {
+      acc[entity.name] = entity;
+
+      return acc;
+    },
+    {},
+  );
+  const values: DeepPartial<NlpValueOrmEntity>[] = nlpValueFixtures.map(
+    (fixture) => {
+      const entityIndex = parseInt(fixture.entity, 10);
+      const entityName = nlpEntityFixtures[entityIndex]?.name;
+      const entity = entityName ? entitiesByName[entityName] : undefined;
+
+      if (!entity) {
+        throw new Error(`Unable to resolve entity for value ${fixture.value}`);
+      }
+
+      return {
+        ...fixture,
+        entity: { id: entity.id },
+        foreignId: null,
+      };
+    },
+  );
+  const records = repository.create(values);
+
+  return await repository.save(records);
+};

package/src/utils/test/fixtures/permission.ts

@@ -0,0 +1,88 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { PermissionCreateDto } from '@/user/dto/permission.dto';
+import { ModelOrmEntity as ModelEntity } from '@/user/entities/model.entity';
+import { PermissionOrmEntity as PermissionEntity } from '@/user/entities/permission.entity';
+import { RoleOrmEntity as RoleEntity } from '@/user/entities/role.entity';
+import { Action } from '@/user/types/action.type';
+
+import { installModelFixturesTypeOrm, modelOrmFixtures } from './model';
+import { installRoleFixturesTypeOrm, roleOrmFixtures } from './role';
+import { installUserFixturesTypeOrm } from './user';
+
+type PermissionOrmFixture = PermissionCreateDto & { id: string };
+
+export const permissionOrmFixtures: PermissionOrmFixture[] = [
+  {
+    id: '77777777-7777-7777-7777-777777777777',
+    model: modelOrmFixtures[0].id,
+    action: Action.CREATE,
+    role: roleOrmFixtures[0].id,
+    relation: 'role',
+  },
+  {
+    id: '88888888-8888-8888-8888-888888888888',
+    model: modelOrmFixtures[0].id,
+    action: Action.DELETE,
+    role: roleOrmFixtures[0].id,
+    relation: 'role',
+  },
+  {
+    id: '99999999-9999-9999-9999-999999999999',
+    model: modelOrmFixtures[0].id,
+    action: Action.READ,
+    role: roleOrmFixtures[1].id,
+    relation: 'role',
+  },
+  {
+    id: 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
+    model: modelOrmFixtures[0].id,
+    action: Action.UPDATE,
+    role: roleOrmFixtures[0].id,
+    relation: 'role',
+  },
+];
+
+export const permissionFixtures: PermissionCreateDto[] =
+  permissionOrmFixtures.map(({ id: _id, ...permission }) => permission);
+
+export const installPermissionFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const modelRepository = dataSource.getRepository(ModelEntity);
+  const roleRepository = dataSource.getRepository(RoleEntity);
+  const permissionRepository = dataSource.getRepository(PermissionEntity);
+  const models =
+    (await modelRepository.count()) === 0
+      ? await installModelFixturesTypeOrm(dataSource)
+      : await modelRepository.find();
+  const roles =
+    (await roleRepository.count()) === 0
+      ? await installRoleFixturesTypeOrm(dataSource)
+      : await roleRepository.find();
+  const users = await installUserFixturesTypeOrm(dataSource);
+
+  if (await permissionRepository.count()) {
+    return await permissionRepository.find({ relations: ['model', 'role'] });
+  }
+
+  const entities = permissionOrmFixtures.map((fixture) =>
+    permissionRepository.create({
+      id: fixture.id,
+      action: fixture.action,
+      relation: fixture.relation,
+      model: { id: fixture.model },
+      role: { id: fixture.role },
+    }),
+  );
+
+  await permissionRepository.save(entities);
+
+  return { models, roles, users, permissions: entities };
+};

package/src/utils/test/fixtures/role.ts

@@ -0,0 +1,52 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { RoleCreateDto } from '@/user/dto/role.dto';
+import { RoleOrmEntity as RoleEntity } from '@/user/entities/role.entity';
+
+type RoleOrmFixture = RoleCreateDto & { id: string };
+
+export const roleFixtureIds = {
+  admin: '11111111-1111-1111-1111-111111111111',
+  manager: '22222222-2222-2222-2222-222222222222',
+  public: '33333333-3333-3333-3333-333333333333',
+} as const;
+
+export const roleOrmFixtures: RoleOrmFixture[] = [
+  {
+    id: roleFixtureIds.admin,
+    name: 'admin',
+    active: true,
+  },
+  {
+    id: roleFixtureIds.manager,
+    name: 'manager',
+    active: true,
+  },
+  {
+    id: roleFixtureIds.public,
+    name: 'public',
+    active: true,
+  },
+];
+
+export const roleFixtures: RoleCreateDto[] = roleOrmFixtures.map(
+  ({ id: _id, ...role }) => role,
+);
+
+export const installRoleFixturesTypeOrm = async (dataSource: DataSource) => {
+  const repository = dataSource.getRepository(RoleEntity);
+
+  if (await repository.count()) {
+    return await repository.find();
+  }
+
+  const entities = repository.create(roleOrmFixtures);
+
+  return await repository.save(entities);
+};

package/src/utils/test/fixtures/setting.ts

@@ -0,0 +1,134 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { SettingCreateDto } from '@/setting/dto/setting.dto';
+import { SettingOrmEntity } from '@/setting/entities/setting.entity';
+import { SettingType } from '@/setting/types';
+import { getRandom } from '@/utils/helpers/safeRandom';
+
+export const settingFixtures: SettingCreateDto[] = [
+  {
+    group: 'chatbot_settings',
+    label: 'default_storage_helper',
+    value: 'local-storage-helper',
+    type: SettingType.text,
+    weight: 1,
+  },
+  {
+    group: 'contact',
+    label: 'contact_email_recipient',
+    value: 'admin@example.com',
+    type: SettingType.text,
+    weight: 1,
+  },
+  {
+    group: 'contact',
+    label: 'company_name',
+    value: 'Your company name',
+    type: SettingType.text,
+    weight: 2,
+  },
+  {
+    group: 'contact',
+    label: 'company_phone',
+    value: '(+999) 9999 9999 999',
+    type: SettingType.text,
+    weight: 3,
+  },
+  {
+    group: 'contact',
+    label: 'company_email',
+    value: 'contact[at]mycompany.com',
+    type: SettingType.text,
+    weight: 4,
+  },
+  {
+    group: 'contact',
+    label: 'company_address1',
+    value: '71 Pilgrim Avenue',
+    type: SettingType.text,
+    weight: 5,
+  },
+  {
+    group: 'contact',
+    label: 'company_address2',
+    value: '',
+    type: SettingType.text,
+    weight: 6,
+  },
+  {
+    group: 'contact',
+    label: 'company_city',
+    value: 'Chevy Chase',
+    type: SettingType.text,
+    weight: 7,
+  },
+  {
+    group: 'contact',
+    label: 'company_zipcode',
+    value: '85705',
+    type: SettingType.text,
+    weight: 8,
+  },
+  {
+    group: 'contact',
+    label: 'company_state',
+    value: 'Orlando',
+    type: SettingType.text,
+    weight: 9,
+  },
+  {
+    group: 'contact',
+    label: 'company_country',
+    value: 'US',
+    type: SettingType.text,
+    weight: 10,
+  },
+  {
+    group: `${getRandom()}_channel`,
+    label: `${getRandom()}`,
+    value: '',
+    type: SettingType.text,
+    weight: 11,
+  },
+  {
+    group: `${getRandom()}_helper`,
+    label: `${getRandom()}`,
+    value: '',
+    type: SettingType.text,
+    weight: 12,
+  },
+  {
+    group: `${getRandom()}_channel`,
+    label: `${getRandom()}`,
+    value: '',
+    type: SettingType.text,
+    weight: 13,
+  },
+  {
+    group: `${getRandom()}_helper`,
+    label: `${getRandom()}`,
+    value: '',
+    type: SettingType.text,
+    weight: 14,
+    translatable: true,
+  },
+  {
+    group: 'local_storage_helper',
+    label: 'default storage helper label',
+    value: 'local-storage-helper',
+    type: SettingType.text,
+    weight: 15,
+  },
+];
+
+export const installSettingFixturesTypeOrm = async (dataSource: DataSource) => {
+  const repository = dataSource.getRepository(SettingOrmEntity);
+  const entities = repository.create(settingFixtures);
+  await repository.save(entities);
+};