pwi-plata-type 0.2.19 → 0.3.0

package/index.ts

@@ -1,7 +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 { PlataRouter } from './libs/routes.js'
 import * as PlataTools from './libs/tools.js'
 import * as PlataModels from './libs/model.js'
 import { PlataSwagger } from './libs/swagger.js'
@@ -12,6 +12,6 @@ export {
     PlataRoutes,
     PlataTools,
     PlataModels,
-    PlataRoute,
+    PlataRouter as PlataRouter,
     PlataSwagger
 }

package/libs/model.ts

@@ -28,6 +28,7 @@ export class Model {
     constructor(template: ModelType) {
         this.template = template
         this.validacoes = new Map()
+        this.tratamentos = new Map()
     }
 
     public addValidacao(nome: string, callback: ModelValicacao) {

package/libs/routes.ts

@@ -1,11 +1,92 @@
+import path from 'node:path'
 import { PlataDirs, PlataRequire, PlataError } from "./tools.js";
 import express, { Router } from "express";
 
-export type _Router = Router & { swaggerHide?: boolean }
+export const HttpMethodsArray = [
+    "all"
+    ,"get"
+    ,"post"
+    ,"put"
+    ,"delete"
+    ,"patch"
+    ,"options"
+    ,"head"
+    ,"checkout"
+    ,"connect"
+    ,"copy"
+    ,"lock"
+    ,"merge"
+    ,"mkactivity"
+    ,"mkcol"
+    ,"move"
+    ,"notify"
+    ,"propfind"
+    ,"proppatch"
+    ,"purge"
+    ,"report"
+    ,"search"
+    ,"subscribe"
+    ,"trace"
+    ,"unlock"
+    ,"unsubscribe"
+    ,"use"
+] 
+
+export type HttpMethods =
+    "all"
+    | "get"
+    | "post"
+    | "put"
+    | "delete"
+    | "patch"
+    | "options"
+    | "head"
+    | "checkout"
+    | "connect"
+    | "copy"
+    | "lock"
+    | "merge"
+    | "mkactivity"
+    | "mkcol"
+    | "move"
+    | "notify"
+    | "propfind"
+    | "proppatch"
+    | "purge"
+    | "report"
+    | "search"
+    | "subscribe"
+    | "trace"
+    | "unlock"
+    | "unsubscribe"
+    | "use"
+;
+
+export type PlataRouterMethods = (
+    (path: string | PlataRequestHandler, ...handlers: PlataRequestHandler[]) => void | Promise<void>
+)
+
+export interface _PlataRoute {    
+    path?: string,
+    method: HttpMethods
+    handlers: PlataRequestHandler[]
+}
+export interface PlataRouterExtras {
+    swaggerHide?: boolean
+    _routes?: _PlataRoute[]
+}
+
+export type PlataRouter = PlataRouterExtras & {    
+    [method in HttpMethods]: PlataRouterMethods
+}
 
-export type PlataRouter = () => _Router | Promise<_Router>
+export type _Router = Router & PlataRouterExtras
 
-export type PlataRequest = express.Request & { user: any, extras: any }
+export type PlataRouterBuilder = (r: PlataRouter) => PlataRouter | Promise<PlataRouter>
+
+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 {
@@ -16,62 +97,36 @@ export interface PlataResponse extends express.Response {
     addOnResponse(callback: PlataOnResponse): void
 }
 
-export interface PlataRequiredRoute extends PlataRequire.RequiredInterface<PlataRouter> {
+export interface PlataRequiredRoute extends PlataRequire.RequiredInterface<PlataRouterBuilder> {
     httpRoute: string
 }
 
-export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
-    const routes = await PlataRequire.requireFolderAsync<PlataRouter>(PlataDirs.getProjectRoutesDir())
-
-    if (routes.errorID === undefined) {
-        if (routes.findIndex(r => r.errorID !== undefined) !== -1) {
-            routes.forEach(r => {
-                if (r.errorID !== undefined) {
-                    console.log(r)
-                }
-            })
-
-            throw routes
+export function createPlataRouter(): any {
+    const router: any = new Object(null)
+    router._routes = []
+
+    for (let i = 0; i < HttpMethodsArray.length; i++) {
+        const method = HttpMethodsArray[i];
+
+        router[method] = (arg, ...args) => {
+            if (typeof arg === 'string') {
+                router._routes.push(
+                    {
+                        path: arg,
+                        method: method,
+                        handlers: args
+
+                    } as _PlataRoute
+                )
+            } else {
+                router._routes.push(
+                    {
+                        method: method,
+                        handlers: [].concat(arg, ...args)
+                    } as _PlataRoute
+                )
+            }
         }
-
-        let r = (routes as PlataRequiredRoute[])
-
-        // Cria as rotas http no array
-        r = r.map(route => {
-            route.httpRoute = route.filePath
-                .replace(PlataDirs.getProjectRoutesDir(), '')
-                .replace(/.(ts|js)$/, '')
-                .replace(/index/, '')
-                .replace(/\\/g, '/')
-                .replace(/\{(.*?)\}/g, ':$1')
-                .replace(/\[(.*?)\]/g, ':$1?')
-            ;
-
-            return route
-        })
-
-        // coloca o index na frente de todas as rotas
-        r = r.sort((x,y) => {
-            if (x.name === 'index') return -1
-
-            return +(x.name > y.name)
-        })
-
-        return r
-    } else {
-        console.log(routes)
-        throw routes
-    }
-}
-
-export async function buildExpressRouter(): Promise<Router> {
-    const router = Router()
-    router.use(express.json())
-
-    const routes = await loadExpressRoutes()
-
-    for (const r of routes) {
-        router.use(r.httpRoute, await r.exports())
     }
 
     return router
@@ -128,4 +183,82 @@ export function PlataRoute(r: PlataRequestHandler): express.RequestHandler {
 
         return r(aReq, aRes, next)
     }
+}
+
+export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
+    const routes = await PlataRequire.requireFolderAsync<PlataRouterBuilder>(PlataDirs.getProjectRoutesDir())
+
+    if (routes.errorID === undefined) {
+        if (routes.findIndex(r => r.errorID !== undefined) !== -1) {
+            routes.forEach(r => {
+                if (r.errorID !== undefined) {
+                    console.log(r)
+                }
+            })
+
+            throw routes
+        }
+
+        let r = (routes as PlataRequiredRoute[])
+
+        // Cria as rotas http no array
+        r = r.map(route => {
+            route.httpRoute = route.filePath
+                .replace(PlataDirs.getProjectRoutesDir(), '')
+                .replace(/.(ts|js)$/, '')
+                .replace(/index/, '')
+                .replace(/\\/g, '/')
+                .replace(/\{(.*?)\}/g, ':$1')
+                .replace(/\[(.*?)\]/g, ':$1?')
+            ;
+
+            return route
+        })
+
+        // coloca o index na frente de todas as rotas
+        r = r.sort((x,y) => {
+            if (x.name === 'index') {
+                if (y.name === 'index') {
+                    return +(x.httpRoute.length > y.httpRoute.length)
+                }
+
+                return -1
+            } 
+
+            return +(x.name > y.name)
+        })
+
+        return r
+    } else {
+        console.log(routes)
+        throw routes
+    }
+}
+
+export async function buildExpressRouter(): Promise<Router> {
+    const router = Router()
+    router.use(express.json())
+
+    const routes = await loadExpressRoutes()
+
+    for (const r of routes) {
+        const pr = await r.exports(createPlataRouter())
+
+        pr._routes = pr._routes ?? []
+
+        for (let i = 0; i < pr._routes.length; i++) {
+            const prr = pr._routes[i];
+
+            if (prr.path === undefined) {
+                (router as any)[prr.method](...prr.handlers.map(PlataRoute))
+            } else {
+                (router as any)[prr.method](
+                    path.normalize(`${r.httpRoute}/${prr.path}`),
+                    ...prr.handlers.map(PlataRoute)
+                )
+            }
+        }
+    }
+
+    return router
 }

package/libs/swagger.ts

@@ -1,19 +1,21 @@
 import swaggerUi from 'swagger-ui-express'
 import { Router } from 'express'
 import path from 'node:path'
-import { _Router } from './routes.js';
+import { PlataRouterBuilder, PlataRequestHandler } from './routes.js';
 import { PlataFiles, PlataDirs } from "./tools.js";
 
 export namespace PlataSwagger {
-    export async function swagger(): Promise<_Router> {
-        const router = Router() as _Router
+    export const swagger: PlataRouterBuilder = async (router) => {
         router.swaggerHide = true
 
         if (process.env._plata_name === '_plata_express') {
-            router.use(swaggerUi.serve, swaggerUi.setup(
-                await _loadSwaggerConfig(),
-                {}
-            ))
+            router.use(
+                swaggerUi.serve as unknown as PlataRequestHandler,
+                swaggerUi.setup(
+                    await _loadSwaggerConfig(),
+                    {}
+                ) as unknown as PlataRequestHandler
+            )
         }
 
         return router

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pwi-plata-type",
-    "version": "0.2.19",
+    "version": "0.3.0",
     "type": "module",
     "main": "index.ts",
     "bin": {
@@ -23,7 +23,8 @@
         "jest": "^28.1.1",
         "swagger-ui-express": "^4.4.0",
         "ts-jest": "^28.0.4",
-        "ts-node": "10.8.2"
+        "ts-node": "10.8.2",
+        "express": "^4.18.1"
     },
     "description": "",
     "devDependencies": {

package/postinstall-tools.mjs

@@ -104,5 +104,12 @@ export function tools(dirs) {
         await tools.copyFile(templateFile, destination)
     }
 
+    tools.copyFileToProject = async (file) => {
+        const templateFile = path.join(dirs.templateDir, file)
+        const destination = path.join(dirs.projectDir, file)
+
+        await tools.copyFileIfNotExists(templateFile, destination)
+    }
+
     return tools
 }

package/templates/create-cli/route.ts

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

package/templates/postinstall/api/_install.mjs

@@ -15,7 +15,7 @@ export async function install({ dirs, projectPackageJson }) {
     promises.push(t.copyFolderToProject('envs'))
     promises.push(t.syncFolderProject('.vscode'))
 
-    promises.push(t.syncFileToProject('Dockerfile'))
+    promises.push(t.copyFileToProject('Dockerfile'))
     promises.push(t.syncFileToProject('tsconfig.json'))
 
     projectPackageJson.type = "module"