@natrave/shared-entities 1.1.1

package/src/app-auth/users/user.entity.ts

@@ -0,0 +1,149 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Unique,
+  OneToMany,
+  BeforeInsert,
+} from 'typeorm';
+
+import { PasswordReset } from 'app-auth/password-resets';
+import { RefreshToken } from 'app-auth/refresh-tokens';
+import { UserAuthProvider } from 'app-auth/user-auth-providers';
+import { UserVerification } from 'app-auth/user-verifications';
+import { UserPaymentProvider } from 'payments';
+import { TournamentPlayer } from 'tournaments';
+
+import { formatUserBeforeInsertData } from './utils/format-data.utils';
+
+/**
+ * Entidade que representa um usuário.
+ *
+ * @remarks
+ * Esta entidade armazena os dados essenciais de um usuário, como nome, email, username, CPF, telefone e senha.
+ * Além disso, mantém a associação com outras entidades, como tokens de atualização, resets de senha,
+ * verificações, provedores de autenticação, sessões de jogo, jogadores de torneio e provedores de pagamento.
+ *
+ * @public
+ */
+@Entity('users')
+@Unique(['email'])
+@Unique(['username'])
+@Unique(['phone'])
+@Unique(['cpf'])
+export class User {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({
+    name: 'numeric_id',
+    type: 'int',
+    unique: true,
+    nullable: false,
+    generated: 'increment',
+  })
+  numericId: number;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  @DeleteDateColumn({ name: 'deleted_at', type: 'timestamptz', nullable: true })
+  deletedAt?: Date;
+
+  @Column({ name: 'first_name', type: 'varchar', length: 255, nullable: true })
+  firstName?: string;
+
+  @Column({ name: 'last_name', type: 'varchar', length: 255, nullable: true })
+  lastName?: string;
+
+  @Column({ type: 'varchar', length: 255, unique: true })
+  email: string;
+
+  @Column({ type: 'varchar', length: 255, unique: true, nullable: true })
+  username: string;
+
+  @Column({ type: 'varchar', length: 14, nullable: true, unique: true })
+  cpf?: string;
+
+  @Column({
+    name: 'phone',
+    type: 'varchar',
+    length: 16,
+    unique: true,
+    nullable: true,
+  })
+  phone?: string;
+
+  @Column({
+    name: 'password_hash',
+    type: 'varchar',
+    length: 255,
+    nullable: true,
+  })
+  passwordHash: string | null;
+
+  @Column({ name: 'image_url', type: 'varchar', length: 500, nullable: true })
+  imageUrl?: string;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com os tokens de atualização do usuário.
+   */
+  @OneToMany(() => RefreshToken, (refreshToken) => refreshToken.user)
+  refreshTokens: RefreshToken[];
+
+  /**
+   * Relação com os resets de senha do usuário.
+   */
+  @OneToMany(() => PasswordReset, (passwordReset) => passwordReset.user)
+  passwordResets: PasswordReset[];
+
+  /**
+   * Relação com as verificações do usuário.
+   */
+  @OneToMany(() => UserVerification, (verification) => verification.user)
+  verifications: UserVerification[];
+
+  /**
+   * Relação com os provedores de autenticação associados ao usuário.
+   */
+  @OneToMany(() => UserAuthProvider, (userAuthProvider) => userAuthProvider.user, {
+    cascade: true,
+  })
+  userAuthProviders: UserAuthProvider[];
+
+  /**
+   * Relação com os jogadores de torneio associados ao usuário.
+   */
+  @OneToMany(() => TournamentPlayer, (tournamentPlayer) => tournamentPlayer.user, {
+    cascade: true,
+  })
+  tournamentPlayers: TournamentPlayer[];
+
+  /**
+   * Relação com os provedores de pagamento associados ao usuário.
+   */
+  @OneToMany(() => UserPaymentProvider, (userPaymentProvider) => userPaymentProvider.user, {
+    cascade: true,
+  })
+  userPaymentProviders: UserPaymentProvider[];
+
+  /**
+   * Prepara os dados do usuário antes de inserir no banco.
+   *
+   * @remarks
+   * A lógica de formatação e validação dos dados é delegada à função externa `formatUserData`,
+   * seguindo o princípio de responsabilidade única (SRP) e facilitando a manutenção e testabilidade do código.
+   */
+  @BeforeInsert()
+  prepareData(): void {
+    formatUserBeforeInsertData(this);
+  }
+}

package/src/app-auth/users/utils/format-data.utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Formata os dados do usuário antes de inseri-los no banco.
+ *
+ * @remarks
+ * Esta função ajusta os campos de email, username, CPF e telefone do usuário:
+ * - Converte email e username para minúsculas e remove espaços desnecessários.
+ * - Remove caracteres não numéricos do CPF.
+ * - Remove caracteres não numéricos do telefone, adiciona o código do Brasil (55) se necessário e prefixa com "+".
+ *
+ * @param user - A instância do usuário a ser formatada.
+ */
+export function formatUserBeforeInsertData(user: {
+  email?: string;
+  username?: string;
+  cpf?: string;
+  phone?: string;
+}): void {
+  if (user.email) {
+    user.email = user.email.toLowerCase().trim();
+  }
+  if (user.username) {
+    user.username = user.username.toLowerCase().trim();
+  }
+  if (user.cpf) {
+    // Remove qualquer caractere que não seja número
+    user.cpf = user.cpf.replace(/\D/g, '').trim();
+  }
+  if (user.phone) {
+    // Remove todos os caracteres que não são números
+    user.phone = user.phone.replace(/\D/g, '').trim();
+    // Garante que o telefone tenha o código do Brasil (55)
+    if (!user.phone.startsWith('55')) {
+      user.phone = `55${user.phone}`;
+    }
+    // Adiciona o sinal de "+" ao início do telefone
+    user.phone = `+${user.phone}`;
+  }
+}

package/src/common/utils/decimal-transformer.utils.ts

@@ -0,0 +1,13 @@
+export const DecimalTransformer = {
+  to: (value: number): number => {
+    if (typeof value !== 'number' || isNaN(value)) {
+      return NaN;
+    }
+    return value;
+  },
+  from: (value: string): number => {
+    if (!value) return NaN;
+    const parsed = parseFloat(value.trim());
+    return isNaN(parsed) ? NaN : parsed;
+  },
+};

package/src/facilities/addresses/address.entity.ts

@@ -0,0 +1,82 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToMany,
+} from 'typeorm';
+
+import { DecimalTransformer } from 'common/utils/decimal-transformer.utils';
+import { Facility } from 'facilities/facilities/facility.entity';
+
+/**
+ * Entidade que representa um endereço.
+ *
+ * @remarks
+ * Esta entidade armazena os dados de endereço, como rua, número, complemento, bairro, cidade, estado,
+ * código postal, país, latitude e longitude. Além disso, mantém a relação com o estabelecimentos associadas a este endereço.
+ *
+ * @public
+ */
+@Entity('addresses')
+export class Address {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  @Column({ name: 'street_address', type: 'varchar', length: 255 })
+  streetAddress: string;
+
+  @Column({ type: 'varchar', length: 10 })
+  number: string;
+
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  complement?: string;
+
+  @Column({ type: 'varchar', length: 100 })
+  neighborhood: string;
+
+  @Column({ type: 'varchar', length: 100 })
+  city: string;
+
+  @Column({ type: 'varchar', length: 100 })
+  state: string;
+
+  @Column({ name: 'postal_code', type: 'varchar', length: 20 })
+  postalCode: string;
+
+  @Column({ type: 'varchar', length: 100 })
+  country: string;
+
+  @Column({
+    type: 'decimal',
+    precision: 10,
+    scale: 8,
+    transformer: DecimalTransformer,
+  })
+  latitude: number;
+
+  @Column({
+    type: 'decimal',
+    precision: 11,
+    scale: 8,
+    transformer: DecimalTransformer,
+  })
+  longitude: number;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com os estabelecimentos associadas a este endereço.
+   */
+  @OneToMany(() => Facility, (facility) => facility.address, {
+    onDelete: 'CASCADE',
+  })
+  facilities: Facility[];
+}

package/src/facilities/addresses/index.ts

@@ -0,0 +1 @@
+export { Address } from './address.entity';

package/src/facilities/facilities/enums/facility-status.enum.ts

@@ -0,0 +1,25 @@
+/**
+ * Enum que representa os status dos estabelecimentos.
+ *
+ * @remarks
+ * Este enum fornece valores para identificar o status de um estabelecimento,
+ * garantindo consistência ao referenciar o status na aplicação.
+ *
+ * @public
+ */
+export enum FacilityStatus {
+  /**
+   * Estabelecimento pendente de aprovação.
+   */
+  PENDING = 'pending',
+
+  /**
+   * Estabelecimento aprovado.
+   */
+  APPROVED = 'approved',
+
+  /**
+   * Estabelecimento rejeitado.
+   */
+  REJECTED = 'rejected',
+}

package/src/facilities/facilities/facility.entity.ts

@@ -0,0 +1,137 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Unique,
+  OneToMany,
+  BeforeInsert,
+  BeforeUpdate,
+  ManyToOne,
+  JoinColumn,
+  Index,
+} from 'typeorm';
+
+import { Address } from 'facilities/addresses';
+import { FacilityImage } from 'facilities/facility-images';
+import { FacilityOwner } from 'facilities/facility-owners';
+import { Field } from 'facilities/fields';
+import { TournamentFacility } from 'tournaments';
+
+import { FacilityStatus } from './enums/facility-status.enum';
+import { sanitizeFacility } from './utils/sanititze.utils';
+
+/**
+ * Entidade que representa um estabelecimento.
+ *
+ * @remarks
+ * Esta entidade armazena os dados de um estabelecimento, incluindo informações de contato,
+ * status e CNPJ. Além disso, mantém as relações com o proprietário, endereço,
+ * campos, usuários, imagens e torneios associados a este estabelecimento.
+ *
+ * @public
+ */
+@Entity('facilities')
+@Unique(['name', 'facilityOwnerId'])
+@Index('idx_facility_owner', ['facilityOwnerId'])
+@Index('idx_facility_address', ['addressId'])
+@Index('idx_facility_status', ['status'])
+export class Facility {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'facility_owner_id', type: 'int' })
+  facilityOwnerId: number;
+
+  @Column({ name: 'address_id', type: 'int' })
+  addressId: number;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  @Column({ name: 'name', type: 'varchar', length: 255 })
+  name: string;
+
+  @Column({
+    name: 'contact_email',
+    type: 'varchar',
+    length: 255,
+    nullable: true,
+  })
+  contactEmail?: string;
+
+  @Column({ name: 'contact_phone', type: 'varchar', length: 16 })
+  contactPhone: string;
+
+  @Column({
+    type: 'enum',
+    enum: FacilityStatus,
+    enumName: 'facility_status',
+  })
+  status: FacilityStatus = FacilityStatus.PENDING;
+
+  @Column({ name: 'cnpj', type: 'varchar', length: 14, nullable: true })
+  cnpj?: string;
+
+  @DeleteDateColumn({ name: 'deleted_at', type: 'timestamptz', nullable: true })
+  deletedAt: Date | null = null;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o endereço associado a este estabelecimento.
+   */
+  @ManyToOne(() => Address, (address) => address.facilities, {
+    eager: true,
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'address_id' })
+  address: Address;
+
+  /**
+   * Relação com o owner associado a este estabelecimento.
+   */
+  @ManyToOne(() => FacilityOwner, (owner) => owner.facilities, {
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'facility_owner_id' })
+  facilityOwner: FacilityOwner;
+
+  /**
+   * Relação com os campos associados a este estabelecimento.
+   */
+  @OneToMany(() => Field, (field) => field.facility)
+  fields: Field[];
+
+  /**
+   * Relação com as imagens do estabelecimento.
+   */
+  @OneToMany(() => FacilityImage, (facilityImage) => facilityImage.facility)
+  facilityImages: FacilityImage[];
+
+  /**
+   * Relação com os torneios associados a este estabelecimento.
+   */
+  @OneToMany(() => TournamentFacility, (tournamentFacility) => tournamentFacility.facility)
+  tournamentFacilities: TournamentFacility[];
+
+  /**
+   * Sanitiza os campos do estabelecimento antes de inserir ou atualizar o registro.
+   *
+   * @remarks
+   * A lógica de sanitização foi delegada à função externa `sanitizeFacility`,
+   * seguindo o princípio de responsabilidade única (SRP) para facilitar a manutenção e testabilidade.
+   */
+  @BeforeInsert()
+  @BeforeUpdate()
+  sanitizeFields(): void {
+    sanitizeFacility(this);
+  }
+}

package/src/facilities/facilities/index.ts

@@ -0,0 +1,3 @@
+export { Facility } from './facility.entity';
+
+export { FacilityStatus } from './enums/facility-status.enum';

package/src/facilities/facilities/utils/sanititze.utils.ts

@@ -0,0 +1,19 @@
+/**
+ * Sanitiza os campos do estabelecimento.
+ *
+ * @remarks
+ * Esta função remove caracteres não numéricos do CNPJ e sanitiza o email de contato.
+ *
+ * @param facility - A instância do estabelecimento a ser sanitizada.
+ */
+export function sanitizeFacility(facility: { cnpj?: string; contactEmail?: string }): void {
+  if (facility.cnpj) {
+    facility.cnpj = facility.cnpj.replace(/[^\d]/g, '').trim();
+    if (facility.cnpj.length !== 14) {
+      facility.cnpj = undefined;
+    }
+  }
+  if (facility.contactEmail) {
+    facility.contactEmail = facility.contactEmail.toLowerCase().trim();
+  }
+}

package/src/facilities/facility-images/facility-image.entity.ts

@@ -0,0 +1,64 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Index,
+  Unique,
+} from 'typeorm';
+
+import { Facility } from 'facilities/facilities';
+
+/**
+ * Entidade que representa uma imagem de estabelecimento.
+ *
+ * @remarks
+ * Esta entidade armazena os dados de uma imagem associada a um estabelecimento,
+ * incluindo a URL, descrição e indicação se a imagem é a principal.
+ * Além disso, mantém a relação com o estabelecimento ao qual a imagem está associada.
+ *
+ * @public
+ */
+@Entity('facility_images')
+@Index('IDX_facility_images_facilityId', ['facilityId'])
+@Index('IDX_facility_images_unique_primary', ['facilityId'], {
+  unique: true,
+  where: `"is_primary" = true`,
+})
+@Unique('UQ_facility_images_facility_url', ['facilityId', 'url'])
+export class FacilityImage {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'facility_id', type: 'int' })
+  facilityId: number;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  @Column({ type: 'text' })
+  url: string;
+
+  @Column({ type: 'text', nullable: true, default: null })
+  description: string;
+
+  @Column({ name: 'is_primary', type: 'boolean', default: false })
+  isPrimary: boolean;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com o estabelecimento ao qual esta imagem está associada.
+   */
+  @ManyToOne(() => Facility, (facility) => facility.facilityImages, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'facility_id' })
+  facility: Facility;
+}

package/src/facilities/facility-images/index.ts

@@ -0,0 +1 @@
+export { FacilityImage } from './facility-image.entity';

package/src/facilities/facility-owners/facility-owner.entity.ts

@@ -0,0 +1,74 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  Unique,
+  BeforeInsert,
+  BeforeUpdate,
+  OneToMany,
+  Index,
+} from 'typeorm';
+
+import { Facility } from 'facilities/facilities/facility.entity';
+
+import { sanitizeFacilityOwner } from './utils/sanitize.utils';
+
+/**
+ * Entidade que representa um proprietário de estabelecimento.
+ *
+ * @remarks
+ * Esta entidade armazena os dados de um proprietário, como nome, email de contato, CNPJ e telefone.
+ * Também mantém as relações com estabelecimentos.
+ *
+ * @public
+ */
+@Entity('facility_owners')
+@Unique(['contactEmail'])
+@Unique(['cnpj'])
+export class FacilityOwner {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  updatedAt: Date;
+
+  @Column({ type: 'varchar', length: 255 })
+  name: string;
+
+  @Index()
+  @Column({ name: 'contact_email', type: 'varchar', length: 255, nullable: true })
+  contactEmail: string;
+
+  @Index()
+  @Column({ name: 'cnpj', type: 'varchar', length: 14, nullable: true })
+  cnpj?: string;
+
+  @Column({ name: 'contact_phone', type: 'varchar', length: 16 })
+  contactPhone: string;
+
+  /** RELAÇÕES */
+
+  /**
+   * Relação com os estabelecimentos associadas a este proprietário.
+   */
+  @OneToMany(() => Facility, (facility) => facility.facilityOwner)
+  facilities: Facility[];
+
+  /**
+   * Sanitiza os campos do proprietário antes de inserir ou atualizar o registro.
+   *
+   * @remarks
+   * A lógica de sanitização foi delegada à função externa `sanitizeFacilityOwner`,
+   * seguindo o princípio de responsabilidade única (SRP) e facilitando a manutenção e testabilidade do código.
+   */
+  @BeforeInsert()
+  @BeforeUpdate()
+  sanitizeFields(): void {
+    sanitizeFacilityOwner(this);
+  }
+}

package/src/facilities/facility-owners/index.ts

@@ -0,0 +1 @@
+export { FacilityOwner } from './facility-owner.entity';

package/src/facilities/facility-owners/utils/sanitize.utils.ts

@@ -0,0 +1,16 @@
+/**
+ * Sanitiza os campos do proprietário do estabelecimento.
+ *
+ * @remarks
+ * Esta função remove caracteres não numéricos do CNPJ e converte o email de contato para minúsculas, removendo espaços.
+ *
+ * @param owner - A instância de FacilityOwner a ser sanitizada.
+ */
+export function sanitizeFacilityOwner(owner: { cnpj?: string; contactEmail?: string }): void {
+  if (owner.cnpj) {
+    owner.cnpj = owner.cnpj.replace(/[^\d]/g, '').trim();
+  }
+  if (owner.contactEmail) {
+    owner.contactEmail = owner.contactEmail.toLowerCase().trim();
+  }
+}

package/src/facilities/fields/enums/surface-type.enum.ts

@@ -0,0 +1,35 @@
+/**
+ * Enum que representa os tipos de superfície de um campo.
+ *
+ * @remarks
+ * Este enum fornece os valores possíveis para o tipo de superfície de um campo,
+ * permitindo diferenciar entre gramado, sintético, areia, madeira, entre outros.
+ *
+ * @public
+ */
+export enum FieldSurfaceType {
+  /**
+   * Campo com superfície de grama natural.
+   */
+  GRASS = 'grass',
+
+  /**
+   * Campo com superfície de grama sintética (turf).
+   */
+  TURF = 'turf',
+
+  /**
+   * Campo com superfície de saibro (clay).
+   */
+  CLAY = 'clay',
+
+  /**
+   * Campo com superfície de areia.
+   */
+  SAND = 'sand',
+
+  /**
+   * Campo com superfície de madeira (indoor).
+   */
+  HARDWOOD = 'hardwood',
+}