pwi-plata-type 0.3.8 → 0.3.11

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

@@ -141,4 +141,22 @@ program.command('task <tasks...>')
     })
 ;
 
+program.command('cluster <clusters...>')
+    .description('Cria o arquivo do worker utilizando o templete da plata')
+    .action(async clusters => {
+        if (!Array.isArray(clusters)) return
+
+        const promises: any[] = []
+        const plataName = PlataDirs.ProjectJson.plata_name
+
+        for (const cluster of clusters) {
+            promises.push(tools.files.deployFileToProject(
+                'clusters',
+                'cluster',
+                `${cluster}.ts`.toLowerCase(),
+                { Name: `${cluster}`, PlataName: `${plataName}` }
+            ).finally(() => console.log(`Worker ${cluster} criada`)))
+        }
+    })
+;
 export const cli = program

package/index.ts

@@ -5,6 +5,7 @@ import * as PlataTools from './libs/tools'
 import * as PlataModels from './libs/model'
 import * as PlataTasks from './libs/tasks'
 import { PlataSwagger } from './libs/swagger'
+import { PlataAxios, PlataAxiosUnsafe } from './libs/axios'
 
 export {
     PlataCluster,
@@ -13,5 +14,7 @@ export {
     PlataTools,
     PlataModels,
     PlataSwagger,
-    PlataTasks
+    PlataTasks,
+    PlataAxios,
+    PlataAxiosUnsafe,
 }

package/libs/axios.ts

@@ -0,0 +1,43 @@
+import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
+import { PlataExtra, PlataResultado } from './tools';
+
+export async function PlataAxios<T = any>(config: AxiosRequestConfig): Promise<PlataResultado<AxiosResponse<T>>> {
+    config.timeout = config.timeout ?? 1000
+
+    if (config.timeout === 0) {
+        return PlataAxiosUnsafe(config)
+    }
+
+    const axiosPromise = PlataAxiosUnsafe(config)
+    const timeoutPromise = PlataExtra.timeout(config.timeout, {
+        errorID: 'PLAX0003',
+        msg: 'API externa não respondeu'
+    })
+
+    return Promise.race([axiosPromise, timeoutPromise])
+}
+
+export async function PlataAxiosUnsafe<T = any>(config: AxiosRequestConfig): Promise<PlataResultado<AxiosResponse<T>>> {
+    return axios(config).then(
+        resp => resp,
+        err => {
+            if (err.response) {
+                return err.response
+            }
+
+            if (err.request) {
+                return {
+                    errorID: 'PLAX0001',
+                    msg: 'Erro ao se comunicar com API externa',
+                    error: err
+                }
+            }
+
+            return {
+                errorID: 'PLAX0002',
+                msg: 'Erro inesperado ao se comunicar com API externa',
+                error: err
+            }
+        }
+    )
+}

package/libs/cluster.ts

@@ -2,13 +2,15 @@ import { PlataRequire, PlataDirs, PlataFiles } from './tools'
 import { cpus } from 'node:os'
 import * as typeCluster from 'node:cluster'
 
+export type PlataWorker = typeCluster.Worker
+
 export interface PlataClusterWorkerConfig {
     name: string,
     env: string,
     onStart: () => Promise<void>
     workers?: number,
     workersEnv?: any,
-    onExit?: (worker: typeCluster.Worker, code: number, signal: string) => void,
+    onExit?: (worker: PlataWorker, code: number, signal: string) => void,
 }
 
 export interface PlataCluster {
@@ -30,6 +32,7 @@ export interface _PlataClusterProcess extends NodeJS.Process {
     _plata?: PlataClusterProcess
 }
 
+
 export function getClusterNodeProcess(): PlataClusterProcess {
     const p = process as _PlataClusterProcess
 
@@ -51,7 +54,7 @@ export class PlataClusterManager {
     private readonly Process = getClusterNodeProcess()
 
     constructor() {
-        // Registra o evento que lida com 
+        // Registra o evento que lida com a morte de workers
         if (this.Cluster.isPrimary) {
             if (this.Cluster.eventNames().indexOf('exit') === -1) {
                 this.Cluster.on('exit', (worker, code, signal) => {
@@ -88,7 +91,7 @@ export class PlataClusterManager {
         }
     }
 
-    public async run(config: PlataClusterWorkerConfig) {
+    public async run(config: PlataClusterWorkerConfig): Promise<void> {
         if (config.workers === undefined) {
             if (config.env === 'prod') {
                 config.workers = cpus().length
@@ -125,7 +128,7 @@ export class PlataClusterManager {
         return this.Cluster.isPrimary
     }
 
-    public async loadClusters() {
+    public async loadClusters(): Promise<void[]> {
         const required = await PlataRequire.requireFolderAsync<PlataClusterWorkerConfig>(PlataDirs.getProjectDirClusters())
 
         if (required.errorID !== undefined) {
@@ -133,7 +136,7 @@ export class PlataClusterManager {
             process.exit(1)
         }
 
-        const promisesClusters: any[] = []
+        const promisesClusters: Promise<void>[] = []
 
         for (const r of required) {
             if (r.errorID !== undefined) {

package/libs/model.ts

@@ -5,27 +5,28 @@ export interface RetornoValidacaoPrimitivo {
     continua: boolean
 }
 
-export interface RetornoValicadaoModel {
-    value: any,
-    errors: PlataError[]
-}
-
 export type ModelValicacao = (value: any) => Promise<PlataError | null>
 
-export type ModelTratamento<T> = (value: T) => T
+export type ModelTratamento<T = any> = (value: T) => T
 
-export type ModelValicacaoPrimitivo = (nome: string, valor: any) => Promise<RetornoValidacaoPrimitivo>
+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 class Model {
-    public readonly template: 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<any>>
+    public readonly tratamentos: Map<string, ModelTratamento>
+    public readonly _type: ExtractType<T>
 
-    constructor(template: ModelType) {
+    constructor(template: T) {
         this.template = template
         this.validacoes = new Map()
         this.tratamentos = new Map()
@@ -56,15 +57,15 @@ export async function _validaCampo(value: any, pipelines: ModelValicacaoPrimitiv
     return null
 }
 
-export function _trataModel<T>(value: T, model: Model): T {
+export function _trataModel<T,Y extends ModelType>(value: T, model: Model<Y>) {
     model.tratamentos.forEach(tratamento => {
         value = tratamento(value)
     })
 
-    return value
+    return value as unknown as typeof model._type
 }
 
-export function _filtraModel(value: any, model: Model): any {
+export function _filtraModel<Y extends ModelType>(value: any, model: Model<Y>) {
     for (const campo in model.template) {
         const t = model.template[campo]
 
@@ -99,10 +100,10 @@ export function _filtraModel(value: any, model: Model): any {
         }
     }
 
-    return value
+    return value as unknown as typeof model._type
 }
 
-export async function _validaModel(value: any, model: Model, name?: string): Promise<PlataError[]> {
+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) {
@@ -182,17 +183,58 @@ export async function _validaModel(value: any, model: Model, name?: string): Pro
     return Erros as PlataError[]
 }
 
-export async function valida(value: any, model: Model): Promise<RetornoValicadaoModel> {
-    value = _filtraModel(value, model)
-
-    value = _trataModel(value, model)
+export async function valida<Y extends ModelType>(value: any, model: Model<Y>) {
+    const v: typeof model._type = _trataModel(_filtraModel(value, model), model)
 
     return {
-        value,
+        value: v,
         errors: await _validaModel(value, model),
     }
 }
 
+export function Min(min: number): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (valor < min) return {
+            error: {
+                errorID: "BPMVMIN001",
+                msg: `O valor de ${nome} tem que ser maior que ${min}` 
+            },
+            continua: false,
+        }
+
+        return { continua: true }
+    }
+}
+
+export function Max(max: number): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (valor > max) return {
+            error: {
+                errorID: "BPMVMIN001",
+                msg: `O valor de ${nome} tem que ser maior que ${max}` 
+            },
+            continua: false,
+        }
+
+        return { continua: true }
+    }
+}
+
+export function Enum(...valores: any[]): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        if (valores.find(v => `${valor}` === `${v}`)) return {
+            error: {
+                errorID: 'BPMVEN0001',
+                msg: `O campo ${nome} so pode ter os valores: ${valores.join(', ')}`,
+                error: `${valor}`
+            },
+            continua: false,
+        }
+
+        return { continua: true }
+    }
+}
+
 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)/
@@ -233,7 +275,7 @@ export function DateTime(): ModelValicacaoPrimitivo {
     }
 }
 
-export function Decimal(tamanhoInteiro: number, casasDecimais: number): ModelValicacaoPrimitivo {
+export function Decimal(tamanhoInteiro: number, casasDecimais: number, min?: number, max?: number): ModelValicacaoPrimitivo {
     return async (nome: string, valor: any) => {
         if (isNaN(+valor)) {
             return {
@@ -281,11 +323,19 @@ export function Decimal(tamanhoInteiro: number, casasDecimais: number): ModelVal
             }
         }
 
+        if (min !== undefined) {
+            return Min(min)(nome, valor)
+        }
+
+        if (max !== undefined) {
+            return Max(max)(nome, valor)
+        }
+
         return { continua: true }
     }
 }
 
-export function Int(): ModelValicacaoPrimitivo {
+export function Int(min?: number, max?: number): ModelValicacaoPrimitivo {
     return async (nome: string, valor: any) => {
         if (isNaN(+valor)) {
             return {
@@ -309,11 +359,19 @@ export function Int(): ModelValicacaoPrimitivo {
             }
         }
 
+        if (min !== undefined) {
+            return Min(min)(nome, valor)
+        }
+
+        if (max !== undefined) {
+            return Max(max)(nome, valor)
+        }
+
         return { continua: true }
     }
 }
 
-export function isArray(tamanhoMaximo?: number): ModelValicacaoPrimitivo {
+export function isArray(tamanhoMaximo?: number, tamanhoMinimo?: number): ModelValicacaoPrimitivo {
     return async (nome: string, valor: any) => {
         if (valor === null) {
             return {
@@ -335,8 +393,20 @@ export function isArray(tamanhoMaximo?: number): ModelValicacaoPrimitivo {
             }
         }
 
-        if (tamanhoMaximo !== undefined && tamanhoMaximo !== Infinity) {
-            if (valor.length > tamanhoMaximo) {
+        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",
@@ -525,18 +595,30 @@ export function TelefoneDDI(): ModelValicacaoPrimitivo {
     }
 }
 
-export function VarChar(size: number): ModelValicacaoPrimitivo {
+export function VarChar(size: number, min?: number): ModelValicacaoPrimitivo {
     return async (nome: string, valor: any) => {
         if (valor.length > size) {
             return {
                 error: {
                     errorID: "BPVVARC001",
-                    msg: `O campo ${nome} tem que menos de ${size} caracteres` 
+                    msg: `O campo ${nome} tem que ter menos de ${size} caracteres` 
                 },
                 continua: false
             }
         }
 
+        if (min !== undefined) {
+            if (valor.length < min) {
+                return {
+                    error: {
+                        errorID: "BPVVARC002",
+                        msg: `O campo ${nome} tem que ter no minimo ${size} caracteres` 
+                    },
+                    continua: false
+                }
+            }
+        }
+
         return { continua: true }
     }
 }

package/libs/tools.ts

@@ -140,7 +140,7 @@ export namespace PlataFiles {
 
     export async function findFile(folders: string[], file: string): Promise<string | null> {
         for (const folder of folders) {
-            const f = glob.sync(`${folder.replace(/\\/g, '/')}/**/${file}`)[0]
+            const f = glob.sync(`${folder.replace(/\\/g, '/')}/**/${file.toLowerCase()}*`)[0]
 
             if (f !== undefined) {
                 return f
@@ -246,7 +246,11 @@ export namespace PlataRequire {
 }
 
 export namespace PlataExtra {
-    export function Sleep(ms: number) {
+    export function sleep(ms: number) {
         return new Promise(resolve => setTimeout(resolve, ms))
     }
+
+    export function timeout(ms: number, error: PlataError): Promise<PlataError> {
+        return new Promise((_, reject) => setTimeout(() => reject(error), ms))
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pwi-plata-type",
-    "version": "0.3.8",
+    "version": "0.3.11",
     "main": "index.ts",
     "bin": {
         "plata": "bin/plata.ts",
@@ -21,6 +21,7 @@
         "@types/jest": "^28.1.1",
         "@types/node-schedule": "^2.1.0",
         "@types/swagger-ui-express": "^4.1.3",
+        "axios": "^0.27.2",
         "commander": "^9.4.0",
         "express": "^4.18.1",
         "glob": "^8.0.3",

package/templates/create-cli/cluster.ts

@@ -0,0 +1,17 @@
+//@ts-nocheck
+import { PlataCluster } from "ç__PlataName__ç"
+
+const onStart = async () => {
+
+}
+
+const onExit = (worker: PlataCluster.PlataWorker, code: number, signal: string) => {
+
+}
+
+export default {
+    name: "ç__Name__ç",
+    env: process.env.ENV ?? 'debug',
+    onStart: onStart,
+    onExit: onExit
+} as PlataCluster.PlataClusterWorkerConfig

package/templates/postinstall/api/tsconfig.json

@@ -30,7 +30,7 @@
         "@Models/*": [ "./models/*" ],
         "@Clusters/*": [ "./clusters/*" ],
         "@Plata/*": [ "./node_modules/pwi-plata-type/*" ],
-        "@PlataBin/*": [ "./node_modules/pwi-plata-type/bin/*" ],
+        "@PlataBin/*": [ "./node_modules/pwi-plata-type/bin/*" ]
       }
     },
     "include": [