pwi-plata-type 0.1.0 → 0.1.3

package/bin/extras/plata-create-api.ts

@@ -1,4 +1,5 @@
 import { tools } from "./plata-create-tools.js";
+import { PlataDirs } from "../../libs/tools.js"
 import * as path from 'node:path'
 
 export async function h() {
@@ -50,6 +51,17 @@ export async function h() {
                 )))
 
             break;
+            case 'model':
+                const modelName = args.shift()
+                const plataName = PlataDirs.ProjectJson.plata_name
+
+                promises.push(tools.files.deployFileToProject(
+                    'models',
+                    'model',
+                    `${modelName.toLowerCase()}.ts`,
+                    { Name: `${modelName}`, PlataName: `${plataName}` }
+                ).finally(() => console.log(`Model ${modelName} criada`)))
+            break;
         }
 
         await Promise.all(promises)

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,474 @@
+export interface ErroValidacao {
+    errorID: string
+    error?: any
+    msg: string
+}
+
+export interface RetornoValidacaoPrimitivo {
+    error?: ErroValidacao
+    continua: 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.continua) {
+            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`,
+                },
+                continua: 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` 
+                },
+                continua: 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`,
+                },
+                continua: false
+            }
+        }
+
+        return { continua: 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` 
+                },
+                continua: 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)}` 
+                },
+                continua: 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` 
+                },
+                continua: 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` 
+                    },
+                    continua: false,
+                }
+            }
+        }
+
+        return { continua: 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` 
+                },
+                continua: false,
+            }
+        }
+
+        if (Math.round(valor) !== valor) {
+            return {
+                error: {
+                    errorID: "BPMVINT002",
+                    msg: `O campo ${nome} tem que ser um número inteiro` 
+                },
+                continua: false,
+            }
+        }
+
+        return { continua: true }
+    }
+}
+
+export function isArray(tamanhoMaximo?: number): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (valor === undefined) {
+            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 (tamanhoMaximo !== undefined && tamanhoMaximo !== Infinity) {
+            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 {
+    return async (nome: string, valor: any) => {
+        if (!valor) {
+            return { continua: false }
+        }
+
+        return { continua: true }
+    }
+}
+
+export function Required(): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (valor === undefined) {
+            return {
+                error: { 
+                    errorID: "BPCVREQ001",
+                    msg: `O campo ${nome} é obrigatório` 
+                },
+                continua: false
+            }
+        }
+    
+        return { continua: true }
+    }
+}
+
+export function SmallDateTime(): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        const regex = /(\d{4})-([01]\d)-([0-3]\d)/
+
+        if (!regex.test(valor)) {
+            return {
+                error: { 
+                    errorID: "BPCVDT001",
+                    msg: `A data no campo ${nome} tem que está no formato yyyy-mm-dd` 
+                },
+                continua: false
+            }
+        }
+    
+        const [ _, ano, mes, dia ] = valor.match(regex)
+    
+        if (isNaN(+ano) || isNaN(+mes) || isNaN(+dia)){
+            return {
+                error: { 
+                    errorID: "BPCVDT002",
+                    msg: `A data no campo ${nome} tem que está no formato yyyy-mm-dd` 
+                },
+                continua: false
+            }
+        }
+    
+        if ((+dia) > 31 || (+mes) > 12 ){
+            return {
+                error: {
+                    errorID: "BPCVDT003",
+                    msg: `A data no campo ${nome} tem que está no formato yyyy-mm-dd` 
+                },
+                continua: false
+            }
+        }
+    
+        //https://sqltutorialtips.blogspot.com/2016/11/smalldatetime-vs-datetime.html
+        if (new Date(+ano, mes - 1, +dia) >= new Date(2079, 11, 31)) {
+            return {
+                error: {
+                    errorID: "BPCVDT004",
+                    msg: `A data no campo ${nome} não pode ser maior que 2079-12-31` 
+                },
+                continua: false
+            }
+        }
+    
+        return { continua: true }
+    }
+}
+
+export function Telefone(): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        const v = `${valor}`.split('-')
+
+        if (v.length !== 2) {
+            return {
+                error: { 
+                    errorID: "BPVTEL001",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        if (v[0].length !== 2 || v[1].length > 9) {
+            return {
+                error: {
+                    errorID: "BPVTEL002",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        if (!+v[0] || !+v[1]) {
+            return {
+                error: {
+                    errorID: "BPVTEL003",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        return { continua: true }
+    }
+}
+
+export function VarChar(size: number): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (valor.length > size) {
+            return {
+                error: {
+                    errorID: "BPVVARC001",
+                    msg: `O campo ${nome} tem que menos de ${nome} caracteres` 
+                },
+                continua: false
+            }
+        }
+
+        return { continua: true }
+    }
+}

package/package.json

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

package/templates/create-cli/model.ts

@@ -0,0 +1,26 @@
+//@ts-nocheck
+import { PlataModels } from "ç__PlataName__ç";
+
+const ç__Name__ç = new PlataModels.Model({
+    campo: [ PlataModels.Required(), PlataModels.Int() ],
+    objeto: {
+        campo: [ PlataModels.Optional(), PlataModels.DateTime() ]
+    },
+    arrayItens: [{
+        campo: [ PlataModels.Required(), PlataModels.Telefone() ]
+    }]
+})
+
+ç__Name__ç.addValidacao('Validação Customizada', async (objeto) => {
+    if (objeto.campo > 30) {
+        return {
+            errorID: 'BM0001',
+            msg: 'O campo não pode ser maior que 30',
+            error: `valor do campo: ${objeto.campo}`
+        }
+    }
+
+    return null
+})
+
+export const ç__Name__çModel = ç__Name__ç

package/templates/postinstall/api/_install.mjs

@@ -7,6 +7,7 @@ export async function install({ dirs, projectPackageJson }) {
     promises.push(t.createFolderProject('clusters'))
     promises.push(t.createFolderProject('routes'))
     promises.push(t.createFolderProject('libs'))
+    promises.push(t.createFolderProject('models'))
 
     promises.push(t.copyFolderToProject('configs'))
     promises.push(t.copyFolderToProject('envs'))