pwi-plata-type 0.3.18 → 0.4.0

package/src/@types/model.d.ts

@@ -0,0 +1,69 @@
+declare namespace Model {
+
+    type ValidateReturn = PlataError | null
+
+    interface PrimitiveValidationTypeReturn {
+        error?: PlataError
+        continua: boolean
+    }
+
+    type PrimitiveValidationType<T = any, D = undefined> = 
+        (nome: string, valor: T | D) => Promise<PrimitiveValidationTypeReturn>
+    ;
+
+    interface Template {
+        readonly [name: string]: 
+            readonly PrimitiveValidationType<unknown, unknown>[] |
+            readonly Template[] |
+            Template |
+            readonly (readonly PrimitiveValidationType[])[]
+    }
+
+    type GetTemplateParamType<T> = 
+        T extends readonly [ PrimitiveValidationType<infer G, infer H> ] ? G | H :
+        T extends readonly [ PrimitiveValidationType<any, infer H>,  PrimitiveValidationType<infer G, any> ] ? G | H :
+        T extends readonly [ PrimitiveValidationType<any, infer H>,  ...any[], PrimitiveValidationType<infer G, any> ] ? G | H :
+        never
+    ;
+
+    type ExtractTemplateParamType<T> = Exclude<GetTemplateParamType<T>, undefined>
+
+    type ExtractTemplateType<T extends Template> = {
+        [P in keyof T]: T[P] extends Template ? ExtractTemplateType<T[P]> : 
+                        T[P] extends readonly Template[] ? ExtractTemplateType<T[P][0]>[] :
+                        T[P] extends readonly (readonly PrimitiveValidationType[])[] ? ExtractTemplateParamType<T[P][0]>[] : 
+                        T[P] extends readonly PrimitiveValidationType<unknown, unknown>[] ? ExtractTemplateParamType<T[P]> :
+                        number | boolean | string | null
+    }
+
+    type ExtractTemplateTypeNotValid<T extends Template> = {
+        [P in keyof T]: T[P] extends Template ? ExtractTemplateTypeNotValid<T[P]> : 
+                        T[P] extends readonly Template[] ? ExtractTemplateTypeNotValid<T[P][0]>[] :
+                        T[P] extends readonly (readonly PrimitiveValidationType[])[] ? (number | boolean | string | null)[] :
+                        number | boolean | string | null
+    }
+
+    type ParcialTemplateType<T extends Template> = Partial<ExtractTemplateType<T>>
+
+    type ModelTemplateValidation<T extends Template> = (value: ExtractTemplateType<T>) => Promise<PlataError | null>
+
+    type ModelTemplateFilter<T extends Template> = (value: ExtractTemplateTypeNotValid<T>) => ExtractTemplateTypeNotValid<T>
+
+    type ModelValidateReturn<T extends Template> = {
+        errors: undefined
+        value: ExtractTemplateType<T>
+    } | {
+        errors: PlataError[]
+        value: ExtractTemplateTypeNotValid<T>
+    }
+
+    type ConvertFunction<T extends Template, O> = (x: ExtractTemplateType<T>) => O
+
+    type Converters<T extends Template> = (AnyRecord<Model.ConvertFunction<T, any>>)
+
+    type GetConverterType<T extends Template, F> = F extends ConvertFunction<T, infer G> ? G : never
+
+    type ModelConvertFuntion<T extends Template, C extends Converters<T>> =
+        <K extends keyof C>(value: ExtractTemplateType<T>, to: K) => PlataResult<GetConverterType<T, C[K]>>
+    ;
+}

package/src/@types/router.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="express" />
+
+import express from 'express'
+
+declare global {
+    namespace Router {
+        interface Request extends express.Request {
+            user: any
+            extras: any
+        }
+    
+        interface Response extends express.Response {
+            oldJson(body?: any): this
+            error(error: PlataError | PlataError[]): this
+        }
+    
+        type RequestHandler = (req: Request, res: Response, next: express.NextFunction) => Promise<any>
+    
+        type HttpMethods =
+            "all"
+            | "get"
+            | "post"
+            | "put"
+            | "delete"
+            | "patch"
+            | "options"
+            | "head"
+            | "checkout"
+            | "connect"
+            | "copy"
+            | "lock"
+            | "merge"
+            | "mkactivity"
+            | "mkcol"
+            | "move"
+            | "notify"
+            | "propfind"
+            | "proppatch"
+            | "purge"
+            | "report"
+            | "search"
+            | "subscribe"
+            | "trace"
+            | "unlock"
+            | "unsubscribe"
+            | "use"
+        ;
+    
+        type RouterFunction = (
+            (path: string | RequestHandler, ...handlers: RequestHandler[]) => void | Promise<void>
+        )
+    
+        interface Route {
+            path?: string
+            method: string
+            handlers: RequestHandler[],
+            swaggerHide?: boolean | undefined
+        }
+
+        type RouterConfig = {
+            swaggerHide?: boolean
+            routes: Route[]
+        }
+
+        type Router  = RouterConfig & {
+            [method in HttpMethods]: RouterFunction
+        }
+
+        type RouterBuilder = (r: Router) => Promise<Router>
+
+        export interface RequiredRoute extends RequiredInterface<RouterBuilder> {
+            httpRoute: string
+        }
+    }
+}

package/src/@types/swagger.d.ts

@@ -0,0 +1,23 @@
+declare namespace SwaggerGen {
+    interface RouteParameter {
+        name: string,
+        required: boolean,
+        in: 'path',
+        type: 'string'
+    }
+
+    interface Route {
+        httpRoute: string
+        method: string
+        params: RouteParameter[]
+    }
+
+    interface Files {
+        swaggerHeader: any
+        route: {
+            header: any,
+            body: any,
+            response: any,
+        }
+    }
+}

package/{bin/extras/plata-create-api.ts → src/bin/extras/create-api-cli.ts}

@@ -1,5 +1,4 @@
 import { tools } from "./plata-create-tools";
-import { PlataDirs } from "../../libs/tools"
 import { Command } from 'commander'
 import path from 'node:path'
 
@@ -7,7 +6,7 @@ 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.version(Plata.PlataJson.version)
 
 program.command('route <routes...>')
     .description('Cria uma rota utilizando o templete da plata')
@@ -17,7 +16,7 @@ program.command('route <routes...>')
         }
 
         const promises: any[] = []
-        const plataName = PlataDirs.ProjectJson.plata_name
+        const plataName = Plata.ProjectJson.plata_name
 
         for (const route of routes) {
             const r = `${route}/`.replace(/:(.*?)(?:\/|$)/g, (_, parm) => {
@@ -103,7 +102,7 @@ program.command('model <models...>')
         }
 
         const promises: any[] = []
-        const plataName = PlataDirs.ProjectJson.plata_name
+        const plataName = Plata.ProjectJson.plata_name
 
         for (const model of models) {
             promises.push(tools.files.deployFileToProject(
@@ -126,7 +125,7 @@ program.command('task <tasks...>')
         }
 
         const promises: any[] = []
-        const plataName = PlataDirs.ProjectJson.plata_name
+        const plataName = Plata.ProjectJson.plata_name
 
         for (const task of tasks) {
             promises.push(tools.files.deployFileToProject(
@@ -147,7 +146,7 @@ program.command('cluster <clusters...>')
         if (!Array.isArray(clusters)) return
 
         const promises: any[] = []
-        const plataName = PlataDirs.ProjectJson.plata_name
+        const plataName = Plata.ProjectJson.plata_name
 
         for (const cluster of clusters) {
             promises.push(tools.files.deployFileToProject(

package/{bin/extras/plata-create-lib.ts → src/bin/extras/create-lib-cli.ts}

@@ -1,12 +1,11 @@
 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.version(Plata.PlataJson.version)
 
 program.command('lib <libs...>')
     .description('Cria uma config com e uma lib utilizando o templete da plata')
@@ -68,7 +67,7 @@ program.command('model <models...>')
         }
 
         const promises: any[] = []
-        const plataName = PlataDirs.ProjectJson.plata_name
+        const plataName = Plata.ProjectJson.plata_name
 
         for (const model of models) {
             promises.push(tools.files.deployFileToProject(
@@ -91,7 +90,7 @@ program.command('task <tasks...>')
         }
 
         const promises: any[] = []
-        const plataName = PlataDirs.ProjectJson.plata_name
+        const plataName = Plata.ProjectJson.plata_name
 
         for (const task of tasks) {
             promises.push(tools.files.deployFileToProject(

package/{bin → src/bin}/extras/plata-create-tools.ts

@@ -34,7 +34,7 @@ export namespace tools {
 
         export async function copyFileToProject(projectFolder: string, templateFile: string, fileName: string): Promise<string> {
             const s = path.resolve(PlataDirs.getPlataTempleteDir('create-cli', `${templateFile}.ts`))
-            let d = path.resolve(PlataDirs.getProjectDir(), projectFolder)
+            let d = path.resolve(Plata.ProjectDir, projectFolder)
 
             await mkdirIfNotExists(d)
             d = path.join(d, fileName)
@@ -58,13 +58,13 @@ export namespace tools {
                 // Procura por texto para subistituir esse texto que esta no formato ç__PARAMETRO__ç
                 let lastIndex = 0
                 while(lastIndex !== -1) {
-                    lastIndex = line.indexOf('ç__', lastIndex)
+                    lastIndex = line.indexOf('$__', lastIndex)
                     
                     if (lastIndex !== -1) {
-                        const pIndex = line.indexOf('__ç', lastIndex)
+                        const pIndex = line.indexOf('__$', lastIndex)
                         const param = line.slice(lastIndex + 3, pIndex)
 
-                        line = line.replace(new RegExp(`ç__${param}__ç`, 'g'), args[param])
+                        line = line.replace(new RegExp(`\\$__${param}__\\$`, 'g'), args[param])
                     }
                 }
 

package/src/bin/plata-api.ts

@@ -0,0 +1,172 @@
+import express from 'express'
+import { PlataClusterManager } from '++/libs/cluster'
+import { createServer } from 'node:https'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { buildExpressRouter, loadRoutesFromProject } from '++/libs/router'
+
+export const main = async () => {
+    const cluster = new PlataClusterManager()
+
+    if (cluster.isPrimary()) {
+
+        let workers: number | undefined = undefined
+
+        if (Plata.config._PLATA_API_WORKERS !== undefined) {
+            workers = +Plata.config._PLATA_API_WORKERS || undefined
+        }
+
+        const clustersPromise: RequireFolderReturn<{ default: Cluster.WorkerConfig }> = require("@@/clusters/*.*")
+
+        cluster.startCluster({
+            name: '__PLATA_EXPRESS__',
+            env: Plata.config.ENV ?? 'prod',
+            onStart: async () => {},
+            workers: workers,
+        })
+
+        const clusters = await clustersPromise
+
+        if (clusters.errorID !== undefined) {
+            console.log(clusters)
+            process.exit(0)
+        }
+        // start Clusters
+        {
+            const promises: any = []
+
+            clusters.forEach(c => {
+                const config = c.exports.default
+                promises.push(cluster.startCluster(config).then(r => {
+                    if (r !== null)  {
+                        console.log(r)
+                        process.exit(0)
+                    }
+                }))
+            })
+
+            await promises
+        }
+    } else {
+        if (Plata.config._PLATA_WORKER_NAME === '__PLATA_EXPRESS__') {
+            const projectRoutesPromise = Plata.FastPromise(() => loadRoutesFromProject())
+            const app = express()
+
+            app.disable('x-powered-by')
+
+            const apiRoots = Plata.config._PLATA_API_ROOT ?? '/api'
+
+            app.use(express.json({ limit: Plata.config._PLATA_API_JSON_SIZE ?? '100kb' }))
+
+
+            const requiredRoutes = await projectRoutesPromise
+
+            if (requiredRoutes.errorID !== undefined) {
+                console.log(requiredRoutes)
+
+                await cluster.send({
+                    action: 'KILL',
+                    msg: 'Erro enquanto carregava as rotas'
+                })
+
+                return 
+            }
+
+            {
+                const result = await buildExpressRouter(requiredRoutes)
+
+                if (result.errorID !== undefined) {
+                    console.log(result)
+
+                    await cluster.send({
+                        action: 'KILL',
+                        msg: 'Erro enquanto carregava as rotas'
+                    })
+
+                    return
+                }
+
+                app.use(apiRoots.split(','), result as any)    
+            }
+            
+            app.use((err, _req, res, _next) => {                
+                return res.status(500).json({
+                    errorID: 'PRAPI0001',
+                    error: 'Erro interno inesperado',
+                    msg: err.message
+                })
+            })
+
+            app.all('*', (req, res) => {
+                return res.status(404).json({
+                    errorID: 'PRAPI0002',
+                    error: 'Rota não encontrada',
+                    msg: req.path
+                })
+            })
+
+            const port = process.env.PORT ?? 3050
+
+            if (!Plata.config._PLATA_API_SSL_KEY || !Plata.config._PLATA_API_SSL_CERT) {
+
+                console.log(`Nenhum certificado configurado na env ${process.env.ENV}:`)
+                console.log(`_PLATA_API_SSL_KEY: ${process.env._PLATA_API_SSL_KEY}`)
+                console.log(`_PLATA_API_SSL_CERT: ${process.env._PLATA_API_SSL_CERT}`)
+
+                app.listen(port, () => {
+                    console.log(`Iniciando Worker Express na porta ${port}`)
+                    setTimeout(() => process.removeAllListeners('exit'), 500)
+                })
+
+            } else {
+
+                console.log('Iniciando a Plata com ssl usando os arquivos:')
+                console.log(`key: ${process.env._PLATA_API_SSL_KEY}`)
+                console.log(`cert: ${process.env._PLATA_API_SSL_CERT}`)
+
+                const [ cert, key ] = await Promise.all([ 
+                    fs.readFile(path.normalize(path.join(
+                        Plata.ProjectDir,
+                        Plata.config._PLATA_API_SSL_CERT
+                    ))),
+                    fs.readFile(path.normalize(path.join(
+                        Plata.ProjectDir,
+                        Plata.config._PLATA_API_SSL_KEY
+                    )))
+                ]).catch(err => {
+                    console.log({
+                        errorID: 'PRAPI0003',
+                        msg: 'Erro ao ler o certifica e chave ssl',
+                        error: err
+                    } satisfies PlataError)
+
+                    process.exit(1)
+                })
+
+                const https = createServer({
+                    cert,
+                    key,
+                    passphrase: process.env._PLATA_API_SSL_PASS
+                }, app)
+
+                https.listen(port, () => {
+                    console.log(`Iniciando Worker Express na porta ${port} com SSL`)
+                    setTimeout(() => process.removeAllListeners('exit'), 500)
+                })
+            }
+        } else {
+            if (Plata.config._PLATA_WORKER_NAME === undefined) {
+                await cluster.send({
+                    action: 'KILL',
+                    msg: 'tried to start a Worker without _PLATA_WORKER_NAME'
+                })
+
+                return 
+            }
+
+            const c: { default: Cluster.WorkerConfig }  = require(`@@/clusters/${Plata.config._PLATA_WORKER_NAME}`)
+
+            await c.default.onStart()
+        }
+    }    
+}

package/src/bin/plata-create.ts

@@ -0,0 +1,21 @@
+export const main = async () => {
+    if (Plata.ProjectJson.plata_no_setup !== undefined) {
+        console.log('Plata not configurated remove plata_no_setup from package.json')
+        process.exit(0)
+    }
+
+    const args = process.argv.slice(process.argv.indexOf('+'))
+
+    switch (Plata.ProjectJson.plata_type ?? 'api') {
+        case 'api':
+            await (require('++/bin/extras/create-api-cli') as CreateCli.ImportedCreateCli).cli.parseAsync(args)
+        break
+        case 'lib':
+            await (require('++/bin/extras/create-lib-cli') as CreateCli.ImportedCreateCli).cli.parseAsync(args)
+        break
+        default:
+            console.log(`${Plata.ProjectJson.plata_type} not supported`)
+            process.exit(0)
+        break
+    }
+}

package/src/bin/plata-runtime.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+import path from 'node:path'
+import fs from 'node:fs'
+import { ok } from 'node:assert'
+import readline from 'node:readline'
+import cluster from 'node:cluster'
+import { build } from 'tsc-prog'
+import glob from 'glob'
+import { loadRuntimeLibs } from './runtime/_setupRuntime'
+
+export function compile() {
+    if (!cluster.isPrimary) return
+
+    build({
+        basePath: Plata.ProjectDir,
+        configFilePath: 'tsconfig.json',
+        compilerOptions: {
+            newLine: 'LF',
+            rootDir: '.'
+        },
+        include: [
+            './**/*'
+        ],
+        exclude: [
+            './__BUILD__',
+            './node_modules',
+            './.vscode'
+        ],
+        copyOtherToOutDir: true,
+        clean: {
+            outDir: true,
+            declarationDir: true,
+            outFile: true
+        },
+    })
+}
+
+const main = async () => {
+    const g = global as any
+
+    g.Plata = await loadRuntimeLibs()
+
+    g.Plata.files = new Object(null)
+
+    g.Plata.files.ReadFileSync = (file: string, callback: (line: string) => string): PlataPromise<string> => {
+        return new Promise(resolve => {
+            try {
+                const content: string[] = []
+                const stream = readline.createInterface({
+                    input: fs.createReadStream(file),
+                    crlfDelay: Infinity
+                })
+
+                stream.on('close', () => {
+                    resolve(content.join('\n'))
+                })
+
+                stream.on('line', (line) => {
+                    content.push(callback(line))
+                })
+
+            } catch(e) {
+                resolve({
+                    errorID: 'PLTRF0004',
+                    msg: `Error while reading file: ${file}`,
+                    error: e
+                })
+            }
+        })
+    }
+
+    g.Plata.files.ReadFileAsync = async (file: string, callback: (line: string) => Promise<void>): Promise<MaybePlataError> => {
+        return new Promise(resolve => {
+            try {
+                const promises: any = []
+
+                const stream = readline.createInterface({
+                    input: fs.createReadStream(file),
+                    crlfDelay: Infinity
+                })
+
+                stream.on('close', () => {
+                    Promise.all(promises).then(
+                        () => resolve(null),
+                        e => resolve({
+                            errorID: 'PPFRFA0002',
+                            msg: `Unexpected error while reading file: ${file}`,
+                            error: e
+                        }),
+                    )
+                })
+
+                stream.on('line', line => {
+                    promises.push(Plata.FastPromise(() => callback(line)))
+                })
+
+            } catch (e) {
+                return resolve({
+                    errorID: 'PPFRFA0001',
+                    msg: `Unexpected error while reading file: ${file}`,
+                    error: e
+                })
+            }
+        })
+    }
+
+    g.Plata.files.FindFiles = async (folders: string[], file: string): Promise<string[]> => {
+        const files: string[] = []
+
+        for (const folder of folders) {
+            files.push(...glob.sync(`${folder.replace(/\\/g, '/')}/**/${file}`))
+        }
+
+        return files
+    }
+
+    compile()
+
+    module.constructor.prototype.require = function (pathRequire) {
+        const self = this;
+        ok(typeof pathRequire === 'string', 'path must be a string');
+        ok(pathRequire, 'missing path');
+    
+        try {
+            switch (pathRequire.slice(0,2)) {
+                case '@@':
+                    pathRequire = pathRequire.replace('@@', `${Plata.ProjectDir}/__BUILD__`)
+                break
+                case '++':
+                    pathRequire = pathRequire.replace('++', `${Plata.PlataDir}/__BUILD__`)
+                break
+            }
+    
+            pathRequire = pathRequire.replace(/\\/g, '/')
+
+            switch (path.extname(pathRequire)) {
+                case '.env':
+                    return Plata.FastPromise(() => Plata.ReadEnvFileToPromise(pathRequire))
+                break
+                case '.*':
+                    return Plata.FastPromise(() => Plata.RequireFolder(path.dirname(pathRequire)))
+                break
+                default:
+                    return self.constructor._load(pathRequire, self)
+                break
+            }
+
+            
+        } catch (err) {
+            // if module not found, we have nothing to do, simply throw it back.
+            if (err.code === 'MODULE_NOT_FOUND') {
+                throw err;
+            }
+            // resolve the path to get absolute path
+            pathRequire = path.resolve(__dirname, pathRequire)
+    
+            // Write to log or whatever
+            console.log('Error in file: ' + pathRequire);
+        }
+    }
+
+    // inicializa a config da plata
+    g.Plata.config = new Object(null)
+
+    const configEnv: EnvConfig = require('@@/configs/env').envConfig
+    const envFilePromise: PlataPromise<any> = require(`@@/envs/${configEnv.env}.env`)
+
+    for (const key in process.env) {
+        g.Plata.config[key] = process.env[key]
+    }
+
+    const envFile = await envFilePromise
+
+    for (const key in envFile) {
+        g.Plata.config[key] = envFile[key]
+    }
+
+    // roda o sript solicitado
+    const run = process.argv[process.argv.indexOf('+') + 1]
+
+    const app: { main: () => Promise<void> } = require(`++/bin/${run}`)
+
+    await app.main()
+
+}
+
+main()