pwi-plata-type 0.3.6 → 0.3.9

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

@@ -1,74 +1,144 @@
 import { tools } from "./plata-create-tools";
 import { PlataDirs } from "../../libs/tools"
+import { Command } from 'commander'
 import path from 'node:path'
 
-export async function h() {
-    return tools.args.forEachArg(async (command, args) => {
+const program = new Command()
+
+program.name('Plata Create cli')
+program.description('CLI usada para criar rotas, libs, models e muito mais na plata')
+program.version(PlataDirs.PlataJson.version)
+
+program.command('route <routes...>')
+    .description('Cria uma rota utilizando o templete da plata')
+    .action(async routes => {
+        if (!Array.isArray(routes)) {
+            return
+        }
+
+        const promises: any[] = []
+        const plataName = PlataDirs.ProjectJson.plata_name
+
+        for (const route of routes) {
+            const r = `${route}/`.replace(/:(.*?)(?:\/|$)/g, (_, parm) => {
+                return parm[parm.length - 1] !== '?' ? `{${parm}}/` : `[${parm.slice(0, -1)}]/`
+            })
+
+            const routeArg = r.slice(0, -1).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`,
+                { PlataName: `${plataName}` }
+            ).finally(() => console.log(
+                `Rota ${routeFilePath}/${routeFileName === 'index' ? '' : routeFileName} criada`
+            )))
+        }
+
+        await Promise.all(promises)
+    })
+;
+
+program.command('lib <libs...>')
+    .description('Cria uma config com e uma lib utilizando o templete da plata')
+    .action(async libs => {
+        if (!Array.isArray(libs)) {
+            return
+        }
+
+        const promises: any[] = []
+        
+        for (const lib of libs) {
+            promises.push(tools.files.deployFileToProject(
+                'configs',
+                'config',
+                `${lib}.ts`.toLowerCase(),
+                { Name: `${lib}`, name: `${lib}`.toLowerCase() }
+            ).finally(() => console.log(`Config ${lib} criada`)))
+
+            promises.push(tools.files.deployFileToProject(
+                'libs',
+                'lib',
+                `${lib}.ts`.toLowerCase(),
+                { Name: `${lib}`, name: `${lib}`.toLowerCase() }
+            ).finally(() => console.log(`Lib ${lib} criada`)))
+        }
+
+        await Promise.all(promises)
+    })
+;
+
+program.command('config <configs...>')
+    .description('Cria uma config utilizando o templete da plata')
+    .action(async configs => {
+        if (!Array.isArray(configs)) {
+            return
+        }
+
+        const promises: any[] = []
+        
+        for (const config of configs) {
+            promises.push(tools.files.deployFileToProject(
+                'configs',
+                'config',
+                `${config}.ts`.toLowerCase(),
+                { Name: `${config}`, name: `${config}`.toLowerCase() }
+            ).finally(() => console.log(`Config ${config} criada`)))
+        }
+
+        await Promise.all(promises)
+
+    })
+;
+
+program.command('model <models...>')
+    .description('Cria um model utilizando o templete da plata')
+    .action(async models => {
+        if (!Array.isArray(models)) {
+            return
+        }
+
         const promises: any[] = []
+        const plataName = PlataDirs.ProjectJson.plata_name
 
-        switch (command) {
-            case 'lib':
-                const nameLib = `${args.shift()}`
-                promises.push(tools.files.deployFileToProject(
-                    'configs',
-                    'config',
-                    `${nameLib}.ts`.toLowerCase(),
-                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
-                ).finally(() => console.log(`Config ${nameLib} criada`)))
-
-                promises.push(tools.files.deployFileToProject(
-                    'libs',
-                    'lib',
-                    `${nameLib}.ts`.toLowerCase(),
-                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
-                ).finally(() => console.log(`Lib ${nameLib} criada`)))
-            break;
-            case 'config':
-                const nameConfig = `${args.shift()}`
-                promises.push(tools.files.deployFileToProject(
-                    'configs',
-                    'config',
-                    `${nameConfig}.ts`.toLowerCase(),
-                    { Name: `${nameConfig}`, name: `${nameConfig}`.toLowerCase() }
-                ).finally(() => console.log(`Config ${nameConfig} criada`)))
-            break;
-            case 'cluster':
-                console.log('CLUSTER AINDA NÃO CRIANDO AINDA')
-            break;
-            case 'route':
-                const r = `${args.shift()}/`.replace(/:(.*?)(?:\/|$)/g, (_, parm) => {
-                    return parm[parm.length - 1] !== '?' ? `{${parm}}/` : `[${parm.slice(0, -1)}]/`
-                })
-
-                const routeArg = r.slice(0, -1).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`,
-                    { PlataName: `${PlataDirs.ProjectJson.plata_name}` }
-                ).finally(() => console.log(
-                    `Rota ${routeFilePath}/${routeFileName === 'index' ? '' : routeFileName} criada`
-                )))
-
-            break;
-            case 'model':
-                const modelName = `${args.shift()}`
-                const plataName = PlataDirs.ProjectJson.plata_name
-
-                promises.push(tools.files.deployFileToProject(
-                    'models',
-                    'model',
-                    `${modelName}.ts`.toLowerCase(),
-                    { Name: `${modelName}`, PlataName: `${plataName}` }
-                ).finally(() => console.log(`Model ${modelName} criada`)))
-            break;
+        for (const model of models) {
+            promises.push(tools.files.deployFileToProject(
+                'models',
+                'model',
+                `${model}.ts`.toLowerCase(),
+                { Name: `${model}`, PlataName: `${plataName}` }
+            ).finally(() => console.log(`Model ${model} criada`)))
         }
 
         await Promise.all(promises)
-        return args
     })
-}
+;
+
+program.command('task <tasks...>')
+    .description('Cria uma task utilizando o templete da plata')
+    .action(async tasks => {
+        if (!Array.isArray(tasks)) {
+            return
+        }
+
+        const promises: any[] = []
+        const plataName = PlataDirs.ProjectJson.plata_name
+
+        for (const task of tasks) {
+            promises.push(tools.files.deployFileToProject(
+                'tasks',
+                'task',
+                `${task}.ts`.toLowerCase(),
+                { Name: `${task}`, PlataName: `${plataName}` }
+            ).finally(() => console.log(`Task ${tasks} criada`)))
+        }
+
+        await Promise.all(promises)
+    })
+;
+
+export const cli = program

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

@@ -1,41 +1,109 @@
 import { tools } from "./plata-create-tools";
+import { PlataDirs } from "../../libs/tools"
+import { Command } from 'commander'
+
+const program = new Command()
+
+program.name('Plata Create cli')
+program.description('CLI usada para criar rotas, libs, models e muito mais na plata')
+program.version(PlataDirs.PlataJson.version)
+
+program.command('lib <libs...>')
+    .description('Cria uma config com e uma lib utilizando o templete da plata')
+    .action(async libs => {
+        if (!Array.isArray(libs)) {
+            return
+        }
+
+        const promises: any[] = []
+        
+        for (const lib of libs) {
+            promises.push(tools.files.deployFileToProject(
+                'configs',
+                'config',
+                `${lib}.ts`.toLowerCase(),
+                { Name: `${lib}`, name: `${lib}`.toLowerCase() }
+            ).finally(() => console.log(`Config ${lib} criada`)))
+
+            promises.push(tools.files.deployFileToProject(
+                'libs',
+                'lib',
+                `${lib}.ts`.toLowerCase(),
+                { Name: `${lib}`, name: `${lib}`.toLowerCase() }
+            ).finally(() => console.log(`Lib ${lib} criada`)))
+        }
+
+        await Promise.all(promises)
+    })
+;
+
+program.command('config <configs...>')
+    .description('Cria uma config utilizando o templete da plata')
+    .action(async configs => {
+        if (!Array.isArray(configs)) {
+            return
+        }
+
+        const promises: any[] = []
+        
+        for (const config of configs) {
+            promises.push(tools.files.deployFileToProject(
+                'configs',
+                'config',
+                `${config}.ts`.toLowerCase(),
+                { Name: `${config}`, name: `${config}`.toLowerCase() }
+            ).finally(() => console.log(`Config ${config} criada`)))
+        }
+
+        await Promise.all(promises)
+
+    })
+;
+
+program.command('model <models...>')
+    .description('Cria um model utilizando o templete da plata')
+    .action(async models => {
+        if (!Array.isArray(models)) {
+            return
+        }
+
+        const promises: any[] = []
+        const plataName = PlataDirs.ProjectJson.plata_name
+
+        for (const model of models) {
+            promises.push(tools.files.deployFileToProject(
+                'models',
+                'model',
+                `${model}.ts`.toLowerCase(),
+                { Name: `${model}`, PlataName: `${plataName}` }
+            ).finally(() => console.log(`Model ${model} criada`)))
+        }
+
+        await Promise.all(promises)
+    })
+;
+
+program.command('task <tasks...>')
+    .description('Cria uma task utilizando o templete da plata')
+    .action(async tasks => {
+        if (!Array.isArray(tasks)) {
+            return
+        }
 
-export async function h() {
-    return tools.args.forEachArg(async (command, args) => {
         const promises: any[] = []
+        const plataName = PlataDirs.ProjectJson.plata_name
 
-        switch (command) {
-            case 'lib':
-                const nameLib = args.shift()
-                promises.push(tools.files.deployFileToProject(
-                    'configs',
-                    'config',
-                    `${nameLib}.ts`.toLowerCase(),
-                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
-                ).finally(() => console.log(`Config ${nameLib} criada`)))
-
-                promises.push(tools.files.deployFileToProject(
-                    'libs',
-                    'lib',
-                    `${nameLib}.ts`.toLowerCase(),
-                    { Name: `${nameLib}`, name: `${nameLib}`.toLowerCase() }
-                ).finally(() => console.log(`Lib ${nameLib} criada`)))
-            break;
-            case 'config':
-                const nameConfig = args.shift()
-                promises.push(tools.files.deployFileToProject(
-                    'configs',
-                    'config',
-                    `${nameConfig}.ts`.toLowerCase(),
-                    { Name: `${nameConfig}`, name: `${nameConfig}`.toLowerCase() }
-                ).finally(() => console.log(`Config ${nameConfig} criada`)))
-            break;
-            case 'cluster':
-                console.log('CLUSTER AINDA NÃO CRIANDO AINDA')
-            break;
+        for (const task of tasks) {
+            promises.push(tools.files.deployFileToProject(
+                'tasks',
+                'task',
+                `${task}.ts`.toLowerCase(),
+                { Name: `${task}`, PlataName: `${plataName}` }
+            ).finally(() => console.log(`Task ${tasks} criada`)))
         }
 
         await Promise.all(promises)
-        return args
     })
-}
+;
+
+export const cli = program

package/bin/plata-create.ts

@@ -3,32 +3,26 @@ import { PlataDirs } from "../libs/tools"
 import * as PlataCreateApi from "./extras/plata-create-api"
 import * as PlataCreateLib from "./extras/plata-create-lib"
 
-interface Handler {
-    h: () => Promise<void>
-}
-
 const main = async () => {
-    const projectPackage = await PlataDirs.ProjectJson
+    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.h()
+            await PlataCreateApi.cli.parseAsync(process.argv)
         break;
         case 'lib':
-            await PlataCreateLib.h()
+            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.ts

@@ -1,5 +1,6 @@
 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'
@@ -21,6 +22,8 @@ const main = async () => {
             }
         }
 
+        await loadTasks()
+
         console.log(process.env.ENV)
 
         clusterLib.run({
@@ -56,6 +59,8 @@ const main = async () => {
             const port = process.env.PORT ?? 3050
             const app: Express = express()
 
+            app.disable('x-powered-by')
+
             app.use(process.env._PLATA_API_ROOT ?? '/api',await buildExpressRouter())
 
             app.use((err, _req, res, _next) => {                
@@ -97,7 +102,7 @@ const main = async () => {
                         PlataDirs.getProjectDir(),
                         process.env._PLATA_API_SSL_KEY
                     ))),
-                    // TODO :::: passphrase: 
+                    passphrase: process.env._PLATA_API_SSL_PASS
                 }, app)
 
                 https.listen(port, () => {

package/index.ts

@@ -3,6 +3,7 @@ import * as PlataEnv from './libs/env'
 import * as PlataRoutes from './libs/routes'
 import * as PlataTools from './libs/tools'
 import * as PlataModels from './libs/model'
+import * as PlataTasks from './libs/tasks'
 import { PlataSwagger } from './libs/swagger'
 
 export {
@@ -11,5 +12,6 @@ export {
     PlataRoutes,
     PlataTools,
     PlataModels,
-    PlataSwagger
+    PlataSwagger,
+    PlataTasks
 }

package/libs/axios.ts

@@ -0,0 +1,43 @@
+import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
+import { PlataExtra, PlataResultado } from './tools';
+
+export async function PlataAxios<T = any>(config: AxiosRequestConfig): Promise<PlataResultado<AxiosResponse<T>>> {
+    config.timeout = config.timeout ?? 1000
+
+    if (config.timeout === 0) {
+        return PlataAxiosUnsafe(config)
+    }
+
+    const axiosPromise = PlataAxiosUnsafe(config)
+    const timeoutPromise = PlataExtra.timeout(config.timeout, {
+        errorID: 'PLAX0003',
+        msg: 'API externa não respondeu'
+    })
+
+    return Promise.race([axiosPromise, timeoutPromise])
+}
+
+export async function PlataAxiosUnsafe<T = any>(config: AxiosRequestConfig): Promise<PlataResultado<AxiosResponse<T>>> {
+    return axios(config).then(
+        resp => resp,
+        err => {
+            if (err.response) {
+                return err.response
+            }
+
+            if (err.request) {
+                return {
+                    errorID: 'PLAX0001',
+                    msg: 'Erro ao se comunicar com API externa',
+                    error: err
+                }
+            }
+
+            return {
+                errorID: 'PLAX0002',
+                msg: 'Erro inesperado ao se comunicar com API externa',
+                error: err
+            }
+        }
+    )
+}

package/libs/tasks.ts

@@ -0,0 +1,157 @@
+import * as schedule from 'node-schedule'
+import { PlataResultado, PlataRequire, PlataDirs, PlataError } from './tools'
+
+export type TaskRule = schedule.RecurrenceRule | schedule.RecurrenceSpecDateRange | schedule.RecurrenceSpecObjLit | Date | string | number
+export type TaskCallback = (fireDate: Date) => Promise<PlataError | null>
+
+export interface PlataTask {
+    name: string
+    rule: TaskRule | null
+    onPlataStart: boolean
+    callback: TaskCallback
+}
+
+export interface StatusPlataTask extends PlataTask {
+    lastRun: Date | null
+    lastReturn: PlataError | null
+}
+
+export interface PlataTasksProcess {
+    tasks: StatusPlataTask[]
+}
+
+export interface _PlataTasksProcess extends NodeJS.Process {
+    _plata?: PlataTasksProcess
+}
+
+export function getTasksNodeProcess(): PlataTasksProcess {
+    const p = process as _PlataTasksProcess
+
+    if (p._plata === undefined) {
+        p._plata = {
+            tasks: []
+        }
+    }
+
+    if (p._plata.tasks === undefined) {
+        p._plata.tasks = []
+    }
+
+    return p._plata
+}
+
+export function buildTaskCallBack(task: PlataTask): schedule.JobCallback {
+    return async (fireDate: Date) => {
+        let status: PlataError | null = null
+        const data = new Date()
+
+        const promise = task.callback(fireDate).then(
+            s => status = s,
+            err => status = {
+                errorID: 'PBT0001',
+                msg: `Erro ao rodar a task ${task.name}`,
+                error: err
+            }
+        )
+
+        const i = getTasksNodeProcess().tasks.findIndex(v => v.name === task.name)
+
+        await promise
+
+        if (i !== -1) {
+            getTasksNodeProcess().tasks[i].lastReturn = status
+            getTasksNodeProcess().tasks[i].lastRun = data
+        }
+    }
+}
+
+export async function buildTask(task: PlataTask): Promise<schedule.Job | null> {
+    if (task.onPlataStart) {
+        let status: PlataError | null = null
+        
+        try{
+            status = await task.callback(new Date())
+        } catch (e) {
+            status = {
+                errorID: 'PBT0002',
+                msg: `Erro ao rodar a task ${task.name}`,
+                error: e
+            }
+        }
+
+        getTasksNodeProcess().tasks.push({
+            ...task,
+            lastRun: new Date(),
+            lastReturn: status                
+        })
+    } else {
+        getTasksNodeProcess().tasks.push({
+            ...task,
+            lastRun: null,
+            lastReturn: null                
+        })
+    }
+
+    if (task.rule === null) {
+        return null
+    }
+
+    return schedule.scheduleJob(task.rule as any, buildTaskCallBack(task))
+}
+
+export async function loadTasks(): Promise<PlataResultado<schedule.Job[]>> {
+    const tasks: schedule.Job[] = []
+
+    const task = await PlataRequire.requireFolderAsync<PlataTask>(
+        PlataDirs.getProjectDirTasks()
+    )
+
+    if (task.errorID !== undefined) {
+        return task
+    }
+
+    for (const t of task) {
+        if (t.errorID !== undefined) {
+            return t
+        }
+        const j = await buildTask(t.exports)
+
+        if (j !== null) tasks.push(j)
+    }
+
+    return tasks
+}
+
+export async function callTask(name: string): Promise<PlataError | null> {
+    const i = getTasksNodeProcess().tasks.findIndex(v => v.name === name)
+
+    if (i === -1) {
+        return {
+            errorID: 'PBT0003',
+            msg: `Task: ${name} não existe`,
+        }
+    }
+
+    const data = new Date()
+
+    return getTasksNodeProcess().tasks[i].callback(data).then(
+        status => {
+            getTasksNodeProcess().tasks[i].lastReturn = status
+            getTasksNodeProcess().tasks[i].lastRun = data
+
+            return status
+        },
+        err => {
+            const status = {
+                errorID: 'PBT0004',
+                msg: `Erro ao rodar a task ${name}`,
+                error: err
+            }
+
+            getTasksNodeProcess().tasks[i].lastReturn = status
+            getTasksNodeProcess().tasks[i].lastRun = data
+
+            return status
+        }
+    )
+}

package/libs/tools.ts

@@ -18,6 +18,10 @@ export namespace PlataDirs {
         return path.resolve('.')
     }
 
+    export function getProjectDirTasks(): string {
+        return path.resolve('.', 'tasks')
+    }
+
     export function getProjectDirSwagger(): string {
         return path.resolve('.', 'swagger')
     }
@@ -59,7 +63,13 @@ export namespace PlataDirs {
     export function getPlataDir(): string {    
         return path.resolve('.', 'node_modules', ProjectJson.plata_name)
     }
-    
+
+    export const PlataJson: any = JSON.parse(
+        fs.readFileSync(
+            path.join(PlataDirs.getPlataDir(), 'package.json')
+        ).toString()
+    )
+
     export function getPlataTempletesDir(): string {
         return path.join(getPlataDir(), 'templates')
     }
@@ -236,7 +246,11 @@ export namespace PlataRequire {
 }
 
 export namespace PlataExtra {
-    export function Sleep(ms: number) {
+    export function sleep(ms: number) {
         return new Promise(resolve => setTimeout(resolve, ms))
     }
+
+    export function timeout(ms: number, error: PlataError): Promise<PlataError> {
+        return new Promise((_, reject) => setTimeout(() => reject(error), ms))
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pwi-plata-type",
-    "version": "0.3.6",
+    "version": "0.3.9",
     "main": "index.ts",
     "bin": {
         "plata": "bin/plata.ts",
@@ -19,13 +19,17 @@
         "@types/express": "^4.17.13",
         "@types/glob": "^7.2.0",
         "@types/jest": "^28.1.1",
+        "@types/node-schedule": "^2.1.0",
         "@types/swagger-ui-express": "^4.1.3",
+        "axios": "^0.27.2",
+        "commander": "^9.4.0",
+        "express": "^4.18.1",
         "glob": "^8.0.3",
         "jest": "^28.1.1",
+        "node-schedule": "^2.1.0",
         "swagger-ui-express": "^4.4.0",
         "ts-jest": "^28.0.4",
         "ts-node": "^10.9.1",
-        "express": "^4.18.1",
         "tsconfig-paths": "^4.0.0"
     },
     "description": "",

package/templates/create-cli/lib.ts

@@ -9,11 +9,15 @@ export class ç__Name__ç {
     }
 }
 
+export function newç__Name__ç(config: typeof ç__Name__çConfig.default): ç__Name__ç {
+    return new ç__Name__ç(ç__Name__çConfig.default)
+}
+
 export function getç__Name__ç(): ç__Name__ç {
     const p = process as any
 
     if (p._plata._libç__Name__ç === undefined) {
-        p._plata._libç__Name__ç = new ç__Name__ç(ç__Name__çConfig.default)
+        p._plata._libç__Name__ç = newç__Name__ç(ç__Name__çConfig.default)
     }
 
     return p._plata._libç__Name__ç

package/templates/create-cli/task.ts

@@ -0,0 +1,13 @@
+//@ts-nocheck
+import { PlataTasks, PlataTools } from "ç__PlataName__ç"
+
+async function main(fireDate: Date): Promise<PlataTools.PlataError | null> {
+    return null
+}
+
+export default {
+    name: '',
+    rule: null, // https://crontab.guru/
+    onPlataStart: false,
+    callback: main
+} as PlataTasks.PlataTask

package/templates/postinstall/api/_install.mjs

@@ -10,6 +10,7 @@ export async function install({ dirs, projectPackageJson }) {
     promises.push(t.createFolderProject('routes'))
     promises.push(t.createFolderProject('libs'))
     promises.push(t.createFolderProject('models'))
+    promises.push(t.createFolderProject('tasks'))
 
     promises.push(t.copyFolderToProject('configs'))
     promises.push(t.copyFolderToProject('envs'))

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

@@ -8,4 +8,5 @@ PORT=3050
 _PLATA_API_ROOT=/api
 _PLATA_API_SSL_KEY=
 _PLATA_API_SSL_CERT=
+_PLATA_API_SSL_PASS=
 _PLATA_API_JSON_SIZE=100kb

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

@@ -9,4 +9,5 @@ PORT=3050
 _PLATA_API_ROOT=/api
 _PLATA_API_SSL_KEY=
 _PLATA_API_SSL_CERT=
+_PLATA_API_SSL_PASS=
 _PLATA_API_JSON_SIZE=100kb

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

@@ -9,4 +9,5 @@ PORT=3050
 _PLATA_API_ROOT=/api
 _PLATA_API_SSL_KEY=
 _PLATA_API_SSL_CERT=
+_PLATA_API_SSL_PASS=
 _PLATA_API_JSON_SIZE=100kb

package/templates/postinstall/lib/_install.mjs

@@ -9,7 +9,7 @@ export async function install({ dirs, projectPackageJson }) {
     promises.push(t.createFolderProject('clusters'))
     promises.push(t.createFolderProject('routes'))
     promises.push(t.createFolderProject('libs'))
-
+    promises.push(t.createFolderProject('tasks'))
     promises.push(t.createFolderProject('configs'))
     promises.push(t.createFolderProject('bin'))
 

package/templates/postinstall/lib/postinstall.js

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