pwi-plata-type 0.1.0 → 0.1.1

package/index.ts

@@ -2,10 +2,12 @@ import * as PlataCluster from './libs/cluster.js'
 import * as PlataEnv from './libs/env.js'
 import * as PlataRoutes from './libs/routes.js'
 import * as PlataTools from './libs/tools.js'
+import * as PlataModels from './libs/model.js'
 
 export {
     PlataCluster,
     PlataEnv,
     PlataRoutes,
     PlataTools,
+    PlataModels,
 }

package/libs/model.ts

@@ -0,0 +1,305 @@
+export interface ErroValidacao {
+    errorID: string
+    error?: any
+    msg: string
+}
+
+export interface RetornoValidacaoPrimitivo {
+    error?: ErroValidacao
+    cotinua: boolean
+}
+
+export interface RetornoValicadaoModel {
+    value: any,
+    errors: ErroValidacao[]
+}
+
+export type ModelValicacao = (value: any) => Promise<ErroValidacao | null>
+
+export type ModelValicacaoPrimitivo = (nome: string, valor: any) => Promise<RetornoValidacaoPrimitivo>
+
+export interface ModelType {
+    [name: string]: ModelValicacaoPrimitivo[] | ModelType[] | ModelType
+}
+
+export class Model {
+    public readonly template: ModelType
+    public readonly validacoes: Map<string, ModelValicacao>
+
+    constructor(template: ModelType) {
+        this.template = template
+        this.validacoes = new Map()
+    }
+
+    public addValidacao(nome: string, callback: ModelValicacao) {
+        this.validacoes.set(nome, callback)
+    }
+}
+
+export async function _validaCampo(value: any, pipeline: ModelValicacaoPrimitivo[], name: string): Promise<ErroValidacao | null> {
+    for (let i = 0; i < pipeline.length; i++) {
+        const result = await pipeline[i](name, value)
+
+        if (result.error !== undefined) {
+            return result.error
+        }
+
+        if (!result.cotinua) {
+            break
+        }
+    }
+
+    return null
+}
+
+export function _filtraModel(value: any, model: Model): any {
+    for (const campo in model.template) {
+        const t = model.template[campo]
+
+        if (t.length === undefined) {
+            if (value[campo] === undefined) {
+                value[campo] = {}
+            }
+
+            const m = new Model(t as ModelType)
+            value[campo] = _filtraModel(value[campo], m)
+            continue
+        }
+        
+        if (typeof t[0] === 'function') {
+            if (value[campo] === undefined) {
+                value[campo] = null
+            }
+
+            continue
+        }
+
+        if (value[campo] === undefined) {
+            value[campo] = []
+
+            continue
+        }
+
+        const m = new Model(t[0] as ModelType)
+
+        for (let i = 0; i < value[campo].length; i++) {
+            value[campo][i] = _filtraModel(value[campo][i], m)
+        }
+    }
+
+    return value
+}
+
+export async function _validaModel(value: any, model: Model, name?: string): Promise<ErroValidacao[]> {
+    let promises: any[] = []
+    let errors: ErroValidacao[] = []
+    
+    for(const campo in model.template) {
+        const t = model.template[campo]
+
+        if (t.length === undefined) {
+            const m = new Model(t as ModelType)
+
+            promises.push(_validaModel(value[campo], m, `${campo}.`))
+            continue
+        }
+
+        if (typeof t[0] === 'function') {
+            promises.push(
+                _validaCampo(
+                    value[campo],
+                    t as ModelValicacaoPrimitivo[],
+                    `${name ?? ''}${campo}`
+                )
+            )
+            continue
+        }
+
+        const m = new Model(t[0])
+
+        for (let i = 0; i < value[campo].length; i++) {
+            promises.push(
+                _validaModel(
+                    value[campo][i],
+                    m,
+                    `${name ?? ''}${campo}[${i}].`
+                )
+            )
+        }
+    }
+
+    let Erros = await Promise.all(promises).then(
+        result => [].concat(...result).filter(v => v !== null),
+        err => {
+            return {
+                errorID: 'BPLM0002',
+                error: err,
+                msg: 'Erro ao validar o body',
+            }
+        }
+    )
+
+    if ((Erros as any).errorID !== undefined) {
+        errors.push(Erros as ErroValidacao)
+
+        return errors
+    }
+
+    errors = errors.concat(Erros)
+
+    if (errors.length !== 0) {
+        return errors
+    }
+
+    promises = []
+
+    for (const [ _, callback ] of model.validacoes) {
+        promises.push(callback(value))
+    }
+
+    Erros = await Promise.all(promises).then(
+        result => [].concat(...result),
+        err => {
+            return {
+                errorID: 'BPLM0003',
+                error: err,
+                msg: 'Erro ao validar o body',
+            }
+        }
+    )
+
+    if ((Erros as any).errorID !== undefined) {
+        errors.push(Erros as ErroValidacao)
+
+        return errors
+    }
+
+    return errors.concat(Erros)
+}
+
+export async function valida(value: any, model: Model): Promise<RetornoValicadaoModel> {
+    value = _filtraModel(value, model)
+
+    return {
+        value,
+        errors: await _validaModel(value, model),
+    }
+}
+
+export function DateTime(): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        const regex = /(\d{4})-([01]\d)-([0-3]\d)T([0-2]\d):([0-5]\d):([0-5]\d)/
+
+        if (!regex.test(valor)) {
+            return {
+                error: {
+                    errorID: "BPMVDT001",
+                    msg: `A data no campo ${nome} tem que está no formato yyyy-mm-ddTHH:MM:SS`,
+                },
+                cotinua: false
+            }
+        }
+
+        const [ _, ano, mes, dia, hora, minutos, segundos ] = valor.match(regex)
+
+        if (isNaN(+ano) || isNaN(+mes) || isNaN(+dia) || isNaN(+hora) || isNaN(+minutos) || isNaN(+segundos) ){
+            return {
+                error: {
+                    errorID: "BPMVDT002",
+                    msg: `A data no campo ${nome} tem que está no formato yyyy-mm-ddTHH:MM:SS` 
+                },
+                cotinua: false
+            }
+        }
+
+        if ((+dia) > 31 || (+mes) > 12 || (+hora) > 24){
+            return {
+                error: {
+                    errorID: "BCVDT003",
+                    msg: `A data no campo ${nome} tem que está no formato yyyy-mm-ddTHH:MM:SS`,
+                },
+                cotinua: false
+            }
+        }
+
+        return { cotinua: true }
+    }
+}
+
+export function Decimal(tamanhoInteiro: number, casasDecimais: number): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (isNaN(+valor)) {
+            return {
+                error: {
+                    errorID: "BPMVDEC001",
+                    msg: `O campo ${nome} tem que ser um decimal` 
+                },
+                cotinua: false,
+            }
+        }
+
+        const v = `${valor}`
+
+        if (v.length > (tamanhoInteiro + casasDecimais + 1)) {
+            return {
+                error: {
+                    errorID: "BPMVDEC002",
+                    msg: `O campo ${nome} não pode ser maior que ${(tamanhoInteiro + casasDecimais + 1)}` 
+                },
+                cotinua: false,
+            }
+        }
+
+        const n = v.split('.')
+
+        if (n[0].length > tamanhoInteiro) {
+            return {
+                error: {
+                    errorID: "BPMVDEC003",
+                    msg: `A parte inteira do ${nome} não pode ter mais de ${tamanhoInteiro} digitos` 
+                },
+                cotinua: false,
+            }
+        }
+
+        if (n[1] !== undefined) {
+            if (n[1].length > casasDecimais) {
+                return {
+                    error: {
+                        errorID: "BPMVDEC004",
+                        msg: `A parte decimal do ${nome} não pode ter mais de ${casasDecimais} digitos` 
+                    },
+                    cotinua: false,
+                }
+            }
+        }
+
+        return { cotinua: true }
+    }
+}
+
+export function Int(): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (isNaN(+valor)) {
+            return {
+                error: {
+                    errorID: "BPMVINT001",
+                    msg: `O campo ${nome} tem que ser um número inteiro` 
+                },
+                cotinua: false,
+            }
+        }
+
+        if (Math.round(valor) !== valor) {
+            return {
+                error: {
+                    errorID: "BPMVINT002",
+                    msg: `O campo ${nome} tem que ser um número inteiro` 
+                },
+                cotinua: false,
+            }
+        }
+
+        return { cotinua: true }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pwi-plata-type",
-    "version": "0.1.0",
+    "version": "0.1.1",
     "type": "module",
     "main": "index.ts",
     "bin": {