Type Fields — Outros

Type Fields complementares para booleanos, objetos JSON, status HTTP, status de aplicação e chaves públicas PEM.

Resumo

Classe	Tipo primitivo	Validação	Arquivo
FBoolean	boolean	Coerção de string/number para boolean	boolean.typefield.ts
FJson	Record<string, unknown>	Objeto JSON válido	json.typefield.ts
FHttpStatus	number (enum)	Enum OHttpStatus	http-status.typefield.ts
FAppStatus	string (enum)	"active" ou "inactive"	status-aplicacao.typefield.ts
FPublicKeyPem	string	Formato PEM com headers BEGIN/END	public-key-pem.typefield.ts

---

FBoolean

Valor booleano com coerção inteligente. Aceita boolean, string ("true", "false", "1", "0", "yes", "no") e number (1, 0).

import { FBoolean } from "tyforge";

const result = FBoolean.create(true);
// Result<FBoolean, ExceptionValidation>

// Coerção a partir de string
const fromString = FBoolean.createOrThrow("yes");
fromString.getValue(); // true

// Coerção a partir de number
const fromNumber = FBoolean.createOrThrow(0);
fromNumber.getValue(); // false

Valores aceitos:

Entrada	Resultado
true, "true", "1", "yes", 1	true
false, "false", "0", "no", 0	false

---

FJson

Objeto JSON genérico (Record<string, unknown>). Aceita tanto objetos quanto strings JSON válidas (que são parseadas automaticamente).

import { FJson } from "tyforge";

// A partir de objeto
const result = FJson.create({ nome: "Maria", idade: 30 });
// Result<FJson, ExceptionValidation>

// A partir de string JSON
const fromStr = FJson.create('{"chave": "valor"}');

const json = FJson.createOrThrow({ dados: [1, 2, 3] });

Métodos de instância:

Método	Retorno	Descrição
serialize()	string	Serializa para string JSON
get(key)	unknown	Retorna valor de uma chave
has(key)	boolean	Verifica se chave existe
keys()	string[]	Lista todas as chaves
isEmpty()	boolean	Verifica se objeto está vazio

const json = FJson.createOrThrow({ nome: "Maria", idade: 30 });

json.get("nome");     // "Maria"
json.has("idade");    // true
json.keys();          // ["nome", "idade"]
json.isEmpty();       // false
json.serialize();     // '{"nome":"Maria","idade":30}'
json.formatted();     // JSON formatado com indentação (2 espaços)

---

FHttpStatus

Código de status HTTP conforme especificação RFC 7231. Validado contra o enum OHttpStatus.

import { FHttpStatus, OHttpStatus } from "tyforge";

const result = FHttpStatus.create(OHttpStatus.OK);
// Result<FHttpStatus, ExceptionValidation>

const status = FHttpStatus.createOrThrow(200);
status.getValue(); // 200

Constante OHttpStatus

export const OHttpStatus = {
  OK: 200,
  CREATED: 201,
  ACCEPTED: 202,
  NO_CONTENT: 204,
  MOVED_PERMANENTLY: 301,
  FOUND: 302,
  NOT_MODIFIED: 304,
  TEMPORARY_REDIRECT: 307,
  PERMANENT_REDIRECT: 308,
  BAD_REQUEST: 400,
  UNAUTHORIZED: 401,
  FORBIDDEN: 403,
  NOT_FOUND: 404,
  METHOD_NOT_ALLOWED: 405,
  CONFLICT: 409,
  UNPROCESSABLE_ENTITY: 422,
  TOO_MANY_REQUESTS: 429,
  INTERNAL_SERVER_ERROR: 500,
  BAD_GATEWAY: 502,
  SERVICE_UNAVAILABLE: 503,
  GATEWAY_TIMEOUT: 504,
} as const;

Tipos relacionados:

• TKeyHttpStatus — chaves do enum ("OK", "CREATED", etc.)
• THttpStatus — valores numéricos do enum (200, 201, etc.)

---

FAppStatus

Status de uma aplicação no sistema. Aceita apenas os valores "active" ou "inactive".

import { FAppStatus, OStatusAplicacao } from "tyforge";

const result = FAppStatus.create("active");
// Result<FAppStatus, ExceptionValidation>

// Criar a partir de booleano
const status = FAppStatus.fromBoolean(true);
status.getValue(); // "active"

// Gerar status ativo por padrão
const ativo = FAppStatus.generate();
ativo.getValue(); // "active"

// Verificar se esta ativo
ativo.isActive(); // true

Constante OStatusAplicacao

export const OStatusAplicacao = {
  ACTIVE: "active",
  INACTIVE: "inactive",
} as const;

Métodos estáticos:

• fromBoolean(isActive) — converte booleano para status
• generate() — cria instância com status "active"

Métodos de instância:

• isActive() — retorna true se o status for "active"

---

FPublicKeyPem

Chave pública no formato PEM (Privacy-Enhanced Mail) para autenticação assimétrica. Valida a presença dos delimitadores e o conteúdo base64.

import { FPublicKeyPem } from "tyforge";

const pem = `-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA...
-----END PUBLIC KEY-----`;

const result = FPublicKeyPem.create(pem);
// Result<FPublicKeyPem, ExceptionValidation>

const chave = FPublicKeyPem.createOrThrow(pem);
chave.formatted(); // Valor com trim

Regras de validação:

• Comprimento entre 100 e 1000 caracteres
• Deve conter -----BEGIN PUBLIC KEY----- e -----END PUBLIC KEY-----
• Conteúdo entre os delimitadores deve ser base64 válido com no mínimo 100 caracteres