pwi-plata-type 0.2.10 → 0.2.13

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

@@ -1,6 +1,6 @@
 import { tools } from "./plata-create-tools.js";
 import { PlataDirs } from "../../libs/tools.js"
-import * as path from 'node:path'
+import path from 'node:path'
 
 export async function h() {
     return tools.args.forEachArg(async (command, args) => {
@@ -12,25 +12,25 @@ export async function h() {
                 promises.push(tools.files.deployFileToProject(
                     'configs',
                     'config',
-                    `${nameLib.toLowerCase()}.ts`,
-                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
-                ).finally(() => console.log(`Config ${nameLib.toLowerCase()} criada`)))
+                    `${nameLib}.ts`.toLowerCase(),
+                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
+                ).finally(() => console.log(`Config ${nameLib} criada`)))
 
                 promises.push(tools.files.deployFileToProject(
                     'libs',
                     'lib',
-                    `${nameLib.toLowerCase()}.ts`,
-                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
-                ).finally(() => console.log(`Lib ${nameLib.toLowerCase()} criada`)))
+                    `${nameLib}.ts`.toLowerCase(),
+                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
+                ).finally(() => console.log(`Lib ${nameLib} criada`)))
             break;
             case 'config':
                 const nameConfig = `${args.shift()}`
                 promises.push(tools.files.deployFileToProject(
                     'configs',
                     'config',
-                    `${nameConfig.toLowerCase()}.ts`,
-                    { Name: `${nameConfig}`, name: `${nameConfig.toLowerCase()}` }
-                ).finally(() => console.log(`Config ${nameConfig.toLowerCase()} criada`)))
+                    `${nameConfig}.ts`.toLowerCase(),
+                    { Name: `${nameConfig}`, name: `${nameConfig}`.toLowerCase() }
+                ).finally(() => console.log(`Config ${nameConfig} criada`)))
             break;
             case 'cluster':
                 console.log('CLUSTER AINDA NÃO CRIANDO AINDA')
@@ -58,7 +58,7 @@ export async function h() {
                 promises.push(tools.files.deployFileToProject(
                     'models',
                     'model',
-                    `${modelName.toLowerCase()}.ts`,
+                    `${modelName}.ts`.toLowerCase(),
                     { Name: `${modelName}`, PlataName: `${plataName}` }
                 ).finally(() => console.log(`Model ${modelName} criada`)))
             break;

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

@@ -10,25 +10,25 @@ export async function h() {
                 promises.push(tools.files.deployFileToProject(
                     'configs',
                     'config',
-                    `${nameLib.toLowerCase()}.ts`,
-                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
-                ).finally(() => console.log(`Config ${nameLib.toLowerCase()} criada`)))
+                    `${nameLib}.ts`.toLowerCase(),
+                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
+                ).finally(() => console.log(`Config ${nameLib} criada`)))
 
                 promises.push(tools.files.deployFileToProject(
                     'libs',
                     'lib',
-                    `${nameLib.toLowerCase()}.ts`,
-                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
-                ).finally(() => console.log(`Lib ${nameLib.toLowerCase()} criada`)))
+                    `${nameLib}.ts`.toLowerCase(),
+                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
+                ).finally(() => console.log(`Lib ${nameLib} criada`)))
             break;
             case 'config':
                 const nameConfig = args.shift()
                 promises.push(tools.files.deployFileToProject(
                     'configs',
                     'config',
-                    `${nameConfig.toLowerCase()}.ts`,
-                    { Name: `${nameConfig}`, name: `${nameConfig.toLowerCase()}` }
-                ).finally(() => console.log(`Config ${nameConfig.toLowerCase()} criada`)))
+                    `${nameConfig}.ts`.toLowerCase(),
+                    { Name: `${nameConfig}`, name: `${nameConfig}`.toLowerCase() }
+                ).finally(() => console.log(`Config ${nameConfig} criada`)))
             break;
             case 'cluster':
                 console.log('CLUSTER AINDA NÃO CRIANDO AINDA')

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

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
+import fs from 'node:fs'
+import path from 'node:path'
 
 import { PlataDirs, PlataFiles } from '../../libs/tools.js'
 

package/bin/plata-swagger-gen.ts

@@ -0,0 +1,190 @@
+import path from 'node:path'
+import fs from 'node:fs'
+import { loadExpressRoutes } from '../libs/routes.js'
+import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../libs/tools.js'
+
+interface dumpParameter { 
+    name: string,
+    required: boolean,
+    in: 'path',
+    type: 'string'
+}
+
+interface dumpRoute {
+    httpRoute: string,
+    metodo: string,
+    params: dumpParameter[]
+}
+
+interface swaggerFiles {
+    swaggerHeader: any,
+    rota: {
+        header: any,
+        body: any,
+        response: any,
+    }
+}
+
+async function toProjectSwagger(file: string, content: any): Promise<PlataError | null> {
+    try {
+        const p = path.resolve(file)
+
+        const r = await PlataFiles.createFileIfNotExists(p, JSON.stringify(content, null, 4))
+
+        return r.errorID !== undefined ? r : null
+
+    } catch (e) {
+        return {
+            errorID: '',
+            msg: `Erro ao salvar o arquivo ${file}`,
+            error: e
+        }
+    }
+}
+
+function fromTemplateJson(file: string): PlataResultado<any> {
+    try {
+        const p = path.resolve(file)
+
+        const j = JSON.parse(fs.readFileSync(p).toString())
+
+        return j
+    } catch (e) {
+        return {
+            errorID: 'PBSW0001',
+            msg: `Erro ao ler o templete da plata ${file}`,
+            error: e
+        }
+    }
+}
+
+function loadSwaggerFiles(): swaggerFiles {
+    const f = {
+        rota: {}
+    }
+    const files = f as swaggerFiles
+
+    const header = fromTemplateJson(
+        PlataDirs.getPlataTempleteDir('swagger-cli', 'header.json')
+    )
+
+    if (header.errorID !== undefined) {
+        throw header
+    }
+
+    files.swaggerHeader = header
+
+    const rotaHeader = fromTemplateJson(
+        PlataDirs.getPlataTempleteDir('swagger-cli', 'rota', 'header.json')
+    )
+
+    if (rotaHeader.errorID !== undefined) {
+        throw rotaHeader
+    }
+
+    files.rota.header = rotaHeader
+
+    const rotaBody = fromTemplateJson(
+        PlataDirs.getPlataTempleteDir('swagger-cli', 'rota', 'body.json')
+    )
+
+    if (rotaBody.errorID !== undefined) {
+        throw rotaBody
+    }
+
+    files.rota.body = rotaBody
+
+    const rotaReturn = fromTemplateJson(
+        PlataDirs.getPlataTempleteDir('swagger-cli', 'rota', 'response.json')
+    )
+
+    if (rotaReturn.errorID !== undefined) {
+        throw rotaReturn
+    }
+
+    files.rota.response = rotaReturn
+
+    return files
+}
+
+async function dumpRotas(): Promise<dumpRoute[]> {
+    const rotas = await loadExpressRoutes()
+    const rotasMetodos: dumpRoute[] = []
+    const regex = /[:|?](.*?)\//g
+    for (let i = 0; i < rotas.length; i++) {
+        const r = rotas[i]
+        const expressRouter = await r.exports()
+
+        if (expressRouter.swaggerHide) {
+            continue
+        }
+
+        for (let j = 0; j < expressRouter.stack.length; j++) {
+            const layer = expressRouter.stack[j];
+            const httpLayerRoute = path.normalize(`${r.httpRoute}/${layer.route.path}/`)
+
+            for (const metodo in layer.route.methods) {
+                const urlParms = httpLayerRoute.match(regex) ?? []
+                const routeParams: dumpParameter[] = []
+
+                for (let k = 0; k < urlParms.length; k++) {
+                    const p = urlParms[k];
+
+                    routeParams.push({
+                        name: p.slice(1, -1),
+                        required: p[0] === ':',
+                        in: 'path',
+                        type: 'string'
+                    })
+                }
+
+                rotasMetodos.push({
+                    httpRoute: httpLayerRoute.replace(regex, '{$1}/'),
+                    params: routeParams,
+                    metodo,
+                })               
+            }
+        }
+    }
+
+    return rotasMetodos
+}
+
+const main = async () => {
+    const rotas = await dumpRotas()
+    const files = loadSwaggerFiles()
+
+    {
+        const pathSwaggerRotas = PlataDirs.getProjectDirSwaggerRotas()
+
+        for (let i = 0; i < rotas.length; i++) {
+            const r = rotas[i];
+            // https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy
+            const f = JSON.parse(JSON.stringify(files))
+
+            f.rota.header.parameters.push(...r.params)
+
+            for (const json in f.rota) {
+                const result = await toProjectSwagger(
+                    path.join(pathSwaggerRotas, r.httpRoute, r.metodo.toLocaleLowerCase(), `${json}.json`),
+                    f.rota[json]
+                )
+
+                if (result !== null) throw result
+            }
+        }
+    }
+
+    {
+        const result = await toProjectSwagger(
+            path.join( PlataDirs.getProjectDirSwagger(), 'header.json'),
+            files.swaggerHeader
+        )
+
+        if (result !== null) throw result
+    }
+
+    console.log('swagger do projeto atualizado com novas rotas')
+}
+
+main()

package/bin/plata.ts

@@ -1,6 +1,6 @@
 import { PlataClusterManager, PlataClusterMsg } from "../libs/cluster.js"
 import { loadEnvProjectFile } from "../libs/env.js"
-import { loadExpressRoutes } from "../libs/routes.js"
+import { buildExpressRouter } from "../libs/routes.js"
 import express, { Express } from "express"
 import { createServer } from 'node:https'
 import fs from 'node:fs'
@@ -56,7 +56,7 @@ const main = async () => {
             const port = process.env.PORT ?? 3050
             const app: Express = express()
 
-            app.use(process.env._PLATA_API_ROOT ?? '/api',await loadExpressRoutes())
+            app.use(process.env._PLATA_API_ROOT ?? '/api',await buildExpressRouter())
 
             app.use((err, req, res, next) => {                
                 return res.status(500).json({
@@ -89,14 +89,15 @@ const main = async () => {
                 console.log(`cert: ${process.env._PLATA_API_SSL_CERT}`)
 
                 const https = createServer({
-                    cert: fs.readdirSync(path.normalize(path.join(
+                    cert: fs.readFileSync(path.normalize(path.join(
                         PlataDirs.getProjectDir(),
                         process.env._PLATA_API_SSL_CERT
                     ))),
-                    key: fs.readdirSync(path.normalize(path.join(
+                    key: fs.readFileSync(path.normalize(path.join(
                         PlataDirs.getProjectDir(),
                         process.env._PLATA_API_SSL_KEY
-                    )))
+                    ))),
+                    // TODO :::: passphrase: 
                 }, app)
 
                 https.listen(port, () => {

package/index.ts

@@ -4,6 +4,7 @@ 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'
+import { PlataSwagger } from './libs/swagger.js'
 
 export {
     PlataCluster,
@@ -12,4 +13,5 @@ export {
     PlataTools,
     PlataModels,
     PlataRoute,
+    PlataSwagger
 }

package/libs/cluster.ts

@@ -126,25 +126,24 @@ export class PlataClusterManager {
     }
 
     public async loadClusters() {
-        const required: any = await PlataRequire.requireFolderAsync<any>(PlataDirs.getProjectDirClusters()).then(
-            result => result,
-            err => {
-                return { err }
-            }
-        )
+        const required = await PlataRequire.requireFolderAsync<PlataClusterWorkerConfig>(PlataDirs.getProjectDirClusters())
 
-        if (required.err !== undefined) {
-            console.log(required.err)
+        if (required.errorID !== undefined) {
+            console.log(required)
             process.exit(1)
         }
 
-        const TypedRequired: PlataRequire.Required<PlataClusterWorkerConfig>[] = required
         const promisesClusters: any[] = []
 
-        for (let i = 0; i < TypedRequired.length; i++) {
-            const required = TypedRequired[i];
-            
-            promisesClusters.push(this.run(required.exports))
+        for (let i = 0; i < required.length; i++) {
+            const r = required[i];
+
+            if (r.errorID !== undefined) {
+                console.log(required)
+                process.exit(1)
+            }
+
+            promisesClusters.push(this.run(r.exports))
         }
         
 

package/libs/routes.ts

@@ -1,7 +1,9 @@
 import { PlataDirs, PlataRequire, PlataError } from "./tools.js";
 import express, { Router } from "express";
 
-export type PlataRouter = () => Router
+export type _Router = Router & { swaggerHide?: boolean }
+
+export type PlataRouter = () => _Router | Promise<_Router>
 
 export type PlataRequest = express.Request & { user: any, extras: any }
 
@@ -14,35 +16,61 @@ export interface PlataResponse extends express.Response {
     addOnResponse(callback: PlataOnResponse): void
 }
 
-export async function loadExpressRoutes(): Promise<Router> {
-    const promise = PlataRequire.requireFolderAsync<PlataRouter>(PlataDirs.getProjectRoutesDir())
-    
-    const router = Router()
-    router.use(express.json())
+export interface PlataRequiredRoute extends PlataRequire.RequiredInterface<PlataRouter> {
+    httpRoute: string
+}
 
-    const routes = await promise.catch(err => { return { error: err } })
+export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
+    const routes = await PlataRequire.requireFolderAsync<PlataRouter>(PlataDirs.getProjectRoutesDir())
 
-    if ((routes as any).error === undefined) {
-        let r = (routes as PlataRequire.Required<PlataRouter>[]).sort((x,y) => {
-            if (x.name === 'index') return -1
+    if (routes.errorID === undefined) {
+        if (routes.findIndex(r => r.errorID !== undefined) !== -1) {
+            routes.forEach(r => {
+                if (r.errorID !== undefined) {
+                    console.log(r)
+                }
+            })
 
-            return +(x.name > y.name)
-        })
+            throw {}
+        }
 
-        for (let i = 0; i < r.length; i++) {
-            const element = r[i];
+        let r = (routes as PlataRequiredRoute[])
 
-            const httpRoute = element.filePath
+        // Cria as rotas http no array
+        r = r.map(route => {
+            route.httpRoute = route.filePath
                 .replace(PlataDirs.getProjectRoutesDir(), '')
                 .replace(/.(ts|js)$/, '')
                 .replace(/index/, '')
                 .replace(/\\/g, '/')
-            ;
 
-            router.use(httpRoute, element.exports())
-        }
+            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 {}
+    }
+}
+
+export async function buildExpressRouter(): Promise<Router> {
+    const router = Router()
+    router.use(express.json())
+
+    const routes = await loadExpressRoutes()
+
+    for (let i = 0; i < routes.length; i++) {
+        const r = routes[i];
+
+        router.use(r.httpRoute, await r.exports())
     }
 
     return router

package/libs/swagger.ts

@@ -0,0 +1,78 @@
+import swaggerUi from 'swagger-ui-express'
+import { Router } from 'express'
+import path from 'node:path'
+import { _Router } from './routes.js';
+import { PlataFiles, PlataDirs } from "./tools.js";
+
+export module PlataSwagger {
+    export async function swagger(): Promise<_Router> {
+        const router = Router() as _Router
+        router.swaggerHide = true
+
+        if (process.env._plata_name === '_plata_express') {
+            router.use(swaggerUi.serve, swaggerUi.setup(
+                await _loadSwaggerConfig(),
+                {}
+            ))
+        }
+
+        return router
+    }
+
+    export async function _loadSwaggerConfig(): Promise<any> {
+        const obj = PlataFiles.readJsonSync(path.join(PlataDirs.getProjectDirSwagger(), 'header.json'))
+
+        obj.paths = new Object(null)
+
+        {
+            const routes = await PlataFiles.findFiles([PlataDirs.getProjectDirSwaggerRotas()], 'header.json')
+
+            for (let i = 0; i < routes.length; i++) {
+                const route = routes[i];
+
+                const docPath = path.normalize(path.dirname(route))
+                const metodo = path.normalize(path.basename(docPath))
+                const httpPath = path.normalize(
+                    path.dirname(docPath.replace(PlataDirs.getProjectDirSwaggerRotas(), ''))
+                )
+
+                const header = PlataFiles.readJsonSync(path.join(docPath, 'header.json'))
+                const body = PlataFiles.readJsonSync(path.join(docPath, 'body.json'))
+                const response = PlataFiles.readJsonSync(path.join(docPath, 'response.json'))
+
+                if (obj.paths[httpPath] === undefined) {
+                    obj.paths[httpPath] = new Object(null)
+                }
+
+                obj.paths[httpPath][metodo] = { ...header, responses: response }
+
+                if (body !== {}) {
+                    if (!Array.isArray(obj.paths[httpPath][metodo].parameters)) {
+                        obj.paths[httpPath][metodo].parameters = []
+                    }
+
+                    const swaggerRouteBody = {
+                        name: "body",
+                        description: body.description,
+                        in: "body",
+                        schema: {
+                            type: body.type ?? "object",
+                        }
+                    } as any
+
+                    if (swaggerRouteBody.schema.type === 'array') {
+                        swaggerRouteBody.schema.items = {
+                            example: body.example
+                        }
+                    } else {
+                        swaggerRouteBody.schema.properties = body.example
+                    }
+
+                    obj.paths[httpPath][metodo].parameters.push(swaggerRouteBody)
+                }
+            }
+        }
+
+        return obj
+    }
+}

package/libs/tools.ts

@@ -1,6 +1,6 @@
-import * as path from 'node:path'
-import * as fs from 'node:fs'
-import * as readline from 'node:readline'
+import path from 'node:path'
+import fs from 'node:fs'
+import readline from 'node:readline'
 import * as tGlob from 'glob'
 
 const glob = (tGlob as any).default as typeof tGlob
@@ -18,6 +18,14 @@ export module PlataDirs {
         return path.resolve('.')
     }
 
+    export function getProjectDirSwagger(): string {
+        return path.resolve('.', 'swagger')
+    }
+
+    export function getProjectDirSwaggerRotas(): string {
+        return path.resolve('.', 'swagger', 'rotas')
+    }
+
     export function getProjectDirClusters(): string {
         return path.resolve('.', 'clusters')
     }
@@ -56,8 +64,8 @@ export module PlataDirs {
         return path.join(getPlataDir(), 'templates')
     }
 
-    export function getPlataTempleteDir(group:string, template: string) {
-        return path.join(getPlataTempletesDir(), group, template)
+    export function getPlataTempleteDir(group:string, ...template: string[]) {
+        return path.join(getPlataTempletesDir(), group, ...template)
     }
 
     export function getPlataBinExtraFile(file: string): string {
@@ -133,10 +141,55 @@ export module PlataFiles {
 
         return null
     }
+
+    export async function findFiles(folders: string[], file: string): Promise<string[]> {
+        const files: string[] = []
+
+        for (let i = 0; i < folders.length; i++) {
+            const folder = folders[i]
+            
+            files.push(...glob.sync(`${folder.replace(/\\/g, '/')}/**/${file}`))
+        }
+
+        return files
+    } 
+
+    export async function createFileIfNotExists(filePath: string, content: string): Promise<PlataResultado<string>> {
+        const p = path.resolve(filePath)
+
+        if (!fs.existsSync(p)) {
+            return createFile(filePath, content)
+        }
+
+        return p
+    }
+
+    export async function createFile(filePath: string, content: string): Promise<PlataResultado<string>> {
+        try {
+            const p = path.resolve(filePath)
+
+            fs.mkdirSync(path.dirname(p), { recursive: true })
+            fs.writeFileSync(p, content)
+
+            return p
+        } catch (e) {
+            return {
+                errorID: 'PLTPF0001',
+                msg: `Erro ao criar ao criar o arquivo ${filePath}`,
+                error: e
+            }
+        }
+        
+    }
+
+    export function readJsonSync(filePath: string): any {
+        return JSON.parse(fs.readFileSync(filePath).toString())
+    }
 }
 
 export module PlataRequire {
-    export interface Required<Type> {
+    export type Required<Type> = PlataResultado<RequiredInterface<Type>>
+    export interface RequiredInterface<Type> {
         filePath: string,
         name: string,
         exports: Type
@@ -145,24 +198,44 @@ export module PlataRequire {
     export async function requireAsync<Type>(file: string): Promise<Required<Type>> {
         const p = path.resolve(file)
 
+        const e = await import(`file:///${p}`.replace(/\\/g, '/')).catch(e => { return {_plataError: e }  })
+
+        if (e._plataError !== undefined) {
+            return {
+                errorID: 'PLTRF0001',
+                msg: `Erro ao importar o arquivo ${file}`,
+                error: e._plataError
+            }
+        }
+
         return {
             filePath: p,
             name: path.basename(p).replace('.ts', '').replace('.js', ''),
-            exports: (await import(`file:///${p}`.replace(/\\/g, '/')) as any).default as Type
+            exports: (e as any).default as Type
         }
     }
 
-    export async function requireFolderAsync<Type>(folder: string): Promise<Required<Type>[]> {
+    export async function requireFolderAsync<Type>(folder: string): Promise<PlataResultado<Required<Type>[]>> {
         const promises: Promise<Required<Type>>[] = []
         const p = path.resolve(folder)
 
-        glob.sync(`${p.replace(/\\/g, '/')}/**/*.ts`).forEach(value => {
-            value = value.replace('.ts', '.js')
-
-            promises.push(requireAsync<Type>(value))
-        })
-
-        return Promise.all(promises)
+        glob.sync(`${p.replace(/\\/g, '/')}/**/*.+(js|ts)`)
+            .filter(file => !file.endsWith('.d.ts'))
+            .forEach(file => {
+                file = file.replace('.ts', '.js')
+
+                promises.push(requireAsync<Type>(file))
+            })
+
+        return Promise.all(promises).catch(
+            e => {
+                return {
+                    errorID: 'PLTRF0002',
+                    msg: `Erro ao importar a pasta ${folder}`,
+                    error: e
+                }
+            }
+        )
     }
 }
 

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "pwi-plata-type",
-    "version": "0.2.10",
+    "version": "0.2.13",
     "type": "module",
     "main": "index.ts",
     "bin": {
         "plata": "bin/plata.ts",
-        "plata-cli-create": "bin/plata-create.ts"
+        "plata-cli-create": "bin/plata-create.ts",
+        "plata-swagger-gen": "bin/plata-swagger-gen.ts"
     },
     "scripts": {
         "postinstall": "node postinstall.js"
@@ -17,8 +18,10 @@
         "@types/express": "^4.17.13",
         "@types/glob": "^7.2.0",
         "@types/jest": "^28.1.1",
+        "@types/swagger-ui-express": "^4.1.3",
         "glob": "^8.0.3",
         "jest": "^28.1.1",
+        "swagger-ui-express": "^4.4.0",
         "ts-jest": "^28.0.4",
         "ts-node": "^10.8.1"
     },

package/postinstall-tools.mjs

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
+import fs from 'node:fs'
+import path from 'node:path'
 
 export function tools(dirs) {
     const tools = new Object(null)

package/postinstall.js

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
+import fs from 'node:fs'
+import path from 'node:path'
 
 const main = async () => {
     const plataDir = path.resolve('.')

package/templates/create-cli/lib.ts

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

package/templates/create-cli/route.ts

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

package/templates/postinstall/api/_install.mjs

@@ -1,4 +1,4 @@
-import * as path from 'node:path'
+import path from 'node:path'
 
 export async function install({ dirs, projectPackageJson }) {
     const { tools } = await import(`file:///${path.resolve(dirs.plataDir, 'postinstall-tools.mjs')}`.replace(/\\/g, '/'))
@@ -23,6 +23,7 @@ export async function install({ dirs, projectPackageJson }) {
     projectPackageJson.scripts.start = `ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata`
     projectPackageJson.scripts.create = `ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata-create --`
     projectPackageJson.scripts.dev = "npx nodemon -e '.js,.mjs,.json,.ts' --exec 'npm start'"
+    projectPackageJson.scripts['swagger:gen'] = `ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata-swagger-gen`
     projectPackageJson.main = undefined
 
     await Promise.all(promises)

package/templates/postinstall/lib/_install.mjs

@@ -1,4 +1,4 @@
-import * as path from 'node:path'
+import path from 'node:path'
 
 export async function install({ dirs, projectPackageJson }) {
     const { tools } = await import(`file:///${path.resolve(dirs.plataDir, 'postinstall-tools.mjs')}`.replace(/\\/g, '/'))

package/templates/postinstall/lib/postinstall-tools.mjs

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
+import fs from 'node:fs'
+import path from 'node:path'
 
 export function tools(dirs) {
     const tools = new Object(null)

package/templates/postinstall/lib/postinstall.js

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
+import fs from 'node:fs'
+import path from 'node:path'
 import { tools } from './postinstall-tools.mjs'
 
 const main = async() => {

package/templates/swagger-cli/header.json

@@ -0,0 +1,21 @@
+{
+    "swagger": "2.0",
+    "info": {
+        "title": "",
+        "description": "",
+        "version": ""
+    },
+    "host": "",
+    "basePath": "/api",
+    "schemes": [
+        "https",
+        "http"
+    ],
+    "securityDefinitions": {
+        "apiKeyAuth": {
+          "type": "apiKey",
+          "name": "x-access-token",
+          "in": "header"
+        }
+      }
+}

package/templates/swagger-cli/rota/body.json

@@ -0,0 +1,10 @@
+{
+    "description": "",
+    "type": "object",
+    "example": {
+        "test": {
+            "type": "number",
+            "example": 123
+        }
+    }
+}

package/templates/swagger-cli/rota/header.json

@@ -0,0 +1,18 @@
+{
+    "summary": "summary",
+    "description": "Descrião da rota",
+    "security": [
+        {
+            "apiKeyAuth": []
+        }
+    ],
+    "parameters": [
+        {
+            "name": "test",
+            "description": "",
+            "in": "header",
+            "required": false,
+            "type": "string"
+        }
+    ]
+}

package/templates/swagger-cli/rota/response.json

@@ -0,0 +1,23 @@
+{
+    "200": {
+        "description": "Okay",
+        "examples": {
+            "status": "Okay"
+        }
+    },
+    "400": {
+        "description": "Requisição invalida",
+        "example":{
+                "errorID": "string",
+                "msg": "string"
+            }
+    },
+    "500": {
+        "description": "Erro Interno",
+        "examples": {
+            "errorID": "string",
+            "msg": "string",
+            "error": "any"
+        }
+    }
+}