pwi-plata-type 0.3.4 → 0.3.7

package/Dockerfile

@@ -1,18 +1,13 @@
-FROM node:16-alpine AS build
+FROM node:16-alpine
 
 WORKDIR /usr/src/app
 
-COPY . ./
-
-RUN npm ci --only=production && \
-    npm run build
-
-FROM node:16-alpine AS bin
+COPY package*.json ./
 
 EXPOSE 3050
 
-WORKDIR /usr/src/app
+RUN npm ci --only=production
 
-COPY --from=build /usr/src/app/build .
+COPY . ./
 
 CMD [ "npm", "start" ]

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

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
-import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../../libs/tools.js';
+import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../../libs/tools';
 
 export namespace tools {
     export interface ProcessExit {
@@ -14,7 +14,8 @@ export namespace tools {
         return new Promise((resolve) => {
             try {
                 const p = spawn(command, args, {
-                    cwd: cwd
+                    cwd: cwd,
+                    shell: true
                 })
 
                 let stdout, stderr = ''

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

@@ -1,74 +1,144 @@
-import { tools } from "./plata-create-tools.js";
-import { PlataDirs } from "../../libs/tools.js"
+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.js";
+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/extras/plata-create-tools.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 
-import { PlataDirs, PlataFiles } from '../../libs/tools.js'
+import { PlataDirs, PlataFiles } from '../../libs/tools'
 
 export namespace tools {
     export namespace files {

package/bin/plata-build.ts

@@ -1,5 +1,5 @@
-import { tools } from './extras/plata-build-tool.js'
-import { PlataResultado, PlataDirs } from '../libs/tools.js'
+import { tools } from './extras/plata-build-tool'
+import { PlataResultado, PlataDirs } from '../libs/tools'
 
 const main = async () => {
     // Prepara o JSONs

package/bin/plata-create.ts

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

package/bin/plata-reload.ts

@@ -0,0 +1,13 @@
+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()

package/bin/plata-swagger-gen.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import fs from 'node:fs'
-import { buildExpressRouter } from '../libs/routes.js'
-import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../libs/tools.js'
+import { buildExpressRouter } from '../libs/routes'
+import { PlataResultado, PlataDirs, PlataFiles, PlataError } from '../libs/tools'
 
 interface dumpParameter { 
     name: string,
@@ -142,6 +142,9 @@ async function dumpRotas(): Promise<dumpRoute[]> {
 }
 
 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()
 

package/bin/plata.ts

@@ -1,10 +1,11 @@
-import { PlataClusterManager, PlataClusterMsg } from "../libs/cluster.js"
-import { loadEnvProjectFile } from "../libs/env.js"
-import { buildExpressRouter } from "../libs/routes.js"
+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.js"
+import { PlataDirs } from "../libs/tools"
 import path from 'node:path'
 
 const main = async () => {
@@ -21,6 +22,8 @@ const main = async () => {
             }
         }
 
+        await loadTasks()
+
         console.log(process.env.ENV)
 
         clusterLib.run({

package/index.ts

@@ -1,9 +1,10 @@
-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'
-import * as PlataModels from './libs/model.js'
-import { PlataSwagger } from './libs/swagger.js'
+import * as PlataCluster from './libs/cluster'
+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 {
     PlataCluster,
@@ -11,5 +12,6 @@ export {
     PlataRoutes,
     PlataTools,
     PlataModels,
-    PlataSwagger
+    PlataSwagger,
+    PlataTasks
 }

package/libs/cluster.ts

@@ -1,4 +1,4 @@
-import { PlataRequire, PlataDirs, PlataFiles } from './tools.js'
+import { PlataRequire, PlataDirs, PlataFiles } from './tools'
 import { cpus } from 'node:os'
 import * as typeCluster from 'node:cluster'
 
@@ -153,14 +153,14 @@ export class PlataClusterManager {
             [
                 PlataDirs.getProjectDirClusters()
             ],
-            `${process.env["_plata_name"]}.ts`
+            `${process.env["_plata_name"]}`
         ).catch(err => {
             console.error(err)
             return null
         })
 
         if (file !== null) {
-            const config: PlataClusterWorkerConfig = (await import(`file:///${file}`.replace(/\\/g, '/'))).default
+            const config: PlataClusterWorkerConfig = (await import(file.replace(/\\/g, '/'))).default
 
             await config.onStart()
         }

package/libs/env.ts

@@ -1,4 +1,4 @@
-import { PlataDirs, PlataFiles } from "./tools.js"
+import { PlataDirs, PlataFiles } from "./tools"
 
 export interface EnvConfig {
     readonly env: 'prod' | 'debug' | 'homolog' | string
@@ -6,7 +6,7 @@ export interface EnvConfig {
 
 export async function loadEnvProjectFile() {
     const config = process.env['ENV'] === undefined ? 
-        (await import(PlataDirs.getProjectConfigFileDir('env.js'))).default as EnvConfig
+        (await import(PlataDirs.getProjectConfigFileDir('env'))).default as EnvConfig
         : { env: process.env['ENV'] }
 
     return PlataFiles.readFileAsync(

package/libs/model.ts

@@ -1,4 +1,4 @@
-import { PlataError } from "./tools.js"
+import { PlataError } from "./tools"
 
 export interface RetornoValidacaoPrimitivo {
     error?: PlataError
@@ -442,7 +442,7 @@ export function Telefone(): ModelValicacaoPrimitivo {
             }
         }
 
-        if (v[0].length !== 2 || v[1].length > 9) {
+        if (v[0].length !== 2 || (v[1].length !== 8 && v[1].length !== 9)) {
             return {
                 error: {
                     errorID: "BPVTEL002",
@@ -481,7 +481,7 @@ export function TelefoneDDI(): ModelValicacaoPrimitivo {
             }
         }
 
-        if (telefone[0].length !== 2 || telefone[1].length > 9) {
+        if (telefone[0].length !== 2 || (telefone[1].length !== 8 && telefone[1].length !== 9)) {
             return {
                 error: {
                     errorID: "BPVTELD002",

package/libs/routes.ts

@@ -1,5 +1,5 @@
 import path from 'node:path'
-import { PlataDirs, PlataRequire, PlataError } from "./tools.js";
+import { PlataDirs, PlataRequire, PlataError } from "./tools";
 import express, { Router } from "express";
 
 export const HttpMethodsArray = [
@@ -206,7 +206,7 @@ export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
         r = r.map(route => {
             route.httpRoute = route.filePath
                 .replace(PlataDirs.getProjectRoutesDir(), '')
-                .replace(/.(ts|js)$/, '')
+                .replace(/\.ts|\.js$/, '')
                 .replace(/index/, '')
                 .replace(/\\/g, '/')
                 .replace(/\{(.*?)\}/g, ':$1')
@@ -239,7 +239,7 @@ export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
 export async function buildExpressRouter(): Promise<_Router> {
     const router = Router() as _Router
     router._routes = []
-    router.use(express.json())
+    router.use(express.json({ limit: process.env._PLATA_API_JSON_SIZE ?? '100kb' }))
 
     const routes = await loadExpressRoutes()
 

package/libs/swagger.ts

@@ -1,7 +1,7 @@
 import swaggerUi from 'swagger-ui-express'
 import path from 'node:path'
-import { PlataRouterBuilder, PlataRequestHandler } from './routes.js';
-import { PlataFiles, PlataDirs } from "./tools.js";
+import { PlataRouterBuilder, PlataRequestHandler } from './routes';
+import { PlataFiles, PlataDirs } from "./tools";
 
 export namespace PlataSwagger {
     export const swagger: PlataRouterBuilder = async (router) => {

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')
     }
@@ -35,7 +39,7 @@ export namespace PlataDirs {
     }
 
     export function getProjectConfigFileDir(file: string): string {
-        return `file:///${path.resolve('.', 'configs', file)}`.replace(/\\/g, '/')
+        return path.resolve('.', 'configs', file).replace(/\\/g, '/')
     }
 
     export function getProjectDirEnvs(): string {
@@ -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')
     }
@@ -69,7 +79,7 @@ export namespace PlataDirs {
     }
 
     export function getPlataBinExtraFile(file: string): string {
-        return `file:///${path.join(getPlataDir(), 'bin', 'extras', file)}`.replace(/\\/g, '/')
+        return `${path.join(getPlataDir(), 'bin', 'extras', file)}`.replace(/\\/g, '/')
     }
 
 }
@@ -194,7 +204,7 @@ export namespace PlataRequire {
     export async function requireAsync<Type>(file: string): Promise<Required<Type>> {
         const p = path.resolve(file)
 
-        const e = await import(`file:///${p}`.replace(/\\/g, '/')).catch(e => { return {_plataError: e }  })
+        const e = await import(p.replace(/\\/g, '/')).catch(e => { return {_plataError: e }  })
 
         if (e._plataError !== undefined) {
             return {
@@ -218,7 +228,7 @@ export namespace PlataRequire {
         glob.sync(`${p.replace(/\\/g, '/')}/**/*.+(js|ts)`)
             .filter(file => !file.endsWith('.d.ts'))
             .forEach(file => {
-                file = file.replace('.ts', '.js')
+                file = file.replace(/\.ts|\.js$/, '')
 
                 promises.push(requireAsync<Type>(file))
             })

package/package.json

@@ -1,30 +1,35 @@
 {
     "name": "pwi-plata-type",
-    "version": "0.3.4",
-    "type": "module",
+    "version": "0.3.7",
     "main": "index.ts",
     "bin": {
         "plata": "bin/plata.ts",
         "plata-cli-create": "bin/plata-create.ts",
-        "plata-swagger-gen": "bin/plata-swagger-gen.ts"
+        "plata-swagger-gen": "bin/plata-swagger-gen.ts",
+        "plata-reload": "bin/plata-reload.ts"
     },
     "scripts": {
-        "postinstall": "node postinstall.js"
+        "postinstall": "node postinstall.mjs"
     },
     "keywords": [],
     "author": "",
     "license": "UNLICENSED",
     "dependencies": {
+        "@swc/core": "^1.2.218",
         "@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",
+        "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.8.2",
-        "express": "^4.18.1"
+        "ts-node": "^10.9.1",
+        "tsconfig-paths": "^4.0.0"
     },
     "description": "",
     "devDependencies": {

package/{postinstall.js → postinstall.mjs}

@@ -15,6 +15,10 @@ const main = async () => {
     projectPackageJson.plata_type = projectPackageJson.plata_type ?? 'api'
     projectPackageJson.plata_name = plataPackageJson.name
     projectPackageJson.license = "UNLICENSED"
+    projectPackageJson['scripts_plata'] = projectPackageJson['scripts_plata'] ?? new Object(null)
+
+    // https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy
+    projectPackageJson.scripts = JSON.parse(JSON.stringify(projectPackageJson['scripts_plata']))
 
     const templateDir = path.join(templatesDir, projectPackageJson.plata_type)
 

package/templates/create-cli/lib.ts

@@ -1,5 +1,5 @@
 //@ts-nocheck
-import * as ç__Name__çConfig from '../configs/ç__name__ç.js'
+import * as ç__Name__çConfig from '@Configs/ç__name__ç'
 
 export class ç__Name__ç {
     private readonly config: typeof ç__Name__çConfig.default

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/Dockerfile

@@ -1,18 +1,13 @@
-FROM node:16-alpine AS build
+FROM node:16-alpine
 
 WORKDIR /usr/src/app
 
-COPY . ./
-
-RUN npm ci --only=production && \
-    npm run build
-
-FROM node:16-alpine AS bin
+COPY package*.json ./
 
 EXPOSE 3050
 
-WORKDIR /usr/src/app
+RUN npm ci --only=production
 
-COPY --from=build /usr/src/app/build .
+COPY . ./
 
 CMD [ "npm", "start" ]

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'))
@@ -18,13 +19,12 @@ export async function install({ dirs, projectPackageJson }) {
     promises.push(t.copyFileToProject('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/${projectPackageJson.plata_name}/bin/plata`
-    projectPackageJson.scripts.build = `npx tsc && ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata-build --`
-    projectPackageJson.scripts.create = `ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata-create --`
+    projectPackageJson.scripts.start = `ts-node -P ./tsconfig.json ./node_modules/${projectPackageJson.plata_name}/bin/plata`
+    projectPackageJson.scripts.build = `npx tsc && ts-node -P ./tsconfig.json ./node_modules/${projectPackageJson.plata_name}/bin/plata-build --`
+    projectPackageJson.scripts.create = `ts-node -P ./tsconfig.json ./node_modules/${projectPackageJson.plata_name}/bin/plata-create --`
     projectPackageJson.scripts.dev = "npx nodemon -e '.js,.mjs,.json,.ts' --exec 'npm start'"
-    projectPackageJson.scripts['swagger:gen'] = `ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata-swagger-gen`
+    projectPackageJson.scripts['swagger:gen'] = `ts-node -P ./tsconfig.json ./node_modules/${projectPackageJson.plata_name}/bin/plata-swagger-gen`
+    projectPackageJson.scripts['plata:reload'] = `ts-node -P ./tsconfig.json ./node_modules/${projectPackageJson.plata_name}/bin/plata-reload.ts`
     projectPackageJson.main = undefined
 
     await Promise.all(promises)

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

@@ -7,4 +7,5 @@ ENV=debug
 PORT=3050
 _PLATA_API_ROOT=/api
 _PLATA_API_SSL_KEY=
-_PLATA_API_SSL_CERT=
+_PLATA_API_SSL_CERT=
+_PLATA_API_JSON_SIZE=100kb

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

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

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

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

package/templates/postinstall/api/tsconfig.json

@@ -1,16 +1,40 @@
 {
+    "ts-node": {
+        "transpileOnly": true,
+        "swc": true,
+        "esm": false,
+        "project": "./tsconfig.json",
+        "skipIgnore": true,
+        "require": [
+          "tsconfig-paths/register"
+        ],
+        "compilerOptions": {
+            "module": "CommonJS"
+        }
+    },
     "compilerOptions": {
-        "strictNullChecks": true,
-        "module": "es2022",
-        "target": "es2022",
-        "declaration": false,
-        "sourceMap": false,
-        "esModuleInterop": true,
-        "outDir": "build",
-        "moduleResolution": "node"
+      "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*/**/*.ts"
+        "./node_modules/pwi-plata-type/**/*.ts"
     ]
 }

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'))
 
@@ -18,10 +18,10 @@ export async function install({ dirs, projectPackageJson }) {
     promises.push(t.syncFileToProject('tsconfig.json'))
 
     projectPackageJson.type = "module"
-    projectPackageJson.scripts = new Object(null)
-    projectPackageJson.scripts.dev = "ts-node"
+    projectPackageJson.scripts.dev = "ts-node -P ./tsconfig.json"
     projectPackageJson.scripts.postinstall = "node postinstall.js"
-    projectPackageJson.scripts.create = `ts-node --transpile-only --esm ./node_modules/${projectPackageJson.plata_name}/bin/plata-create --`
+    projectPackageJson.scripts.create = `ts-node -P ./tsconfig.json ./node_modules/${projectPackageJson.plata_name}/bin/plata-create --`
+    projectPackageJson.scripts['plata:reload'] = `ts-node -P ./tsconfig.json ./node_modules/${projectPackageJson.plata_name}/bin/plata-reload.ts`
     projectPackageJson.main = undefined
 
     await Promise.all(promises)

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)
 }

package/templates/postinstall/lib/tsconfig.json

@@ -1,16 +1,40 @@
 {
-    "compilerOptions": {
-        "strictNullChecks": true,
-        "module": "es2022",
-        "target": "es2022",
-        "declaration": false,
-        "sourceMap": false,
-        "esModuleInterop": true,
-        "outDir": "build",
-        "moduleResolution": "node"
-    },
-    "include": [
-        "./**/*.ts",
-        "node_modules/pwi-plata*/**/*.ts"
-    ]
+  "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"
+  ]
 }

package/tsconfig.json

@@ -1,16 +1,40 @@
 {
+    "ts-node": {
+        "transpileOnly": true,
+        "swc": true,
+        "esm": false,
+        "project": "./tsconfig.json",
+        "skipIgnore": true,
+        "require": [
+          "tsconfig-paths/register"
+        ],
+        "compilerOptions": {
+            "module": "CommonJS"
+        }
+    },
     "compilerOptions": {
-        "strictNullChecks": true,
-        "module": "es2022",
-        "target": "es2022",
-        "declaration": false,
-        "sourceMap": false,
-        "esModuleInterop": true,
-        "outDir": "build",
-        "moduleResolution": "node"
+      "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*/**/*.ts"
+        "./node_modules/pwi-plata-type/**/*.ts"
     ]
 }