@hed-hog/core 0.0.4

package/src/install/dto/generate-migration.dto.ts

@@ -0,0 +1,31 @@
+import { Type } from 'class-transformer';
+import { IsArray, IsNotEmpty, IsString, ValidateNested } from 'class-validator';
+
+class MailLocaleTranslation {
+  @IsString()
+  @IsNotEmpty()
+  locale_code: string;
+
+  @IsString()
+  @IsNotEmpty()
+  subject: string;
+
+  @IsString()
+  @IsNotEmpty()
+  body: string;
+}
+
+export class GenerateMailMigrationDTO {
+  @IsString()
+  @IsNotEmpty()
+  slug: string;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => MailLocaleTranslation)
+  translations: MailLocaleTranslation[];
+
+  @IsArray()
+  @IsString({ each: true })
+  variables: string[];
+}

package/src/install/dto/install.dto.ts

@@ -0,0 +1,27 @@
+import { IsEmail, IsOptional, IsString, MinLength } from 'class-validator';
+
+export class InstallDTO {
+  @IsOptional()
+  @IsString({ message: 'Nome da aplicação obrigatório' })
+  @MinLength(1, { message: 'Nome da aplicação obrigatório' })
+  appName?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Slogan obrigatório' })
+  @MinLength(1, { message: 'Slogan obrigatório' })
+  slogan?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Nome de usuário obrigatório' })
+  @MinLength(1, { message: 'Nome de usuário obrigatório' })
+  userName?: string;
+
+  @IsOptional()
+  @IsEmail({}, { message: 'Email inválido' })
+  email?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Senha deve ter pelo menos 6 caracteres' })
+  @MinLength(6, { message: 'Senha deve ter pelo menos 6 caracteres' })
+  password?: string;
+}

package/src/install/install.controller.ts

@@ -0,0 +1,26 @@
+import { Public } from '@hed-hog/api';
+import { Body, Controller, Get, Post } from '@nestjs/common';
+import { GenerateMailMigrationDTO } from './dto/generate-migration.dto';
+import { InstallDTO } from './dto/install.dto';
+import { InstallService } from './install.service';
+
+@Public()
+@Controller('install')
+export class InstallController {
+  constructor(private readonly service: InstallService) { }
+
+  @Post()
+  install(@Body() data: InstallDTO) {
+    return this.service.install(data);
+  }
+
+  @Get()
+  check() {
+    return this.service.check();
+  }
+
+  @Post('generate-mail-migration')
+  generateMailMigration(@Body() data: GenerateMailMigrationDTO) {
+    return this.service.generateMailMigration(data);
+  }
+}

package/src/install/install.module.ts

@@ -0,0 +1,19 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { AuthModule } from '../auth/auth.module';
+import { SecurityModule } from '../security/security.module';
+import { SettingModule } from '../setting/setting.module';
+import { InstallController } from './install.controller';
+import { InstallService } from './install.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => SettingModule),
+    forwardRef(() => SecurityModule),
+    forwardRef(() => AuthModule),
+  ],
+  controllers: [InstallController],
+  providers: [InstallService],
+})
+export class InstallModule { }

package/src/install/install.service.ts

@@ -0,0 +1,345 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { existsSync, readFileSync } from 'fs';
+import { writeFile } from 'fs/promises';
+import { resolve } from 'path';
+import { SecurityService } from '../security/security.service';
+import { InstallDTO } from './dto/install.dto';
+
+@Injectable()
+export class InstallService {
+
+  private readonly logger = new Logger(InstallService.name);
+
+  constructor(
+    private readonly security: SecurityService,
+    private readonly prisma: PrismaService
+  ) { }
+
+  private async forceReset() {
+
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    //leia o arquivo src/main.ts e salveo com o mesmo conteudo para forcar o nestjs a reiniciar a aplicacao
+    const mainFilePath = resolve(process.cwd(), 'src', 'main.ts');
+    if (!existsSync(mainFilePath)) {
+      throw new BadRequestException('main.ts file not found.');
+    }
+    let mainContent: string;
+    try {
+      mainContent = readFileSync(mainFilePath, 'utf-8');
+    } catch (err: any) {
+      throw new BadRequestException(`Failed to read main.ts file: ${err.message}`);
+    }
+    try {
+      this.logger.verbose('Forcing application restart by touching main.ts...');
+      await writeFile(mainFilePath, mainContent, 'utf-8');
+    } catch (err: any) {
+      throw new BadRequestException(`Failed to write main.ts file: ${err.message}`);
+    }
+
+  }
+
+  private async checkInstallation() {
+
+    const hedhogFilePath = resolve(process.cwd(), '..', '..', 'hedhog.json');
+
+    let data = {
+      installed: false
+    };
+
+    if (existsSync(hedhogFilePath)) {
+      try {
+        const fileContent = readFileSync(hedhogFilePath, 'utf-8');
+        data = JSON.parse(fileContent);
+      } catch (err: any) {
+        this.logger.warn(`Failed to read hedhog.json: ${err.message}`);
+      }
+    }
+
+    return data.installed === true;
+
+  }
+
+  private async markAsInstalled() {
+
+    const hedhogFilePath = resolve(process.cwd(), '..', '..', 'hedhog.json');
+
+    let content: any = {}
+
+    if (existsSync(hedhogFilePath)) {
+      try {
+        const fileContent = readFileSync(hedhogFilePath, 'utf-8');
+        content = JSON.parse(fileContent);
+      } catch (err: any) {
+        this.logger.warn(`Failed to read hedhog.json: ${err.message}`);
+      }
+    }
+
+    content.installed = true;
+    content.installedAt = new Date().toISOString();
+
+    try {
+      this.logger.verbose('Marking application as installed in hedghog.json...');
+      await writeFile(hedhogFilePath, JSON.stringify(content, null, 2), 'utf-8');
+    } catch (err: any) {
+      throw new BadRequestException(`Failed to write hedhog.json: ${err.message}`);
+    }
+
+    return true;
+  }
+
+  private async updateEnvSecrets(pepper: string) {
+
+    const envFilePath = resolve(process.cwd(), '..', '..', 'apps', 'api', '.env');
+    if (!existsSync(envFilePath)) {
+      throw new BadRequestException('.env file not found.');
+    }
+
+    let envContent: string;
+    try {
+      envContent = await readFileSync(envFilePath, 'utf-8');
+    } catch (err: any) {
+      throw new BadRequestException(`Failed to read .env file: ${err.message}`);
+    }
+
+    const envConfig = this.parseEnv(envContent);
+
+    if (!('DATABASE_URL' in envConfig)) {
+      const envExamplePath = resolve(process.cwd(), '..', '..', 'apps', 'api', '.env.example');
+      if (!existsSync(envExamplePath)) {
+        throw new BadRequestException('.env.example file not found.');
+      }
+      try {
+        const exampleContent = await readFileSync(envExamplePath, 'utf-8');
+        await writeFile(envFilePath, exampleContent, 'utf-8');
+        envContent = exampleContent;
+        Object.assign(envConfig, this.parseEnv(envContent));
+      } catch (err: any) {
+        throw new BadRequestException(`Failed to copy .env.example: ${err.message}`);
+      }
+    }
+
+    envConfig['JWT_SECRET'] = this.base64Encode(this.security.randomOpaque(32));
+    envConfig['PEPPER'] = pepper;
+
+    // Only wrap in double quotes if the value contains spaces, #, or special characters
+    const newEnvContent = Object.entries(envConfig)
+      .map(([key, value]) => {
+        // If value contains only safe characters, no quotes needed
+        if (/^[A-Za-z0-9._-]+$/.test(value)) {
+          return `${key}=${value}`;
+        }
+        // Otherwise, escape quotes and wrap in double quotes
+        return `${key}="${value.replace(/"/g, '\\"')}"`;
+      })
+      .join('\n');
+
+    try {
+      this.logger.verbose('Updating .env file with new secrets...');
+      await writeFile(envFilePath, newEnvContent, 'utf-8');
+    } catch (err: any) {
+      throw new BadRequestException(`Failed to write .env file: ${err.message}`);
+    }
+  }
+
+  private parseEnv(content: string): Record<string, string> {
+    const lines = content.split('\n').filter(line => line.trim() !== '');
+    const envConfig: Record<string, string> = {};
+    for (const line of lines) {
+      if (line.startsWith('#') || !line.includes('=')) continue;
+      const [key, ...rest] = line.split('=');
+      if (!key || rest.length === 0) continue;
+      let value = rest.join('=').trim();
+      // Remove surrounding double quotes if present
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1).replace(/\\"/g, '"');
+      }
+      envConfig[key.trim()] = value;
+    }
+    return envConfig;
+  }
+
+  private base64Encode(str: string): string {
+    return Buffer.from(str).toString('base64');
+  }
+
+  async install({ appName, email, password, slogan, userName }: InstallDTO) {
+
+    if (await this.checkInstallation()) {
+      throw new BadRequestException('Application is already installed.');
+    }
+
+    const pepper = this.base64Encode(this.security.randomOpaque(16));
+
+    await this.prisma.$transaction(async (prisma) => {
+
+      this.logger.log('Starting installation process...');
+
+      await prisma.setting.update({
+        where: {
+          slug: 'system-name'
+        },
+        data: {
+          value: appName
+        }
+      });
+
+      this.logger.log(`Set system name to: ${appName}`);
+
+      this.logger.log(`Setting system slogan to: ${slogan}`);
+
+      await prisma.setting.update({
+        where: {
+          slug: 'system-slogan'
+        },
+        data: {
+          value: slogan
+        }
+      });
+
+      this.logger.log('System slogan set.');
+
+      this.logger.log(`Setting system email to: ${email}`);
+
+      const check = await prisma.user.findFirst({
+        where: {
+          user_identifier: {
+            some: {
+              type: 'email',
+              value: email,
+            }
+          }
+        }
+      });
+
+      if (check) {
+        throw new BadRequestException('A user with this email already exists.');
+      }
+
+      this.logger.log(`Creating admin user: ${userName} <${email}>`);
+
+      const passwordHash = await this.security.hashArgon2(password, pepper);
+
+      const user = await prisma.user.create({
+        data: {
+          name: userName,
+          user_identifier: {
+            create: {
+              type: 'email',
+              value: email,
+            }
+          },
+          user_credential: {
+            create: {
+              type: 'password',
+              hash: passwordHash,
+            }
+          }
+        }
+      });
+
+      this.logger.log(`Admin user created with ID: ${user.id}`);
+
+      const roles = await prisma.role.findMany();
+
+      if (roles.length === 0) {
+        throw new BadRequestException('No roles found. Please seed the roles before installation.');
+      }
+
+      this.logger.log(`Assigning roles to user ID: ${user.id}`);
+
+      await prisma.role_user.createMany({
+        data: roles.map((role) => ({
+          role_id: role.id,
+          user_id: user.id,
+        })),
+      });
+
+      this.logger.log(`Roles assigned to user ID: ${user.id}`);
+
+      await this.markAsInstalled();
+      await this.updateEnvSecrets(pepper);
+      this.forceReset();
+
+      this.logger.log('Installation process completed successfully.');
+
+    });
+
+    return { success: true };
+
+  }
+
+  async check() {
+    if (await this.checkInstallation()) {
+      return { success: true };
+    } else {
+      throw new BadRequestException('Application is not installed.');
+    }
+
+  }
+
+  async generateMailMigration({
+    slug,
+    translations,
+    variables,
+  }: {
+    slug: string;
+    translations: Array<{ locale_code: string; subject: string; body: string }>;
+    variables: string[];
+  }) {
+    try {
+      const timestamp = new Date().toISOString().replace(/[-:T]/g, '').split('.')[0];
+      const migrationName = `${timestamp}_mail_${slug.replace(/[^a-z0-9]/gi, '_')}`;
+      const migrationsPath = resolve(process.cwd(), 'prisma', 'migrations', migrationName);
+
+      const fs = await import('fs/promises');
+      await fs.mkdir(migrationsPath, { recursive: true });
+
+      const escapeSQL = (str: string) => str.replace(/'/g, "''");
+      let sql = `-- CreateMailTemplate: ${slug}\n\n`;
+      sql += `-- Insert mail template\n`;
+      sql += `INSERT INTO "mail" ("slug", "created_at", "updated_at")\n`;
+      sql += `VALUES ('${escapeSQL(slug)}', NOW(), NOW())\n`;
+      sql += `ON CONFLICT ("slug") DO NOTHING;\n\n`;
+
+      if (translations && translations.length > 0) {
+        sql += `-- Insert mail locales\n`;
+        sql += `INSERT INTO "mail_locale" ("mail_id", "locale_id", "subject", "body")\n`;
+        sql += `VALUES \n`;
+        const localeValues = translations.map((translation, index) => {
+          const comma = index < translations.length - 1 ? ',' : '';
+          return `  ((SELECT "id" FROM "mail" WHERE "slug" = '${escapeSQL(slug)}'), (SELECT "id" FROM "locale" WHERE "code" = '${escapeSQL(translation.locale_code)}'), '${escapeSQL(translation.subject)}', '${escapeSQL(translation.body)}')${comma}`;
+        }).join('\n');
+        sql += localeValues;
+        sql += `\nON CONFLICT ("mail_id", "locale_id") DO UPDATE\n`;
+        sql += `  SET "subject" = EXCLUDED."subject",\n`;
+        sql += `      "body" = EXCLUDED."body";\n\n`;
+      }
+
+      if (variables && variables.length > 0) {
+        sql += `-- Insert mail variables\n`;
+        sql += `INSERT INTO "mail_var" ("mail_id", "name")\n`;
+        sql += `VALUES \n`;
+        const varValues = variables.map(v => 
+          `  ((SELECT "id" FROM "mail" WHERE "slug" = '${escapeSQL(slug)}'), '${escapeSQL(v)}')`
+        ).join(',\n');
+        sql += varValues;
+        sql += `\nON CONFLICT ("mail_id", "name") DO NOTHING;\n`;
+      }
+
+      const migrationFilePath = resolve(migrationsPath, 'migration.sql');
+      await fs.writeFile(migrationFilePath, sql, 'utf-8');
+      this.logger.log(`Migration created: ${migrationName}`);
+
+      return {
+        success: true,
+        migrationName,
+        path: migrationsPath,
+      };
+    } catch (error: any) {
+      this.logger.error('Error generating mail migration:', error);
+      throw new BadRequestException(`Failed to generate migration: ${error.message}`);
+    }
+  }
+}

package/src/language/en.json

@@ -0,0 +1,112 @@
+{
+  "settingNotFound": "Setting not found or user cannot override.",
+  "userNotFound": "User not found.",
+  "accessDenied": "Access denied.",
+  "defaultRoleNotFound": "Default user role not found.",
+  "defaultNameMfaEmail": "Default E-mail MFA",
+  "urlSettingMissing": "URL setting is missing.",
+  "userIdentifierNotFound": "User identifier not found.",
+  "invalidMfaCode": "Invalid MFA code.",
+  "invalidRecoveryCode": "Invalid recovery code.",
+  "noEmailMfaFound": "No email MFA method found for this user.",
+  "webauthnNotConfigured": "WebAuthn not configured.",
+  "challengeNotFound": "Challenge not found or expired.",
+  "verificationFailed": "Verification failed.",
+  "userIdsRequired": "At least one User ID is required to delete users.",
+  "invalidIds": "Invalid IDs.",
+  "invalidCode": "Invalid code.",
+  "totpNotFound": "TOTP method not found.",
+  "invalidMfaToken": "Invalid MFA token.",
+  "invalidJsonFile": "File does not contain valid JSON.",
+  "invalidJsonArray": "The JSON file must contain an array of settings.",
+  "deleteItemsRequired": "You must select at least one item to delete.",
+  "signup": {
+    "emailExists": "Email already in use."
+  },
+  "forgot": {
+    "rateLimit": "Too many requests. Please try again later."
+  },
+  "reset": {
+    "password": {
+      "required": "Password is required.",
+      "minLength": "Password must be at least 8 characters long."
+    },
+    "code": {
+      "required": "Reset code is required."
+    }
+  },
+  "session": {
+    "userIdRequired": "User ID is required to create a session.",
+    "ipAddressRequired": "IP address is required to create a session.",
+    "userAgentRequired": "User agent is required to create a session."
+  },
+  "profile": {
+    "update": {
+      "nameRequired": "Name is required."
+    },
+    "emailIdentifierNotFound": "Email identifier not found.",
+    "defaultNameMfaEmail": "Email Verification",
+    "emailVerification": {
+      "pinInvalid": "PIN must be exactly 6 digits.",
+      "pinIsString": "PIN must be a string."
+    },
+    "changePassword": {
+      "currentPasswordIsString": "Current password must be a string.",
+      "newPasswordIsString": "New password must be a string."
+    },
+    "sendEmailVerification": {
+      "emailIsString": "Email must be a string."
+    }
+  },
+  "password": {
+    "weakPassword": "Password does not meet the security requirements defined in system settings.",
+    "required": "Password is required.",
+    "minLength": "Password must be at least {minLength} characters long.",
+    "minLowercase": "Password must contain at least {minLowercase} lowercase letter(s).",
+    "minUppercase": "Password must contain at least {minUppercase} uppercase letter(s).",
+    "minNumbers": "Password must contain at least {minNumbers} number(s).",
+    "minSymbols": "Password must contain at least {minSymbols} special character(s)."
+  },
+  "createUser": {
+    "nameRequired": "Name is required."
+  },
+  "pinCode": {
+    "invalidLength": "PIN code must be exactly {length} digits long."
+  },
+  "validation": {
+    "emailRequired": "Email is required.",
+    "emailInvalid": "The provided email is invalid.",
+    "currentEmailRequired": "Current email is required.",
+    "currentEmailInvalid": "The current email provided is invalid.",
+    "newEmailRequired": "New email is required.",
+    "newEmailInvalid": "The new email provided is invalid.",
+    "passwordRequired": "Password is required.",
+    "passwordMinLength": "Password must be at least 8 characters long.",
+    "passwordStrength": "Password must be at least 6 characters long and contain at least 1 lowercase letter.",
+    "codeMustBeString": "Code must be a string.",
+    "codeRequired": "Code is required.",
+    "tokenInvalid": "Invalid token.",
+    "tokenMustBeJWT": "Token must be a valid JWT.",
+    "methodTypeInvalid": "Method type must be totp, email, or recovery.",
+    "streetMustBeString": "Street must be a string.",
+    "numberMustBeString": "Number must be a string.",
+    "complementMustBeString": "Complement must be a string.",
+    "districtMustBeString": "District must be a string.",
+    "cityMustBeString": "City must be a string.",
+    "stateMustBeString": "State must be a string.",
+    "postalCodeMustBeString": "Postal code must be a string.",
+    "nameMustBeString": "Name must be a string.",
+    "nameRequired": "Name is required.",
+    "slugMustBeString": "Slug must be a string.",
+    "slugRequired": "Slug is required.",
+    "descriptionMustBeString": "Description must be a string.",
+    "descriptionRequired": "Description is required.",
+    "urlMustBeString": "URL must be a string.",
+    "urlRequired": "URL is required.",
+    "methodMustBeString": "Method must be a string.",
+    "methodMustBeValid": "Method must be a valid HTTP method (GET, POST, PUT, DELETE, PATCH, OPTIONS, or HEAD).",
+    "iconMustBeString": "Icon must be a string.",
+    "orderMustBeNumber": "Order must be a number.",
+    "tokenMustBe6Digits": "Token must be a 6-digit numeric string."
+  }
+}

package/src/language/pt.json

@@ -0,0 +1,112 @@
+{
+  "settingNotFound": "Configuração não encontrada ou o usuário não pode substituir.",
+  "userNotFound": "Usuário não encontrado.",
+  "accessDenied": "Acesso negado.",
+  "defaultRoleNotFound": "Função de usuário padrão não encontrada.",
+  "defaultNameMfaEmail": "MFA de E-mail Padrão",
+  "urlSettingMissing": "Configuração de URL está faltando.",
+  "userIdentifierNotFound": "Identificador de usuário não encontrado.",
+  "invalidMfaCode": "Código MFA inválido.",
+  "invalidRecoveryCode": "Código de recuperação inválido.",
+  "noEmailMfaFound": "Nenhum método de MFA por e-mail encontrado para este usuário.",
+  "webauthnNotConfigured": "WebAuthn não configurado.",
+  "challengeNotFound": "Desafio não encontrado ou expirado.",
+  "verificationFailed": "Verificação falhou.",
+  "userIdsRequired": "Pelo menos um ID de usuário é necessário para excluir usuários.",
+  "invalidIds": "IDs inválidos.",
+  "invalidCode": "Código inválido.",
+  "totpNotFound": "Método TOTP não encontrado.",
+  "invalidMfaToken": "Token MFA inválido.",
+  "invalidJsonFile": "Arquivo não contém um JSON válido.",
+  "invalidJsonArray": "O arquivo JSON deve conter um array de settings.",
+  "deleteItemsRequired": "Você deve selecionar pelo menos um item para excluir.",
+  "signup": {
+    "emailExists": "E-mail já está em uso."
+  },
+  "forgot": {
+    "rateLimit": "Muitas solicitações. Por favor, tente novamente mais tarde."
+  },
+  "reset": {
+    "password": {
+      "required": "Senha é obrigatória.",
+      "minLength": "A senha deve ter no mínimo 8 caracteres."
+    },
+    "code": {
+      "required": "Código de redefinição é obrigatório."
+    }
+  },
+  "session": {
+    "userIdRequired": "O ID do usuário é necessário para criar uma sessão.",
+    "ipAddressRequired": "O endereço IP é necessário para criar uma sessão.",
+    "userAgentRequired": "O agente do usuário é necessário para criar uma sessão."
+  },
+  "profile": {
+    "update": {
+      "nameRequired": "Nome é obrigatório."
+    },
+    "emailIdentifierNotFound": "Identificador de email não encontrado.",
+    "defaultNameMfaEmail": "Verificação de Email",
+    "emailVerification": {
+      "pinInvalid": "O PIN deve conter exatamente 6 dígitos.",
+      "pinIsString": "O PIN deve ser uma string."
+    },
+    "changePassword": {
+      "currentPasswordIsString": "A senha atual deve ser uma string.",
+      "newPasswordIsString": "A nova senha deve ser uma string."
+    },
+    "sendEmailVerification": {
+      "emailIsString": "O email deve ser uma string."
+    }
+  },
+  "password": {
+    "weakPassword": "A senha não atende aos requisitos de segurança definidos nas configurações do sistema.",
+    "required": "A senha é obrigatória.",
+    "minLength": "A senha deve ter no mínimo {minLength} caracteres.",
+    "minLowercase": "A senha deve conter pelo menos {minLowercase} letra(s) minúscula(s).",
+    "minUppercase": "A senha deve conter pelo menos {minUppercase} letra(s) maiúscula(s).",
+    "minNumbers": "A senha deve conter pelo menos {minNumbers} número(s).",
+    "minSymbols": "A senha deve conter pelo menos {minSymbols} caractere(s) especial(is)."
+  },
+  "createUser": {
+    "nameRequired": "Nome é obrigatório."
+  },
+  "pinCode": {
+    "invalidLength": "O código PIN deve conter exatamente {length} dígitos."
+  },
+  "validation": {
+    "emailRequired": "E-mail é obrigatório.",
+    "emailInvalid": "O e-mail fornecido não é válido.",
+    "currentEmailRequired": "O e-mail atual é obrigatório.",
+    "currentEmailInvalid": "O e-mail atual informado não é válido.",
+    "newEmailRequired": "O novo e-mail é obrigatório.",
+    "newEmailInvalid": "O novo e-mail informado não é válido.",
+    "passwordRequired": "A senha é obrigatória.",
+    "passwordMinLength": "A senha deve ter pelo menos 8 caracteres.",
+    "passwordStrength": "A senha deve ter pelo menos 6 caracteres e conter pelo menos 1 letra minúscula.",
+    "codeMustBeString": "O código deve ser uma string.",
+    "codeRequired": "Código é obrigatório.",
+    "tokenInvalid": "Token inválido.",
+    "tokenMustBeJWT": "Token deve ser um JWT válido.",
+    "methodTypeInvalid": "Tipo de método deve ser totp, email ou recovery.",
+    "streetMustBeString": "O endereço deve ser uma string.",
+    "numberMustBeString": "O número deve ser uma string.",
+    "complementMustBeString": "O complemento deve ser uma string.",
+    "districtMustBeString": "O bairro deve ser uma string.",
+    "cityMustBeString": "A cidade deve ser uma string.",
+    "stateMustBeString": "O estado deve ser uma string.",
+    "postalCodeMustBeString": "O CEP deve ser uma string.",
+    "nameMustBeString": "O nome deve ser uma string.",
+    "nameRequired": "Nome é obrigatório.",
+    "slugMustBeString": "O slug deve ser uma string.",
+    "slugRequired": "O slug é obrigatório.",
+    "descriptionMustBeString": "A descrição deve ser uma string.",
+    "descriptionRequired": "A descrição é obrigatória.",
+    "urlMustBeString": "A URL deve ser uma string.",
+    "urlRequired": "A URL é obrigatória.",
+    "methodMustBeString": "O método deve ser uma string.",
+    "methodMustBeValid": "O método deve ser um método HTTP válido (GET, POST, PUT, DELETE, PATCH, OPTIONS ou HEAD).",
+    "iconMustBeString": "O ícone deve ser uma string.",
+    "orderMustBeNumber": "A ordem deve ser um número.",
+    "tokenMustBe6Digits": "Token deve ser uma string numérica de 6 dígitos."
+  }
+}