pwi-plata-type 0.3.17 → 0.4.0

package/libs/routes.ts

@@ -1,275 +0,0 @@
-import path from 'node:path'
-import { PlataDirs, PlataRequire, PlataError } from "./tools";
-import express, { Router } from "express";
-
-export const HttpMethodsArray = [
-    "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"
-] 
-
-export 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"
-;
-
-export type PlataRouterMethods = (
-    (path: string | PlataRequestHandler, ...handlers: PlataRequestHandler[]) => void | Promise<void>
-)
-
-export interface _PlataRoute {    
-    path?: string,
-    method: HttpMethods
-    handlers: PlataRequestHandler[],
-    swaggerHide?: boolean
-}
-export interface PlataRouterExtras {
-    swaggerHide?: boolean
-    _routes?: _PlataRoute[]
-}
-
-export type PlataRouter = PlataRouterExtras & {    
-    [method in HttpMethods]: PlataRouterMethods
-}
-
-export type _Router = Router & PlataRouterExtras
-
-export type PlataRouterBuilder = (r: PlataRouter) => PlataRouter | Promise<PlataRouter>
-
-export type PlataRequest = express.Request & { 
-    user: any,
-    extras: any,
-    _onResponse: PlataOnResponse[]
-}
-
-export type PlataOnResponse = (req: PlataRequest, response?: any, error?: PlataError, nodeError?: any) => Promise<any>
-export interface PlataResponse extends express.Response {
-    _oldJson(body?: any): this
-    _onResponseEvent(req: PlataRequest, response?: any, error?: PlataError, nodeError?: any): void
-    error(error: PlataError, nodeError?: any): this
-    addOnResponse(callback: PlataOnResponse): void
-}
-
-export interface PlataRequiredRoute extends PlataRequire.RequiredInterface<PlataRouterBuilder> {
-    httpRoute: string
-}
-
-export function createPlataRouter(): any {
-    const router: any = new Object(null)
-    router._routes = []
-
-    for (let i = 0; i < HttpMethodsArray.length; i++) {
-        const method = HttpMethodsArray[i];
-
-        router[method] = (arg, ...args) => {
-            if (typeof arg === 'string') {
-                router._routes.push(
-                    {
-                        path: arg,
-                        method: method,
-                        handlers: args
-
-                    } as _PlataRoute
-                )
-            } else {
-                router._routes.push(
-                    {
-                        method: method,
-                        handlers: [].concat(arg, ...args)
-                    } as _PlataRoute
-                )
-            }
-        }
-    }
-
-    return router
-}
-
-export type PlataRequestHandler = (req: PlataRequest, res: PlataResponse, next: express.NextFunction) => Promise<any>
-
-export function PlataRoute(r: PlataRequestHandler): express.RequestHandler {
-    return async (req, res, next) => {
-        const aReq = req as any
-        
-        if (aReq.user === undefined) {
-            aReq.user = new Object(null)
-        }
-
-        if (aReq.extras === undefined) {
-            aReq.extras = new Object(null)
-        }
-
-        const aRes = res as any
-
-        if (aReq._onResponse === undefined) {
-            aReq._onResponse = []
-        }
-
-        if (aRes.addOnResponse === undefined) {
-            aRes.addOnResponse = (a) => {
-                aReq._onResponse.push(a)
-            }
-        }
-
-        if (aRes._oldJson === undefined) {
-            aRes._oldJson = aRes.json
-
-            aRes._onResponseEvent = (...a) => {
-                aReq._onResponse.forEach(r => {
-                    try {
-                        r(...a)
-                    } catch (e) {}
-                })
-            }
-
-            aRes.json = (body) => {
-                (async () => { aRes._onResponseEvent(aReq, body, undefined, undefined) })()
-
-                return aRes._oldJson(body)
-            }
-
-            aRes.error = (error, nodeError) => {
-                (async () => { aRes._onResponseEvent(aReq, undefined, error, nodeError) })()
-
-                return aRes._oldJson(error)
-            }
-        }
-
-
-        return r(aReq, aRes, next)
-    }
-}
-
-export async function loadExpressRoutes(): Promise<PlataRequiredRoute[]> {
-    const routes = await PlataRequire.requireFolderAsync<PlataRouterBuilder>(PlataDirs.getProjectRoutesDir())
-
-    if (routes.errorID === undefined) {
-        if (routes.findIndex(r => r.errorID !== undefined) !== -1) {
-            routes.forEach(r => {
-                if (r.errorID !== undefined) {
-                    console.log(r)
-                }
-            })
-
-            throw routes
-        }
-
-        let r = (routes as PlataRequiredRoute[])
-
-        // Cria as rotas http no array
-        r = r.map(route => {
-            route.httpRoute = route.filePath
-                .replace(PlataDirs.getProjectRoutesDir(), '')
-                .replace(/\.ts|\.js$/, '')
-                .replace(/index/, '')
-                .replace(/\\/g, '/')
-                .replace(/\{(.*?)\}/g, ':$1')
-                .replace(/\[(.*?)\]/g, ':$1?')
-            ;
-
-            return route
-        })
-
-        // coloca o index na frente de todas as rotas
-        r = r.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 r
-    } else {
-        console.log(routes)
-        throw routes
-    }
-}
-
-export async function buildExpressRouter(): Promise<_Router> {
-    const router = Router() as _Router
-    router._routes = []
-    router.use(express.json({ limit: process.env._PLATA_API_JSON_SIZE ?? '100kb' }))
-
-    const routes = await loadExpressRoutes()
-
-    for (const r of routes) {
-        const pr = await r.exports(createPlataRouter())
-
-        pr._routes = pr._routes ?? []
-
-        for (let i = 0; i < pr._routes.length; i++) {
-            const prr = pr._routes[i];
-
-            let httpPath = r.httpRoute
-            
-            if (prr.path !== undefined) {
-                httpPath = path.normalize(`${r.httpRoute}/${prr.path}`).replace(/\\/g, '/')
-            }
-
-            router[prr.method](httpPath, ...prr.handlers.map(PlataRoute))
-
-            router._routes.push({
-                path: httpPath,
-                method: prr.method,
-                handlers: [],
-                swaggerHide: prr.swaggerHide === undefined ? pr.swaggerHide : undefined
-            })
-        }
-    }
-
-    return router
-}

package/libs/swagger.ts

@@ -1,79 +0,0 @@
-import swaggerUi from 'swagger-ui-express'
-import path from 'node:path'
-import { PlataRouterBuilder, PlataRequestHandler } from './routes';
-import { PlataFiles, PlataDirs } from "./tools";
-
-export namespace PlataSwagger {
-    export const swagger: PlataRouterBuilder = async (router) => {
-        router.swaggerHide = true
-
-        if (process.env._plata_name === '_plata_express') {
-            router.use(
-                swaggerUi.serve as unknown as PlataRequestHandler,
-                swaggerUi.setup(
-                    await _loadSwaggerConfig(),
-                    {}
-                ) as unknown as PlataRequestHandler
-            )
-        }
-
-        return router
-    }
-
-    export async function _loadSwaggerConfig(): Promise<any> {
-        const obj = PlataFiles.readJsonSync(path.join(PlataDirs.getProjectDirSwagger(), 'header.json'))
-
-        obj.paths = new Object(null)
-
-        {
-            const routes = await PlataFiles.findFiles([PlataDirs.getProjectDirSwaggerRotas()], 'header.json')
-
-            for (const route of routes) {
-
-                const docPath = path.normalize(path.dirname(route))
-                const metodo = path.normalize(path.basename(docPath))
-                const httpPath = path.normalize(
-                    path.dirname(docPath.replace(PlataDirs.getProjectDirSwaggerRotas(), ''))
-                ).replace(/\\/g, '/')
-
-                const header = PlataFiles.readJsonSync(path.join(docPath, 'header.json'))
-                const body = PlataFiles.readJsonSync(path.join(docPath, 'body.json'))
-                const response = PlataFiles.readJsonSync(path.join(docPath, 'response.json'))
-
-                if (obj.paths[httpPath] === undefined) {
-                    obj.paths[httpPath] = new Object(null)
-                }
-
-                obj.paths[httpPath][metodo] = { ...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][metodo].parameters)) {
-                        obj.paths[httpPath][metodo].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][metodo].parameters.push(swaggerRouteBody)
-                }
-            }
-        }
-
-        return obj
-    }
-}

package/postinstall-tools.mjs

@@ -1,115 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-export function tools(dirs) {
-    const tools = new Object(null)
-
-    tools.mkdirIfNotExists = async (dir) => {
-        try {
-            const p = path.resolve(dir)
-
-            if (!fs.existsSync(p)) {
-                fs.mkdirSync(p, { resolve: true })
-            }
-        } catch (err) {
-            console.error(err)
-            process.exit(1)
-        }
-    }
-
-    tools.copyFile = async (source, destination) => {
-        try {
-            const s = path.resolve(source)
-            const d = path.resolve(destination)
-
-            fs.copyFileSync(s, d)
-        } catch (err) {
-            console.error(err)
-            process.exit(1)
-        }
-    }
-
-    tools.copyFileIfNotExists = async (source, destination) => {
-        try {
-            const s = path.resolve(source)
-            const d = path.resolve(destination)
-
-            if (!fs.existsSync(d)) {
-                tools.copyFile(s, d)
-            }
-        } catch (err) {
-            console.error(err)
-            process.exit(1)
-        }
-    }
-
-    tools.forEachFileInFolder = async (folder, callback) => {
-        try {
-            const f = path.resolve(folder)
-            const files = fs.readdirSync(f)
-
-            const promises = []
-
-            files.forEach(file => {
-                const filePath = path.join(f, file)
-
-                promises.push(
-                    (async () => callback(file, filePath))()
-                )
-            })
-
-            await Promise.all(promises)
-        } catch (err) {
-            console.error(err)
-            process.exit(1)
-        }
-    }
-
-    tools.createFolderProject = (async (folder) => 
-        tools.mkdirIfNotExists(path.join(dirs.projectDir, folder))
-    )
-
-    tools.copyFolderToProject = async (folder) => {
-        const templateFolder = path.join(dirs.templateDir, folder)
-        const destination = path.join(dirs.projectDir, folder)
-
-        await tools.mkdirIfNotExists(destination)
-
-        await tools.forEachFileInFolder(templateFolder, async (file, filePath) =>
-            tools.copyFileIfNotExists(
-                filePath,
-                path.join(destination, file)
-            )
-        )
-    }
-
-    tools.syncFolderProject = async (folder) => {
-        const templateFolder = path.join(dirs.templateDir, folder)
-        const destination = path.join(dirs.projectDir, folder)
-
-        await tools.mkdirIfNotExists(destination)
-
-        await tools.forEachFileInFolder(templateFolder, async (file, filePath) =>
-            tools.copyFile(
-                filePath,
-                path.join(destination, file)
-            )
-        )
-    }
-
-    tools.syncFileToProject = async (file) => {
-        const templateFile = path.join(dirs.templateDir, file)
-        const destination = path.join(dirs.projectDir, file)
-
-        await tools.copyFile(templateFile, destination)
-    }
-
-    tools.copyFileToProject = async (file) => {
-        const templateFile = path.join(dirs.templateDir, file)
-        const destination = path.join(dirs.projectDir, file)
-
-        await tools.copyFileIfNotExists(templateFile, destination)
-    }
-
-    return tools
-}

package/postinstall.mjs

@@ -1,42 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-const main = async () => {
-    const plataDir = path.resolve('.')
-    const templatesDir = path.resolve(plataDir, 'templates', 'postinstall')
-    const projectDir = path.resolve(plataDir, '..', '..')
-    let projectPackageJson = JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json')).toString())
-    const plataPackageJson = JSON.parse(fs.readFileSync(path.join(plataDir, 'package.json')))
-
-    if (projectPackageJson.plata_no_setup !== undefined) {
-        process.exit(0)
-    }
-
-    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)
-
-    const { install } = await import(`file:///${path.join(templateDir, '_install.mjs')}`.replace(/\\/g, '/'))
-
-    projectPackageJson = await install({
-        dirs: {
-            plataDir,
-            templateDir,
-            projectDir,
-        },
-        projectPackageJson
-    })
-
-    fs.writeFileSync(
-        path.join(projectDir, 'package.json'),
-        JSON.stringify(projectPackageJson, null, 4)
-    )
-}
-
-main()

package/templates/postinstall/api/_install.mjs

@@ -1,34 +0,0 @@
-import path from 'node:path'
-
-export async function install({ dirs, projectPackageJson }) {
-    const { tools } = await import(`file:///${path.resolve(dirs.plataDir, 'postinstall-tools.mjs')}`.replace(/\\/g, '/'))
-    const promises = []
-
-    const t = tools(dirs)
-
-    promises.push(t.createFolderProject('clusters'))
-    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'))
-    promises.push(t.syncFolderProject('.vscode'))
-
-    promises.push(t.copyFileToProject('Dockerfile'))
-    promises.push(t.syncFileToProject('tsconfig.json'))
-
-    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 run debug"
-    projectPackageJson.scripts.debug = `node --inspect -r ts-node/register ./node_modules/${projectPackageJson.plata_name}/bin/plata`
-    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)
-
-    return projectPackageJson
-}

package/templates/postinstall/lib/_install.mjs

@@ -1,30 +0,0 @@
-import path from 'node:path'
-
-export async function install({ dirs, projectPackageJson }) {
-    const { tools } = await import(`file:///${path.resolve(dirs.plataDir, 'postinstall-tools.mjs')}`.replace(/\\/g, '/'))
-    const promises = []
-
-    const t = tools(dirs)
-
-    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'))
-
-    promises.push(t.syncFileToProject('postinstall.js'))
-    promises.push(t.syncFileToProject('postinstall-tools.mjs'))
-    promises.push(t.syncFileToProject('tsconfig.json'))
-
-    projectPackageJson.type = "module"
-    projectPackageJson.scripts.dev = "ts-node -P ./tsconfig.json"
-    projectPackageJson.scripts.postinstall = "node postinstall.js"
-    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)
-
-    return projectPackageJson
-}