pwi-plata-type 0.4.166 → 0.4.167

package/src/libs/swagger.ts

@@ -1,82 +1,82 @@
-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 = Object.create(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(/\\/g, '/').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] = Object.create(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: {
-                            ...body.extras,
-                            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
+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 = Object.create(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(/\\/g, '/').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] = Object.create(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: {
+                            ...body.extras,
+                            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/src/libs/tools.ts

@@ -1,241 +1,241 @@
-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
-
-export interface PlataError {
-    errorID: string,
-    msg: string,
-    error?: any
-}
-
-export type PlataResultado<T> = (T & { errorID?: undefined }) | PlataError 
-
-export namespace PlataDirs {
-    export function getProjectDir(): string {
-        return path.resolve('.')
-    }
-
-    export function getProjectDirTasks(): string {
-        return path.resolve('.', 'tasks')
-    }
-
-    export function getProjectDirSwagger(): string {
-        return path.resolve('.', 'swagger')
-    }
-
-    export function getProjectDirSwaggerRotas(): string {
-        return path.resolve('.', 'swagger', 'rotas')
-    }
-
-    export function getProjectDirClusters(): string {
-        return path.resolve('.', 'clusters')
-    }
-
-    export function getProjectDirConfig(): string {
-        return path.resolve('.', 'configs')
-    }
-
-    export function getProjectConfigFileDir(file: string): string {
-        return path.resolve('.', 'configs', file).replace(/\\/g, '/')
-    }
-
-    export function getProjectDirEnvs(): string {
-        return path.resolve('.', 'envs')
-    }
-
-    export function getProjectEnvFileDir(file: string): string {
-        return path.resolve('.', 'envs', file)
-    }
-
-    export function getProjectRoutesDir(): string {
-        return path.resolve('.', 'routes')
-    }
-
-    export function getPlataTempletesDir(): string {
-        return path.join(Plata.PlataDir, 'templates')
-    }
-
-    export function getPlataTempleteDir(group:string, ...template: string[]) {
-        return path.join(getPlataTempletesDir(), group, ...template)
-    }
-
-    export function getPlataBinExtraFile(file: string): string {
-        return `${path.join(Plata.ProjectJson, 'bin', 'extras', file)}`.replace(/\\/g, '/')
-    }
-
-}
-
-export namespace PlataFiles {
-    export type readLineCallback = (line: string) => Promise<void>
-
-    export type readLineCallbackSync = (line: string) => string
-
-    export function readFileAsync(file: string, callback: readLineCallback): Promise<Error | null> {
-        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),
-                        (err) => resolve(err),
-                    )
-                })
-
-                stream.on('line', (line) => {
-                    promises.push(callback(line))
-                })
-            } catch (e) {
-                resolve(e)
-            }
-        })
-    }
-
-    export function readFileSync(file: string, callback: readLineCallbackSync): Promise<string | { err: any }> {
-        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({ err: e })
-            }
-        })
-    }
-
-    export async function findFile(folders: string[], file: string): Promise<string | null> {
-        for (const folder of folders) {
-            const f = glob.sync(`${folder.replace(/\\/g, '/')}/**/${file.toLowerCase()}*`)[0]
-
-            if (f !== undefined) {
-                return f
-            }
-        }
-
-        return null
-    }
-
-    export async function findFiles(folders: string[], file: string): Promise<string[]> {
-        const files: string[] = []
-
-        for (const folder of folders) {            
-            files.push(...glob.sync(`${folder.replace(/\\/g, '/')}/**/${file}`))
-        }
-
-        return files
-    } 
-
-    export async function createFileIfNotExists(filePath: string, content: string): Promise<PlataResultado<string>> {
-        const p = path.resolve(filePath)
-
-        if (!fs.existsSync(p)) {
-            return createFile(filePath, content)
-        }
-
-        return p
-    }
-
-    export async function createFile(filePath: string, content: string): Promise<PlataResultado<string>> {
-        try {
-            const p = path.resolve(filePath)
-
-            fs.mkdirSync(path.dirname(p), { recursive: true })
-            fs.writeFileSync(p, content)
-
-            return p
-        } catch (e) {
-            return {
-                errorID: 'PLTPF0001',
-                msg: `Erro ao criar ao criar o arquivo ${filePath}`,
-                error: e
-            }
-        }
-        
-    }
-
-    export function readJsonSync(filePath: string): any {
-        return JSON.parse(fs.readFileSync(filePath).toString())
-    }
-}
-
-export namespace PlataRequire {
-    export type Required<Type> = PlataResultado<RequiredInterface<Type>>
-    export interface RequiredInterface<Type> {
-        filePath: string,
-        name: string,
-        exports: Type
-    }
-
-    export async function requireAsync<Type>(file: string): Promise<Required<Type>> {
-        const p = path.resolve(file)
-
-        const e = await import(p.replace(/\\/g, '/')).catch(e => { return {_plataError: e }  })
-
-        if (e._plataError !== undefined) {
-            return {
-                errorID: 'PLTRF0001',
-                msg: `Erro ao importar o arquivo ${file}`,
-                error: e._plataError
-            }
-        }
-
-        return {
-            filePath: p,
-            name: path.basename(p).replace('.ts', '').replace('.js', ''),
-            exports: e.default as Type
-        }
-    }
-
-    export async function requireFolderAsync<Type>(folder: string): Promise<PlataResultado<Required<Type>[]>> {
-        const promises: Promise<Required<Type>>[] = []
-        const p = path.resolve(folder)
-
-        glob.sync(`${p.replace(/\\/g, '/')}/**/*.+(js|ts)`)
-            .filter(file => !file.endsWith('.d.ts'))
-            .forEach(file => {
-                file = file.replace(/\.ts|\.js$/, '')
-
-                promises.push(requireAsync<Type>(file))
-            })
-
-        return Promise.all(promises).catch(
-            e => {
-                return {
-                    errorID: 'PLTRF0002',
-                    msg: `Erro ao importar a pasta ${folder}`,
-                    error: e
-                }
-            }
-        )
-    }
-}
-
-export namespace PlataExtra {
-    export function sleep(ms: number) {
-        return new Promise(resolve => setTimeout(resolve, ms))
-    }
-
-    export function timeout(ms: number, error: PlataError): Promise<PlataError> {
-        return new Promise((_, reject) => setTimeout(() => reject(error), ms))
-    }
+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
+
+export interface PlataError {
+    errorID: string,
+    msg: string,
+    error?: any
+}
+
+export type PlataResultado<T> = (T & { errorID?: undefined }) | PlataError 
+
+export namespace PlataDirs {
+    export function getProjectDir(): string {
+        return path.resolve('.')
+    }
+
+    export function getProjectDirTasks(): string {
+        return path.resolve('.', 'tasks')
+    }
+
+    export function getProjectDirSwagger(): string {
+        return path.resolve('.', 'swagger')
+    }
+
+    export function getProjectDirSwaggerRotas(): string {
+        return path.resolve('.', 'swagger', 'rotas')
+    }
+
+    export function getProjectDirClusters(): string {
+        return path.resolve('.', 'clusters')
+    }
+
+    export function getProjectDirConfig(): string {
+        return path.resolve('.', 'configs')
+    }
+
+    export function getProjectConfigFileDir(file: string): string {
+        return path.resolve('.', 'configs', file).replace(/\\/g, '/')
+    }
+
+    export function getProjectDirEnvs(): string {
+        return path.resolve('.', 'envs')
+    }
+
+    export function getProjectEnvFileDir(file: string): string {
+        return path.resolve('.', 'envs', file)
+    }
+
+    export function getProjectRoutesDir(): string {
+        return path.resolve('.', 'routes')
+    }
+
+    export function getPlataTempletesDir(): string {
+        return path.join(Plata.PlataDir, 'templates')
+    }
+
+    export function getPlataTempleteDir(group:string, ...template: string[]) {
+        return path.join(getPlataTempletesDir(), group, ...template)
+    }
+
+    export function getPlataBinExtraFile(file: string): string {
+        return `${path.join(Plata.ProjectJson, 'bin', 'extras', file)}`.replace(/\\/g, '/')
+    }
+
+}
+
+export namespace PlataFiles {
+    export type readLineCallback = (line: string) => Promise<void>
+
+    export type readLineCallbackSync = (line: string) => string
+
+    export function readFileAsync(file: string, callback: readLineCallback): Promise<Error | null> {
+        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),
+                        (err) => resolve(err),
+                    )
+                })
+
+                stream.on('line', (line) => {
+                    promises.push(callback(line))
+                })
+            } catch (e) {
+                resolve(e)
+            }
+        })
+    }
+
+    export function readFileSync(file: string, callback: readLineCallbackSync): Promise<string | { err: any }> {
+        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({ err: e })
+            }
+        })
+    }
+
+    export async function findFile(folders: string[], file: string): Promise<string | null> {
+        for (const folder of folders) {
+            const f = glob.sync(`${folder.replace(/\\/g, '/')}/**/${file.toLowerCase()}*`)[0]
+
+            if (f !== undefined) {
+                return f
+            }
+        }
+
+        return null
+    }
+
+    export async function findFiles(folders: string[], file: string): Promise<string[]> {
+        const files: string[] = []
+
+        for (const folder of folders) {            
+            files.push(...glob.sync(`${folder.replace(/\\/g, '/')}/**/${file}`))
+        }
+
+        return files
+    } 
+
+    export async function createFileIfNotExists(filePath: string, content: string): Promise<PlataResultado<string>> {
+        const p = path.resolve(filePath)
+
+        if (!fs.existsSync(p)) {
+            return createFile(filePath, content)
+        }
+
+        return p
+    }
+
+    export async function createFile(filePath: string, content: string): Promise<PlataResultado<string>> {
+        try {
+            const p = path.resolve(filePath)
+
+            fs.mkdirSync(path.dirname(p), { recursive: true })
+            fs.writeFileSync(p, content)
+
+            return p
+        } catch (e) {
+            return {
+                errorID: 'PLTPF0001',
+                msg: `Erro ao criar ao criar o arquivo ${filePath}`,
+                error: e
+            }
+        }
+        
+    }
+
+    export function readJsonSync(filePath: string): any {
+        return JSON.parse(fs.readFileSync(filePath).toString())
+    }
+}
+
+export namespace PlataRequire {
+    export type Required<Type> = PlataResultado<RequiredInterface<Type>>
+    export interface RequiredInterface<Type> {
+        filePath: string,
+        name: string,
+        exports: Type
+    }
+
+    export async function requireAsync<Type>(file: string): Promise<Required<Type>> {
+        const p = path.resolve(file)
+
+        const e = await import(p.replace(/\\/g, '/')).catch(e => { return {_plataError: e }  })
+
+        if (e._plataError !== undefined) {
+            return {
+                errorID: 'PLTRF0001',
+                msg: `Erro ao importar o arquivo ${file}`,
+                error: e._plataError
+            }
+        }
+
+        return {
+            filePath: p,
+            name: path.basename(p).replace('.ts', '').replace('.js', ''),
+            exports: e.default as Type
+        }
+    }
+
+    export async function requireFolderAsync<Type>(folder: string): Promise<PlataResultado<Required<Type>[]>> {
+        const promises: Promise<Required<Type>>[] = []
+        const p = path.resolve(folder)
+
+        glob.sync(`${p.replace(/\\/g, '/')}/**/*.+(js|ts)`)
+            .filter(file => !file.endsWith('.d.ts'))
+            .forEach(file => {
+                file = file.replace(/\.ts|\.js$/, '')
+
+                promises.push(requireAsync<Type>(file))
+            })
+
+        return Promise.all(promises).catch(
+            e => {
+                return {
+                    errorID: 'PLTRF0002',
+                    msg: `Erro ao importar a pasta ${folder}`,
+                    error: e
+                }
+            }
+        )
+    }
+}
+
+export namespace PlataExtra {
+    export function sleep(ms: number) {
+        return new Promise(resolve => setTimeout(resolve, ms))
+    }
+
+    export function timeout(ms: number, error: PlataError): Promise<PlataError> {
+        return new Promise((_, reject) => setTimeout(() => reject(error), ms))
+    }
 }