@77sol-ui/form-schemas 1.0.0

package/src/domains/financing/formalization/schemas/SolfacilPFSchema.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod'
+import { DocumentTypeEnum, SexEnum } from '../../../../shared/enums'
+import { textField } from '../../../../shared/fields/primitives'
+import {
+  birthDateSchema,
+  cepSchema,
+  cpfCnpjSchema,
+  cpfSchema,
+  currencySchema,
+  emailSchema,
+  issueDateSchema,
+  phoneBRSchema,
+} from '../../../../shared/regex'
+import { formalizationExtras } from '../extras'
+import { applyPfRefinements } from '../refinements'
+
+export const solfacilPfObject = z.object({
+  ...formalizationExtras,
+  name: textField(),
+  cep: cepSchema,
+  cpf: cpfSchema,
+  address: textField(),
+  birth_date: birthDateSchema,
+  number: textField(),
+  sex: SexEnum,
+  complement: textField(15).optional(),
+  mother_name: textField(),
+  district: textField(),
+  energy_account_in_requester_name: textField(),
+  city: textField(),
+  energy_bill_owner_document: cpfCnpjSchema.optional(),
+  state: textField(2),
+  nationality: textField(),
+  cellphone: phoneBRSchema,
+  email: emailSchema,
+  monthly_income: currencySchema,
+  profession: textField(),
+  type_doc: DocumentTypeEnum,
+  doc: textField(15),
+  issuing_body: textField(6),
+  doc_issue_date: issueDateSchema,
+})
+
+export const solfacilPfSchema = solfacilPfObject.strict().superRefine(applyPfRefinements)
+
+export type SolfacilPfFicha = z.infer<typeof solfacilPfSchema>

package/src/domains/financing/formalization/schemas/SolfacilPJSchema.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod'
+import { SexEnum } from '../../../../shared/enums'
+import { textField } from '../../../../shared/fields/primitives'
+import {
+  birthDateSchema,
+  cepSchema,
+  cnpjSchema,
+  cpfSchema,
+  currencySchema,
+  emailSchema,
+  issueDateSchema,
+  phoneBRSchema,
+} from '../../../../shared/regex'
+import { formalizationExtras } from '../extras'
+import { applyPjRefinements } from '../refinements'
+
+export const solfacilPjObject = z.object({
+  ...formalizationExtras,
+  financing_company: z
+    .object({
+      corporate_name: textField(),
+      cep: cepSchema,
+      address: textField(),
+      foundation_date: issueDateSchema,
+      number: textField(),
+      cnpj: cnpjSchema,
+      email: emailSchema,
+      complement: textField(15).optional(),
+      phone: phoneBRSchema,
+      district: textField(),
+      legal_nature: textField(),
+      city: textField(),
+      state: textField(2),
+    })
+    .strict(),
+  financing_company_guarantor: z.array(
+    z
+      .object({
+        name: textField(),
+        cep: cepSchema,
+        cpf: cpfSchema,
+        address: textField(),
+        birth_date: birthDateSchema,
+        number: textField(),
+        complement: textField(15).optional(),
+        cellphone: phoneBRSchema,
+        phone: phoneBRSchema,
+        email: emailSchema,
+        district: textField(),
+        sex: SexEnum,
+        city: textField(),
+        state: textField(2),
+        civil_status: textField(),
+        office: textField(),
+        doc: textField(),
+        issuing_body: textField(),
+        uf_issuing_body: textField(2),
+        doc_issue_date: issueDateSchema,
+        mother_name: textField(),
+        monthly_income: currencySchema,
+        patrimony: currencySchema,
+        nationality: textField(),
+      })
+      .strict(),
+  ),
+})
+
+export const solfacilPjSchema = solfacilPjObject.strict().superRefine(applyPjRefinements)
+
+export type SolfacilPjFicha = z.infer<typeof solfacilPjSchema>

package/src/domains/financing/formalization/uiMeta.ts

@@ -0,0 +1,122 @@
+export type FormalizationFieldKind =
+  | 'text'
+  | 'cpf'
+  | 'cnpj'
+  | 'cpfCnpj'
+  | 'cep'
+  | 'phone'
+  | 'email'
+  | 'date'
+  | 'currency'
+  | 'integer'
+  | 'number'
+  | 'select'
+  | 'file'
+  | 'toggle'
+  | 'group'
+  | 'array'
+
+export interface FormalizationFieldMeta {
+  kind: FormalizationFieldKind
+  label: string
+  step: number
+}
+
+export const FORMALIZATION_FIELD_META: Record<string, FormalizationFieldMeta> = {
+  energy_bill_upload: { kind: 'file', label: 'Conta de energia', step: 1 },
+  account_third_party: {
+    kind: 'select',
+    label: 'Conta em nome de terceiro?',
+    step: 1,
+  },
+  bond_document_upload: {
+    kind: 'file',
+    label: 'Documento de vínculo com o titular',
+    step: 1,
+  },
+  document_front_upload: {
+    kind: 'file',
+    label: 'Documento de identidade (frente)',
+    step: 2,
+  },
+  document_back_upload: {
+    kind: 'file',
+    label: 'Documento de identidade (verso)',
+    step: 2,
+  },
+  rd_re_insurance_toggle: {
+    kind: 'toggle',
+    label: 'Seguro prestamista (RD/RE)',
+    step: 3,
+  },
+
+  name: { kind: 'text', label: 'Nome', step: 3 },
+  cpf: { kind: 'cpf', label: 'CPF', step: 3 },
+  birth_date: { kind: 'date', label: 'Data de nascimento', step: 3 },
+  nationality: { kind: 'text', label: 'Nacionalidade', step: 3 },
+  type_doc: { kind: 'select', label: 'Tipo de documento', step: 3 },
+  doc: { kind: 'text', label: 'Número do documento', step: 3 },
+  issuing_body: { kind: 'text', label: 'Órgão emissor', step: 3 },
+  emitting_state: { kind: 'text', label: 'UF emissor', step: 3 },
+  doc_issue_date: { kind: 'date', label: 'Data de expedição', step: 3 },
+  email: { kind: 'email', label: 'E-mail', step: 3 },
+  cellphone: { kind: 'phone', label: 'Celular', step: 3 },
+  monthly_income: { kind: 'currency', label: 'Renda mensal', step: 3 },
+  equity_value: { kind: 'currency', label: 'Patrimônio', step: 3 },
+  mother_name: { kind: 'text', label: 'Nome da mãe', step: 3 },
+  civil_status: { kind: 'text', label: 'Estado civil', step: 3 },
+  naturalness: { kind: 'text', label: 'Naturalidade', step: 3 },
+  uf_naturalness: { kind: 'text', label: 'UF de naturalidade', step: 3 },
+  nature_of_occupation: {
+    kind: 'text',
+    label: 'Natureza da ocupação',
+    step: 3,
+  },
+  company_time: { kind: 'number', label: 'Tempo de empresa (meses)', step: 3 },
+  cnpj_proprietary: { kind: 'cnpj', label: 'CNPJ do proprietário', step: 3 },
+  pep_relationship: { kind: 'text', label: 'Relação com PEP', step: 3 },
+  residence_situation: {
+    kind: 'text',
+    label: 'Situação da residência',
+    step: 3,
+  },
+  months_in_residence: {
+    kind: 'integer',
+    label: 'Tempo de residência (meses)',
+    step: 3,
+  },
+  is_installation_at_requester: {
+    kind: 'text',
+    label: 'Instalação no endereço do solicitante',
+    step: 3,
+  },
+  energy_account_in_requester_name: {
+    kind: 'text',
+    label: 'Conta de energia no nome do solicitante',
+    step: 3,
+  },
+  energy_bill_owner_document: {
+    kind: 'cpfCnpj',
+    label: 'Documento do titular da conta de energia',
+    step: 3,
+  },
+
+  cep: { kind: 'cep', label: 'CEP', step: 3 },
+  address: { kind: 'text', label: 'Endereço', step: 3 },
+  number: { kind: 'text', label: 'Número', step: 3 },
+  complement: { kind: 'text', label: 'Complemento', step: 3 },
+  district: { kind: 'text', label: 'Bairro', step: 3 },
+  state: { kind: 'text', label: 'Estado (UF)', step: 3 },
+  city: { kind: 'text', label: 'Cidade', step: 3 },
+
+  sex: { kind: 'select', label: 'Sexo', step: 4 },
+  profession: { kind: 'text', label: 'Profissão', step: 4 },
+
+  financing_company: { kind: 'group', label: 'Dados da empresa', step: 3 },
+  financing_company_guarantor: { kind: 'array', label: 'Avalistas', step: 3 },
+  financing_company_qsa: {
+    kind: 'array',
+    label: 'Quadro societário (QSA)',
+    step: 3,
+  },
+}

package/src/domains/financing/index.ts

@@ -0,0 +1 @@
+export * from './formalization'

package/src/index.ts

@@ -0,0 +1 @@
+export * from './domains/financing'

package/src/shared/enums/document-type.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod'
+
+export const DocumentTypeEnum = z.enum(['rg', 'cnh', 'rne'])
+export type DocumentType = z.infer<typeof DocumentTypeEnum>

package/src/shared/enums/index.ts

@@ -0,0 +1,3 @@
+export * from './document-type'
+export * from './nationality'
+export * from './sex'

package/src/shared/enums/nationality.ts

@@ -0,0 +1,2 @@
+// Usada na regra que força tipo de documento = RNE para estrangeiros.
+export const NATIONALITY_BRAZIL = 'brasil' as const

package/src/shared/enums/sex.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod'
+
+export const SexEnum = z.enum(['masculino', 'feminino'])
+export type Sex = z.infer<typeof SexEnum>

package/src/shared/fields/index.ts

@@ -0,0 +1 @@
+export * from './primitives'

package/src/shared/fields/primitives.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+
+export function textField(maxLength?: number) {
+  const base = z.string().trim().min(1, 'Campo obrigatório')
+  return maxLength === undefined ? base : base.max(maxLength, `Máximo ${maxLength} caracteres`)
+}
+
+export const numberField = z
+  .number({ invalid_type_error: 'Valor numérico inválido' })
+  .nonnegative('Valor não pode ser negativo')
+
+export const integerField = z
+  .number({ invalid_type_error: 'Valor numérico inválido' })
+  .int('Deve ser um número inteiro')
+  .nonnegative('Valor não pode ser negativo')
+
+export function selectField<T extends readonly [string, ...string[]]>(values: T) {
+  return z.enum(values)
+}
+
+// Valida apenas os metadados do arquivo; o binário é tratado pelo serviço de upload.
+export const MAX_UPLOAD_BYTES = 5 * 1024 * 1024
+export const ACCEPTED_UPLOAD_MIME = ['image/jpeg', 'image/png', 'application/pdf'] as const
+
+export const fileUploadField = z.object({
+  url: z.string().url().optional(),
+  mime: z.enum(ACCEPTED_UPLOAD_MIME, {
+    errorMap: () => ({ message: 'Formato deve ser JPEG, PNG ou PDF' }),
+  }),
+  sizeBytes: z.number().max(MAX_UPLOAD_BYTES, 'Arquivo deve ter no máximo 5MB'),
+})
+export type FileUpload = z.infer<typeof fileUploadField>

package/src/shared/regex/index.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod'
+import { PATTERNS } from './patterns'
+import {
+  isAdultDMY,
+  isNotFutureDMY,
+  isValidCNPJ,
+  isValidCPF,
+  onlyDigits,
+  parseDMY,
+} from './validators'
+
+export * from './patterns'
+export * from './validators'
+
+export const cpfSchema = z
+  .string()
+  .transform(onlyDigits)
+  .refine((v) => PATTERNS.cpf.test(v), 'CPF deve ter 11 dígitos')
+  .refine(isValidCPF, 'CPF inválido')
+
+export const cnpjSchema = z
+  .string()
+  .transform(onlyDigits)
+  .refine((v) => PATTERNS.cnpj.test(v), 'CNPJ deve ter 14 dígitos')
+  .refine(isValidCNPJ, 'CNPJ inválido')
+
+export const cpfCnpjSchema = z
+  .string()
+  .transform(onlyDigits)
+  .refine(
+    (v) => PATTERNS.cpf.test(v) || PATTERNS.cnpj.test(v),
+    'Documento deve ter 11 (CPF) ou 14 (CNPJ) dígitos',
+  )
+  .refine((v) => (v.length === 11 ? isValidCPF(v) : isValidCNPJ(v)), 'Documento inválido')
+
+export const cepSchema = z
+  .string()
+  .transform(onlyDigits)
+  .refine((v) => PATTERNS.cep.test(v), 'CEP deve ter 8 dígitos')
+
+export const phoneBRSchema = z
+  .string()
+  .transform(onlyDigits)
+  .refine((v) => PATTERNS.phoneBR.test(v), 'Telefone deve ter 11 dígitos com DDD')
+
+export const emailSchema = z
+  .string()
+  .trim()
+  .refine((v) => PATTERNS.email.test(v), 'E-mail inválido')
+
+export const dateDMYSchema = z
+  .string()
+  .refine((v) => PATTERNS.dateDMY.test(v), 'Data deve estar no formato DD/MM/AAAA')
+  .refine((v) => parseDMY(v) !== null, 'Data inexistente no calendário')
+
+export const birthDateSchema = dateDMYSchema.refine(
+  (v) => isAdultDMY(v),
+  'É necessário ser maior de idade (18+)',
+)
+
+// RN-011 (prazo por tipo de documento) é aplicada no schema PF.
+export const issueDateSchema = dateDMYSchema.refine(
+  (v) => isNotFutureDMY(v),
+  'Data de emissão não pode ser futura',
+)
+
+export const currencySchema = z
+  .number({ invalid_type_error: 'Valor monetário inválido' })
+  .positive('Valor deve ser positivo')
+
+export const billDueDaySchema = z
+  .number()
+  .int('Deve ser um número inteiro')
+  .min(1, 'Mínimo 1')
+  .max(28, 'Máximo 28')

package/src/shared/regex/patterns.ts

@@ -0,0 +1,15 @@
+// Regras de formato (validação), não máscara visual da UI. Assumem input já
+// "limpo" (somente dígitos quando aplicável). Dígito verificador: validators.ts.
+export const PATTERNS = {
+  cpf: /^\d{11}$/,
+  cnpj: /^\d{14}$/,
+  cep: /^\d{8}$/,
+  phoneBR: /^\d{11}$/,
+  email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  dateDMY: /^\d{2}\/\d{2}\/\d{4}$/,
+  cnhNumber: /^\d{11}$/,
+  rneNumber: /^[A-Za-z0-9]+$/,
+  rgNumber: /^[A-Za-z0-9./-]+$/,
+} as const
+
+export type PatternKey = keyof typeof PATTERNS

package/src/shared/regex/validators.spec.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest'
+import {
+  birthDateSchema,
+  cepSchema,
+  cnpjSchema,
+  cpfSchema,
+  emailSchema,
+  issueDateSchema,
+  phoneBRSchema,
+} from './index'
+import {
+  ageInYears,
+  isAdultDMY,
+  isNotFutureDMY,
+  isValidCNPJ,
+  isValidCPF,
+  onlyDigits,
+  parseDMY,
+  yearsSinceDMY,
+} from './validators'
+
+describe('CPF', () => {
+  it('aceita CPF com dígito verificador válido', () => {
+    expect(isValidCPF('52998224725')).toBe(true)
+    expect(cpfSchema.safeParse('529.982.247-25').success).toBe(true)
+  })
+
+  it('rejeita dígito verificador inválido', () => {
+    expect(isValidCPF('52998224724')).toBe(false)
+    expect(cpfSchema.safeParse('52998224724').success).toBe(false)
+  })
+
+  it('rejeita tamanho errado', () => {
+    expect(isValidCPF('1234567890')).toBe(false) // 10 dígitos
+    expect(cpfSchema.safeParse('123').success).toBe(false)
+  })
+
+  it('rejeita repetidos (todos os dígitos iguais)', () => {
+    expect(isValidCPF('11111111111')).toBe(false)
+  })
+})
+
+describe('CNPJ', () => {
+  it('aceita CNPJ com dígito verificador válido', () => {
+    expect(isValidCNPJ('11222333000181')).toBe(true)
+    expect(cnpjSchema.safeParse('11.222.333/0001-81').success).toBe(true)
+  })
+
+  it('rejeita dígito verificador inválido', () => {
+    expect(isValidCNPJ('11222333000180')).toBe(false)
+    expect(cnpjSchema.safeParse('11222333000180').success).toBe(false)
+  })
+
+  it('rejeita tamanho errado', () => {
+    expect(isValidCNPJ('112223330001')).toBe(false) // 12 dígitos
+  })
+})
+
+describe('CEP', () => {
+  it('aceita 8 dígitos', () => {
+    expect(cepSchema.safeParse('01310930').success).toBe(true)
+    expect(cepSchema.safeParse('01310-930').success).toBe(true)
+  })
+
+  it('rejeita tamanho diferente de 8', () => {
+    expect(cepSchema.safeParse('1234567').success).toBe(false)
+    expect(cepSchema.safeParse('123456789').success).toBe(false)
+  })
+})
+
+describe('Telefone', () => {
+  it('aceita 11 dígitos com DDD', () => {
+    expect(phoneBRSchema.safeParse('11999998888').success).toBe(true)
+    expect(phoneBRSchema.safeParse('(11) 99999-8888').success).toBe(true)
+  })
+
+  it('rejeita menos de 11 dígitos', () => {
+    expect(phoneBRSchema.safeParse('1199998888').success).toBe(false)
+  })
+})
+
+describe('Email', () => {
+  it('aceita e-mail válido', () => {
+    expect(emailSchema.safeParse('cliente@exemplo.com').success).toBe(true)
+  })
+
+  it('rejeita e-mail inválido', () => {
+    expect(emailSchema.safeParse('cliente@@exemplo').success).toBe(false)
+    expect(emailSchema.safeParse('sem-arroba.com').success).toBe(false)
+  })
+})
+
+describe('parseDMY', () => {
+  it('faz parse de data válida', () => {
+    const d = parseDMY('10/05/1990')
+    expect(d).not.toBeNull()
+    expect(d?.getFullYear()).toBe(1990)
+    expect(d?.getMonth()).toBe(4) // maio = índice 4
+    expect(d?.getDate()).toBe(10)
+  })
+
+  it('rejeita data de calendário inexistente (31/02/2000)', () => {
+    expect(parseDMY('31/02/2000')).toBeNull()
+  })
+
+  it('rejeita formato inválido', () => {
+    expect(parseDMY('1990-05-10')).toBeNull()
+    expect(parseDMY('5/5/1990')).toBeNull()
+  })
+})
+
+describe('onlyDigits', () => {
+  it('remove tudo que não for dígito', () => {
+    expect(onlyDigits('(11) 99999-8888')).toBe('11999998888')
+  })
+})
+
+describe('birthDate (idade mínima)', () => {
+  const reference = new Date(2026, 5, 1) // 01/06/2026
+
+  it('rejeita menor de 18 anos', () => {
+    expect(isAdultDMY('01/01/2010', reference)).toBe(false)
+    expect(birthDateSchema.safeParse('01/01/2015').success).toBe(false)
+  })
+
+  it('aceita adulto', () => {
+    expect(isAdultDMY('01/01/1990', reference)).toBe(true)
+    expect(birthDateSchema.safeParse('10/05/1990').success).toBe(true)
+  })
+})
+
+describe('issueDate (não futura)', () => {
+  const reference = new Date(2026, 5, 1)
+
+  it('rejeita data futura', () => {
+    expect(isNotFutureDMY('01/01/2030', reference)).toBe(false)
+    expect(issueDateSchema.safeParse('01/01/2999').success).toBe(false)
+  })
+
+  it('aceita data passada', () => {
+    expect(isNotFutureDMY('01/01/2020', reference)).toBe(true)
+    expect(issueDateSchema.safeParse('01/01/2020').success).toBe(true)
+  })
+})
+
+describe('yearsSinceDMY / ageInYears', () => {
+  const reference = new Date(2026, 5, 1) // 01/06/2026
+
+  it('calcula anos completos de forma coerente', () => {
+    expect(yearsSinceDMY('01/06/2016', reference)).toBe(10)
+    expect(yearsSinceDMY('02/06/2016', reference)).toBe(9) // aniversário ainda não chegou
+  })
+
+  it('retorna null para data inválida', () => {
+    expect(yearsSinceDMY('31/02/2000', reference)).toBeNull()
+  })
+
+  it('ageInYears é consistente entre duas datas', () => {
+    expect(ageInYears(new Date(2000, 0, 1), new Date(2026, 0, 1))).toBe(26)
+    expect(ageInYears(new Date(2000, 0, 2), new Date(2026, 0, 1))).toBe(25)
+  })
+})

package/src/shared/regex/validators.ts

@@ -0,0 +1,96 @@
+export function onlyDigits(value: string): string {
+  return value.replace(/\D/g, '')
+}
+
+export function isValidCPF(value: string): boolean {
+  const cpf = onlyDigits(value)
+  if (cpf.length !== 11) {
+    return false
+  }
+  if (/^(\d)\1{10}$/.test(cpf)) {
+    return false
+  }
+
+  const calcCheck = (slice: number): number => {
+    let sum = 0
+    for (let i = 0; i < slice; i++) {
+      sum += Number(cpf[i]) * (slice + 1 - i)
+    }
+    const rest = (sum * 10) % 11
+    return rest === 10 ? 0 : rest
+  }
+
+  return calcCheck(9) === Number(cpf[9]) && calcCheck(10) === Number(cpf[10])
+}
+
+export function isValidCNPJ(value: string): boolean {
+  const cnpj = onlyDigits(value)
+  if (cnpj.length !== 14) {
+    return false
+  }
+  if (/^(\d)\1{13}$/.test(cnpj)) {
+    return false
+  }
+
+  const calcCheck = (length: number): number => {
+    const weights =
+      length === 12 ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+    let sum = 0
+    for (const [i, weight] of weights.entries()) {
+      sum += Number(cnpj[i]) * weight
+    }
+    const rest = sum % 11
+    return rest < 2 ? 0 : 11 - rest
+  }
+
+  return calcCheck(12) === Number(cnpj[12]) && calcCheck(13) === Number(cnpj[13])
+}
+
+export function parseDMY(value: string): Date | null {
+  const match = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(value)
+  if (!match) {
+    return null
+  }
+  const [, dd, mm, yyyy] = match
+  const day = Number(dd)
+  const month = Number(mm)
+  const year = Number(yyyy)
+  const date = new Date(year, month - 1, day)
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
+    return null
+  }
+  return date
+}
+
+export function ageInYears(birth: Date, reference: Date = new Date()): number {
+  let age = reference.getFullYear() - birth.getFullYear()
+  const monthDiff = reference.getMonth() - birth.getMonth()
+  if (monthDiff < 0 || (monthDiff === 0 && reference.getDate() < birth.getDate())) {
+    age--
+  }
+  return age
+}
+
+export function isAdultDMY(value: string, reference?: Date): boolean {
+  const date = parseDMY(value)
+  if (!date) {
+    return false
+  }
+  return ageInYears(date, reference) >= 18
+}
+
+export function isNotFutureDMY(value: string, reference: Date = new Date()): boolean {
+  const date = parseDMY(value)
+  if (!date) {
+    return false
+  }
+  return date.getTime() <= reference.getTime()
+}
+
+export function yearsSinceDMY(value: string, reference: Date = new Date()): number | null {
+  const date = parseDMY(value)
+  if (!date) {
+    return null
+  }
+  return ageInYears(date, reference)
+}