pwi-plata-type 0.3.17 → 0.4.0

package/templates/create-cli/route.ts

@@ -1,7 +1,5 @@
 //@ts-nocheck
-import { PlataRoutes } from 'ç__PlataName__ç'
-
-export default (router: PlataRoutes.PlataRouter): PlataRoutes.PlataRouter => {
+export default async (router: Router.Router): Promise<Router.Router> => {
 
     router.get('/', async (req, res) => {
         return res.status(200).json({})

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

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

package/templates/postinstall/api/tsconfig.json

@@ -1,40 +1,23 @@
 {
-    "ts-node": {
-        "transpileOnly": true,
-        "swc": true,
-        "esm": false,
-        "project": "./tsconfig.json",
-        "skipIgnore": true,
-        "require": [
-          "tsconfig-paths/register"
-        ],
-        "compilerOptions": {
-            "module": "CommonJS"
-        }
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "CommonJS",
+		"lib": ["esnext"],
+		"declaration": false,
+		"allowJs": true,
+		"outDir": "./__BUILD__",
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"strictNullChecks": true,
+		"sourceMap": true,
+		"types": [ "node", "pwi-plata-type" ],
+		"forceConsistentCasingInFileNames": true,
+		"baseUrl": ".",
+		"paths": {
+			"@@/*": [ "./*" ]
+		}
     },
-    "compilerOptions": {
-      "target": "ESNext",
-      "module": "CommonJS",
-      "lib": ["esnext"],
-      "allowJs": true,
-      "outDir": "./build",
-      "rootDir": "./",
-      "esModuleInterop": true,
-      "resolveJsonModule": true,
-      "strictNullChecks": true,
-      "forceConsistentCasingInFileNames": true,
-      "baseUrl": ".",
-      "paths": {
-        "@Libs/*": ["./libs/*"],
-        "@Configs/*": [ "./configs/*" ],
-        "@Models/*": [ "./models/*" ],
-        "@Clusters/*": [ "./clusters/*" ],
-        "@Plata/*": [ "./node_modules/pwi-plata-type/*" ],
-        "@PlataBin/*": [ "./node_modules/pwi-plata-type/bin/*" ]
-      }
-    },
-    "include": [
-        "./**/*.ts",
-        "./node_modules/pwi-plata-type/**/*.ts"
-    ]
+	"include": [
+		"./**/*"
+	]
 }

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
-
+// TODO matar esse aquivo e usar o PlataFS
 export function tools(dirs) {
     const tools = new Object(null)
 

package/templates/postinstall/lib/postinstall.js

@@ -23,6 +23,7 @@ const main = async() => {
     promises.push(t.syncFolderProject('clusters'))
     promises.push(t.syncFolderProject('libs'))
     promises.push(t.syncFolderProject('tasks'))
+    promises.push(t.syncFolderProject('@types'))
 
     await Promise.all(promises)
 }

package/templates/postinstall/lib/tsconfig.json

@@ -1,40 +1,23 @@
 {
-  "ts-node": {
-      "transpileOnly": true,
-      "swc": true,
-      "esm": false,
-      "project": "./tsconfig.json",
-      "skipIgnore": true,
-      "require": [
-        "tsconfig-paths/register"
-      ],
-      "compilerOptions": {
-          "module": "CommonJS"
-      }
-  },
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "CommonJS",
-    "lib": ["esnext"],
-    "allowJs": true,
-    "outDir": "./build",
-    "rootDir": "./",
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "strictNullChecks": true,
-    "forceConsistentCasingInFileNames": true,
-    "baseUrl": ".",
-    "paths": {
-      "@Libs/*": ["./libs/*"],
-      "@Configs/*": [ "./configs/*" ],
-      "@Models/*": [ "./models/*" ],
-      "@Clusters/*": [ "./clusters/*" ],
-      "@Plata/*": [ "./node_modules/pwi-plata-type/*" ],
-      "@PlataBin/*": [ "./node_modules/pwi-plata-type/bin/*" ],
-    }
-  },
-  "include": [
-      "./**/*.ts",
-      "./node_modules/pwi-plata-type/**/*.ts"
-  ]
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "CommonJS",
+		"lib": ["esnext"],
+		"declaration": false,
+		"allowJs": true,
+		"outDir": "./__BUILD__",
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"strictNullChecks": true,
+		"sourceMap": true,
+		"types": [ "node", "pwi-plata-type" ],
+		"forceConsistentCasingInFileNames": true,
+		"baseUrl": ".",
+		"paths": {
+			"@@/*": [ "./*" ]
+		}
+    },
+	"include": [
+		"./**/*"
+	]
 }

package/tsconfig.json

@@ -1,40 +1,28 @@
 {
-    "ts-node": {
-        "transpileOnly": true,
-        "swc": true,
-        "esm": false,
-        "project": "./tsconfig.json",
-        "skipIgnore": true,
-        "require": [
-          "tsconfig-paths/register"
-        ],
-        "compilerOptions": {
-            "module": "CommonJS"
-        }
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "CommonJS",
+		"lib": ["esnext"],
+		"declaration": false,
+		"allowJs": true,
+		"outDir": "./__BUILD__",
+		"rootDir": "./src",
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"strictNullChecks": true,
+		"sourceMap": true,
+		"removeComments": true,
+		"types": ["node"],
+		"forceConsistentCasingInFileNames": true,
+		"baseUrl": ".",
+		"paths": {
+			"++/*": [ "./src/*" ]
+		}
     },
-    "compilerOptions": {
-      "target": "ESNext",
-      "module": "CommonJS",
-      "lib": ["esnext"],
-      "allowJs": true,
-      "outDir": "./build",
-      "rootDir": "./",
-      "esModuleInterop": true,
-      "resolveJsonModule": true,
-      "strictNullChecks": true,
-      "forceConsistentCasingInFileNames": true,
-      "baseUrl": ".",
-      "paths": {
-        "@libs/*": ["./libs/*"],
-        "@configs/*": [ "./configs/*" ],
-        "@models/*": [ "./models/*" ],
-        "@clusters/*": [ "./clusters/*" ],
-        "@Plata/*": [ "./node_modules/pwi-plata-type/*" ],
-        "@PlataBin/*": [ "./node_modules/pwi-plata-type/bin/*" ],
-      }
-    },
-    "include": [
-        "./**/*.ts",
-        "./node_modules/pwi-plata-type/**/*.ts"
-    ]
+	"include": [
+		"./src/**/*"
+	],
+	"exclude": [
+		"./templates/**/*"
+	]
 }

package/Dockerfile

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

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

@@ -1,151 +0,0 @@
-import { spawn } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../../libs/tools';
-
-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,
-                    shell: true
-                })
-
-                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/plata-build.ts

@@ -1,144 +0,0 @@
-import { tools } from './extras/plata-build-tool'
-import { PlataResultado, PlataDirs } from '../libs/tools'
-
-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-create.ts

@@ -1,28 +0,0 @@
-import { PlataDirs } from "../libs/tools"
-
-import * as PlataCreateApi from "./extras/plata-create-api"
-import * as PlataCreateLib from "./extras/plata-create-lib"
-
-const main = async () => {
-    const projectPackage = 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)
-    }
-
-    switch(projectPackage.plata_type ?? 'api') {
-        case 'api':
-            await PlataCreateApi.cli.parseAsync(process.argv)
-        break;
-        case 'lib':
-            await PlataCreateLib.cli.parseAsync(process.argv)
-        break;
-        default:
-            console.log(`tipo ${projectPackage.plata_type} não suportado pela plata`)
-            process.exit(0)
-        break;
-    }
-}
-
-main()

package/bin/plata-reload.ts

@@ -1,13 +0,0 @@
-import { tools } from './extras/plata-build-tool'
-import { PlataDirs } from '../libs/tools'
-
-
-const main = async () => {
-    console.log(await tools.runIn(
-        'node',
-        [ 'postinstall.mjs' ],
-        PlataDirs.getPlataDir()
-    ))
-}
-
-main()