pwi-plata-type 0.3.18 → 0.4.0

package/{libs/model.ts → src/libs/model-validations.ts}

@@ -1,198 +1,4 @@
-import { PlataError } from "./tools"
-
-export interface RetornoValidacaoPrimitivo {
-    error?: PlataError
-    continua: boolean
-}
-
-export type ModelValicacao = (value: any) => Promise<PlataError | null>
-
-export type ModelTratamento<T = any> = (value: T) => T
-
-export type ModelValicacaoPrimitivo<T = any, D = null> = (nome: string, valor: T | D) => Promise<RetornoValidacaoPrimitivo> & { _output?: T | D }
-
-export interface ModelType {
-    [name: string]: ModelValicacaoPrimitivo[] | ModelType[] | ModelType
-}
-
-export type ExtractType<T extends ModelType> = {
-    [P in keyof T]: T[P] extends ModelType ? ExtractType<T[P]> : 
-                    T[P] extends ModelType[] ? ExtractType<T[P][0]>[] : any
-}
-
-export class Model<T extends ModelType>{
-    public readonly template: T
-    public readonly validacoes: Map<string, ModelValicacao>
-    public readonly tratamentos: Map<string, ModelTratamento>
-    public readonly _type: ExtractType<T>
-
-    constructor(template: T) {
-        this.template = template
-        this.validacoes = new Map()
-        this.tratamentos = new Map()
-    }
-
-    public addValidacao(nome: string, callback: ModelValicacao) {
-        this.validacoes.set(nome, callback)
-    }
-
-    public addTratamento<T>(nome: string, callback: ModelTratamento<T>) {
-        this.tratamentos.set(nome, callback)
-    }
-}
-
-export async function _validaCampo(value: any, pipelines: ModelValicacaoPrimitivo[], name: string): Promise<PlataError | null> {
-    for (const pipeline of pipelines) {
-        const result = await pipeline(name, value)
-
-        if (result.error !== undefined) {
-            return result.error
-        }
-
-        if (!result.continua) {
-            break
-        }
-    }
-
-    return null
-}
-
-export function _trataModel<T,Y extends ModelType>(value: T, model: Model<Y>) {
-    model.tratamentos.forEach(tratamento => {
-        value = tratamento(value)
-    })
-
-    return value as unknown as typeof model._type
-}
-
-export function _filtraModel<Y extends ModelType>(value: any, model: Model<Y>) {
-    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 as unknown as typeof model._type
-}
-
-export async function _validaModel<Y extends ModelType>(value: any, model: Model<Y>, name?: string): Promise<PlataError[]> {
-    let promises: any[] = []
-    
-    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, `${name ?? ''}${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) {
-        return Erros as PlataError[]
-    }
-
-    if ((Erros as any[]).length !== 0) {
-        return Erros as PlataError[]
-    }
-
-    promises = []
-
-    for (const [ _, callback ] of model.validacoes) {
-        promises.push(callback(value))
-    }
-
-    Erros = await Promise.all(promises).then(
-        result => [].concat(...result).filter(v => v !== null),
-        err => {
-            return {
-                errorID: 'BPLM0003',
-                error: err,
-                msg: 'Erro ao validar o body',
-            }
-        }
-    )
-
-    if ((Erros as any).errorID !== undefined) {
-        return Erros as PlataError[]
-    }
-
-    return Erros as PlataError[]
-}
-
-export async function valida<Y extends ModelType>(value: any, model: Model<Y>) {
-    const v: typeof model._type = _trataModel(_filtraModel(value, model), model)
-
-    return {
-        value: v,
-        errors: await _validaModel(value, model),
-    }
-}
-
-export function Min(min: number): ModelValicacaoPrimitivo {
+export function Min(min: number): Model.PrimitiveValidationType<any> {
     return async (nome: string, valor: any) => {
         if (valor < min) return {
             error: {
@@ -206,7 +12,7 @@ export function Min(min: number): ModelValicacaoPrimitivo {
     }
 }
 
-export function Max(max: number): ModelValicacaoPrimitivo {
+export function Max(max: number): Model.PrimitiveValidationType<any> {
     return async (nome: string, valor: any) => {
         if (valor > max) return {
             error: {
@@ -220,9 +26,9 @@ export function Max(max: number): ModelValicacaoPrimitivo {
     }
 }
 
-export function Enum(...valores: any[]): ModelValicacaoPrimitivo {
+export function Enum<T extends readonly any[]>(valores: T): Model.PrimitiveValidationType<T[number]> {
     return async (nome: string, valor: any) => {
-        if (valores.find(v => `${valor}` === `${v}`)) return {
+        if (valores.findIndex(v => `${valor}` === `${v}`) === -1) return {
             error: {
                 errorID: 'BPMVEN0001',
                 msg: `O campo ${nome} so pode ter os valores: ${valores.join(', ')}`,
@@ -235,14 +41,14 @@ export function Enum(...valores: any[]): ModelValicacaoPrimitivo {
     }
 }
 
-export function DateTime(): ModelValicacaoPrimitivo {
+export function StringDateTime(): Model.PrimitiveValidationType<string> {
     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",
+                    errorID: "BPVSDT001",
                     msg: `A data no campo ${nome} tem que está no formato yyyy-mm-ddTHH:MM:SS`,
                 },
                 continua: false
@@ -254,7 +60,7 @@ export function DateTime(): ModelValicacaoPrimitivo {
         if (isNaN(+ano) || isNaN(+mes) || isNaN(+dia) || isNaN(+hora) || isNaN(+minutos) || isNaN(+segundos) ){
             return {
                 error: {
-                    errorID: "BPMVDT002",
+                    errorID: "BPVSDT002",
                     msg: `A data no campo ${nome} tem que está no formato yyyy-mm-ddTHH:MM:SS` 
                 },
                 continua: false
@@ -264,7 +70,7 @@ export function DateTime(): ModelValicacaoPrimitivo {
         if ((+dia) > 31 || (+mes) > 12 || (+hora) > 24){
             return {
                 error: {
-                    errorID: "BCVDT003",
+                    errorID: "BCVSDT003",
                     msg: `A data no campo ${nome} tem que está no formato yyyy-mm-ddTHH:MM:SS`,
                 },
                 continua: false
@@ -275,7 +81,17 @@ export function DateTime(): ModelValicacaoPrimitivo {
     }
 }
 
-export function Decimal(tamanhoInteiro: number, casasDecimais: number, min?: number, max?: number): ModelValicacaoPrimitivo {
+export function DateTime(): Model.PrimitiveValidationType<Date> {
+    return async (nome, value) => value instanceof Date ? { continua: true } : {
+        error: {
+            errorID: 'BPVDT001',
+            msg: `O campo ${nome} não é do tipo Date`
+        }, 
+        continua: false
+    }
+} 
+
+export function Decimal(tamanhoInteiro: number, casasDecimais: number, min?: number, max?: number): Model.PrimitiveValidationType<number> {
     return async (nome: string, valor: any) => {
         if (isNaN(+valor)) {
             return {
@@ -335,7 +151,7 @@ export function Decimal(tamanhoInteiro: number, casasDecimais: number, min?: num
     }
 }
 
-export function Int(min?: number, max?: number): ModelValicacaoPrimitivo {
+export function Int(min?: number, max?: number): Model.PrimitiveValidationType<number> {
     return async (nome: string, valor: any) => {
         if (isNaN(+valor)) {
             return {
@@ -371,57 +187,7 @@ export function Int(min?: number, max?: number): ModelValicacaoPrimitivo {
     }
 }
 
-export function isArray(tamanhoMaximo?: number, tamanhoMinimo?: number): ModelValicacaoPrimitivo {
-    return async (nome: string, valor: any) => {
-        if (valor === null) {
-            return {
-                error: {
-                    errorID: "BPCVARR001",
-                    msg: `O campo ${nome} tem ser um array` 
-                },
-                continua: false
-            }
-        }
-
-        if (valor.length === undefined) {
-            return {
-                error: { 
-                    errorID: "BPCVARR002",
-                    msg: `O campo ${nome} tem ser um array` 
-                },
-                continua: false
-            }
-        }
-
-        if (tamanhoMinimo !== undefined) {
-            if (valor.length > tamanhoMinimo) {
-                return {
-                    error: { 
-                        errorID: "BPCVARR004",
-                        msg: `O campo ${nome} não pode ter menos que ${tamanhoMinimo} itens` 
-                    },
-                    continua: false
-                }
-            }
-        }
-
-        if (tamanhoMaximo !== undefined) {
-            if (valor.length < tamanhoMaximo) {
-                return {
-                    error: { 
-                        errorID: "BPCVARR003",
-                        msg: `O campo ${nome} não pode ter mais de ${tamanhoMaximo} itens` 
-                    },
-                    continua: false
-                }
-            }
-        }
-
-        return { continua: true }
-    }
-}
-
-export function Optional(): ModelValicacaoPrimitivo {
+export function Optional(): Model.PrimitiveValidationType<any, null> {
     return async (_nome: string, valor: any) => {
         if (!valor) {
             return { continua: false }
@@ -431,7 +197,7 @@ export function Optional(): ModelValicacaoPrimitivo {
     }
 }
 
-export function Required(): ModelValicacaoPrimitivo {
+export function Required(): Model.PrimitiveValidationType {
     return async (nome: string, valor: any) => {
         if (valor === null) {
             return {
@@ -447,7 +213,7 @@ export function Required(): ModelValicacaoPrimitivo {
     }
 }
 
-export function SmallDateTime(): ModelValicacaoPrimitivo {
+export function SmallDateTime(): Model.PrimitiveValidationType<string> {
     return async (nome: string, valor: any) => {
         const regex = /(\d{4})-([01]\d)-([0-3]\d)/
 
@@ -498,7 +264,7 @@ export function SmallDateTime(): ModelValicacaoPrimitivo {
     }
 }
 
-export function Telefone(): ModelValicacaoPrimitivo {
+export function Telefone(): Model.PrimitiveValidationType<string> {
     return async (nome: string, valor: any) => {
         const v = `${valor}`.split('-')
 
@@ -536,7 +302,7 @@ export function Telefone(): ModelValicacaoPrimitivo {
     }
 }
 
-export function TelefoneDDI(): ModelValicacaoPrimitivo {
+export function TelefoneDDI(): Model.PrimitiveValidationType<string> {
     return async (nome: string, valor: any) => {
         const [ ddi, t ] = `${valor}`.split(' ')
         const telefone = `${t}`.split('-')
@@ -595,9 +361,9 @@ export function TelefoneDDI(): ModelValicacaoPrimitivo {
     }
 }
 
-export function VarChar(size: number, min?: number): ModelValicacaoPrimitivo {
+export function VarChar(size: number, min?: number): Model.PrimitiveValidationType<string> {
     return async (nome: string, valor: any) => {
-        if (valor.length > size) {
+        if (`${valor}`.length > size) {
             return {
                 error: {
                     errorID: "BPVVARC001",
@@ -608,7 +374,7 @@ export function VarChar(size: number, min?: number): ModelValicacaoPrimitivo {
         }
 
         if (min !== undefined) {
-            if (valor.length < min) {
+            if (`${valor}`.length < min) {
                 return {
                     error: {
                         errorID: "BPVVARC002",

package/src/libs/model.ts

@@ -0,0 +1,233 @@
+export namespace Internals {
+    export function filterTemplate<Y extends Model.Template>(value: any, template: Y) {
+        for (const param in template) {
+            const t = template[param]
+    
+            if (t.length === undefined) {
+                if (value[param] === undefined) {
+                    value[param] = new Object(null)
+                }
+    
+                value[param] = filterTemplate(value[param], t as Model.Template)
+                continue
+            }
+    
+            if (typeof t[0] === 'function') {
+                if (value[param] === undefined) {
+                    value[param] = null
+                }
+
+                continue
+            }
+    
+            if (t[0].length !== undefined) {
+                if (value[param] === undefined) {
+                    value[param] = []
+                }
+    
+                if (!Array.isArray(value[param])) {
+                    value[param] = []
+                }
+
+                continue
+            }
+    
+            if (value[param] === undefined) {
+                value[param] = []
+    
+                continue
+            }
+    
+            for (let i = 0; i < value[param].length; i++) {
+                value[param][i] = filterTemplate(value[param][i], t[0])
+            }
+        }
+    
+        return value as Model.ExtractTemplateTypeNotValid<typeof template>
+    }
+    
+    export async function validateParameter(value: any, pipeline: Model.PrimitiveValidationType[], name: string): Promise<Model.ValidateReturn> {
+        for (const validation of pipeline) {
+            const result = await validation(name, value)
+    
+            if (result.error !== undefined) {
+                return result.error
+            }
+    
+            if (!result.continua) {
+                break
+            }
+        }
+    
+        return null
+    }
+    
+    export async function validateTemplate<Y extends Model.Template>(value: any, template: Y, name?: string): PlataPromise<PlataError[]> {        
+        const promises: any[] = []
+        for (const param in template) {
+            const t = template[param]
+    
+            if (t.length === undefined) {
+                promises.push(validateTemplate(
+                    value[param],
+                    t as Model.Template,
+                    `${name ?? ''}${param}.`
+                ))
+    
+                continue
+            }
+    
+            if (typeof t[0] === 'function') {
+                promises.push(
+                    validateParameter(
+                        value[param],
+                        t as Model.PrimitiveValidationType[],
+                        `${name ?? ''}${param}`
+                    )
+                )
+    
+                continue
+            }
+    
+            if (t[0].length !== undefined) {
+                for (let i = 0; i < value[param].length; i++) {
+                    promises.push(
+                        validateParameter(
+                            value[param][i],
+                            t[0],
+                            `${name ?? ''}${param}[${i}]`
+                        )
+                    )
+                }
+    
+                continue
+            }
+    
+            for (let i = 0; i < value[param].length; i++) {
+                promises.push(
+                    validateTemplate(
+                        value[param][i],
+                        t[0],
+                        `${name ?? ''}${param}[${i}].`
+                    )
+                )
+            }
+        }
+
+        return Plata.FastPromise(() => Promise.all(promises)).then(
+            result => [].concat(...result).filter(v => v !== null),
+            err => {
+                return {
+                    errorID: 'BPLM0001',
+                    msg: `unexpected error while validating template (${name})`,
+                    error: err
+                }
+            }
+        )
+    }
+}
+
+export class ModelTemplate<T extends Model.Template, C extends Model.Converters<T>> {
+    public readonly template: T
+    public readonly converters: C | {}
+    public readonly validations: Map<string, Model.ModelTemplateValidation<T>>
+    public readonly filters: Map<string, Model.ModelTemplateFilter<T>>
+    public readonly type: Model.ExtractTemplateType<T>
+
+    constructor(template: T, converters: C | {}) {
+        this.template = template
+        this.converters = converters
+        this.validations = new Map()
+        this.filters = new Map()
+    }
+
+    public addValidation(nome: string, callback: Model.ModelTemplateValidation<T>) {
+        this.validations.set(nome, callback)
+    }
+
+    public addFilter(nome: string, callback: Model.ModelTemplateFilter<T>) {
+        this.filters.set(nome, callback)
+    }
+
+    public convert: Model.ModelConvertFuntion<T, C> = (value, to) => {
+        const c: Model.ConvertFunction<T, any> | undefined = this.converters[to as string]
+
+        if (c === undefined)
+            return {
+                errorID: 'BPLM0002',
+                msg: 'Invalid Converter',
+                error: to
+            }
+        ;
+
+        try {
+            return c(value)
+        } catch (e) {
+            return {
+                errorID: 'BPLM0003',
+                msg: 'Unexpected converter error',
+                error: e
+            }
+        }
+    }
+
+    public filter(value: any) {
+        let v = Internals.filterTemplate(value, this.template)
+
+        this.filters.forEach(f => {
+            v = f(v)
+        })
+
+        return v
+    }
+
+    public async validate(value: any): Promise<Model.ModelValidateReturn<T>> {
+        const v = this.filter(value)
+        const errors = await Internals.validateTemplate(v, this.template)
+
+        if (errors.errorID !== undefined) {
+            return {
+                value: v as any,
+                errors: [errors]
+            }
+        }
+
+        if (errors.length !== 0) {
+            return {
+                value: v as any,
+                errors
+            }
+        }
+
+        const promises: Promise<Model.ValidateReturn>[] = []
+
+        this.validations.forEach(validation => {
+            promises.push(validation(v as any))
+        })
+
+        const result: PlataResult<PlataError[]> = await Plata.FastPromise(() => Promise.all(promises)).then(
+            r => ([] as Model.ValidateReturn[]).concat(...r).filter(v => v !== null),
+            err => {
+                return {
+                    errorID: 'BPLM0002',
+                    msg: `unexpected error while validating model`,
+                    error: err
+                }
+            }
+        ) as any
+
+        if (result.errorID !== undefined) {
+            return {
+                value: v as any,
+                errors: [result]
+            }
+        }
+
+        return {
+            value: v as any,
+            errors: result.length !== 0 ? result : undefined
+        }
+    }
+}
+
+export * from './model-validations'