pwi-plata-type 0.3.17 → 0.4.0

package/bin/plata-swagger-gen.ts

@@ -1,183 +0,0 @@
-import path from 'node:path'
-import fs from 'node:fs'
-import { buildExpressRouter } from '../libs/routes'
-import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../libs/tools'
-
-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)
-
-        return JSON.parse(fs.readFileSync(p).toString())
-    } 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 buildExpressRouter()
-    const rotasMetodos: dumpRoute[] = []
-    const regex = /:(.*?)\??\//g
-
-    if (rotas._routes === undefined) return []
-
-    for (const r of rotas._routes) {
-        if (r.swaggerHide) {
-            continue
-        }
-
-        r.path = path.normalize(`${r.path ?? '/'}/`).replace(/\\/g, '/')
-
-        const routeParams: dumpParameter[] = []
-        const urlParms = r.path.match(regex) ?? []
-
-        for (const p of urlParms) {
-            routeParams.push({
-                name: p.replace(regex, '$1'),
-                required: p[p.length - 2] !== '?',
-                in: 'path',
-                type: 'string'
-            })
-        }
-
-        rotasMetodos.push({
-            httpRoute: r.path.replace(regex, '{$1}/'),
-            metodo: r.method,
-            params: routeParams,        
-        })
-    }
-
-    return rotasMetodos
-}
-
-const main = async () => {
-    // TODO :: Colocar isso em um function que inicializa a process._plata ou n usa isso mais
-    (process as any)._plata = new Object(null)
-
-    const rotas = await dumpRotas()
-    const files = loadSwaggerFiles()
-
-    {
-        const pathSwaggerRotas = PlataDirs.getProjectDirSwaggerRotas()
-
-        for (const r of rotas) {
-            // 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,122 +0,0 @@
-import { PlataClusterManager, PlataClusterMsg } from "../libs/cluster"
-import { loadEnvProjectFile } from "../libs/env"
-import { loadTasks } from "../libs/tasks"
-import { buildExpressRouter } from "../libs/routes"
-import express, { Express } from "express"
-import { createServer } from 'node:https'
-import fs from 'node:fs'
-import { PlataDirs } from "../libs/tools"
-import path from 'node:path'
-
-const main = async () => {
-    const clusterLib = new PlataClusterManager();
-
-    if (clusterLib.isPrimary()) {
-        {
-            console.log('Carregando .env')
-            const err = await loadEnvProjectFile()
-
-            if (err !== null) {
-                console.log(err)
-                process.exit(1)
-            }
-        }
-
-        await loadTasks()
-
-        console.log(process.env.ENV)
-
-        clusterLib.run({
-            name: '_plata_express',
-            onStart: async () => { /*****/ },
-            env: process.env.ENV ?? 'prod'
-        })
-
-        clusterLib.loadClusters()
-    } else {
-        await loadEnvProjectFile()
-
-        process.on('message', async (msg: PlataClusterMsg) => {
-            process.emit(msg.id as any, msg as any)
-        })
-
-        if (process.env._plata_name === '_plata_express') {
-            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()
-
-            app.disable('x-powered-by')
-
-            const apiRoots = process.env._PLATA_API_ROOT ?? '/api'
-
-            app.use(apiRoots.split(','), await buildExpressRouter())
-
-            app.use((err, _req, res, _next) => {                
-                return res.status(500).json({
-                    errorId: 'B00000',
-                    error: 'Erro interno da aplicação',
-                    msg: err.message
-                })
-            })
-
-            app.all('*', (req, res) => {
-                return res.status(404).json({
-                    errorId: 'B00001',
-                    error: 'Rota não encontrada',
-                    msg: req.path
-                })
-            })
-
-            if (!process.env._PLATA_API_SSL_KEY || !process.env._PLATA_API_SSL_CERT) {
-                console.log(`Nenhum certificado configurado na env ${process.env.ENV}:`)
-                console.log(`_PLATA_API_SSL_KEY: ${process.env._PLATA_API_SSL_KEY}`)
-                console.log(`_PLATA_API_SSL_CERT: ${process.env._PLATA_API_SSL_CERT}`)
-
-                app.listen(port, () => {
-                    console.log(`Iniciando Worker Express na porta ${port}`)
-                    setTimeout(() => process.removeAllListeners('exit'), 500)
-                })
-            } else {
-                console.log('Iniciando a Plata com ssl usando os arquivos:')
-                console.log(`key: ${process.env._PLATA_API_SSL_KEY}`)
-                console.log(`cert: ${process.env._PLATA_API_SSL_CERT}`)
-
-                const https = createServer({
-                    cert: fs.readFileSync(path.normalize(path.join(
-                        PlataDirs.getProjectDir(),
-                        process.env._PLATA_API_SSL_CERT
-                    ))),
-                    key: fs.readFileSync(path.normalize(path.join(
-                        PlataDirs.getProjectDir(),
-                        process.env._PLATA_API_SSL_KEY
-                    ))),
-                    passphrase: process.env._PLATA_API_SSL_PASS
-                }, app)
-
-                https.listen(port, () => {
-                    console.log(`Iniciando Worker Express na porta ${port} com SSL`)
-                    setTimeout(() => process.removeAllListeners('exit'), 500)
-                })
-            }
-
-        } else {
-            await clusterLib.loadWorker()
-        }
-    }
-}
-
-main()

package/libs/cluster.ts

@@ -1,219 +0,0 @@
-import { PlataRequire, PlataDirs, PlataFiles, PlataResultado } 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: PlataWorker, code: number, signal: string) => void,
-}
-
-export interface PlataCluster {
-    pids: number[],
-    config: PlataClusterWorkerConfig
-}
-
-export interface PlataClusterMsg {
-    name: string,
-    id: string,
-    data: any
-}
-
-export interface PlataClusterProcess {
-    clusters: PlataCluster[]
-}
-
-export interface _PlataClusterProcess extends NodeJS.Process {
-    _plata?: PlataClusterProcess
-}
-
-
-export function getClusterNodeProcess(): PlataClusterProcess {
-    const p = process as _PlataClusterProcess
-
-    if (p._plata === undefined) {
-        p._plata = {
-            clusters: []
-        }
-    }
-
-    if (p._plata.clusters === undefined) {
-        p._plata.clusters = []
-    }
-
-    return p._plata
-}
-
-export class PlataClusterManager {
-    private readonly Cluster = typeCluster.default as unknown as typeCluster.Cluster
-    private readonly Process = getClusterNodeProcess()
-
-    constructor() {
-        // 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) => {
-                    if (worker.process.pid === undefined) return
-                    
-                    const clusterIndex = this.Process.clusters.findIndex(cluster => 
-                        cluster.pids.indexOf(worker.process.pid ?? 0) !== -1
-                    )
-
-                    if(clusterIndex !== -1) {
-                        const cluster = this.Process.clusters[clusterIndex]
-
-                        console.log(`O Worker ${worker.process.pid} do cluster ${cluster.config.name} morreu com o codigo ${code} ${signal ?? ''}`)
-                        console.log(`Iniciando um novo worker no cluster ${cluster.config.name}`)
-
-                        this.Cluster.emit(`_plata.cluster.worker.exit-${cluster.config.name}`, worker, code, signal)
-
-                        const w = this.Cluster.fork({
-                            ...cluster.config.workersEnv,
-                            ENV: cluster.config.env,
-                            _plata_name: cluster.config.name
-                        })
-
-                        const pidIndex = cluster.pids.indexOf(worker.process.pid)
-
-                        cluster.pids[pidIndex] = w.process.pid ?? 0
-                    }
-                })
-            }
-
-            if (this.Cluster.eventNames().indexOf('message') === -1) {
-                this.Cluster.on('message', this._clusterMsgServer(this))
-            }
-        }
-    }
-
-    public async run(config: PlataClusterWorkerConfig): Promise<void> {
-        if (config.workers === undefined) {
-            if (config.env === 'prod') {
-                config.workers = cpus().length
-            } else {
-                config.workers = 1
-            }
-        }
-
-        console.log(`Iniciando ${config.workers} workers para o cluster ${config.name}`)
-
-        const cluster: PlataCluster = {
-            pids: [],
-            config
-        }
-
-        for (let i = 0; i < config.workers; i++) {
-            const w = this.Cluster.fork({
-                ...config.workersEnv,
-                ENV: cluster.config.env,
-                _plata_name: cluster.config.name
-            })
-
-            cluster.pids.push(w.process.pid ?? 0)
-        }
-
-        if (config.onExit !== undefined) 
-            this.Cluster.on(`_plata.cluster.worker.exit-${cluster.config.name}`, config.onExit)
-        ;
-
-        this.Process.clusters.push(cluster)
-    }
-
-    public isPrimary(): boolean {
-        return this.Cluster.isPrimary
-    }
-
-    public async loadClusters(): Promise<void[]> {
-        const required = await PlataRequire.requireFolderAsync<PlataClusterWorkerConfig>(PlataDirs.getProjectDirClusters())
-
-        if (required.errorID !== undefined) {
-            console.log(required)
-            process.exit(1)
-        }
-
-        const promisesClusters: Promise<void>[] = []
-
-        for (const r of required) {
-            if (r.errorID !== undefined) {
-                console.log(required)
-                process.exit(1)
-            }
-
-            promisesClusters.push(this.run(r.exports))
-        }
-        
-
-        return Promise.all(promisesClusters)
-    }
-
-    public async loadWorker() {
-        const file: string | null = await PlataFiles.findFile(
-            [
-                PlataDirs.getProjectDirClusters()
-            ],
-            `${process.env["_plata_name"]}`
-        ).catch(err => {
-            console.error(err)
-            return null
-        })
-
-        if (file !== null) {
-            const config: PlataClusterWorkerConfig = (await import(file.replace(/\\/g, '/'))).default
-
-            await config.onStart()
-        }
-    }
-
-    private async sendAllWorkers(msg: PlataClusterMsg) {
-        if (this.Cluster.workers === undefined) return
-
-        for (const worker of Object.values(this.Cluster.workers)) {
-            if (worker === undefined) continue
-
-            worker.send(msg)
-        }
-    }
-
-    private _clusterMsgServer(t: PlataClusterManager) {
-        return async (_worker: typeCluster.Worker, msg: PlataClusterMsg) => {
-            if (msg.name !== '_plata') {
-                // TODO :::
-            } else {
-                switch(msg.data.action) {
-                    case 'KILL':
-                        console.log('Solicitado kill do app')
-                        process.exit(0)
-                    ;
-                    case 'ECHO':
-                        t.sendAllWorkers(msg.data.msg)
-                        return
-                    ;
-                }
-            }
-        }
-    }
-}
-
-export async function send(msg: PlataClusterMsg): Promise<PlataResultado<boolean>> {
-    if (process.send === undefined) {
-        return {
-            errorID: 'PBLCLWS0001',
-            msg: `Erro interno no cluster da plataforma`
-        }
-    }
-
-    process.send({
-        name: '_plata',
-        data: {
-            action: 'ECHO',
-            msg
-        }
-    } as PlataClusterMsg)
-
-    return true
-}

package/libs/env.ts

@@ -1,28 +0,0 @@
-import { PlataDirs, PlataFiles } from "./tools"
-
-export interface EnvConfig {
-    readonly env: 'prod' | 'debug' | 'homolog' | string
-}
-
-export async function loadEnvProjectFile() {
-    const config = process.env['ENV'] === undefined ? 
-        (await import(PlataDirs.getProjectConfigFileDir('env'))).default as EnvConfig
-        : { env: process.env['ENV'] }
-
-    return PlataFiles.readFileAsync(
-        PlataDirs.getProjectEnvFileDir(`${config.env}.env`),
-        async (line) => {
-            if (line[0] === '#') return
-
-            if (line !== '') {
-                const env = line.split('=')
-
-                if (env.length >= 2) {
-                    const [ key, ...value ] = env
-
-                    process.env[key.toUpperCase()] = value.join('')
-                }
-            }
-        }
-    )
-}