pwi-plata-type 0.3.18 → 0.4.0

package/src/bin/plata-swagger.ts

@@ -0,0 +1,100 @@
+import path from 'node:path'
+import fs from 'node:fs'
+import { buildExpressRouter, loadRoutesFromProject } from "++/libs/router"
+
+export async function dumpRoutes() {
+    const requiredRoutes = await loadRoutesFromProject()
+
+    if (requiredRoutes.errorID !== undefined) {
+        console.log(requiredRoutes)
+        process.exit(1)
+    }
+
+    const router = await buildExpressRouter(requiredRoutes)
+
+    if (router.errorID !== undefined) {
+        console.log(router)
+        process.exit(1)
+    }
+
+    const dumpedRoutes: SwaggerGen.Route[] = []
+    const regex = /:(.*?)\??\//g
+
+    for (const r of router.routes) {
+        if (r.swaggerHide) {
+            continue
+        }
+
+        r.path = path.normalize(`${r.path ?? '/'}/`).replace(/\\/g, '/')
+
+        const dumpedRouteParams: SwaggerGen.RouteParameter[] = []
+        const urlParms = r.path.match(regex) ?? []
+
+        for (const p of urlParms) {
+            dumpedRouteParams.push({
+                name: p.replace(regex, '$1'),
+                required: p[p.length - 2] !== '?',
+                in: 'path',
+                type: 'string'
+            })
+        }
+
+        dumpedRoutes.push({
+            httpRoute: r.path.replace(regex, '{$1}/'),
+            method: r.method,
+            params: dumpedRouteParams,
+        })
+    }
+
+    return dumpedRoutes
+}
+
+export async function toProjectSwagger(file: string, content: any): Promise<void> {
+    try {
+        const p = path.resolve(Plata.ProjectDir, 'swagger', file)
+
+        if (!fs.existsSync(p)) {
+            fs.mkdirSync(path.dirname(p), { recursive: true })
+            fs.writeFileSync(p, JSON.stringify(content, null, 4))
+        }
+
+    } catch (e) {
+        console.log(e)
+        process.exit(1)
+    }
+}
+
+export const main = async () => {
+    const routes = await dumpRoutes()
+
+    const templateFolder = path.join(Plata.PlataDir, 'templates', 'swagger-cli')
+
+    const files: SwaggerGen.Files = {
+        swaggerHeader: require(path.join(templateFolder, 'header.json')),
+        route: {
+            header: require(path.join(templateFolder, 'route', 'header.json')),
+            body: require(path.join(templateFolder, 'route', 'body.json')),
+            response: require(path.join(templateFolder, 'route', 'response.json')),
+        }
+    }
+
+    for (const route of routes) {
+
+        // https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy
+        const fileCopy:SwaggerGen.Files = JSON.parse(JSON.stringify(files))
+
+        for(const json in fileCopy.route) {
+            await toProjectSwagger(
+                path.join('routes', route.httpRoute, route.method.toLowerCase(), `${json}.json`),
+                fileCopy.route[json]
+            )
+        }
+    }
+
+    await toProjectSwagger(
+        'header.json',
+        files.swaggerHeader
+    )
+
+    console.log('Done')
+}

package/src/bin/runtime/_setupRuntime.ts

@@ -0,0 +1,49 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+export async function loadRuntimeLibs() {
+    const plata = new Object(null)
+
+    const runtimeLibs: PlataResult<string[]> = await fs.readdir(path.join(__dirname)).catch(err => {
+        return {
+            errorID: 'PRLORUNTIME',
+            msg: err.message,
+            error: err
+        }
+    })
+
+    if (runtimeLibs.errorID !== undefined) {
+        console.error(runtimeLibs)
+        process.exit(1)
+    }
+
+    const promises = runtimeLibs.map(lib => Promise.resolve().then(() => new Promise(resolve => {
+        if (lib.slice(-4) === 'd.ts') 
+            return resolve(true)
+        ;
+
+        if (path.extname(lib) === '.map')
+            return resolve(true)
+        ;
+
+        const r: { PlataRuntimeE?: any } = require(path.join(__dirname, lib))
+
+        if (r.PlataRuntimeE === undefined) {
+            return resolve(true)
+        }
+
+        for (const key in r.PlataRuntimeE) {
+            plata[key] = r.PlataRuntimeE[key]
+        }
+
+        return resolve(true)
+    })))
+
+    await Promise.all(promises).catch(err => {
+        console.error(err)
+        process.exit(1)
+    })
+
+
+    return plata
+}

package/src/bin/runtime/_types.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="class.ts" />
+/// <reference path="dirs.ts" />
+/// <reference path="promises.ts" />
+/// <reference path="require.ts" />

package/src/bin/runtime/class.ts

@@ -0,0 +1,21 @@
+declare global {
+    interface PlataRuntime extends PlataRuntimeEType {}
+}
+
+type PlataRuntimeEType = typeof PlataRuntimeE
+
+export namespace PlataRuntimeE {
+    export function CacheClass<T>(newFunction: (...args: any) => T): T {
+        const p = process as any
+
+        if (p.cache === undefined) {
+            p.cache = new Object(null)
+        }
+
+        if (p.cache[newFunction.name] === undefined) {
+            p.cache[newFunction.name] = newFunction() 
+        }
+
+        return p.cache[newFunction.name]
+    }
+}

package/src/bin/runtime/dirs.ts

@@ -0,0 +1,26 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+declare global {
+    interface PlataRuntime extends PlataRuntimeEType {}
+}
+
+type PlataRuntimeEType = typeof PlataRuntimeE
+
+export namespace PlataRuntimeE {
+    export const ProjectDir =  path.resolve('.')
+
+    export const ProjectJson = JSON.parse(
+        fs.readFileSync(
+            path.join(ProjectDir, 'package.json')
+        ).toString()
+    )
+
+    export const PlataDir =  path.resolve('.', 'node_modules', ProjectJson.plata_name ?? '..')
+
+    export const PlataJson = JSON.parse(
+        fs.readFileSync(
+            path.join(PlataDir, 'package.json')
+        ).toString()
+    )
+}

package/src/bin/runtime/promises.ts

@@ -0,0 +1,15 @@
+declare global {
+    interface PlataRuntime extends PlataRuntimeEType {}
+}
+
+type PlataRuntimeEType = typeof PlataRuntimeE
+
+export namespace PlataRuntimeE {
+    export function FastPromise<T>(p: () => Promise<T>): Promise<T> {
+        return Promise.resolve().then(p)
+    }
+
+    export function BuildPlataError(e: PlataError): PlataError {
+        return e
+    }
+}

package/src/bin/runtime/require.ts

@@ -0,0 +1,104 @@
+import glob from 'glob'
+import path from 'node:path'
+
+declare global {
+    interface PlataRuntime extends PlataRuntimeEType {}
+}
+
+type PlataRuntimeEType = typeof PlataRuntimeE
+
+export namespace PlataRuntimeE {
+
+    export async function RequireAsync<T = any>(p: string): RequireAsyncReturn<T> {
+        try {
+            return {
+                filePath: p,
+                name: path.basename(p).replace('.ts', '').replace('.js', ''),
+                exports: require(p) as T
+            }
+        } catch(err) {
+            return {
+                errorID: 'PLTRF0001',
+                msg: `Error while importing file ${p}`,
+                error: err
+            }
+        }
+    }
+
+    export async function RequireFolder<T = any>(p: string): RequireFolderReturn<T> {
+        const promises: PlataPromise<RequiredInterface<T>>[] = []
+
+        glob.sync(`${p.replace(/\\/g, '/')}/**/*.+(js|ts)`)
+            .filter(file => !file.endsWith('.d.ts'))
+            .forEach(file => {
+                file = file.replace(/(\.ts|\.js)$/, '')
+
+                promises.push(Plata.FastPromise(() => Plata.RequireAsync(file)))
+            })
+        ;
+
+        return Promise.all(promises).then(
+            rs => {
+                const errors: PlataError[] = []
+                const result: RequiredInterface<T>[] = []
+
+                rs.forEach(r => {
+                    if (r.errorID !== undefined) {
+                        errors.push(r)
+                    } else {
+                        result.push(r)
+                    }
+                })
+
+                if (errors.length !== 0) {
+                    return {
+                        errorID: 'PLTRF0003',
+                        msg: `Errors while importing folder: ${p}`,
+                        error: errors
+                    }
+                }
+                
+                return result
+            },
+            e => {
+                return {
+                    errorID: 'PLTRF0002',
+                    msg: `Error while importing folder: ${p}`,
+                    error: e
+                }
+            }
+            
+        )
+    }
+
+    export async function ReadEnvFileToPromise(p: string) {
+        const envFile = new Object(null)
+
+        const result = await Plata.files.ReadFileAsync(p, async line => {
+            if (line[0] === '#') return
+
+            if (line !== '') {
+                const env = line.split('=')
+
+                if (env.length >= 2) {
+                    const [ key, ...v ] = env
+                    let value = v.join('=')
+
+                    if (value[0] === '{' && value.slice(-1) === '}')
+                        value = process.env[value.slice(1, -1)] ?? ''
+                    ;
+
+                    if (value !== '')
+                        envFile[key] = value
+                    ;
+                }
+            }
+        })
+
+        if (result !== null) {
+            return result
+        }
+
+        return envFile
+    }
+}

package/{index.ts → src/index.ts}

@@ -1,15 +1,13 @@
 import * as PlataCluster from './libs/cluster'
-import * as PlataEnv from './libs/env'
-import * as PlataRoutes from './libs/routes'
+import * as PlataRoutes from './libs/router'
 import * as PlataTools from './libs/tools'
 import * as PlataModels from './libs/model'
 import * as PlataTasks from './libs/tasks'
-import { PlataSwagger } from './libs/swagger'
+import * as PlataSwagger from './libs/swagger'
 import { PlataAxios, PlataAxiosUnsafe } from './libs/axios'
 
 export {
     PlataCluster,
-    PlataEnv,
     PlataRoutes,
     PlataTools,
     PlataModels,

package/src/libs/cluster.ts

@@ -0,0 +1,189 @@
+import cluster from "node:cluster";
+import { cpus } from "node:os";
+
+export class PlataClusterManager {
+    private readonly NodeCluster = cluster
+
+    constructor() {
+        if (this.NodeCluster.isPrimary) {
+            Plata.cluster = {
+                isPrimary: true,
+                clusters: []
+            }
+
+            if (this.NodeCluster.eventNames().indexOf('exit') === -1) {
+                this.NodeCluster.on('exit', this.onWorkerKilled)
+            }
+
+            if (this.NodeCluster.eventNames().indexOf('message') === -1) {
+                this.NodeCluster.on('message', (
+                    (t) => t.onMessage(t)
+                )(this))
+            }
+        } else {
+            Plata.cluster = {
+                isPrimary: false
+            }
+        }
+    }
+
+    public async startCluster(config: Cluster.WorkerConfig): Promise<MaybePlataError> {
+        if (!Plata.cluster.isPrimary) return {
+            errorID: 'PBLCLWS0002',
+            msg: 'startCluster must be called from primary process'
+        }
+
+        if (config.workers === undefined) {
+            if (config.env === 'prod') {
+                config.workers = cpus().length
+            } else {
+                config.workers = 1
+            }
+        }
+
+        if (config.workers === -1) {
+            config.workers = cpus().length
+        }
+
+        if (config.workers === 0) {
+            return null
+        }
+
+        console.log(`Starting ${config.workers} workers on cluster ${config.name}`)
+
+        const cluster: Cluster.ClusterConfig = {
+            pids: [],
+            config
+        }
+
+        for (let i = 0; i < config.workers; i++) {
+            const w = this.fork(config)
+
+            if (w.process.pid === undefined) {
+                return {
+                    errorID: 'PBLCLWS0003',
+                    msg: `Erro while starting worker ${i} from cluster ${config.name}`,
+                    error: w.process.exitCode
+                }
+            }
+
+            cluster.pids.push(w.process.pid)
+        }
+
+        if (config.onExit !== undefined) {
+            this.NodeCluster.on(this.getClusterEvents(config.name).worker.exit, config.onExit)
+        }
+
+        Plata.cluster.clusters.push(cluster)
+
+        return null
+    }
+
+    public isPrimary() {
+        return this.NodeCluster.isPrimary
+    }
+
+    public fork(config: Cluster.WorkerConfig) {
+        return this.NodeCluster.fork({
+            ...config.workersEnv,
+            ENV: config.env,
+            _PLATA_WORKER_NAME: config.name
+        })
+    }
+
+    public getClusterEvents(clusterName: string) {
+        const base = `plata.cluster.${clusterName}`
+        return {
+            worker: {
+                exit: `${base}.worker.exit`
+            }
+        }
+    }
+    public onWorkerKilled(t: this) {
+        return (worker: Cluster.Worker, code: number, signal: string) => {
+            if (worker.process.pid === undefined) return
+            if (!Plata.cluster.isPrimary) return
+
+            const clusterIndex = Plata.cluster.clusters.findIndex(cluster => 
+                cluster.pids.indexOf(worker.process.pid ?? 0) !== -1
+            )
+
+            if (clusterIndex !== -1) {
+                const c = Plata.cluster.clusters[clusterIndex]
+
+                console.log(`O Worker ${worker.process.pid} do cluster ${c.config.name} morreu com o codigo ${code} ${signal ?? ''}`)
+                console.log(`Iniciando um novo worker no cluster ${c.config.name}`)
+
+                cluster.emit(
+                    t.getClusterEvents(c.config.name).worker.exit, // TODO :: this !== PlataClusterManager
+                    worker,
+                    code,
+                    signal,
+                )
+
+                const w = t.fork(c.config)
+
+                const pidIndex = c.pids.indexOf(worker.process.pid)
+
+                c.pids[pidIndex] = w.process.pid ?? 0
+            }
+        }
+    }
+
+    public async sendMsgToAllWorkers(msg: Cluster.Actions) {
+        if (this.NodeCluster.workers === undefined) return
+
+        for (const worker of Object.values(this.NodeCluster.workers)) {
+            if (worker === undefined) continue
+            
+            worker.send(msg)
+        }
+    }
+
+    public async sendMsgToCluster(name: string, msg: Cluster.Actions) {
+        if (this.NodeCluster.workers === undefined) return
+        if (!Plata.cluster.isPrimary) return
+
+        const clusterIndex = Plata.cluster.clusters.findIndex(cluster => cluster.config.name === name)
+
+        if (clusterIndex === -1) return
+
+        const pids = Plata.cluster.clusters[clusterIndex].pids
+
+        for (const worker of Object.values(this.NodeCluster.workers)) {
+            if (worker === undefined) continue
+
+            if (pids.includes(worker.process.pid ?? 0)) 
+                worker.send(msg)
+            ;
+        }
+    }
+
+    public onMessage(t: this) {
+        return (worker: Cluster.Worker, actionEvent: Cluster.Actions) =>  {
+            switch(actionEvent.action) {
+                case 'KILL':
+                    console.log(`Process kill requested: ${actionEvent.msg}`)
+                    process.exit(0)
+                break
+                case 'ECHO':
+                    t.sendMsgToAllWorkers(actionEvent.msg)
+                break
+                case 'ECHO-CLUSTER':
+                    t.sendMsgToCluster(actionEvent.msg.name, actionEvent.msg.data)
+                break
+            }
+        }   
+    }
+
+    public async send(msg: Cluster.Actions): PlataPromise<boolean> {
+        if (process.send === undefined) {
+            return {
+                errorID: 'PBLCLWS0001',
+                msg: `process don't have send function`
+            }
+        }
+
+        return process.send(msg)
+    }
+}