pwi-plata-type 0.2.13 → 0.2.14

package/bin/extras/plata-build-tool.ts

@@ -0,0 +1,150 @@
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../../libs/tools.js';
+
+export namespace tools {
+    export interface ProcessExit {
+        exitCode: number,
+        stdout: string,
+        stderr: string
+    }
+
+    export function runIn(command: string, args: string[], cwd: string,): Promise<PlataResultado<ProcessExit>> {
+        return new Promise((resolve) => {
+            try {
+                const p = spawn(command, args, {
+                    cwd: cwd
+                })
+
+                let stdout, stderr = ''
+
+                p.stdout.on('data', (data) => {
+                    stdout += `${data}\n`
+                })
+
+                p.stderr.on('data', (data) => {
+                    stderr += `${data}\n`
+                })
+
+                p.on('close', (code) => {
+                    return resolve({
+                        exitCode: code ?? 999,
+                        stdout: stdout,
+                        stderr: stderr,
+                    })
+                })
+            } catch (e) {
+                return resolve({
+                    errorID: 'PBEBT0001',
+                    msg: [ 'Erro ao rodar o comando no projeto:', command, ...args ].join(' '),
+                    error: e
+                })
+            }
+        })
+    }
+
+    export async function runInProject(command: string, args: string[], folder?: string): Promise<PlataResultado<ProcessExit>> {
+        return runIn(
+            command,
+            args,
+            path.join(PlataDirs.getProjectDir(), folder ?? '')
+        )
+    }
+
+    export function getProjectJson(): any {
+        return PlataDirs.ProjectJson
+    }
+
+    export function getPlataJson(): any {
+        return PlataFiles.readJsonSync(path.join(
+            PlataDirs.getPlataDir(),
+            'package.json'
+        ))
+    }
+
+    export function getBuildFolder(): string {
+        return path.join(PlataDirs.getProjectDir(), 'build')
+    }
+
+    export function getBuildPlataFolder(plataName: string): string {
+        return path.join(getBuildFolder(), 'node_modules', plataName)
+    }
+
+    export function doError(error: PlataError): any {
+        console.log(error.errorID)
+        console.log(error.msg)
+        if (error.error) {
+            throw error.error
+        }
+
+        process.exit(1)
+    }
+
+    export function copyFolder(folder: string, destination: string): Promise<PlataResultado<string>> {
+        return new Promise(resolve => {
+            const p = path.join(destination, path.basename(folder))
+            fs.cp(folder, p, { recursive: true, errorOnExist: false },(err) => {
+                if (err !== null) {
+                    return resolve({
+                        errorID: 'PBEBT0002',
+                        msg: `Erro ao copiar a pasta ${folder} para ${p}`,
+                        error: err
+                    })
+                }
+
+                return resolve(p)
+            })
+        })
+    }
+
+    export async function copyFolderIfExits(folder: string, destination: string): Promise<PlataResultado<string>> {
+        try {
+            if (fs.existsSync(folder)) {
+                return copyFolder(folder, destination)
+            }
+
+            return ''
+        } catch(e) {
+            return {
+                errorID: 'PBEBT0003',
+                msg: `Erro ao checar se a pasta ${folder} existe`,
+                error: e
+            }
+        }  
+    }
+
+    export function saveJson(folder: string, file: string, content: any): Promise<PlataResultado<string>> {
+        return new Promise(resolve => {
+            const p = path.join(folder, file)
+            fs.writeFile(p, JSON.stringify(content, null, 4), err => {
+                if (err !== null) {
+                    return resolve({
+                        errorID: 'PBEBT0004',
+                        msg: `Erro salvar o arquivo ${p}`,
+                        error: err
+                    })
+                }
+
+                return resolve(p)
+            })
+        })
+    }
+
+    export async function createFolderIfNotExists(...folder: string[]): Promise<PlataResultado<string>> {
+        try {
+            const p = path.join(...folder)
+            if (!fs.existsSync(p)) {
+                fs.mkdirSync(p, { recursive: true })
+            }
+
+            return p
+        } catch (e) {
+            return {
+                errorID: 'PBEBT0005',
+                msg: `Ao criar a pasta ${folder}`,
+                error: e
+            }
+        }
+    }
+}

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

@@ -3,8 +3,8 @@ import path from 'node:path'
 
 import { PlataDirs, PlataFiles } from '../../libs/tools.js'
 
-export module tools {
-    export module files {
+export namespace tools {
+    export namespace files {
         export async function mkdirIfNotExists(dir: string) {
             try {
                 const p = path.resolve(dir)
@@ -80,7 +80,7 @@ export module tools {
         }
     }
 
-    export module args {
+    export namespace args {
         export type argsCallBack = (command: string, args: string[]) => Promise<string[]>
 
         export async function forEachArg(callback: argsCallBack) {

package/bin/plata-build.ts

@@ -0,0 +1,144 @@
+import { tools } from './extras/plata-build-tool.js'
+import { PlataResultado, PlataDirs } from '../libs/tools.js'
+
+const main = async () => {
+    // Prepara o JSONs
+    const projectJson = tools.getProjectJson()
+    const plataJson = tools.getPlataJson()
+
+    plataJson.main = 'index.js'
+    
+    projectJson.plata_no_setup = "true"
+    projectJson.dependencies = { ...projectJson.dependencies, ...plataJson.dependencies }
+    
+    for (const dependencia in projectJson.dependencies) {
+        switch (dependencia) {
+            case 'ts-jest':
+                delete projectJson.dependencies['ts-jest']
+            break
+            case 'ts-node':
+                delete projectJson.dependencies['ts-node']
+            break
+            case plataJson.name:
+                delete projectJson.dependencies[plataJson.name]
+            break
+            default:
+                if (/^@types/.test(dependencia)) {
+                    delete projectJson.dependencies[dependencia]
+                }
+            break
+        }
+    }
+
+    projectJson.scripts = {
+        start: `node ./node_modules/${plataJson.name}/bin/plata`,
+    }
+
+    // Faz a manipulação dos arquivos para deixar certinho
+    const buildFolder = tools.getBuildFolder()
+
+    // Copia a pasta da plata compilada para fora da node_modules
+
+    const plataTmpFolder = await tools.copyFolder(
+        tools.getBuildPlataFolder(plataJson.name),
+        buildFolder
+    )
+
+    if (plataTmpFolder.errorID !== undefined) {
+        return tools.doError(plataTmpFolder)
+    }
+
+    // Salva os packages.json
+    {
+        const promises: Promise<PlataResultado<unknown>>[] = []
+        
+        promises.push(tools.saveJson(
+            buildFolder,
+            'package.json',
+            projectJson
+        ))
+
+        promises.push(tools.saveJson(
+            plataTmpFolder,
+            'package.json',
+            plataJson
+        ))
+
+        const resultado = await Promise.all(promises)
+
+        for (const r of resultado) {
+            if (r.errorID !== undefined) {
+                return tools.doError(r)
+            }
+        }
+    }
+    
+    // Instala as dependencias
+    {
+        const install = await tools.runIn('npm', ['i'], buildFolder)
+
+        if (install.errorID !== undefined) {
+            return tools.doError(install)
+        }
+
+        if (install.exitCode !== 0) {
+            return tools.doError({
+                errorID: 'PBB0002',
+                msg: `out:\n${install.stdout}\n err:\n${install.stderr}\n`
+            })
+        }
+    }
+
+    // Copia as pastas:
+    // plata compilada => node_modules
+    // env => projeto compilado
+    // swagger => projeto compilado
+    {
+        const promises: Promise<PlataResultado<unknown>>[] = []
+
+        promises.push(tools.copyFolder(
+            plataTmpFolder,
+            tools.getBuildPlataFolder('')
+        ))
+
+        promises.push(tools.copyFolder(
+            PlataDirs.getProjectEnvFileDir(''),
+            buildFolder
+        ))
+
+        promises.push(tools.copyFolderIfExits(
+            PlataDirs.getProjectDirSwagger(),
+            buildFolder
+        ))
+
+        const resultado = await Promise.all(promises)
+
+        for (const r of resultado) { 
+            if (r.errorID !== undefined) {
+                return tools.doError(r)
+            }
+        }
+    }
+
+    // Cria as pasta caso ela não exista
+    {
+        const promises: Promise<PlataResultado<unknown>>[] = []
+
+        promises.push(tools.createFolderIfNotExists(buildFolder, 'clusters'))
+        promises.push(tools.createFolderIfNotExists(buildFolder, 'models'))
+        promises.push(tools.createFolderIfNotExists(buildFolder, 'routes'))
+
+        const resultado = await Promise.all(promises)
+
+        for (const r of resultado) {
+            if (r.errorID !== undefined) {
+                return tools.doError(r)
+            }
+
+        }
+    }
+
+    console.log('Projeto compilado')
+}
+
+main()

package/bin/plata-swagger-gen.ts

@@ -46,9 +46,7 @@ function fromTemplateJson(file: string): PlataResultado<any> {
     try {
         const p = path.resolve(file)
 
-        const j = JSON.parse(fs.readFileSync(p).toString())
-
-        return j
+        return JSON.parse(fs.readFileSync(p).toString())
     } catch (e) {
         return {
             errorID: 'PBSW0001',
@@ -111,25 +109,23 @@ 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]
+    for (const r of rotas) {
         const expressRouter = await r.exports()
 
         if (expressRouter.swaggerHide) {
             continue
         }
 
-        for (let j = 0; j < expressRouter.stack.length; j++) {
-            const layer = expressRouter.stack[j];
+        for (const layer of expressRouter.stack) {
+            if (layer.route === undefined) continue
+
             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];
-
+                for (const p of urlParms) {
                     routeParams.push({
                         name: p.slice(1, -1),
                         required: p[0] === ':',
@@ -142,7 +138,7 @@ async function dumpRotas(): Promise<dumpRoute[]> {
                     httpRoute: httpLayerRoute.replace(regex, '{$1}/'),
                     params: routeParams,
                     metodo,
-                })               
+                })
             }
         }
     }
@@ -157,8 +153,7 @@ const main = async () => {
     {
         const pathSwaggerRotas = PlataDirs.getProjectDirSwaggerRotas()
 
-        for (let i = 0; i < rotas.length; i++) {
-            const r = rotas[i];
+        for (const r of rotas) {
             // https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy
             const f = JSON.parse(JSON.stringify(files))
 

package/bin/plata.ts

@@ -25,7 +25,7 @@ const main = async () => {
 
         clusterLib.run({
             name: '_plata_express',
-            onStart: async () => {},
+            onStart: async () => { /*****/ },
             env: process.env.ENV ?? 'prod'
         })
 
@@ -58,7 +58,7 @@ const main = async () => {
 
             app.use(process.env._PLATA_API_ROOT ?? '/api',await buildExpressRouter())
 
-            app.use((err, req, res, next) => {                
+            app.use((err, _req, res, _next) => {                
                 return res.status(500).json({
                     errorId: 'B00000',
                     error: 'Erro interno da aplicação',

package/libs/cluster.ts

@@ -135,9 +135,7 @@ export class PlataClusterManager {
 
         const promisesClusters: any[] = []
 
-        for (let i = 0; i < required.length; i++) {
-            const r = required[i];
-
+        for (const r of required) {
             if (r.errorID !== undefined) {
                 console.log(required)
                 process.exit(1)
@@ -162,13 +160,13 @@ export class PlataClusterManager {
         })
 
         if (file !== null) {
-            const config: PlataClusterWorkerConfig = (await import(`file:///${file}`.replace(/\\/g, '/')) as any).default
+            const config: PlataClusterWorkerConfig = (await import(`file:///${file}`.replace(/\\/g, '/'))).default
 
             await config.onStart()
         }
     }
 
-    private async _clusterMsgServer(worker: typeCluster.Worker, msg: PlataClusterMsg) {
+    private async _clusterMsgServer(_worker: typeCluster.Worker, msg: PlataClusterMsg) {
         if (msg.name !== '_plata') {
             // TODO :::
         } else {

package/libs/env.ts

@@ -6,7 +6,7 @@ export interface EnvConfig {
 
 export async function loadEnvProjectFile() {
     const config = process.env['ENV'] === undefined ? 
-        (await import(PlataDirs.getProjectConfigFileDir('env.js')) as any).default as EnvConfig
+        (await import(PlataDirs.getProjectConfigFileDir('env.js'))).default as EnvConfig
         : { env: process.env['ENV'] }
 
     return PlataFiles.readFileAsync(

package/libs/model.ts

@@ -32,9 +32,9 @@ export class Model {
     }
 }
 
-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)
+export async function _validaCampo(value: any, pipelines: ModelValicacaoPrimitivo[], name: string): Promise<PlataError | null> {
+    for (const pipeline of pipelines) {
+        const result = await pipeline(name, value)
 
         if (result.error !== undefined) {
             return result.error
@@ -332,7 +332,7 @@ export function isArray(tamanhoMaximo?: number): ModelValicacaoPrimitivo {
 }
 
 export function Optional(): ModelValicacaoPrimitivo {
-    return async (nome: string, valor: any) => {
+    return async (_nome: string, valor: any) => {
         if (!valor) {
             return { continua: false }
         }

package/libs/routes.ts

@@ -31,7 +31,7 @@ export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
                 }
             })
 
-            throw {}
+            throw routes
         }
 
         let r = (routes as PlataRequiredRoute[])
@@ -57,7 +57,7 @@ export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
         return r
     } else {
         console.log(routes)
-        throw {}
+        throw routes
     }
 }
 
@@ -67,9 +67,7 @@ export async function buildExpressRouter(): Promise<Router> {
 
     const routes = await loadExpressRoutes()
 
-    for (let i = 0; i < routes.length; i++) {
-        const r = routes[i];
-
+    for (const r of routes) {
         router.use(r.httpRoute, await r.exports())
     }
 
@@ -112,13 +110,13 @@ export function PlataRoute(r: PlataRequestHandler): express.RequestHandler {
             }
 
             aRes.json = (body) => {
-                (async () => { aRes._onResponseEvent(aReq, body, undefined, undefined) })
+                (async () => { aRes._onResponseEvent(aReq, body, undefined, undefined) })()
 
                 return aRes._oldJson(body)
             }
 
             aRes.error = (error, nodeError) => {
-                (async () => { aRes._onResponseEvent(aReq, undefined, error, nodeError) })
+                (async () => { aRes._onResponseEvent(aReq, undefined, error, nodeError) })()
 
                 return aRes._oldJson(error)
             }

package/libs/swagger.ts

@@ -4,7 +4,7 @@ import path from 'node:path'
 import { _Router } from './routes.js';
 import { PlataFiles, PlataDirs } from "./tools.js";
 
-export module PlataSwagger {
+export namespace PlataSwagger {
     export async function swagger(): Promise<_Router> {
         const router = Router() as _Router
         router.swaggerHide = true
@@ -27,8 +27,7 @@ export module PlataSwagger {
         {
             const routes = await PlataFiles.findFiles([PlataDirs.getProjectDirSwaggerRotas()], 'header.json')
 
-            for (let i = 0; i < routes.length; i++) {
-                const route = routes[i];
+            for (const route of routes) {
 
                 const docPath = path.normalize(path.dirname(route))
                 const metodo = path.normalize(path.basename(docPath))

package/libs/tools.ts

@@ -13,7 +13,7 @@ export interface PlataError {
 
 export type PlataResultado<T> = (T & { errorID?: undefined }) | PlataError 
 
-export module PlataDirs {
+export namespace PlataDirs {
     export function getProjectDir(): string {
         return path.resolve('.')
     }
@@ -74,7 +74,7 @@ export module PlataDirs {
 
 }
 
-export module PlataFiles {
+export namespace PlataFiles {
     export type readLineCallback = (line: string) => Promise<void>
 
     export type readLineCallbackSync = (line: string) => string
@@ -129,9 +129,7 @@ export module PlataFiles {
     }
 
     export async function findFile(folders: string[], file: string): Promise<string | null> {
-        for (let i = 0; i < folders.length; i++) {
-            const folder = folders[i];
-
+        for (const folder of folders) {
             const f = glob.sync(`${folder.replace(/\\/g, '/')}/**/${file}`)[0]
 
             if (f !== undefined) {
@@ -145,9 +143,7 @@ export module PlataFiles {
     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]
-            
+        for (const folder of folders) {            
             files.push(...glob.sync(`${folder.replace(/\\/g, '/')}/**/${file}`))
         }
 
@@ -187,7 +183,7 @@ export module PlataFiles {
     }
 }
 
-export module PlataRequire {
+export namespace PlataRequire {
     export type Required<Type> = PlataResultado<RequiredInterface<Type>>
     export interface RequiredInterface<Type> {
         filePath: string,
@@ -211,7 +207,7 @@ export module PlataRequire {
         return {
             filePath: p,
             name: path.basename(p).replace('.ts', '').replace('.js', ''),
-            exports: (e as any).default as Type
+            exports: e.default as Type
         }
     }
 
@@ -239,7 +235,7 @@ export module PlataRequire {
     }
 }
 
-export module PlataExtra {
+export namespace PlataExtra {
     export function Sleep(ms: number) {
         return new Promise(resolve => setTimeout(resolve, ms))
     }

package/package.json

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

package/templates/postinstall/api/_install.mjs

@@ -21,6 +21,7 @@ export async function install({ dirs, projectPackageJson }) {
     projectPackageJson.type = "module"
     projectPackageJson.scripts = new Object(null)
     projectPackageJson.scripts.start = `ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata`
+    projectPackageJson.scripts.build = `npx tsc && ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata-build --`
     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`

package/templates/postinstall/api/tsconfig.json

@@ -3,14 +3,14 @@
         "strictNullChecks": true,
         "module": "es2022",
         "target": "es2022",
-        "noImplicitAny": true,
-        "declaration": true,
-        "sourceMap": true,
-        "esModuleInterop": true
+        "declaration": false,
+        "sourceMap": false,
+        "esModuleInterop": true,
+        "outDir": "build",
+        "moduleResolution": "node"
     },
     "include": [
-        "./node_modules/plata-type/**/*"
+        "./**/*.ts",
+        "node_modules/pwi-plata*/**/*.ts"
     ]
-
-}
-  
+}

package/templates/postinstall/lib/tsconfig.json

@@ -3,14 +3,14 @@
         "strictNullChecks": true,
         "module": "es2022",
         "target": "es2022",
-        "noImplicitAny": true,
-        "declaration": true,
-        "sourceMap": true,
-        "esModuleInterop": true
+        "declaration": false,
+        "sourceMap": false,
+        "esModuleInterop": true,
+        "outDir": "build",
+        "moduleResolution": "node"
     },
     "include": [
-        "./node_modules/plata-type/**/*"
+        "./**/*.ts",
+        "node_modules/pwi-plata*/**/*.ts"
     ]
-
-}
-  
+}

package/tsconfig.json

@@ -3,14 +3,14 @@
         "strictNullChecks": true,
         "module": "es2022",
         "target": "es2022",
-        "noImplicitAny": true,
-        "declaration": true,
-        "sourceMap": true,
-        "esModuleInterop": true
+        "declaration": false,
+        "sourceMap": false,
+        "esModuleInterop": true,
+        "outDir": "build",
+        "moduleResolution": "node"
     },
     "include": [
-        "./node_modules/plata-type/**/*"
+        "./**/*.ts",
+        "node_modules/pwi-plata*/**/*.ts"
     ]
-
-}
-  
+}