pwi-plata-type 0.3.17 → 0.4.0

package/src/libs/router.ts

@@ -0,0 +1,147 @@
+import path from 'node:path'
+import express, { Router } from 'express'
+
+export namespace Internals {
+    export function buildRouterObject(): Router.Router {
+        const router: Router.RouterConfig = {
+            routes: [],
+            swaggerHide: false
+        }
+
+        return new Proxy(router, {
+            get: (targetRouter, prop) => {
+                if (targetRouter[prop] !== undefined) {
+                    return targetRouter[prop]
+                }
+
+                if (prop === 'then') {
+                    return targetRouter
+                }
+
+                return (httpPathOrHandler: string | Router.RequestHandler, ...handlers: Router.RequestHandler[]) => {
+                    let httpPath: string | undefined = undefined
+
+                    if (typeof httpPathOrHandler === 'string') {
+                        httpPath = httpPathOrHandler
+                    } else {
+                        handlers = [ httpPathOrHandler, ...handlers ]
+                    }
+                    
+                    targetRouter.routes.push({
+                        method: prop.toString(),
+                        handlers,
+                        path: httpPath
+                    })
+                } 
+            },
+
+            set: (targetRouter, prop, value) => {
+                if (targetRouter[prop] !== undefined) {
+                    targetRouter[prop] = value
+                }
+
+                return true
+            }
+        }) as  Router.Router
+    }
+
+    export function buildRequestHandler(r: Router.RequestHandler): express.RequestHandler {
+        return async (req, res, next) => {
+            const aReq = req as Router.Request
+            const aRes = res as Router.Response
+
+            if (aReq.user === undefined) {
+                aReq.user = new Object(null)
+            }
+
+            if (aReq.extras === undefined) {
+                aReq.extras = new Object(null)
+            }
+
+            if (aRes.oldJson === undefined) {
+                aRes.oldJson = aRes.json
+            }
+
+            aRes.error = error => {
+                return aRes.oldJson(error)
+            }
+
+            return r(aReq, aRes, next)
+        }
+    }
+}
+
+export async function loadRoutesFromProject(): PlataPromise<Router.RequiredRoute[]> {
+    const routes: RequiredFolder<{default: Router.RouterBuilder}> = await require('@@/routes/*.*')
+
+    if (routes.errorID !== undefined) {
+        return routes
+    }
+
+    let rs = routes.map(route => {
+        const r: Router.RequiredRoute = {
+            ...route,
+            exports: route.exports.default,
+            httpRoute: path.normalize(route.filePath
+                .replace('__BUILD__', '')
+                .replace(Plata.ProjectDir, '')
+                .replace('routes', '')
+                .replace(/(\.ts|\.js)$/, '')
+                .replace(/index/, '')
+                .replace(/\{(.*?)\}/g, ':$1')
+                .replace(/\[(.*?)\]/g, ':$1?')
+            ).replace(/\\/g, '/'),
+        }
+
+        return r
+    })
+
+    rs = rs.sort((x, y) => {
+        if (x.name === 'index') {
+            if (y.name === 'index') {
+                return +(x.httpRoute.length > y.httpRoute.length)
+            }
+
+            return -1
+        } 
+
+        return +(x.name > y.name)
+    })
+
+    return rs
+}
+
+export async function buildExpressRouter(requiredRoutes: Router.RequiredRoute[]): PlataPromise<Router.Router> {
+    const router = Router() as any as Router.Router
+
+    router.routes = []
+    router.swaggerHide = false
+
+    for (const r of requiredRoutes) {
+        const v = await r.exports(Internals.buildRouterObject())
+
+        const routes = v.routes
+        const swaggerHide = v.swaggerHide
+
+        for (let i = 0; i < routes.length; i++) {
+            const route = routes[i]
+
+            let httpPath = r.httpRoute
+
+            if (route.path !== undefined) {
+                httpPath = path.normalize(`${httpPath}/${route.path}`).replace(/\\/g, '/')
+            }
+
+            router[route.method](httpPath, ...route.handlers.map(Internals.buildRequestHandler))
+
+            router.routes.push({
+                path: httpPath,
+                method: route.method,
+                handlers: [],
+                swaggerHide: swaggerHide
+            })
+        }
+    }
+
+    return router
+}

package/src/libs/swagger.ts

@@ -0,0 +1,81 @@
+import swaggerUi from 'swagger-ui-express'
+import path from 'node:path'
+
+export namespace Internals {
+    export async function loadSwaggerConfig(): Promise<any> {
+        const obj = require('@@/swagger/header.json')
+
+        obj.paths = new Object(null)
+
+        const swaggerFolder = path.join(
+            Plata.ProjectDir, '__BUILD__', 'swagger', 'routes'
+        ).replace(/\\/g, '/')
+
+        // build routes
+        {
+            const routes = await Plata.files.FindFiles([ swaggerFolder ], 'header.json')
+
+            for (const route of routes) {
+                const docPath = path.normalize(path.dirname(route))
+                const method = path.normalize(path.basename(docPath))
+                const httpPath = path.normalize(
+                    path.dirname(docPath.replace(swaggerFolder, ''))
+                ).replace(/\\/g, '/')
+
+                const header = require(path.join(docPath, 'header.json'))
+                const body = require(path.join(docPath, 'body.json'))
+                const response = require(path.join(docPath, 'response.json'))
+
+                if (obj.paths[httpPath] === undefined) {
+                    obj.paths[httpPath] = new Object(null)
+                }
+
+                obj.paths[httpPath][method] = { ...header, responses: response }
+
+                //https://bobbyhadz.com/blog/javascript-check-if-object-is-empty
+                if (Object.keys(body).length !== 0) {
+                    if (!Array.isArray(obj.paths[httpPath][method].parameters)) {
+                        obj.paths[httpPath][method].parameters = []
+                    }
+
+                    const swaggerRouteBody = {
+                        name: "body",
+                        description: body.description,
+                        in: "body",
+                        schema: {
+                            type: body.type ?? "object",
+                        }
+                    } as any
+
+                    if (swaggerRouteBody.schema.type === 'array') {
+                        swaggerRouteBody.schema.items = {
+                            example: body.example
+                        }
+                    } else {
+                        swaggerRouteBody.schema.properties = body.example
+                    }
+
+                    obj.paths[httpPath][method].parameters.push(swaggerRouteBody)
+                }
+            }
+        }
+
+        return obj
+    }
+}
+
+export const swagger: Router.RouterBuilder = async (router) => {
+    router.swaggerHide = true
+
+    if (Plata.config._PLATA_WORKER_NAME === '__PLATA_EXPRESS__') {
+        router.use(
+            swaggerUi.serve as any,
+            swaggerUi.setup(
+                await Internals.loadSwaggerConfig(),
+                {}
+            ) as any
+        )
+    }
+
+    return router
+} 

package/{libs → src/libs}/tools.ts

@@ -2,6 +2,7 @@ import path from 'node:path'
 import fs from 'node:fs'
 import readline from 'node:readline'
 import * as tGlob from 'glob'
+// TODO matar esse aquivo e usar o PlataFS
 
 const glob = (tGlob as any).default as typeof tGlob
 
@@ -54,24 +55,8 @@ export namespace PlataDirs {
         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 const PlataJson: any = JSON.parse(
-        fs.readFileSync(
-            path.join(PlataDirs.getPlataDir(), 'package.json')
-        ).toString()
-    )
-
     export function getPlataTempletesDir(): string {
-        return path.join(getPlataDir(), 'templates')
+        return path.join(Plata.PlataDir, 'templates')
     }
 
     export function getPlataTempleteDir(group:string, ...template: string[]) {
@@ -79,7 +64,7 @@ export namespace PlataDirs {
     }
 
     export function getPlataBinExtraFile(file: string): string {
-        return `${path.join(getPlataDir(), 'bin', 'extras', file)}`.replace(/\\/g, '/')
+        return `${path.join(Plata.ProjectJson, 'bin', 'extras', file)}`.replace(/\\/g, '/')
     }
 
 }

package/src/scripts/post-install/api.ts

@@ -0,0 +1,32 @@
+import { PlataFs } from "++/libs/fs"
+
+export async function install(tools: PlataFs.CliTools, projectPackageJson: any) {
+    const promises: Promise<void>[] = []
+
+    promises.push(tools.createFolderToDest('clusters'))
+    promises.push(tools.createFolderToDest('routes'))
+    promises.push(tools.createFolderToDest('libs'))
+    promises.push(tools.createFolderToDest('models'))
+    promises.push(tools.createFolderToDest('tasks'))
+    promises.push(tools.createFolderToDest('@types'))
+
+    promises.push(tools.copyFolderToDest('configs'))
+    promises.push(tools.copyFolderToDest('envs'))
+    promises.push(tools.syncFolder('.vscode'))
+
+    promises.push(tools.copyFileToDest('Dockerfile'))
+    promises.push(tools.copyFileToDest('tsconfig.json'))
+
+    projectPackageJson.scripts.start = 'plata-runtime + plata-api'
+    projectPackageJson.scripts.create = 'plata-runtime + plata-create'
+    //projectPackageJson.scripts.dev = "npx nodemon -e '.js,.mjs,.json,.ts' --exec npm run debug"
+    //projectPackageJson.scripts.debug = 'tsc --sourceMap=true -p . && plata'
+    projectPackageJson.scripts['gen:swagger'] = 'plata-runtime + 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)
+
+    return projectPackageJson
+
+}

package/src/scripts/post-install/lib.ts

@@ -0,0 +1,30 @@
+import { PlataFs } from "++/libs/fs"
+
+export async function install(tools: PlataFs.CliTools, projectPackageJson: any) {
+    const promises: Promise<void>[] = []
+
+    promises.push(tools.createFolderToDest('clusters'))
+    promises.push(tools.createFolderToDest('libs'))
+    promises.push(tools.createFolderToDest('tasks'))
+    promises.push(tools.createFolderToDest('@types'))
+    promises.push(tools.createFolderToDest('bin'))
+
+    promises.push(tools.copyFolderToDest('configs'))
+    promises.push(tools.copyFolderToDest('envs'))
+    promises.push(tools.syncFolder('.vscode'))
+
+    promises.push(tools.syncFileToDest('postinstall.js')) // TODO :: compilar esse cara ou colocar como um bin na plata mesmo
+    promises.push(tools.syncFileToDest('postinstall-tools.mjs'))
+    promises.push(tools.syncFileToDest('tsconfig.json'))
+
+    projectPackageJson.type = "module"
+    projectPackageJson.scripts.create = 'plata-runtime + plata-create'
+    projectPackageJson.scripts.postinstall = "node postinstall.js"
+
+    projectPackageJson.main = undefined
+
+    await Promise.all(promises)
+
+    return projectPackageJson
+
+}

package/src/scripts/post-install.ts

@@ -0,0 +1,65 @@
+import { PlataFs } from '../libs/fs'
+import path from 'node:path'
+
+const main = async () => {
+    const plataDir = path.resolve('.')
+
+    if (path.basename(path.dirname(plataDir)) !== 'node_modules') return
+
+    const templatesDir = path.resolve(plataDir, 'templates', 'postinstall')
+    const projectDir = path.resolve(plataDir, '..', '..')
+
+    // read Plata and project package.json
+    let projectPackageJson: Dictionary<string | number | null | boolean | Object | undefined> = {} 
+    let plataPackageJson: Dictionary<string | number | null | boolean | Object | undefined> = {}
+
+    {
+        const promises: Promise<void>[] = []
+
+        promises.push(Promise.resolve().then( () =>
+            PlataFs.fs.readFile(path.join(projectDir, 'package.json')).then(
+                b => projectPackageJson = JSON.parse(b.toString()),
+                err => {
+                    console.error(err)
+                    process.exit(1)
+                }
+            )
+        ))
+
+        promises.push(Promise.resolve().then(() =>
+            PlataFs.fs.readFile(path.join(plataDir, 'package.json')).then(
+                b => plataPackageJson = JSON.parse(b.toString()),
+                err => {
+                    console.error(err)
+                    process.exit(1)
+                }
+            )
+        ))
+
+        await Promise.all(promises)
+    }
+
+    if (projectPackageJson.plata_no_setup !== undefined) {
+        return
+    }
+
+    projectPackageJson.plata_type = projectPackageJson.plata_type ?? 'api'
+    projectPackageJson.plata_name = plataPackageJson.name
+    projectPackageJson['my-scripts'] = projectPackageJson['my-scripts'] ?? new Object(null)
+
+    // https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy
+    projectPackageJson.scripts = JSON.parse(JSON.stringify(projectPackageJson['my-scripts']))
+
+    const templateDir = path.join(templatesDir, `${projectPackageJson.plata_type}`)
+
+    const { install } = await import(`./post-install/${projectPackageJson.plata_type}`.replace(/\\/g, '/'))
+
+    projectPackageJson = await install(
+        new PlataFs.CliTools(templateDir, projectDir),
+        projectPackageJson
+    )
+
+    await PlataFs.fs.writeFile(path.join(projectDir, 'package.json'), JSON.stringify(projectPackageJson, null, 4))
+}
+
+main()

package/src/scripts/pre-test.ts

@@ -0,0 +1,34 @@
+import { PlataFs } from '../libs/fs'
+import path from 'node:path'
+
+const main = async () => {
+    const plataDir = path.resolve('.')
+
+    // Copy assets folder
+    {
+        const srcAssetsFolder = path.join(plataDir, 'src', 'tests', 'assets')
+        const buildAssetsFolder = path.join(plataDir, '__BUILD__', 'tests', 'assets')
+
+        if (await PlataFs.access(buildAssetsFolder)) {
+            await PlataFs.fs.rm(
+                buildAssetsFolder, 
+                { force: true, recursive: true, maxRetries: 1, retryDelay: 1 }
+            )
+        }
+
+        await PlataFs.fs.mkdir(buildAssetsFolder, { recursive: true })
+
+        const err = await PlataFs.cp(
+            srcAssetsFolder,
+            buildAssetsFolder,
+            { force: true, recursive: true }
+        )
+
+        if (err !== null) {
+            console.log(err)
+            process.exit(1)
+        }
+    }
+}
+
+main()

package/src/tests/assets/config/test.txt

@@ -0,0 +1 @@
+1

package/src/tests/config.test.ts

@@ -0,0 +1,13 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import fs from "node:fs/promises"
+import path from "node:path"
+
+describe('Test status', () => {
+    it('Assert working', () => assert.strictEqual(1,1))
+
+    it('Assets working', async () => {
+        const t = await fs.readFile(path.join(__dirname, 'assets', 'config', 'test.txt'))
+        assert.equal(t.toString(), '1')
+    })
+})

package/src/tests/model.test.ts

@@ -0,0 +1,115 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { PlataModels } from ".."
+import { loadRuntimeLibs } from "../bin/runtime/_setupRuntime"
+
+describe('PlataModels', () => {
+    const plataPromise = (async () => {
+        const g = global as any
+    
+        g.Plata = await loadRuntimeLibs()
+    })()
+
+    const modelStruct = new PlataModels.ModelTemplate({
+        param: [ PlataModels.Required(), PlataModels.Int() ],
+        object: {
+            param: [ PlataModels.Required(), PlataModels.DateTime() ],
+        },
+        array: [ [ PlataModels.VarChar(30) ] ],
+        array_objects: [{
+            param: [ PlataModels.Optional(), PlataModels.Decimal(10,2) ]
+        }]
+    } as const, {
+        toValidationsOkay: (x): typeof modelValidations.type => {
+            return {
+                enum: 0,
+                stringDateTime: '2022-12-04T02:06:22',
+                dateTime: new Date(),
+                decimal: 99.99,
+                intMin: 5,
+                intMax: 5,
+                intRequired: 1,
+                smallDateTime: '2022-12-04',
+                telefone: '99-999999999',
+                telefoneDDI: '+055 99-999999999',
+                varCharMin: '1',
+                varChar: '1',
+            }
+        },
+        toValidationsError: (x): typeof modelValidations.type => {
+            return {
+                enum: 2,
+                stringDateTime: '',
+                dateTime: '',
+                decimal: 5.666666666666,
+                intMin: 1,
+                intMax: 6,
+                intRequired: null,
+                smallDateTime: '',
+                telefone: '',
+                telefoneDDI: '',
+                varCharMin: '',
+                varChar: '11',
+            } as any // Forced just for test
+        }
+    })
+
+    const modelValidations = new PlataModels.ModelTemplate({
+        enum: [ PlataModels.Enum([ 0,1 ] as const) ],
+        stringDateTime: [ PlataModels.StringDateTime() ],
+        dateTime: [ PlataModels.DateTime() ],
+        decimal: [ PlataModels.Decimal(2,2) ],
+        intMin: [ PlataModels.Int(5) ],
+        intMax: [ PlataModels.Int(undefined, 5) ],
+        intRequired:  [ PlataModels.Required(), PlataModels.Int() ],
+        smallDateTime: [ PlataModels.SmallDateTime() ],
+        telefone: [ PlataModels.Telefone() ],
+        telefoneDDI: [ PlataModels.TelefoneDDI() ],
+        varCharMin: [ PlataModels.VarChar(1, 1) ],
+        varChar:  [ PlataModels.VarChar(1) ],
+    } as const, {})
+
+    it('Struct Filter', () => {
+        const InitObj = {
+            array_objects: [{ param: '123' }]
+        }
+
+        const FilteredObj = modelStruct.filter(InitObj)
+
+        assert.deepStrictEqual(FilteredObj, {
+            param: null,
+            object: {
+                param: null,
+            },
+            array: [],
+            array_objects: [{
+                param: '123'
+            }]
+        })
+    })
+
+    it('Validations (Okay)', async () => {
+        await plataPromise
+        const okayObj = modelStruct.convert({} as any, 'toValidationsOkay')
+
+        const { errors, value } = await modelValidations.validate(okayObj)
+
+        assert.strictEqual(errors, undefined)
+        assert.deepStrictEqual(value, okayObj)
+    })
+
+    it('Validations (Not Okay)', async () => {
+        await plataPromise
+        const notOkayObj = modelStruct.convert({} as any, 'toValidationsError')
+
+        const { errors, value } = await modelValidations.validate(notOkayObj)
+
+        assert.notStrictEqual(errors, undefined)
+        assert.strictEqual(
+            errors?.length,
+            Object.keys(modelValidations.template).length, 
+            errors?.map(e => `${e.errorID} - ${e.msg}`).join('\n')
+        )
+        assert.deepStrictEqual(value, notOkayObj)
+    })
+})

package/templates/create-cli/cluster.ts

@@ -1,17 +1,15 @@
 //@ts-nocheck
-import { PlataCluster } from "ç__PlataName__ç"
-
-const onStart = async () => {
+export async function main() {
 
 }
 
-const onExit = (worker: PlataCluster.PlataWorker, code: number, signal: string) => {
+export function exit(worker: Cluster.Worker, code: number, signal: string) {
 
 }
 
 export default {
-    name: "ç__Name__ç",
-    env: process.env.ENV ?? 'debug',
-    onStart: onStart,
-    onExit: onExit
-} as PlataCluster.PlataClusterWorkerConfig
+    name: '$__name__$',
+    env: Plata.config.ENV ?? 'debug',
+    onStart: main,
+    onExit: exit,
+} satisfies Cluster.WorkerConfig

package/templates/create-cli/config.ts

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

package/templates/create-cli/lib.ts

@@ -1,24 +1,14 @@
 //@ts-nocheck
-import * as ç__Name__çConfig from '@Configs/ç__name__ç'
-
-export class ç__Name__ç {
-    private readonly config: typeof ç__Name__çConfig.default
-
-    constructor(config: typeof ç__Name__çConfig.default) {
-        this.config = config
+export class $__Name__$ {
+    constructor() {
+        
     }
 }
 
-export function newç__Name__ç(config: typeof ç__Name__çConfig.default): ç__Name__ç {
-    return new ç__Name__ç(ç__Name__çConfig.default)
+export function new$__Name__$(): $__Name__$ {
+    return new $__Name__$()
 }
 
-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)
-    }
-
-    return p._plata._libç__Name__ç
+export function get$__Name__$(): $__Name__$ {
+    return Plata.CacheClass(new$__Name__$)
 }

package/templates/create-cli/model.ts

@@ -1,26 +1,15 @@
 //@ts-nocheck
-import { PlataModels } from "ç__PlataName__ç";
+import { PlataModels } from '$__PlataName__$'
 
-const ç__Name__ç = new PlataModels.Model({
-    campo: [ PlataModels.Required(), PlataModels.Int() ],
-    objeto: {
-        campo: [ PlataModels.Optional(), PlataModels.DateTime() ]
+const $__Name__$ = new PlataModels.ModelTemplate({
+    param: [ PlataModels.Required(), PlataModels.Int() ],
+    object: {
+        param: [ PlataModels.Required(), PlataModels.DateTime() ],
     },
-    arrayItens: [{
-        campo: [ PlataModels.Required(), PlataModels.Telefone() ]
+    array: [ [ PlataModels.VarChar(30) ] ],
+    array_objects: [{
+        param: [ PlataModels.Optional(), PlataModels.Decimal(10,2) ]
     }]
-})
+} as const, {})
 
-ç__Name__ç.addValidacao('Validação Customizada', async (objeto) => {
-    if (objeto.campo > 30) {
-        return {
-            errorID: 'BM0001',
-            msg: 'O campo não pode ser maior que 30',
-            error: `valor do campo: ${objeto.campo}`
-        }
-    }
-
-    return null
-})
-
-export const ç__Name__çModel = ç__Name__ç
+export const $__Name__$Model = $__Name__$