Merge pull request #146 from mapeveri/feat/142_term

Add entities term and related #142

src/languages/_dependencyInjection/repositories.ts

@@ -2,10 +2,10 @@ import { AUTH_SESSION_REPOSITORY } from '@src/languages/domain/auth/authSessionR
 import { COUNTRY_REPOSITORY } from '@src/languages/domain/country/countryRepository';
 import { USER_REPOSITORY } from '@src/languages/domain/user/userRepository';
 import { TERM_REPOSITORY } from '@src/languages/domain/term/termRepository';
-import TypeOrmTermRepository from '@src/languages/infrastructure/persistence/typeOrm/repositories/typeOrmTermRepository';
 import MikroOrmUserRepository from '@src/languages/infrastructure/persistence/mikroOrm/repositories/mikroOrmUserRepository';
 import MikroOrmCountryRepository from '../infrastructure/persistence/mikroOrm/repositories/mikroOrmCountryRepository';
 import MikroOrmAuthSessionRepository from '../infrastructure/persistence/mikroOrm/repositories/mikroOrmAuthSessionRepository';
+import MikroOrmTermRepository from '../infrastructure/persistence/mikroOrm/repositories/mikroOrmTermRepository';
 
 export const repositories = [
   {
@@ -18,7 +18,7 @@ export const repositories = [
   },
   {
     provide: TERM_REPOSITORY,
-    useClass: TypeOrmTermRepository,
+    useClass: MikroOrmTermRepository,
   },
   {
     provide: USER_REPOSITORY,

src/languages/app/mikroorm-migrations/Migration20240824163753.ts

@@ -0,0 +1,14 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20240824163753 extends Migration {
+  async up(): Promise<void> {
+    this.addSql('drop table if exists "term" cascade;');
+  }
+
+  async down(): Promise<void> {
+    this.addSql(
+      'CREATE TABLE "term" ("id" character varying, "type" character varying, "languageId" character varying, "countryId" character varying, "userId" character varying, "created_at" TIMESTAMP DEFAULT now(), "updated_at" TIMESTAMP DEFAULT now(), "terms" json DEFAULT \'{"terms":[]}\', CONSTRAINT "PK_55b0479f0743f2e5d5ec414821e" PRIMARY KEY ("id"))',
+    );
+    this.addSql('CREATE INDEX "IDX_19a144ebe2c3c451ea16ff1685" ON "term" ("type") ');
+  }
+}

src/languages/app/mikroorm-migrations/Migration20240825125425.ts

@@ -0,0 +1,14 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20240825125425 extends Migration {
+  async up(): Promise<void> {
+    this.addSql(
+      'create table "term" ("id" uuid not null, "type" varchar(30) not null, "language_id" varchar(10) not null, "country_id" uuid not null, "user_id" uuid not null, "likes" jsonb not null, "created_at" timestamptz null, "updated_at" timestamptz null, "terms" jsonb null, constraint "term_pkey" primary key ("id"));',
+    );
+    this.addSql('create index "term_type_index" on "term" ("type");');
+  }
+
+  async down(): Promise<void> {
+    this.addSql('drop table if exists "term" cascade;');
+  }
+}

src/languages/infrastructure/persistence/mikroOrm/entities/common/dates.ts

@@ -0,0 +1,4 @@
+export const dates = {
+  createdAt: { type: 'Date', onCreate: () => new Date(), nullable: true },
+  updatedAt: { type: 'Date', onCreate: () => new Date(), onUpdate: () => new Date(), nullable: true },
+};

src/languages/infrastructure/persistence/mikroOrm/entities/expression.ts

@@ -0,0 +1,15 @@
+import { EntitySchema } from '@mikro-orm/core';
+import Expression from '@src/languages/domain/term/expression/expression';
+import { ExpressionTermCollectionType } from '../types/expressionTermCollectionType';
+import { TermSchema } from './term';
+
+export const ExpressionSchema = new EntitySchema({
+  class: Expression,
+  tableName: 'expressions',
+  extends: TermSchema,
+  properties: {
+    terms: {
+      type: ExpressionTermCollectionType,
+    },
+  },
+});

src/languages/infrastructure/persistence/mikroOrm/entities/term.ts

@@ -0,0 +1,38 @@
+import { dates } from '@src/languages/infrastructure/persistence/mikroOrm/entities/common/dates';
+import { EntitySchema } from '@mikro-orm/core';
+import Term from '@src/languages/domain/term/term';
+import { TermIdType } from '../types/termIdType';
+import { CountryIdType } from '../types/countryIdType';
+import { UserIdType } from '../types/userIdType';
+import { LikesCollectionType } from '../types/likesCollectionType';
+import { TermTypeType } from '../types/termTypeType';
+
+export const TermSchema = new EntitySchema({
+  class: Term,
+  abstract: true,
+  properties: {
+    id: {
+      type: TermIdType,
+      primary: true,
+    },
+    type: {
+      type: TermTypeType,
+    },
+    languageId: {
+      type: String,
+      length: 10,
+    },
+    countryId: {
+      type: CountryIdType,
+    },
+    userId: {
+      type: UserIdType,
+    },
+    likes: {
+      type: LikesCollectionType,
+    },
+    ...dates,
+  },
+  discriminatorColumn: 'type',
+  discriminatorMap: { expression: 'Expression', word: 'Word' },
+});

src/languages/infrastructure/persistence/mikroOrm/entities/word.ts

@@ -0,0 +1,15 @@
+import { EntitySchema } from '@mikro-orm/core';
+import { TermSchema } from './term';
+import Word from '@src/languages/domain/term/word/word';
+import { WordTermCollectionType } from '../types/wordTermCollectionType';
+
+export const WordSchema = new EntitySchema({
+  class: Word,
+  tableName: 'words',
+  extends: TermSchema,
+  properties: {
+    terms: {
+      type: WordTermCollectionType,
+    },
+  },
+});

src/languages/infrastructure/persistence/mikroOrm/repositories/mikroOrmTermRepository.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { EntityManager, EntityRepository } from '@mikro-orm/core';
+import { InjectRepository } from '@mikro-orm/nestjs';
+import TermRepository from '@src/languages/domain/term/termRepository';
+import { TermSchema } from '../entities/term';
+import Term from '@src/languages/domain/term/term';
+import TermId from '@src/languages/domain/term/termId';
+
+@Injectable()
+export default class MikroOrmTermRepository implements TermRepository {
+  constructor(
+    @InjectRepository(TermSchema)
+    private readonly termRepository: EntityRepository<Term>,
+    private readonly em: EntityManager,
+  ) {}
+
+  async findById(id: TermId): Promise<Term | null> {
+    return await this.termRepository.findOne(id);
+  }
+
+  async remove(term: Term): Promise<void> {
+    await this.termRepository.nativeDelete(term);
+  }
+
+  async save(term: Term): Promise<void> {
+    await this.em.persistAndFlush(term);
+  }
+}

src/languages/infrastructure/persistence/mikroOrm/types/expressionTermCollectionType.ts

@@ -0,0 +1,21 @@
+import { JsonType } from '@mikro-orm/core';
+import { ExpressionTermPrimitives } from '@src/languages/domain/term/expression/expressionTerm';
+import ExpressionTermCollection from '@src/languages/domain/term/expression/expressionTermCollection';
+
+export class ExpressionTermCollectionType extends JsonType {
+  convertToDatabaseValue(value: ExpressionTermCollection): string {
+    if (!value) {
+      return '[]';
+    }
+
+    return JSON.stringify(value.toArray());
+  }
+
+  convertToJSValue(value: ExpressionTermPrimitives[] | null): ExpressionTermCollection {
+    return ExpressionTermCollection.fromPrimitives(value || []);
+  }
+
+  getColumnType() {
+    return 'jsonb';
+  }
+}

src/languages/infrastructure/persistence/mikroOrm/types/likesCollectionType.ts

@@ -0,0 +1,23 @@
+import { JsonType } from '@mikro-orm/core';
+import TermLike, { TermLikePrimitives } from '@src/languages/domain/term/termLike';
+
+export class LikesCollectionType extends JsonType {
+  convertToDatabaseValue(value: TermLike[]): string {
+    if (!value) {
+      return '[]';
+    }
+
+    return JSON.stringify(value.map((like: TermLike) => like.toPrimitives()));
+  }
+
+  convertToJSValue(value: TermLikePrimitives[] | null): TermLike[] {
+    const termLikes = value;
+    if (!termLikes) return [];
+
+    return termLikes.map((termLike) => TermLike.fromPrimitives(termLike)) || [];
+  }
+
+  getColumnType() {
+    return 'jsonb';
+  }
+}

src/languages/infrastructure/persistence/mikroOrm/types/termIdType.ts

@@ -0,0 +1,12 @@
+import TermId from '@src/languages/domain/term/termId';
+import { ValueObjectType } from '@src/shared/infrastructure/persistence/mikroOrm/types/valueObjectType';
+
+export class TermIdType extends ValueObjectType<string> {
+  constructor() {
+    super(TermId);
+  }
+
+  getColumnType() {
+    return 'uuid';
+  }
+}

src/languages/infrastructure/persistence/mikroOrm/types/termTypeType.ts

@@ -0,0 +1,12 @@
+import TermType from '@src/languages/domain/term/termType';
+import { ValueObjectType } from '@src/shared/infrastructure/persistence/mikroOrm/types/valueObjectType';
+
+export class TermTypeType extends ValueObjectType<string> {
+  constructor() {
+    super(TermType);
+  }
+
+  getColumnType() {
+    return 'varchar(30)';
+  }
+}

src/languages/infrastructure/persistence/mikroOrm/types/wordTermCollectionType.ts

@@ -0,0 +1,21 @@
+import { JsonType } from '@mikro-orm/core';
+import { WordTermPrimitives } from '@src/languages/domain/term/word/wordTerm';
+import WordTermCollection from '@src/languages/domain/term/word/wordTermCollection';
+
+export class WordTermCollectionType extends JsonType {
+  convertToDatabaseValue(value: WordTermCollection): string {
+    if (!value) {
+      return '[]';
+    }
+
+    return JSON.stringify(value.toArray());
+  }
+
+  convertToJSValue(value: WordTermPrimitives[] | null): WordTermCollection {
+    return WordTermCollection.fromPrimitives(value || []);
+  }
+
+  getColumnType() {
+    return 'jsonb';
+  }
+}