pwi-plata-type 0.2.4 → 0.2.7

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

@@ -8,7 +8,7 @@ export async function h() {
 
         switch (command) {
             case 'lib':
-                const nameLib = args.shift()
+                const nameLib = `${args.shift()}`
                 promises.push(tools.files.deployFileToProject(
                     'configs',
                     'config',
@@ -24,7 +24,7 @@ export async function h() {
                 ).finally(() => console.log(`Lib ${nameLib.toLowerCase()} criada`)))
             break;
             case 'config':
-                const nameConfig = args.shift()
+                const nameConfig = `${args.shift()}`
                 promises.push(tools.files.deployFileToProject(
                     'configs',
                     'config',
@@ -45,14 +45,14 @@ export async function h() {
                     routeFilePath,
                     'route',
                     `${routeFileName}.ts`,
-                    {}
+                    { PlataName: `${PlataDirs.ProjectJson.plata_name}` }
                 ).finally(() => console.log(
                     `Rota ${routeFilePath}/${routeFileName === 'index' ? '' : routeFileName} criada`
                 )))
 
             break;
             case 'model':
-                const modelName = args.shift()
+                const modelName = `${args.shift()}`
                 const plataName = PlataDirs.ProjectJson.plata_name
 
                 promises.push(tools.files.deployFileToProject(

package/bin/plata.ts

@@ -21,8 +21,8 @@ const main = async () => {
 
         clusterLib.run({
             name: '_plata_express',
-            onStart: async () => null,
-            env: process.env.ENV
+            onStart: async () => {},
+            env: process.env.ENV ?? 'prod'
         })
 
         clusterLib.loadClusters()
@@ -34,13 +34,20 @@ const main = async () => {
         })
 
         if (process.env._plata_name === '_plata_express') {
-            process.on('exit', () => process.send({
-                id: 0,
-                name: '_plata',
-                data: {
-                    action: 'KILL'
+            process.on('exit', () => {
+                if (process.send === undefined) {
+                    console.log('Erro ao iniciar o cluster verifique a versão do node')
+                    return
                 }
-            }))
+
+                process.send({
+                    id: 0,
+                    name: '_plata',
+                    data: {
+                        action: 'KILL'
+                    }
+                })
+            })
 
             const port = process.env.PORT ?? 3050
             const app: Express = express()

package/index.ts

@@ -1,6 +1,7 @@
 import * as PlataCluster from './libs/cluster.js'
 import * as PlataEnv from './libs/env.js'
 import * as PlataRoutes from './libs/routes.js'
+import { PlataRoute } from './libs/routes.js'
 import * as PlataTools from './libs/tools.js'
 import * as PlataModels from './libs/model.js'
 
@@ -10,4 +11,5 @@ export {
     PlataRoutes,
     PlataTools,
     PlataModels,
+    PlataRoute,
 }

package/libs/model.ts

@@ -1,20 +1,16 @@
-export interface ErroValidacao {
-    errorID: string
-    error?: any
-    msg: string
-}
+import { PlataError } from "./tools.js"
 
 export interface RetornoValidacaoPrimitivo {
-    error?: ErroValidacao
+    error?: PlataError
     continua: boolean
 }
 
 export interface RetornoValicadaoModel {
     value: any,
-    errors: ErroValidacao[]
+    errors: PlataError[]
 }
 
-export type ModelValicacao = (value: any) => Promise<ErroValidacao | null>
+export type ModelValicacao = (value: any) => Promise<PlataError | null>
 
 export type ModelValicacaoPrimitivo = (nome: string, valor: any) => Promise<RetornoValidacaoPrimitivo>
 
@@ -36,7 +32,7 @@ export class Model {
     }
 }
 
-export async function _validaCampo(value: any, pipeline: ModelValicacaoPrimitivo[], name: string): Promise<ErroValidacao | null> {
+export async function _validaCampo(value: any, pipeline: ModelValicacaoPrimitivo[], name: string): Promise<PlataError | null> {
     for (let i = 0; i < pipeline.length; i++) {
         const result = await pipeline[i](name, value)
 
@@ -90,7 +86,7 @@ export function _filtraModel(value: any, model: Model): any {
     return value
 }
 
-export async function _validaModel(value: any, model: Model, name?: string): Promise<ErroValidacao[]> {
+export async function _validaModel(value: any, model: Model, name?: string): Promise<PlataError[]> {
     let promises: any[] = []
     
     for(const campo in model.template) {
@@ -139,11 +135,11 @@ export async function _validaModel(value: any, model: Model, name?: string): Pro
     )
 
     if ((Erros as any).errorID !== undefined) {
-        return Erros as ErroValidacao[]
+        return Erros as PlataError[]
     }
 
     if ((Erros as any[]).length !== 0) {
-        return Erros as ErroValidacao[]
+        return Erros as PlataError[]
     }
 
     promises = []
@@ -164,10 +160,10 @@ export async function _validaModel(value: any, model: Model, name?: string): Pro
     )
 
     if ((Erros as any).errorID !== undefined) {
-        return Erros as ErroValidacao[]
+        return Erros as PlataError[]
     }
 
-    return Erros as ErroValidacao[]
+    return Erros as PlataError[]
 }
 
 export async function valida(value: any, model: Model): Promise<RetornoValicadaoModel> {
@@ -450,6 +446,65 @@ export function Telefone(): ModelValicacaoPrimitivo {
     }
 }
 
+export function TelefoneDDI(): ModelValicacaoPrimitivo {
+    return async (nome: string, valor: any) => {
+        const [ ddi, t ] = `${valor}`.split(' ')
+        const telefone = `${t}`.split('-')
+
+        if (telefone.length !== 2) {
+            return {
+                error: { 
+                    errorID: "BPVTELD001",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato +000 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        if (telefone[0].length !== 2 || telefone[1].length > 9) {
+            return {
+                error: {
+                    errorID: "BPVTELD002",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato +000 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        if (!+telefone[0] || !+telefone[1]) {
+            return {
+                error: {
+                    errorID: "BPVTELD003",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato +000 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        if (ddi.length !== 4) {
+            return {
+                error: {
+                    errorID: "BPVTELD004",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato +000 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        if (ddi[0] !== '+' || !+ddi) {
+            return {
+                error: {
+                    errorID: "BPVTELD005",
+                    msg: `O campo ${nome} tem que ser um telefone em no formato +000 99-999999999` 
+                },
+                continua: false
+            }
+        }
+
+        return { continua: true }
+    }
+}
+
 export function VarChar(size: number): ModelValicacaoPrimitivo {
     return async (nome: string, valor: any) => {
         if (valor.length > size) {

package/libs/routes.ts

@@ -1,8 +1,19 @@
-import { PlataDirs, PlataRequire } from "./tools.js";
-import express, { Express, Router } from "express";
+import { PlataDirs, PlataRequire, PlataError } from "./tools.js";
+import express, { Router } from "express";
 
 export type PlataRouter = () => Router
 
+export type PlataRequest = express.Request & { user: any, extras: any }
+
+export type PlataOnResponse = (req: PlataRequest, response?: any, error?: PlataError, nodeError?: any) => Promise<any>
+export interface PlataResponse extends express.Response {
+    _onResponse: PlataOnResponse[]
+    _oldJson(body?: any): this
+    _onResponseEvent(req: PlataRequest, response?: any, error?: PlataError, nodeError?: any): void
+    error(error: PlataError, nodeError?: any): this
+    addOnResponse(callback: PlataOnResponse): void
+}
+
 export async function loadExpressRoutes(): Promise<Router> {
     const promise = PlataRequire.requireFolderAsync<PlataRouter>(PlataDirs.getProjectRoutesDir())
     
@@ -12,7 +23,11 @@ export async function loadExpressRoutes(): Promise<Router> {
     const routes = await promise.catch(err => { return { error: err } })
 
     if ((routes as any).error === undefined) {
-        const r = routes as PlataRequire.Required<PlataRouter>[]
+        let r = (routes as PlataRequire.Required<PlataRouter>[]).sort((x,y) => {
+            if (x.name === 'index') return -1
+
+            return +(x.name > y.name)
+        })
 
         for (let i = 0; i < r.length; i++) {
             const element = r[i];
@@ -31,4 +46,57 @@ export async function loadExpressRoutes(): Promise<Router> {
     }
 
     return router
+}
+
+export type PlataRequestHandler = (req: PlataRequest, res: PlataResponse, next: express.NextFunction) => Promise<any>
+
+export function PlataRoute(r: PlataRequestHandler): express.RequestHandler {
+    return async (req, res, next) => {
+        const aReq = req as any
+        
+        if (aReq.user === undefined) {
+            aReq.user = new Object(null)
+        }
+
+        if (aReq.extras === undefined) {
+            aReq.extras = new Object(null)
+        }
+
+        const aRes = res as any
+
+        if (aRes._onResponse === undefined) {
+            aRes._onResponse = []
+        }
+
+        if (aRes.addOnResponse === undefined) {
+            aRes.addOnResponse = aRes._onResponse.push
+        }
+
+        if (aRes._oldJson === undefined) {
+            aRes._oldJson = aRes.json
+
+            aRes._onResponseEvent = (...a) => {
+                aRes._onResponse.forEach(r => {
+                    try {
+                        r(...a)
+                    } catch (e) {}
+                })
+            }
+
+            aRes.json = (body) => {
+                (async () => { aRes._onResponseEvent(aReq, body, undefined, undefined) })
+
+                return aRes._oldJson(body)
+            }
+
+            aRes.error = (error, nodeError) => {
+                (async () => { aRes._onResponseEvent(aReq, undefined, error, nodeError) })
+
+                return aRes._oldJson(error)
+            }
+        }
+
+
+        return r(aReq, aRes, next)
+    }
 }

package/libs/tools.ts

@@ -5,6 +5,12 @@ import * as tGlob from 'glob'
 
 const glob = (tGlob as any).default as typeof tGlob
 
+export interface PlataError {
+    errorID: string,
+    msg: string,
+    error?: any
+}
+
 export module PlataDirs {
     export function getProjectDir(): string {
         return path.resolve('.')
@@ -92,7 +98,7 @@ export module PlataFiles {
     export function readFileSync(file: string, callback: readLineCallbackSync): Promise<string | { err: any }> {
         return new Promise(resolve => {
             try {
-                const content = []
+                const content: string[] = []
                 const stream = readline.createInterface({
                     input: fs.createReadStream(file),
                     crlfDelay: Infinity

package/package.json

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

package/templates/create-cli/lib.ts

@@ -2,8 +2,10 @@
 import * as ç__Name__çConfig from '../configs/ç__name__ç.js'
 
 export class ç__Name__ç {
-    constructor(config: typeof ç__Name__çConfig.default) {
+    private readonly config: typeof ç__Name__çConfig
 
+    constructor(config: typeof ç__Name__çConfig.default) {
+        this.config = config
     }
 }
 

package/templates/create-cli/route.ts

@@ -1,11 +1,13 @@
+//@ts-nocheck
 import { Router } from 'express'
+import { PlataRoute } from 'ç__PlataName__ç'
 
 export default (): Router => {
     const router = Router()
 
-    router.get('/', (req, res) => {
+    router.get('/', PlataRoute(async (req, res) => {
         return res.status(200).json({})
-    })
+    }))
 
     return router
 }