pwi-plata-type 0.4.166 → 0.4.167

package/src/libs/hot-reload.ts

@@ -1,64 +1,64 @@
-import watch from 'node-watch'
-import { PlataCluster } from '..'
-import { PlataBuild } from './build'
-
-export namespace HotReload {
-    export function canReload(filename: string): boolean {
-        if (filename.includes('__BUILD__'))
-            return false
-        ;
-
-        if (filename.includes('__RELEASE__'))
-            return false
-        ;
-
-        if (filename.includes('node_modules'))
-            return false
-        ;
-
-        if (Plata.ProjectJson['ignore-hot'])
-            for (let i = 0; i < Plata.ProjectJson['ignore-hot'].length; i++) {
-                const ignore = Plata.ProjectJson['ignore-hot'][i];
-                
-                if(filename.includes(ignore))
-                    return false
-                ;
-            }
-        ;
-
-        return /(ts|env|json)$/.test(filename)
-    }
-
-    export async function realod() {
-        await PlataBuild.compile({
-            basePath: Plata.ProjectDir,
-            mapFiles: true,
-            packageJsonSetup: false,
-            otimizar: false,
-        })
-
-        const cluster = new PlataCluster.PlataClusterManager()
-
-        cluster._sendMsgToAllWorkers({
-            action: 'RELOAD',
-            msg: true
-        })
-    }
-
-    export async function setupHotReloadPrimary() {
-        console.log('🔥 Hot Realod ativo')
-        watch(Plata.ProjectDir, { 
-            recursive: true,
-            delay: 500,
-            filter: HotReload.canReload 
-        }, HotReload.realod)
-    }
-
-    export async function setupHotReloadWorker() {
-        process.on('message', (msg: Cluster.Actions) => {
-            if (msg.action === 'RELOAD')
-                process.exit(0)
-            ;
-        })
-    }
+import watch from 'node-watch'
+import { PlataCluster } from '..'
+import { PlataBuild } from './build'
+
+export namespace HotReload {
+    export function canReload(filename: string): boolean {
+        if (filename.includes('__BUILD__'))
+            return false
+        ;
+
+        if (filename.includes('__RELEASE__'))
+            return false
+        ;
+
+        if (filename.includes('node_modules'))
+            return false
+        ;
+
+        if (Plata.ProjectJson['ignore-hot'])
+            for (let i = 0; i < Plata.ProjectJson['ignore-hot'].length; i++) {
+                const ignore = Plata.ProjectJson['ignore-hot'][i];
+                
+                if(filename.includes(ignore))
+                    return false
+                ;
+            }
+        ;
+
+        return /(ts|env|json)$/.test(filename)
+    }
+
+    export async function realod() {
+        await PlataBuild.compile({
+            basePath: Plata.ProjectDir,
+            mapFiles: true,
+            packageJsonSetup: false,
+            otimizar: false,
+        })
+
+        const cluster = new PlataCluster.PlataClusterManager()
+
+        cluster._sendMsgToAllWorkers({
+            action: 'RELOAD',
+            msg: true
+        })
+    }
+
+    export async function setupHotReloadPrimary() {
+        console.log('🔥 Hot Realod ativo')
+        watch(Plata.ProjectDir, { 
+            recursive: true,
+            delay: 500,
+            filter: HotReload.canReload 
+        }, HotReload.realod)
+    }
+
+    export async function setupHotReloadWorker() {
+        process.on('message', (msg: Cluster.Actions) => {
+            if (msg.action === 'RELOAD')
+                process.exit(0)
+            ;
+        })
+    }
 }

package/src/libs/models/index.ts

@@ -1,5 +1,5 @@
-export * from './model-validations'
-export * from './model-template'
-export * from './model-template-env'
-export * from './model-template-union'
+export * from './model-validations'
+export * from './model-template'
+export * from './model-template-env'
+export * from './model-template-union'
 export * from './model-template-combine'

package/src/libs/models/model-template-combine.ts

@@ -1,94 +1,94 @@
-export class ModelTemplateCombine<const T extends readonly Model.ModelClass[]> {
-    readonly type: ArrayCombine<T>['type']
-    readonly models: T
-    public readonly validations: Set<(value: typeof this.type) => Promise<Model.ValidateReturn>>
-    public readonly filters: Set<(value: Model.RemoveTypesForFilter<typeof this.type>) => ArrayCombine<T>['type']>
-
-    constructor(models: T) {
-        this.models = models
-        this.validations = new Set()
-        this.filters = new Set()
-    }
-
-    public addValidation(callback: (value: typeof this.type) => Promise<Model.ValidateReturn>) {
-        this.validations.add(callback)
-    }
-
-    public addFilters(callback: (value: Model.RemoveTypesForFilter<typeof this.type>) => Model.RemoveTypesForFilter<typeof this.type>) {
-        this.filters.add(callback)
-    }
-
-    public filter(obj: any): any {
-        let value = obj
-        for (let i = 0; i < this.models.length; i++) {
-            const model = this.models[i]
-
-            if (model.filter !== undefined) {
-                value = model.filter(value)
-            }
-        }
-
-        this.filters.forEach(f => { value = f(value)})
-
-        return value
-    }
-
-    public async validate(obj: any, skipFilter?: true): Promise<Model.ModelValidateReturnHelper<typeof this.type, undefined>> {
-        let v = obj
-
-        if (!skipFilter) {
-            v = this.filter(v)
-        }
-
-        { // Valida as models
-            const promises: Promise<{ errors?: PlataError[] }>[] = []
-
-            for (let i = 0; i < this.models.length; i++) {
-                const model = this.models[i];
-                
-                promises.push(Plata.FastPromise(() => model.validate(v, true)))
-            }
-
-            const results = await Promise.all(promises)
-
-            const errors = results
-                .filter((r): r is { errors: PlataError[] } => r.errors !== undefined)
-                .flatMap(r => r.errors)
-            ;
-
-            if (errors.length !== 0) {
-                return {
-                    value: undefined,
-                    errors
-                }
-            }
-        }
-
-
-        { // Validacoes adicionais
-            const promises: Promise<Model.ValidateReturn>[] = []
-
-            this.validations.forEach(va => 
-                promises.push(
-                    Plata.FastPromise(() => va(v))
-                )
-            )
-
-            const result = await Promise.all(promises)
-
-            const errors = result.filter(Boolean)
-
-            if (errors.length !== 0) {
-                return  {
-                    errors,
-                    value: undefined
-                }
-            }
-        }
-
-        return {
-            value: v,
-            errors: undefined
-        } 
-    }
+export class ModelTemplateCombine<const T extends readonly Model.ModelClass[]> {
+    readonly type: ArrayCombine<T>['type']
+    readonly models: T
+    public readonly validations: Set<(value: typeof this.type) => Promise<Model.ValidateReturn>>
+    public readonly filters: Set<(value: Model.RemoveTypesForFilter<typeof this.type>) => ArrayCombine<T>['type']>
+
+    constructor(models: T) {
+        this.models = models
+        this.validations = new Set()
+        this.filters = new Set()
+    }
+
+    public addValidation(callback: (value: typeof this.type) => Promise<Model.ValidateReturn>) {
+        this.validations.add(callback)
+    }
+
+    public addFilters(callback: (value: Model.RemoveTypesForFilter<typeof this.type>) => Model.RemoveTypesForFilter<typeof this.type>) {
+        this.filters.add(callback)
+    }
+
+    public filter(obj: any): any {
+        let value = obj
+        for (let i = 0; i < this.models.length; i++) {
+            const model = this.models[i]
+
+            if (model.filter !== undefined) {
+                value = model.filter(value)
+            }
+        }
+
+        this.filters.forEach(f => { value = f(value)})
+
+        return value
+    }
+
+    public async validate(obj: any, skipFilter?: true): Promise<Model.ModelValidateReturnHelper<typeof this.type, undefined>> {
+        let v = obj
+
+        if (!skipFilter) {
+            v = this.filter(v)
+        }
+
+        { // Valida as models
+            const promises: Promise<{ errors?: PlataError[] }>[] = []
+
+            for (let i = 0; i < this.models.length; i++) {
+                const model = this.models[i];
+                
+                promises.push(Plata.FastPromise(() => model.validate(v, true)))
+            }
+
+            const results = await Promise.all(promises)
+
+            const errors = results
+                .filter((r): r is { errors: PlataError[] } => r.errors !== undefined)
+                .flatMap(r => r.errors)
+            ;
+
+            if (errors.length !== 0) {
+                return {
+                    value: undefined,
+                    errors
+                }
+            }
+        }
+
+
+        { // Validacoes adicionais
+            const promises: Promise<Model.ValidateReturn>[] = []
+
+            this.validations.forEach(va => 
+                promises.push(
+                    Plata.FastPromise(() => va(v))
+                )
+            )
+
+            const result = await Promise.all(promises)
+
+            const errors = result.filter(Boolean)
+
+            if (errors.length !== 0) {
+                return  {
+                    errors,
+                    value: undefined
+                }
+            }
+        }
+
+        return {
+            value: v,
+            errors: undefined
+        } 
+    }
 }

package/src/libs/models/model-template-env.ts

@@ -1,58 +1,58 @@
-import { PlataError } from "../tools"
-import { ModelsInternals } from "./tools"
-
-export class ModelTemplateEnv<const T extends Model.TemplateEnv> {
-    public readonly template: T
-    public readonly validations: Model.ModelTemplateEnvValidation<T>[] = []
-    public readonly type: Model.ExtractTemplateEnvType<T>
-
-    constructor(template: T) {
-        this.template = template
-    }
-
-    public addValidation(callback: Model.ModelTemplateEnvValidation<T>) {
-        this.validations.push(callback)
-    }
-
-    public async validate(value: Record<string, string | undefined>): Promise<Model.ModelValidateEnvReturn<T>> {
-        let errors = await ModelsInternals.validateTemplateEnv(value, this.template)
-
-        if (errors.errorID !== undefined) {
-            return {
-                errors: [errors],
-                value: undefined
-            }
-        }
-
-        if (errors.length !== 0) {
-            return {
-                errors,
-                value: undefined
-            }
-        }
-
-        const promises: Promise<null | PlataError>[] = []
-
-        for (let i = this.validations.length - 1; i >= 0; i--) {
-            const validation = this.validations[i];
-
-            promises.push(Plata.FastPromise(() => validation(value as any)))
-        }
-
-        errors = (await Promise.all(promises)).filter(Boolean)
-
-        if (errors.length !== 0) {
-            return {
-                errors,
-                value: undefined
-            }
-        }
-
-        return {
-            value: value as any,
-            errors: undefined
-        }
-
-    }
-
-}
+import { PlataError } from "../tools"
+import { ModelsInternals } from "./tools"
+
+export class ModelTemplateEnv<const T extends Model.TemplateEnv> {
+    public readonly template: T
+    public readonly validations: Model.ModelTemplateEnvValidation<T>[] = []
+    public readonly type: Model.ExtractTemplateEnvType<T>
+
+    constructor(template: T) {
+        this.template = template
+    }
+
+    public addValidation(callback: Model.ModelTemplateEnvValidation<T>) {
+        this.validations.push(callback)
+    }
+
+    public async validate(value: Record<string, string | undefined>): Promise<Model.ModelValidateEnvReturn<T>> {
+        let errors = await ModelsInternals.validateTemplateEnv(value, this.template)
+
+        if (errors.errorID !== undefined) {
+            return {
+                errors: [errors],
+                value: undefined
+            }
+        }
+
+        if (errors.length !== 0) {
+            return {
+                errors,
+                value: undefined
+            }
+        }
+
+        const promises: Promise<null | PlataError>[] = []
+
+        for (let i = this.validations.length - 1; i >= 0; i--) {
+            const validation = this.validations[i];
+
+            promises.push(Plata.FastPromise(() => validation(value as any)))
+        }
+
+        errors = (await Promise.all(promises)).filter(Boolean)
+
+        if (errors.length !== 0) {
+            return {
+                errors,
+                value: undefined
+            }
+        }
+
+        return {
+            value: value as any,
+            errors: undefined
+        }
+
+    }
+
+}

package/src/libs/models/model-template-union.ts

@@ -1,84 +1,84 @@
-export class ModelTemplateUnion<const C extends Model.TemplateUnionConfig, const R extends Model.TemplateRecord> {
-    public readonly config: C
-    public readonly templates: R
-    public readonly type: Model.ExtractModelUnionType<C, R>
-    public readonly filters: Set<(x: Model.ExtractModelUnionTypeFilter<C, R>) => Model.ExtractModelUnionTypeFilter<C, R>>
-
-    constructor(config: C, templates: R) {
-        this.config = config
-        this.templates = templates
-        this.filters = new Set()
-    }
-
-    public addFilter(filter: (x: Model.ExtractModelUnionTypeFilter<C, R>) => Model.ExtractModelUnionTypeFilter<C, R>) {
-        this.filters.add(filter)
-    }
-
-    public getExtractFromUnion(value: any): PlataResult<Model.ExtractModelUnionReturn<C, R>> {
-        let type = `${value[this.config.key] ?? null}`
-        value[this.config.key] = value[this.config.key] ?? null
-
-        const template = this.templates[type]
-
-        if (template === undefined) {
-            return {
-                errorID: 'PLMODUNEXTFRUN001',
-                msg: `O Valor de ${this.config.key} tem que ser ${Object.keys(this.templates).join(',')}`,
-                error: type
-            }
-        }
-
-        return {
-            model: template,
-            value: value,
-        } as any
-    }
-
-    /**
-     * Essa função so é para ser usada dentro da plataforma, considera que logo depois será rodado o validate
-     */
-    public filter(value: any): any {
-        const extraced = this.getExtractFromUnion(value)
-
-        if (extraced.errorID !== undefined) {
-            return value
-        }
-
-        if (extraced.model.filter !== undefined) {
-            value = extraced.model.filter(value)
-        }
-
-        this.filters.forEach(f => { value = f(value)})
-
-        return value
-    }
-
-    public async validate(value: any, skipFilter?: true): Promise<Model.ModelValidateReturnHelper<typeof this.type, undefined>> {
-        const extraced = this.getExtractFromUnion(value)
-
-        if (extraced.errorID !== undefined) {
-            return {
-                errors: [extraced],
-                value: undefined
-            }
-        }
-
-        if (!skipFilter) {
-            this.filters.forEach(f => { value = f(value) })
-        }
-
-        const result = await extraced.model.validate(extraced.value, skipFilter)
-
-        if (result.errors !== undefined) {
-            return {
-                errors: result.errors,
-                value: undefined
-            }
-        }
-
-        return {
-            errors: undefined,
-            value: result.value
-        }
-    }
+export class ModelTemplateUnion<const C extends Model.TemplateUnionConfig, const R extends Model.TemplateRecord> {
+    public readonly config: C
+    public readonly templates: R
+    public readonly type: Model.ExtractModelUnionType<C, R>
+    public readonly filters: Set<(x: Model.ExtractModelUnionTypeFilter<C, R>) => Model.ExtractModelUnionTypeFilter<C, R>>
+
+    constructor(config: C, templates: R) {
+        this.config = config
+        this.templates = templates
+        this.filters = new Set()
+    }
+
+    public addFilter(filter: (x: Model.ExtractModelUnionTypeFilter<C, R>) => Model.ExtractModelUnionTypeFilter<C, R>) {
+        this.filters.add(filter)
+    }
+
+    public getExtractFromUnion(value: any): PlataResult<Model.ExtractModelUnionReturn<C, R>> {
+        let type = `${value[this.config.key] ?? null}`
+        value[this.config.key] = value[this.config.key] ?? null
+
+        const template = this.templates[type]
+
+        if (template === undefined) {
+            return {
+                errorID: 'PLMODUNEXTFRUN001',
+                msg: `O Valor de ${this.config.key} tem que ser ${Object.keys(this.templates).join(',')}`,
+                error: type
+            }
+        }
+
+        return {
+            model: template,
+            value: value,
+        } as any
+    }
+
+    /**
+     * Essa função so é para ser usada dentro da plataforma, considera que logo depois será rodado o validate
+     */
+    public filter(value: any): any {
+        const extraced = this.getExtractFromUnion(value)
+
+        if (extraced.errorID !== undefined) {
+            return value
+        }
+
+        if (extraced.model.filter !== undefined) {
+            value = extraced.model.filter(value)
+        }
+
+        this.filters.forEach(f => { value = f(value)})
+
+        return value
+    }
+
+    public async validate(value: any, skipFilter?: true): Promise<Model.ModelValidateReturnHelper<typeof this.type, undefined>> {
+        const extraced = this.getExtractFromUnion(value)
+
+        if (extraced.errorID !== undefined) {
+            return {
+                errors: [extraced],
+                value: undefined
+            }
+        }
+
+        if (!skipFilter) {
+            this.filters.forEach(f => { value = f(value) })
+        }
+
+        const result = await extraced.model.validate(extraced.value, skipFilter)
+
+        if (result.errors !== undefined) {
+            return {
+                errors: result.errors,
+                value: undefined
+            }
+        }
+
+        return {
+            errors: undefined,
+            value: result.value
+        }
+    }
 }