pwi-plata-type 0.1.0

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

@@ -0,0 +1,58 @@
+import { tools } from "./plata-create-tools.js";
+import * as path from 'node:path'
+
+export async function h() {
+    return tools.args.forEachArg(async (command, args) => {
+        const promises: any[] = []
+
+        switch (command) {
+            case 'lib':
+                const nameLib = args.shift()
+                promises.push(tools.files.deployFileToProject(
+                    'configs',
+                    'config',
+                    `${nameLib.toLowerCase()}.ts`,
+                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
+                ).finally(() => console.log(`Config ${nameLib.toLowerCase()} criada`)))
+
+                promises.push(tools.files.deployFileToProject(
+                    'libs',
+                    'lib',
+                    `${nameLib.toLowerCase()}.ts`,
+                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
+                ).finally(() => console.log(`Lib ${nameLib.toLowerCase()} 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`)))
+            break;
+            case 'cluster':
+                console.log('CLUSTER AINDA NÃO CRIANDO AINDA')
+            break;
+            case 'route':
+                const routeArg = `${args.shift()}`.split('/')
+
+                const routeFileName = routeArg[routeArg.length - 1] === '' ? 'index' : routeArg.pop()
+                const routeFilePath = path.join('routes', ...routeArg.filter(v => v !== ''))
+
+                promises.push(tools.files.deployFileToProject(
+                    routeFilePath,
+                    'route',
+                    `${routeFileName}.ts`,
+                    {}
+                ).finally(() => console.log(
+                    `Rota ${routeFilePath}/${routeFileName === 'index' ? '' : routeFileName} criada`
+                )))
+
+            break;
+        }
+
+        await Promise.all(promises)
+        return args
+    })
+}

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

@@ -0,0 +1,41 @@
+import { tools } from "./plata-create-tools.js";
+
+export async function h() {
+    return tools.args.forEachArg(async (command, args) => {
+        const promises: any[] = []
+
+        switch (command) {
+            case 'lib':
+                const nameLib = args.shift()
+                promises.push(tools.files.deployFileToProject(
+                    'configs',
+                    'config',
+                    `${nameLib.toLowerCase()}.ts`,
+                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
+                ).finally(() => console.log(`Config ${nameLib.toLowerCase()} criada`)))
+
+                promises.push(tools.files.deployFileToProject(
+                    'libs',
+                    'lib',
+                    `${nameLib.toLowerCase()}.ts`,
+                    { Name: `${nameLib}`, name: `${nameLib.toLowerCase()}` }
+                ).finally(() => console.log(`Lib ${nameLib.toLowerCase()} 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`)))
+            break;
+            case 'cluster':
+                console.log('CLUSTER AINDA NÃO CRIANDO AINDA')
+            break;
+        }
+
+        await Promise.all(promises)
+        return args
+    })
+}

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

@@ -0,0 +1,98 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import { PlataDirs, PlataFiles } from '../../libs/tools.js'
+
+export module tools {
+    export module files {
+        export async function mkdirIfNotExists(dir: string) {
+            try {
+                const p = path.resolve(dir)
+
+                if (!fs.existsSync(p)) {
+                    fs.mkdirSync(p, { recursive: true })
+                }
+            } catch (err) {
+                console.error(err)
+                process.exit(1)
+            }
+        }
+
+        export async function copyFileIfNotExists(source: string, destination: string) {
+            try {
+                const s = path.resolve(source)
+                const d = path.resolve(destination)
+
+                if (!fs.existsSync(d)) {
+                    fs.copyFileSync(s, d)
+                }
+            } catch (err) {
+                console.error(err)
+                process.exit(1)
+            }
+        }
+
+        export async function copyFileToProject(projectFolder: string, templateFile: string, fileName: string): Promise<string> {
+            const s = path.resolve(PlataDirs.getPlataTempleteDir('create-cli', `${templateFile}.ts`))
+            let d = path.resolve(PlataDirs.getProjectDir(), projectFolder)
+
+            await mkdirIfNotExists(d)
+            d = path.join(d, fileName)
+            await copyFileIfNotExists(s, d)
+
+            return d
+        }
+
+        export async function deployFileToProject(projectFolder: string, templateFile: string, fileName: string, args: any) {
+            const fileInProject = await copyFileToProject(projectFolder, templateFile, fileName)
+
+            const content: any = await PlataFiles.readFileSync(fileInProject, (line) => {
+                if (line === '//@ts-nocheck') {
+                    return ''
+                }
+
+                if (line === '') {
+                    return ''
+                }
+
+                // Procura por texto para subistituir esse texto que esta no formato ç__PARAMETRO__ç
+                let lastIndex = 0
+                while(lastIndex !== -1) {
+                    lastIndex = line.indexOf('ç__', lastIndex)
+                    
+                    if (lastIndex !== -1) {
+                        const pIndex = line.indexOf('__ç', lastIndex)
+                        const param = line.slice(lastIndex + 3, pIndex)
+
+                        line = line.replace(new RegExp(`ç__${param}__ç`, 'g'), args[param])
+                    }
+                }
+
+                return line
+            })
+
+            if (content.err !== undefined) {
+                console.log(content.err)
+                process.exit(1)
+            } else {
+                fs.writeFileSync(fileInProject, content)
+            }
+        }
+    }
+
+    export module args {
+        export type argsCallBack = (command: string, args: string[]) => Promise<string[]>
+
+        export async function forEachArg(callback: argsCallBack) {
+            let args = process.argv.slice(process.argv.indexOf('--') + 1)
+            
+            while(args.length !== 0) {
+                const command = args.shift()
+
+                if (command !== undefined) {
+                    args = await callback(command, args)
+                }
+            }
+        }
+    }
+}

package/bin/plata-create.ts

@@ -0,0 +1,34 @@
+import { PlataDirs } from "../libs/tools.js";
+
+interface Handler {
+    h: () => Promise<void>
+}
+
+const main = async () => {
+    const projectPackage = await PlataDirs.ProjectJson
+
+    if (projectPackage.plata_no_setup !== undefined) {
+        console.log('Existe o parametro plata_no_setup no package.json ou seja a plata não esta configurada')
+        process.exit(0)
+        
+    }
+
+    let handler: Handler
+
+    switch(projectPackage.plata_type ?? 'api') {
+        case 'api':
+            handler = (await import('./extras/plata-create-api.js')) as unknown as Handler
+        break;
+        case 'lib':
+            handler = (await import('./extras/plata-create-lib.js')) as unknown as Handler
+        break;
+        default:
+            console.log(`tipo ${projectPackage.plata_type} não suportado pela plata`)
+            process.exit(0)
+        break;
+    }
+
+    await handler.h()
+}
+
+main()

package/bin/plata.ts

@@ -0,0 +1,76 @@
+import { PlataClusterManager, PlataClusterMsg } from "../libs/cluster.js"
+import { loadEnvProjectFile } from "../libs/env.js"
+import { loadExpressRoutes } from "../libs/routes.js"
+import express, { Express } from "express"
+
+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)
+            }
+        }
+
+        console.log(process.env.ENV)
+
+        clusterLib.run({
+            name: '_plata_express',
+            onStart: async () => null,
+            env: process.env.ENV
+        })
+
+        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', () => process.send({
+                id: 0,
+                name: '_plata',
+                data: {
+                    action: 'KILL'
+                }
+            }))
+
+            const port = process.env.PORT ?? 3050
+            const app: Express = express()
+
+            app.use(process.env._PLATA_API_ROOT ?? '/api',await loadExpressRoutes())
+
+            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
+                })
+            })
+
+            app.listen(port, () => {
+                console.log(`Iniciando Worker Express na porta ${port}`)
+                setTimeout(() => process.removeAllListeners('exit'), 500)
+            })
+        } else {
+            await clusterLib.loadWorker()
+        }
+    }
+}
+
+main()

package/index.ts

@@ -0,0 +1,11 @@
+import * as PlataCluster from './libs/cluster.js'
+import * as PlataEnv from './libs/env.js'
+import * as PlataRoutes from './libs/routes.js'
+import * as PlataTools from './libs/tools.js'
+
+export {
+    PlataCluster,
+    PlataEnv,
+    PlataRoutes,
+    PlataTools,
+}

package/libs/cluster.ts

@@ -0,0 +1,184 @@
+import { PlataRequire, PlataDirs, PlataFiles } from './tools.js'
+import { cpus } from 'node:os'
+import * as typeCluster from 'node:cluster'
+
+export interface PlataClusterWorkerConfig {
+    name: string,
+    env: string,
+    onStart: () => Promise<void>
+    workers?: number,
+    workersEnv?: any,
+    onExit?: (worker: typeCluster.Worker, 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 
+        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)
+            }
+        }
+    }
+
+    public async run(config: PlataClusterWorkerConfig) {
+        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() {
+        const required: any = await PlataRequire.requireFolderAsync<any>(PlataDirs.getProjectDirClusters()).then(
+            result => result,
+            err => {
+                return { err }
+            }
+        )
+
+        if (required.err !== undefined) {
+            console.log(required.err)
+            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))
+        }
+        
+
+        return Promise.all(promisesClusters)
+    }
+
+    public async loadWorker() {
+        const file: string | null = await PlataFiles.findFile(
+            [
+                PlataDirs.getProjectDirClusters()
+            ],
+            `${process.env["_plata_name"]}.ts`
+        ).catch(err => {
+            console.error(err)
+            return null
+        })
+
+        if (file !== null) {
+            const config: PlataClusterWorkerConfig = (await import(file) as any).default
+
+            await config.onStart()
+        }
+    }
+
+    private async _clusterMsgServer(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)
+                ;
+            }
+        }
+    }
+}

package/libs/env.ts

@@ -0,0 +1,28 @@
+import { PlataDirs, PlataFiles } from "./tools.js"
+
+export interface EnvConfig {
+    readonly env: 'prod' | 'debug' | 'homolog' | string
+}
+
+export async function loadEnvProjectFile() {
+    const config = process.env['ENV'] === undefined ? 
+        (await import(PlataDirs.getProjectConfigFileDir('env.js')) as any).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('')
+                }
+            }
+        }
+    )
+}

package/libs/routes.ts

@@ -0,0 +1,34 @@
+import { PlataDirs, PlataRequire } from "./tools.js";
+import express, { Express, Router } from "express";
+
+export type PlataRouter = () => Router
+
+export async function loadExpressRoutes(): Promise<Router> {
+    const promise = PlataRequire.requireFolderAsync<PlataRouter>(PlataDirs.getProjectRoutesDir())
+    
+    const router = Router()
+    router.use(express.json())
+
+    const routes = await promise.catch(err => { return { error: err } })
+
+    if ((routes as any).error === undefined) {
+        const r = routes as PlataRequire.Required<PlataRouter>[]
+
+        for (let i = 0; i < r.length; i++) {
+            const element = r[i];
+
+            const httpRoute = element.filePath
+                .replace(PlataDirs.getProjectRoutesDir(), '')
+                .replace(/.(ts|js)$/, '')
+                .replace(/index/, '')
+                .replace(/\\/, '/')
+            ;
+
+            router.use(httpRoute, element.exports())
+        }
+    } else {
+        console.log(routes)
+    }
+
+    return router
+}

package/libs/tools.ts

@@ -0,0 +1,161 @@
+import * as path from 'node:path'
+import * as fs from 'node:fs'
+import * as readline from 'node:readline'
+import * as tGlob from 'glob'
+
+const glob = (tGlob as any).default as typeof tGlob
+
+export module PlataDirs {
+    export function getProjectDir(): string {
+        return path.resolve('.')
+    }
+
+    export function getProjectDirClusters(): string {
+        return path.resolve('.', 'clusters')
+    }
+
+    export function getProjectDirConfig(): string {
+        return path.resolve('.', 'configs')
+    }
+
+    export function getProjectConfigFileDir(file: string): string {
+        return path.resolve('.', 'configs', file)
+    }
+
+    export function getProjectDirEnvs(): string {
+        return path.resolve('.', 'envs')
+    }
+
+    export function getProjectEnvFileDir(file: string): string {
+        return path.resolve('.', 'envs', file)
+    }
+
+    export function getProjectRoutesDir(): string {
+        return path.resolve('.', 'routes')
+    }
+
+    export const ProjectJson: any = JSON.parse(
+        fs.readFileSync(
+            path.join(PlataDirs.getProjectDir(), 'package.json')
+        ).toString()
+    )
+
+    export function getPlataDir(): string {    
+        return path.resolve('.', 'node_modules', ProjectJson.plata_name)
+    }
+    
+    export function getPlataTempletesDir(): string {
+        return path.join(getPlataDir(), 'templates')
+    }
+
+    export function getPlataTempleteDir(group:string, template: string) {
+        return path.join(getPlataTempletesDir(), group, template)
+    }
+
+}
+
+export module PlataFiles {
+    export type readLineCallback = (line: string) => Promise<void>
+
+    export type readLineCallbackSync = (line: string) => string
+
+    export function readFileAsync(file: string, callback: readLineCallback): Promise<Error | null> {
+        return new Promise(resolve => {
+            try {
+                const promises: any = []
+
+                const stream = readline.createInterface({
+                    input: fs.createReadStream(file),
+                    crlfDelay: Infinity
+                })
+
+                stream.on('close', () => {
+                    Promise.all(promises).then(
+                        () => resolve(null),
+                        (err) => resolve(err),
+                    )
+                })
+
+                stream.on('line', (line) => {
+                    promises.push(callback(line))
+                })
+            } catch (e) {
+                resolve(e)
+            }
+        })
+    }
+
+    export function readFileSync(file: string, callback: readLineCallbackSync): Promise<string | { err: any }> {
+        return new Promise(resolve => {
+            try {
+                const content = []
+                const stream = readline.createInterface({
+                    input: fs.createReadStream(file),
+                    crlfDelay: Infinity
+                })
+
+                stream.on('close', () => {
+                    resolve(content.join('\n'))
+                })
+
+                stream.on('line', (line) => {
+                    content.push(callback(line))
+                })
+
+            } catch(e) {
+                resolve({ err: e })
+            }
+        })
+    }
+
+    export async function findFile(folders: string[], file: string): Promise<string | null> {
+        for (let i = 0; i < folders.length; i++) {
+            const folder = folders[i];
+
+            const f = glob.sync(`${folder}/**/${file}`)[0]
+
+            if (f !== undefined) {
+                return f
+            }
+        }
+
+        return null
+    }
+}
+
+export module PlataRequire {
+    export interface Required<Type> {
+        filePath: string,
+        name: string,
+        exports: Type
+    }
+
+    export async function requireAsync<Type>(file: string): Promise<Required<Type>> {
+        const p = path.resolve(file)
+
+        return {
+            filePath: p,
+            name: path.basename(p).replace('.ts', '').replace('.js', ''),
+            exports: (await import(p) as any).default as Type
+        }
+    }
+
+    export async function requireFolderAsync<Type>(folder: string): Promise<Required<Type>[]> {
+        const promises: Promise<Required<Type>>[] = []
+        const p = path.resolve(folder)
+
+        glob.sync(`${p}/**/*.ts`).forEach(value => {
+            value = value.replace('.ts', '.js')
+
+            promises.push(requireAsync<Type>(value))
+        })
+
+        return Promise.all(promises)
+    }
+}
+
+export module PlataExtra {
+    export function Sleep(ms: number) {
+        return new Promise(resolve => setTimeout(resolve, ms))
+    }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "pwi-plata-type",
+    "version": "0.1.0",
+    "type": "module",
+    "main": "index.ts",
+    "bin": {
+        "plata": "bin/plata.ts",
+        "plata-cli-create": "bin/plata-create.ts"
+    },
+    "scripts": {
+        "postinstall": "node postinstall.js"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "UNLICENSED",
+    "dependencies": {
+        "@types/express": "^4.17.13",
+        "@types/glob": "^7.2.0",
+        "@types/jest": "^28.1.1",
+        "glob": "^8.0.3",
+        "jest": "^28.1.1",
+        "ts-jest": "^28.0.4",
+        "ts-node": "^10.8.1"
+    },
+    "description": "",
+    "devDependencies": {
+        "express": "^4.18.1"
+    }
+}

package/postinstall-tools.mjs

@@ -0,0 +1,108 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+export function tools(dirs) {
+    const tools = new Object(null)
+
+    tools.mkdirIfNotExists = async (dir) => {
+        try {
+            const p = path.resolve(dir)
+
+            if (!fs.existsSync(p)) {
+                fs.mkdirSync(p, { resolve: true })
+            }
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.copyFile = async (source, destination) => {
+        try {
+            const s = path.resolve(source)
+            const d = path.resolve(destination)
+
+            fs.copyFileSync(s, d)
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.copyFileIfNotExists = async (source, destination) => {
+        try {
+            const s = path.resolve(source)
+            const d = path.resolve(destination)
+
+            if (!fs.existsSync(d)) {
+                tools.copyFile(s, d)
+            }
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.forEachFileInFolder = async (folder, callback) => {
+        try {
+            const f = path.resolve(folder)
+            const files = fs.readdirSync(f)
+
+            const promises = []
+
+            files.forEach(file => {
+                const filePath = path.join(f, file)
+
+                promises.push(
+                    (async () => callback(file, filePath))()
+                )
+            })
+
+            await Promise.all(promises)
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.createFolderProject = (async (folder) => 
+        tools.mkdirIfNotExists(path.join(dirs.projectDir, folder))
+    )
+
+    tools.copyFolderToProject = async (folder) => {
+        const templateFolder = path.join(dirs.templateDir, folder)
+        const destination = path.join(dirs.projectDir, folder)
+
+        await tools.mkdirIfNotExists(destination)
+
+        await tools.forEachFileInFolder(templateFolder, async (file, filePath) =>
+            tools.copyFileIfNotExists(
+                filePath,
+                path.join(destination, file)
+            )
+        )
+    }
+
+    tools.syncFolderProject = async (folder) => {
+        const templateFolder = path.join(dirs.templateDir, folder)
+        const destination = path.join(dirs.projectDir, folder)
+
+        await tools.mkdirIfNotExists(destination)
+
+        await tools.forEachFileInFolder(templateFolder, async (file, filePath) =>
+            tools.copyFile(
+                filePath,
+                path.join(destination, file)
+            )
+        )
+    }
+
+    tools.syncFileToProject = async (file) => {
+        const templateFile = path.join(dirs.templateDir, file)
+        const destination = path.join(dirs.projectDir, file)
+
+        await tools.copyFile(templateFile, destination)
+    }
+
+    return tools
+}

package/postinstall.js

@@ -0,0 +1,38 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+const main = async () => {
+    const plataDir = path.resolve('.')
+    const templatesDir = path.resolve(plataDir, 'templates', 'postinstall')
+    const projectDir = path.resolve(plataDir, '..', '..')
+    let projectPackageJson = JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json')).toString())
+    const plataPackageJson = JSON.parse(fs.readFileSync(path.join(plataDir, 'package.json')))
+
+    if (projectPackageJson.plata_no_setup !== undefined) {
+        process.exit(0)
+    }
+
+    projectPackageJson.plata_type = projectPackageJson.plata_type ?? 'api'
+    projectPackageJson.plata_name = plataPackageJson.name
+    projectPackageJson.license = "UNLICENSED"
+
+    const templateDir = path.join(templatesDir, projectPackageJson.plata_type)
+
+    const { install } = await import(path.join(templateDir, '_install.mjs'))
+
+    projectPackageJson = await install({
+        dirs: {
+            plataDir,
+            templateDir,
+            projectDir,
+        },
+        projectPackageJson
+    })
+
+    fs.writeFileSync(
+        path.join(projectDir, 'package.json'),
+        JSON.stringify(projectPackageJson, null, 4)
+    )
+}
+
+main()

package/templates/create-cli/config.ts

@@ -0,0 +1,9 @@
+const config: ç__Name__çConfig = {
+
+}
+
+interface ç__Name__çConfig {
+
+}
+
+export default config

package/templates/create-cli/lib.ts

@@ -0,0 +1,19 @@
+//@ts-nocheck
+import * as ç__Name__çConfigImport from '../configs/ç__name__ç.js'
+const ç__Name__çConfig = ç__Name__çConfigImport.default as unknown as typeof ç__Name__çConfigImport
+
+export class ç__Name__ç {
+    constructor(config: typeof ç__Name__çConfig) {
+
+    }
+}
+
+export function getç__Name__ç(): ç__Name__ç {
+    const p = process as any
+
+    if (p._plata._libç__Name__ç === undefined) {
+        p._plata._libç__Name__ç = new ç__Name__ç(ç__Name__çConfig)
+    }
+
+    return p._plata._libç__Name__ç
+}

package/templates/create-cli/route.ts

@@ -0,0 +1,11 @@
+import { Router } from 'express'
+
+export default (): Router => {
+    const router = Router()
+
+    router.get('/', (req, res) => {
+        return res.status(200).json({})
+    })
+
+    return router
+}

package/templates/postinstall/api/.vscode/launch.json

@@ -0,0 +1,34 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "DEV",
+            "request": "launch",
+            "runtimeArgs": [
+                "run-script",
+                "dev"
+            ],
+            "runtimeExecutable": "npm",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "node"
+        },
+        {
+            "name": "DEBUG",
+            "request": "launch",
+            "runtimeArgs": [
+                "run-script",
+                "start"
+            ],
+            "runtimeExecutable": "npm",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "node"
+        }
+    ]
+}

package/templates/postinstall/api/Dockerfile

@@ -0,0 +1,13 @@
+FROM node:16-alpine
+
+WORKDIR /usr/src/app
+
+COPY package*.json ./
+
+EXPOSE 3050
+
+RUN npm ci --only=production
+
+COPY . ./
+
+CMD [ "npm", "start" ]

package/templates/postinstall/api/_install.mjs

@@ -0,0 +1,28 @@
+export async function install({ dirs, projectPackageJson }) {
+    const { tools } = await import('../../../postinstall-tools.mjs')
+    const promises = []
+
+    const t = tools(dirs)
+
+    promises.push(t.createFolderProject('clusters'))
+    promises.push(t.createFolderProject('routes'))
+    promises.push(t.createFolderProject('libs'))
+
+    promises.push(t.copyFolderToProject('configs'))
+    promises.push(t.copyFolderToProject('envs'))
+    promises.push(t.syncFolderProject('.vscode'))
+
+    promises.push(t.syncFileToProject('Dockerfile'))
+    promises.push(t.syncFileToProject('tsconfig.json'))
+
+    projectPackageJson.type = "module"
+    projectPackageJson.scripts = new Object(null)
+    projectPackageJson.scripts.start = "ts-node --transpile-only --esm ./node_modules/.bin/plata"
+    projectPackageJson.scripts.create = "ts-node --transpile-only --esm ./node_modules/.bin/plata-cli-create --"
+    projectPackageJson.scripts.dev = "npx nodemon -e '.js,.mjs,.json,.ts' --exec 'npm start'"
+    projectPackageJson.main = undefined
+
+    await Promise.all(promises)
+
+    return projectPackageJson
+}

package/templates/postinstall/api/configs/env.ts

@@ -0,0 +1,9 @@
+const config: EnvConfig = {
+    env: 'debug'
+}
+
+interface EnvConfig {
+    readonly env: 'prod' | 'debug' | 'homolog' | string
+}
+
+export default config

package/templates/postinstall/api/envs/debug.env

@@ -0,0 +1,8 @@
+# Ambiente:
+ENV=debug
+
+
+
+# Configurações da plata:
+PORT=3050
+_PLATA_API_ROOT=/api

package/templates/postinstall/api/envs/homolog.env

@@ -0,0 +1,9 @@
+# Ambiente:
+ENV=homolog
+
+
+
+
+# Configurações da plata:
+PORT=3050
+_PLATA_API_ROOT=/api

package/templates/postinstall/api/envs/prod.env

@@ -0,0 +1,9 @@
+# Ambiente:
+ENV=prod
+
+
+
+
+# Configurações da plata:
+PORT=3050
+_PLATA_API_ROOT=/api

package/templates/postinstall/api/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "strictNullChecks": true,
+        "module": "es2022",
+        "target": "es2022",
+        "noImplicitAny": true,
+        "declaration": true,
+        "sourceMap": true,
+        "esModuleInterop": true
+    },
+    "include": [
+        "./node_modules/plata-type/**/*"
+    ]
+
+}
+  

package/templates/postinstall/lib/_install.mjs

@@ -0,0 +1,28 @@
+export async function install({ dirs, projectPackageJson }) {
+    const { tools } = await import('../../../postinstall-tools.mjs')
+    const promises = []
+
+    const t = tools(dirs)
+
+    promises.push(t.createFolderProject('clusters'))
+    promises.push(t.createFolderProject('routes'))
+    promises.push(t.createFolderProject('libs'))
+
+    promises.push(t.createFolderProject('configs'))
+    promises.push(t.createFolderProject('bin'))
+
+    promises.push(t.syncFileToProject('postinstall.js'))
+    promises.push(t.syncFileToProject('postinstall-tools.mjs'))
+    promises.push(t.syncFileToProject('tsconfig.json'))
+
+    projectPackageJson.type = "module"
+    projectPackageJson.scripts = new Object(null)
+    projectPackageJson.scripts.dev = "ts-node"
+    projectPackageJson.scripts.postinstall = "node postinstall.js"
+    projectPackageJson.scripts.create = "ts-node --transpile-only --esm ./node_modules/.bin/plata-cli-create --"
+    projectPackageJson.main = undefined
+
+    await Promise.all(promises)
+
+    return projectPackageJson
+}

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

@@ -0,0 +1,112 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+export function tools(dirs) {
+    const tools = new Object(null)
+
+    tools.mkdirIfNotExists = async (dir) => {
+        try {
+            const p = path.resolve(dir)
+
+            if (!fs.existsSync(p)) {
+                fs.mkdirSync(p, { resolve: true })
+            }
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.copyFile = async (source, destination) => {
+        try {
+            const s = path.resolve(source)
+            const d = path.resolve(destination)
+
+            fs.copyFileSync(s, d)
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.copyFileIfNotExists = async (source, destination) => {
+        try {
+            const s = path.resolve(source)
+            const d = path.resolve(destination)
+
+            if (!fs.existsSync(d) && fs.existsSync(s)) {
+                tools.copyFile(s, d)
+            }
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.forEachFileInFolder = async (folder, callback) => {
+        try {
+            const f = path.resolve(folder)
+            if (!fs.existsSync(f)) {
+                return
+            }
+
+            const files = fs.readdirSync(f)
+
+            const promises = []
+
+            files.forEach(file => {
+                const filePath = path.join(f, file)
+
+                promises.push(
+                    (async () => callback(file, filePath))()
+                )
+            })
+
+            await Promise.all(promises)
+        } catch (err) {
+            console.error(err)
+            process.exit(1)
+        }
+    }
+
+    tools.createFolderProject = (async (folder) => 
+        tools.mkdirIfNotExists(path.join(dirs.projectDir, folder))
+    )
+
+    tools.copyFolderToProject = async (folder) => {
+        const templateFolder = path.join(dirs.templateDir, folder)
+        const destination = path.join(dirs.projectDir, folder)
+
+        await tools.mkdirIfNotExists(destination)
+
+        await tools.forEachFileInFolder(templateFolder, async (file, filePath) =>
+            tools.copyFileIfNotExists(
+                filePath,
+                path.join(destination, file)
+            )
+        )
+    }
+
+    tools.syncFolderProject = async (folder) => {
+        const templateFolder = path.join(dirs.templateDir, folder)
+        const destination = path.join(dirs.projectDir, folder)
+
+        await tools.mkdirIfNotExists(destination)
+
+        await tools.forEachFileInFolder(templateFolder, async (file, filePath) =>
+            tools.copyFile(
+                filePath,
+                path.join(destination, file)
+            )
+        )
+    }
+
+    tools.syncFileToProject = async (file) => {
+        const templateFile = path.join(dirs.templateDir, file)
+        const destination = path.join(dirs.projectDir, file)
+
+        await tools.copyFile(templateFile, destination)
+    }
+
+    return tools
+}

package/templates/postinstall/lib/postinstall.js

@@ -0,0 +1,29 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { tools } from './postinstall-tools.mjs'
+
+const main = async() => {
+    const plataDir = path.resolve('.')
+    const projectDir = path.resolve(plataDir, '..', '..')
+    const projectPackageJson = JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json')).toString())
+
+    if (projectPackageJson.plata_no_setup !== undefined) {
+        process.exit(0)
+    }
+
+    const t = tools({
+        plataDir,
+        projectDir,
+        templateDir: plataDir
+    })
+
+    const promises = []
+
+    promises.push(t.copyFolderToProject('configs'))
+    promises.push(t.syncFolderProject('clusters'))
+    promises.push(t.syncFolderProject('libs'))
+
+    await Promise.all(promises)
+}
+
+main()

package/templates/postinstall/lib/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "strictNullChecks": true,
+        "module": "es2022",
+        "target": "es2022",
+        "noImplicitAny": true,
+        "declaration": true,
+        "sourceMap": true,
+        "esModuleInterop": true
+    },
+    "include": [
+        "./node_modules/plata-type/**/*"
+    ]
+
+}
+  

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "strictNullChecks": true,
+        "module": "es2022",
+        "target": "es2022",
+        "noImplicitAny": true,
+        "declaration": true,
+        "sourceMap": true,
+        "esModuleInterop": true
+    },
+    "include": [
+        "./node_modules/plata-type/**/*"
+    ]
+
+}
+