@hexabot-ai/api 3.0.0-alpha.3

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

@@ -0,0 +1,68 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { Invitation } from '@/user/dto/invitation.dto';
+import { InvitationOrmEntity as InvitationEntity } from '@/user/entities/invitation.entity';
+import { RoleOrmEntity as RoleEntity } from '@/user/entities/role.entity';
+import { sha256Hash } from '@/user/utilities/hash';
+
+import { getFixturesWithDefaultValues } from '../defaultValues';
+import { TFixtures } from '../types';
+
+import { installRoleFixturesTypeOrm, roleOrmFixtures } from './role';
+
+type InvitationOrmFixture = TFixtures<Invitation> & { id: string };
+
+const invitations: InvitationOrmFixture[] = [
+  {
+    id: 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
+    email: 'email@test.com',
+    roles: [roleOrmFixtures[0].id],
+    token: sha256Hash('testtoken'),
+  },
+];
+
+export const invitationsFixtures = getFixturesWithDefaultValues({
+  fixtures: invitations,
+});
+
+export const installInvitationFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const roleRepository = dataSource.getRepository(RoleEntity);
+  const invitationRepository = dataSource.getRepository(InvitationEntity);
+  const roles =
+    (await roleRepository.count()) === 0
+      ? await installRoleFixturesTypeOrm(dataSource)
+      : await roleRepository.find();
+
+  if (await invitationRepository.count()) {
+    return await invitationRepository.find({ relations: ['roles'] });
+  }
+
+  const roleByFixtureId = new Map<string, RoleEntity>();
+  roleOrmFixtures.forEach((fixture, index) => {
+    const role = roles[index];
+    if (role) {
+      roleByFixtureId.set(fixture.id, role);
+    }
+  });
+
+  const entities = invitationsFixtures.map((fixture) =>
+    invitationRepository.create({
+      id: fixture.id,
+      email: fixture.email,
+      token: fixture.token,
+      roles: fixture.roles
+        .map((roleId) => roleByFixtureId.get(roleId))
+        .filter((role): role is RoleEntity => Boolean(role)),
+    }),
+  );
+
+  return await invitationRepository.save(entities);
+};

package/src/utils/test/fixtures/label-group.ts

@@ -0,0 +1,96 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { LabelGroup, LabelGroupCreateDto } from '@/chat/dto/label-group.dto';
+import { LabelGroupOrmEntity } from '@/chat/entities/label-group.entity';
+import { LabelOrmEntity } from '@/chat/entities/label.entity';
+
+import { getFixturesWithDefaultValues } from '../defaultValues';
+import { FixturesTypeBuilder } from '../types';
+
+import {
+  contentLabelDefaultValues,
+  installLabelFixturesTypeOrm,
+  TLabelFixtures,
+} from './label';
+
+type TLabelGroupFixtures = FixturesTypeBuilder<LabelGroup, LabelGroupCreateDto>;
+
+export const labelGroupFixtures: TLabelGroupFixtures['values'][] = [
+  {
+    name: 'Subscription',
+  },
+];
+
+export const labelGroupLabels: TLabelFixtures['values'][] = [
+  {
+    name: 'FREE',
+    title: 'Free',
+  },
+  {
+    name: 'STANDARD',
+    title: 'Standard',
+  },
+  {
+    name: 'PREMIUM',
+    title: 'Premium',
+  },
+];
+
+export const groupedLabelFixtures = getFixturesWithDefaultValues<
+  TLabelFixtures['values']
+>({
+  fixtures: labelGroupLabels,
+  defaultValues: contentLabelDefaultValues,
+});
+
+const findLabelGroups = async (dataSource: DataSource) => {
+  const repository = dataSource.getRepository(LabelGroupOrmEntity);
+
+  return await repository.find({ relations: ['labels'] });
+};
+const findLabels = async (dataSource: DataSource) => {
+  const repository = dataSource.getRepository(LabelOrmEntity);
+
+  return await repository.find({ relations: ['group', 'users'] });
+};
+
+export const installLabelGroupFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const labelGroupRepository = dataSource.getRepository(LabelGroupOrmEntity);
+  const labelRepository = dataSource.getRepository(LabelOrmEntity);
+  const baseLabels = await installLabelFixturesTypeOrm(dataSource);
+
+  if (await labelGroupRepository.count()) {
+    return {
+      labelGroups: await findLabelGroups(dataSource),
+      labels: await findLabels(dataSource),
+      baseLabels,
+    };
+  }
+
+  const groupEntities = labelGroupFixtures.map((fixture) =>
+    labelGroupRepository.create(fixture),
+  );
+  const savedGroups = await labelGroupRepository.save(groupEntities);
+  const [primaryGroup] = savedGroups;
+  const groupedLabelEntities = groupedLabelFixtures.map((fixture) =>
+    labelRepository.create({
+      ...fixture,
+      group: primaryGroup ? { id: primaryGroup.id } : null,
+    }),
+  );
+  await labelRepository.save(groupedLabelEntities);
+
+  return {
+    labelGroups: await findLabelGroups(dataSource),
+    labels: await findLabels(dataSource),
+    baseLabels,
+  };
+};

package/src/utils/test/fixtures/label.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 { Label, LabelCreateDto } from '@/chat/dto/label.dto';
+import { LabelGroupOrmEntity } from '@/chat/entities/label-group.entity';
+import { LabelOrmEntity } from '@/chat/entities/label.entity';
+
+import { getFixturesWithDefaultValues } from '../defaultValues';
+import { FixturesTypeBuilder } from '../types';
+
+export type TLabelFixtures = FixturesTypeBuilder<Label, LabelCreateDto>;
+
+export const contentLabelDefaultValues: TLabelFixtures['defaultValues'] = {
+  builtin: false,
+};
+
+export const labels: TLabelFixtures['values'][] = [
+  {
+    description: 'test description 1',
+    label_id: {
+      messenger: 'messenger',
+      web: 'web',
+      twitter: 'twitter',
+      dimelo: 'dimelo',
+    },
+    name: 'TEST_TITLE_1',
+    title: 'test title 1',
+  },
+  {
+    description: 'test description 2',
+    label_id: {
+      messenger: 'messenger',
+      web: 'web',
+      twitter: 'twitter',
+      dimelo: 'dimelo',
+    },
+    name: 'TEST_TITLE_2',
+    title: 'test title 2',
+  },
+  {
+    description: 'test description 3',
+    label_id: {
+      messenger: 'messenger',
+      web: 'web',
+      twitter: 'twitter',
+      dimelo: 'dimelo',
+    },
+    name: 'TEST_TITLE_3',
+    title: 'test title 3',
+  },
+];
+
+export const labelFixtures = getFixturesWithDefaultValues<
+  TLabelFixtures['values']
+>({
+  fixtures: labels,
+  defaultValues: contentLabelDefaultValues,
+});
+
+export const installLabelFixturesTypeOrm = async (dataSource: DataSource) => {
+  const repository = dataSource.getRepository(LabelOrmEntity);
+
+  if (await repository.count()) {
+    return await repository.find({ relations: ['group', 'users'] });
+  }
+
+  const entities = labelFixtures.map((fixture) => {
+    const { group, ...label } = fixture;
+
+    return repository.create({
+      ...label,
+      builtin: fixture.builtin ?? false,
+      description:
+        fixture.description === undefined ? null : fixture.description,
+      label_id: fixture.label_id === undefined ? null : fixture.label_id,
+      group: group ? ({ id: group } as Pick<LabelGroupOrmEntity, 'id'>) : null,
+    });
+  });
+
+  await repository.save(entities);
+
+  return await repository.find({ relations: ['group', 'users'] });
+};

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

@@ -0,0 +1,41 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { LanguageCreateDto } from '@/i18n/dto/language.dto';
+import { LanguageOrmEntity } from '@/i18n/entities/language.entity';
+
+export const languageFixtures: LanguageCreateDto[] = [
+  {
+    title: 'English',
+    code: 'en',
+    isDefault: true,
+    isRTL: false,
+  },
+  {
+    title: 'Français',
+    code: 'fr',
+    isDefault: false,
+    isRTL: false,
+  },
+];
+
+export const installLanguageFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const repository = dataSource.getRepository(LanguageOrmEntity);
+  LanguageOrmEntity.registerEntityManagerProvider(() => repository.manager);
+
+  const existing = await repository.find();
+  if (existing.length) {
+    return existing;
+  }
+
+  const entities = repository.create(languageFixtures);
+
+  return await repository.save(entities);
+};

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

@@ -0,0 +1,181 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource, DeepPartial } from 'typeorm';
+
+import { MenuCreateDto } from '@/cms/dto/menu.dto';
+import { MenuOrmEntity, MenuType } from '@/cms/entities/menu.entity';
+
+export const websiteMenuFixture: MenuCreateDto = {
+  type: MenuType.web_url,
+  url: 'https://orange.tn',
+  title: 'Site Web',
+};
+
+export const offerMenuFixture: MenuCreateDto = {
+  title: 'Nos Offres et Nos Boutiques',
+  type: MenuType.nested,
+};
+
+export const rootMenuFixtures: MenuCreateDto[] = [
+  offerMenuFixture,
+  {
+    type: MenuType.nested,
+    title: 'Gérer Mon Compte',
+  },
+  websiteMenuFixture,
+];
+
+export const offersMenuFixtures: MenuCreateDto[] = [
+  {
+    parent: '0',
+    type: MenuType.postback,
+    payload: 'Lignes mobiles',
+    title: 'Offres mobiles',
+  },
+  {
+    parent: '0',
+    type: MenuType.nested,
+    title: 'Devices',
+  },
+  {
+    parent: '0',
+    title: 'Points de Ventes et Boutiques',
+    type: MenuType.postback,
+    payload: 'Points de Ventes et Boutiques',
+  },
+];
+
+export const devicesMenuFixtures: MenuCreateDto[] = [
+  {
+    parent: '4',
+    type: MenuType.postback,
+    payload: 'Smartphones',
+    title: 'Smartphones',
+  },
+  {
+    parent: '4',
+    title: 'Tablettes',
+    type: MenuType.postback,
+    payload: 'Tablettes',
+  },
+  {
+    parent: '4',
+    title: 'Accessoires',
+    type: MenuType.postback,
+    payload: 'Accessoires',
+  },
+];
+
+export const accountMenuFixtures: MenuCreateDto[] = [
+  {
+    parent: '1',
+    type: MenuType.postback,
+    payload: 'Consultation de solde',
+    title: 'Consultation de solde',
+  },
+  {
+    parent: '1',
+    type: MenuType.postback,
+    payload: "Achat d'options",
+    title: "Achat d'options",
+  },
+  {
+    parent: '1',
+    title: 'Mon offre',
+    type: MenuType.postback,
+    payload: 'Mon offre',
+  },
+  {
+    parent: '1',
+    title: 'Obtenir mon code PUK',
+    type: MenuType.postback,
+    payload: 'Obtenir mon code PUK',
+  },
+];
+
+export const installMenuFixturesTypeOrm = async (
+  dataSource: DataSource,
+): Promise<void> => {
+  const repository = dataSource.getRepository(MenuOrmEntity);
+  MenuOrmEntity.registerEntityManagerProvider(() => repository.manager);
+
+  const count = await repository.count();
+  if (count > 0) {
+    return;
+  }
+
+  const resolveParentId = (
+    parent: string | undefined,
+    collection: MenuOrmEntity[],
+  ) => {
+    if (!parent) {
+      return undefined;
+    }
+    const idx = Number(parent);
+    if (!Number.isInteger(idx) || !collection[idx]) {
+      throw new Error(`Unable to resolve menu parent for index: ${parent}`);
+    }
+
+    return collection[idx].id;
+  };
+  const toParentRelation = (id?: string): DeepPartial<MenuOrmEntity> | null =>
+    id ? ({ id } as DeepPartial<MenuOrmEntity>) : null;
+  const roots = await repository.save(
+    repository.create(
+      rootMenuFixtures.map(
+        (menu): DeepPartial<MenuOrmEntity> => ({
+          title: menu.title,
+          type: menu.type,
+          payload: menu.payload,
+          url: menu.url,
+        }),
+      ),
+    ),
+  );
+  const offers = await repository.save(
+    repository.create(
+      offersMenuFixtures.map(
+        (menu): DeepPartial<MenuOrmEntity> => ({
+          title: menu.title,
+          type: menu.type,
+          payload: menu.payload,
+          url: menu.url,
+          parent: toParentRelation(resolveParentId(menu.parent, roots)),
+        }),
+      ),
+    ),
+  );
+  const all = [...roots, ...offers];
+
+  await repository.save(
+    repository.create(
+      devicesMenuFixtures.map(
+        (menu): DeepPartial<MenuOrmEntity> => ({
+          title: menu.title,
+          type: menu.type,
+          payload: menu.payload,
+          url: menu.url,
+          parent: toParentRelation(resolveParentId(menu.parent, all)),
+        }),
+      ),
+    ),
+  );
+
+  await repository.save(
+    repository.create(
+      accountMenuFixtures.map(
+        (menu): DeepPartial<MenuOrmEntity> => ({
+          title: menu.title,
+          type: menu.type,
+          payload: menu.payload,
+          url: menu.url,
+          parent: toParentRelation(resolveParentId(menu.parent, roots)),
+        }),
+      ),
+    ),
+  );
+};

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

@@ -0,0 +1,116 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { Message, MessageCreateDto } from '@/chat/dto/message.dto';
+import { MessageOrmEntity } from '@/chat/entities/message.entity';
+
+import { getFixturesWithDefaultValues } from '../defaultValues';
+import { FixturesTypeBuilder, TFixturesDefaultValues } from '../types';
+
+import { installSubscriberFixturesTypeOrm } from './subscriber';
+
+type TMessageFixtures = FixturesTypeBuilder<Message, MessageCreateDto>;
+
+const messages: TMessageFixtures['values'][] = [
+  {
+    mid: 'mid-1',
+    sender: '1',
+    recipient: '1',
+    sentBy: '0',
+    message: { text: 'Hello from the past' },
+    read: true,
+    delivery: true,
+  },
+  {
+    mid: 'mid-2',
+    sender: '1',
+    recipient: '1',
+    sentBy: '0',
+    message: { text: 'Hello' },
+    delivery: true,
+  },
+  {
+    mid: 'mid-3',
+    sender: '1',
+    recipient: '1',
+    sentBy: '0',
+    message: { text: 'Hello back' },
+  },
+];
+
+export const messageDefaultValues: TFixturesDefaultValues<Message> = {
+  read: false,
+  delivery: false,
+  handover: false,
+};
+
+export const messageFixtures = getFixturesWithDefaultValues<
+  Message,
+  TMessageFixtures['values']
+>({
+  fixtures: messages,
+  defaultValues: messageDefaultValues,
+});
+
+const findMessages = async (dataSource: DataSource) =>
+  await dataSource.getRepository(MessageOrmEntity).find({
+    relations: ['sender', 'recipient', 'sentBy'],
+  });
+const parseIndex = (value?: string | null) => {
+  if (value == null) {
+    return null;
+  }
+
+  const index = Number.parseInt(value, 10);
+
+  return Number.isNaN(index) ? null : index;
+};
+
+export const installMessageFixturesTypeOrm = async (dataSource: DataSource) => {
+  const repository = dataSource.getRepository(MessageOrmEntity);
+  const { subscribers, users } =
+    await installSubscriberFixturesTypeOrm(dataSource);
+
+  if (await repository.count()) {
+    return await findMessages(dataSource);
+  }
+
+  const entities = messageFixtures.map((fixture) => {
+    const senderIndex = parseIndex(fixture.sender);
+    const recipientIndex = parseIndex(fixture.recipient);
+    const sentByIndex = parseIndex(fixture.sentBy);
+    const sender =
+      senderIndex != null && subscribers[senderIndex]
+        ? { id: subscribers[senderIndex].id }
+        : null;
+    const recipient =
+      recipientIndex != null && subscribers[recipientIndex]
+        ? { id: subscribers[recipientIndex].id }
+        : null;
+    const sentBy =
+      sentByIndex != null && users[sentByIndex]
+        ? { id: users[sentByIndex].id }
+        : null;
+
+    return repository.create({
+      mid: fixture.mid ?? null,
+      message: fixture.message,
+      read: fixture.read ?? false,
+      delivery: fixture.delivery ?? false,
+      handover: fixture.handover ?? false,
+      sender,
+      recipient,
+      sentBy,
+      createdAt: fixture.createdAt,
+    });
+  });
+
+  await repository.save(entities);
+
+  return await findMessages(dataSource);
+};

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

@@ -0,0 +1,25 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { MetadataCreateDto } from '@/setting/dto/metadata.dto';
+import { MetadataOrmEntity } from '@/setting/entities/metadata.entity';
+
+const metadataFixtures: MetadataCreateDto[] = [
+  {
+    name: 'app-version',
+    value: '2.2.0',
+  },
+];
+
+export const installMetadataFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const repository = dataSource.getRepository(MetadataOrmEntity);
+  const entities = repository.create(metadataFixtures);
+  await repository.save(entities);
+};

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

@@ -0,0 +1,30 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { MigrationOrmEntity } from '@/migration/migration.entity';
+import { MigrationAction } from '@/migration/types';
+
+const migrationFixtures: Array<Partial<MigrationOrmEntity>> = [
+  {
+    version: 'v3.0.2',
+    status: MigrationAction.UP,
+  },
+  {
+    version: 'v3.0.1',
+    status: MigrationAction.DOWN,
+  },
+];
+
+export const installMigrationFixturesTypeOrm = async (
+  dataSource: DataSource,
+) => {
+  const repository = dataSource.getRepository(MigrationOrmEntity);
+  const entities = repository.create(migrationFixtures);
+
+  return await repository.save(entities);
+};

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

@@ -0,0 +1,51 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { DataSource } from 'typeorm';
+
+import { ModelCreateDto } from '@/user/dto/model.dto';
+import { ModelOrmEntity as ModelEntity } from '@/user/entities/model.entity';
+
+type ModelOrmFixture = ModelCreateDto & { id: string };
+
+export const modelFixtureIds = {
+  contentType: '44444444-4444-4444-4444-444444444444',
+  content: '55555555-5555-5555-5555-555555555555',
+} as const;
+
+export const modelOrmFixtures: ModelOrmFixture[] = [
+  {
+    id: modelFixtureIds.contentType,
+    name: 'ContentType',
+    identity: 'contenttype',
+    attributes: { att: 'att' },
+    relation: 'role',
+  },
+
+  {
+    id: modelFixtureIds.content,
+    name: 'Content',
+    identity: 'content',
+    attributes: { att: 'att' },
+    relation: 'role',
+  },
+];
+
+export const modelFixtures: ModelCreateDto[] = modelOrmFixtures.map(
+  ({ id: _id, ...model }) => model,
+);
+
+export const installModelFixturesTypeOrm = async (dataSource: DataSource) => {
+  const repository = dataSource.getRepository(ModelEntity);
+
+  if (await repository.count()) {
+    return await repository.find();
+  }
+
+  const entities = repository.create(modelOrmFixtures);
+
+  return await repository.save(entities);
+};