pwi-plata-type 0.4.166 → 0.4.167

package/src/bin/plata-swagger.ts

@@ -1,100 +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')
+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

@@ -1,49 +1,49 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-export async function loadRuntimeLibs() {
-    const plata = Object.create(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
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+export async function loadRuntimeLibs() {
+    const plata = Object.create(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

@@ -1,8 +1,8 @@
-/// <reference path="class.ts" />
-/// <reference path="dirs.ts" />
-/// <reference path="promises.ts" />
-/// <reference path="require.ts" />
-/// <reference path="fs.ts" />
-/// <reference path="sql.ts" />
-/// <reference path="switch.ts" />
+/// <reference path="class.ts" />
+/// <reference path="dirs.ts" />
+/// <reference path="promises.ts" />
+/// <reference path="require.ts" />
+/// <reference path="fs.ts" />
+/// <reference path="sql.ts" />
+/// <reference path="switch.ts" />
 /// <reference path="effect.ts" />

package/src/bin/runtime/class.ts

@@ -1,21 +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 = Object.create(null)
-        }
-
-        if (p.cache[newFunction.name] === undefined) {
-            p.cache[newFunction.name] = newFunction() 
-        }
-
-        return p.cache[newFunction.name]
-    }
+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 = Object.create(null)
+        }
+
+        if (p.cache[newFunction.name] === undefined) {
+            p.cache[newFunction.name] = newFunction() 
+        }
+
+        return p.cache[newFunction.name]
+    }
 }

package/src/bin/runtime/dirs.ts

@@ -1,26 +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()
-    )
+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/effect.ts

@@ -1,61 +1,61 @@
-import { Effect } from 'effect'
-
-declare global {
-    interface PlataRuntime extends PlataRuntimeEType {}
-}
-
-type PlataRuntimeEType = typeof PlataRuntimeE
-
-
-export namespace PlataRuntimeE {
-    export async function PromiseAll<
-        T extends readonly unknown[] | [],
-        R = RemovePlataResultOnPromiseAll<{ -readonly [P in keyof T]: Awaited<T[P]> }>
-    >(promises: T): PlataPromise<
-        R extends [] ? 
-            T extends Promise<infer U>[] ? RemovePlataResult<U>[]
-            : never
-        : R
-    > {
-        if (promises.length === 0) {
-            return [] as any
-        }
-
-        const results: any[] = []
-        let error: PlataError | null = null
-        const promisesWithID = promises.map((p, i) => ({
-            promise: p,
-            id: i 
-        }))
-
-        const effect = Effect.forEach(promisesWithID, (p) => Effect.gen(function* (_) {
-            const result: PlataResult<any> = yield* _(Effect.promise(() => p.promise))
-            
-            if (result.errorID !== undefined) {
-                error = result
-                return yield* _(Effect.interrupt)
-            }
-    
-            results[p.id] = result
-        }), { concurrency: 'unbounded' })
-
-        await Effect.runPromise(effect).catch((err) => {
-            if (error === null)
-                error = {
-                    errorID: 'PBRUNEFFPROALL001',
-                    msg: 'Erro ao realizar a operação',
-                    error: {
-                        message: err?.toString(),
-                        stack: err?.stack ?? new Error().stack
-                    }
-                }
-            ;
-        })
-
-        if (error !== null) {
-            return error
-        }
-    
-        return results as any
-    }
+import { Effect } from 'effect'
+
+declare global {
+    interface PlataRuntime extends PlataRuntimeEType {}
+}
+
+type PlataRuntimeEType = typeof PlataRuntimeE
+
+
+export namespace PlataRuntimeE {
+    export async function PromiseAll<
+        T extends readonly unknown[] | [],
+        R = RemovePlataResultOnPromiseAll<{ -readonly [P in keyof T]: Awaited<T[P]> }>
+    >(promises: T): PlataPromise<
+        R extends [] ? 
+            T extends Promise<infer U>[] ? RemovePlataResult<U>[]
+            : never
+        : R
+    > {
+        if (promises.length === 0) {
+            return [] as any
+        }
+
+        const results: any[] = []
+        let error: PlataError | null = null
+        const promisesWithID = promises.map((p, i) => ({
+            promise: p,
+            id: i 
+        }))
+
+        const effect = Effect.forEach(promisesWithID, (p) => Effect.gen(function* (_) {
+            const result: PlataResult<any> = yield* _(Effect.promise(() => p.promise))
+            
+            if (result.errorID !== undefined) {
+                error = result
+                return yield* _(Effect.interrupt)
+            }
+    
+            results[p.id] = result
+        }), { concurrency: 'unbounded' })
+
+        await Effect.runPromise(effect).catch((err) => {
+            if (error === null)
+                error = {
+                    errorID: 'PBRUNEFFPROALL001',
+                    msg: 'Erro ao realizar a operação',
+                    error: {
+                        message: err?.toString(),
+                        stack: err?.stack ?? new Error().stack
+                    }
+                }
+            ;
+        })
+
+        if (error !== null) {
+            return error
+        }
+    
+        return results as any
+    }
 }

package/src/bin/runtime/fs.ts

@@ -1,11 +1,11 @@
-import { PlataFs } from "../../libs/fs"
-
-declare global {
-   interface PlataRuntime extends PlataRuntimeEType {}
-}
-
-type PlataRuntimeEType = typeof PlataRuntimeE
-
-export namespace PlataRuntimeE {
-    export const files = PlataFs
+import { PlataFs } from "../../libs/fs"
+
+declare global {
+   interface PlataRuntime extends PlataRuntimeEType {}
+}
+
+type PlataRuntimeEType = typeof PlataRuntimeE
+
+export namespace PlataRuntimeE {
+    export const files = PlataFs
 }

package/src/bin/runtime/promises.ts

@@ -1,19 +1,19 @@
-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
-    }
-
-    export function BuildObject<T>(o: T): T {
-        return o
-    }
+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
+    }
+
+    export function BuildObject<T>(o: T): T {
+        return o
+    }
 }