pwi-plata-type 0.4.165 → 0.4.166

package/src/tests/effect.test.ts

@@ -1,63 +1,63 @@
-import { describe, it, before } from "node:test"
-import assert from "node:assert"
-import { loadRuntimeLibs } from "../bin/runtime/_setupRuntime"
-
-
-describe('PromiseAll', () => {
-    const plataPromise = (async () => {
-        const g = global as any
-
-        g.Plata = await loadRuntimeLibs()
-    })()
-
-    before(async () => {
-        await plataPromise
-    })
-
-    it('should resolve an array of promises', async () => {
-        const promises = [
-            Plata.FastPromise(async (): Promise<1> => 1),
-            Plata.FastPromise(async (): Promise<2> => 2),
-            Plata.FastPromise(async (): Promise<3> => 3),
-        ] as const
-
-        const result = await Plata.PromiseAll(promises)
-
-        assert.strictEqual(result.errorID, undefined)
-        
-        const type: [ 1, 2, 3 ] = result
-        assert.deepStrictEqual(result, [1, 2, 3])
-        
-    })
-
-    it('should return an empty array if input is an empty array', async () => {
-        const promises: [] = []
-
-        const result = await Plata.PromiseAll(promises)
-
-        assert.strictEqual(result.errorID, undefined)
-    
-        const type: unknown[] = result
-        assert.deepStrictEqual(result, [])
-    })
-
-    it('should handle promises that reject', async () => {
-        const promises = [
-            Plata.FastPromise(() => Promise.resolve(1)),
-            Plata.FastPromise(() => Promise.resolve(Plata.BuildPlataError({
-                errorID: 'a',
-                msg: '',
-                error: ''
-            }))),
-            Plata.FastPromise(() => Promise.resolve(3)),
-        ]
-
-        const result = await Plata.PromiseAll(promises)
-
-        if (result.errorID === undefined) {
-            const type: number[] = result    
-        }
-        
-        assert.strictEqual(result.errorID, 'a')
-    })
+import { describe, it, before } from "node:test"
+import assert from "node:assert"
+import { loadRuntimeLibs } from "../bin/runtime/_setupRuntime"
+
+
+describe('PromiseAll', () => {
+    const plataPromise = (async () => {
+        const g = global as any
+
+        g.Plata = await loadRuntimeLibs()
+    })()
+
+    before(async () => {
+        await plataPromise
+    })
+
+    it('should resolve an array of promises', async () => {
+        const promises = [
+            Plata.FastPromise(async (): Promise<1> => 1),
+            Plata.FastPromise(async (): Promise<2> => 2),
+            Plata.FastPromise(async (): Promise<3> => 3),
+        ] as const
+
+        const result = await Plata.PromiseAll(promises)
+
+        assert.strictEqual(result.errorID, undefined)
+        
+        const type: [ 1, 2, 3 ] = result
+        assert.deepStrictEqual(result, [1, 2, 3])
+        
+    })
+
+    it('should return an empty array if input is an empty array', async () => {
+        const promises: [] = []
+
+        const result = await Plata.PromiseAll(promises)
+
+        assert.strictEqual(result.errorID, undefined)
+    
+        const type: unknown[] = result
+        assert.deepStrictEqual(result, [])
+    })
+
+    it('should handle promises that reject', async () => {
+        const promises = [
+            Plata.FastPromise(() => Promise.resolve(1)),
+            Plata.FastPromise(() => Promise.resolve(Plata.BuildPlataError({
+                errorID: 'a',
+                msg: '',
+                error: ''
+            }))),
+            Plata.FastPromise(() => Promise.resolve(3)),
+        ]
+
+        const result = await Plata.PromiseAll(promises)
+
+        if (result.errorID === undefined) {
+            const type: number[] = result    
+        }
+        
+        assert.strictEqual(result.errorID, 'a')
+    })
 })

package/src/tests/model.env.test.ts

@@ -1,67 +1,67 @@
-import { describe, it, before } from "node:test"
-import assert from "node:assert"
-import { loadRuntimeLibs } from "../bin/runtime/_setupRuntime"
-import { PlataModels } from ".."
-
-describe('PlataModels.env', () => {
-    const plataPromise = (async () => {
-        const g = global as any
-    
-        g.Plata = await loadRuntimeLibs()
-    })()
-
-    before(async () => {
-        await plataPromise
-    })
-
-    const model = new PlataModels.ModelTemplateEnv({
-        ENV_enum: [ PlataModels.Enum([ 0, 1 ]) ],
-        ENV_decimal: [ PlataModels.Decimal(2,2) ],
-        ENV_intMin: [ PlataModels.Int(5) ],
-        ENV_intMax: [ PlataModels.Int(undefined, 5) ],
-        ENV_intRequired: [ PlataModels.Required(), PlataModels.Int() ],
-        ENV_smallDateTime: [ PlataModels.SmallDateTime() ],
-        ENV_varChar: [ PlataModels.VarChar(1) ],
-    })
-
-    const getOkayObj = () => ({
-        ENV_enum: `${0}`,
-        ENV_decimal: `${22.22}`,
-        ENV_intMin: `${5}`,
-        ENV_intMax: `${5}`,
-        ENV_intRequired: `${6}`,
-        ENV_smallDateTime: '2022-12-04',
-        ENV_varChar: '1',
-    })
-
-    const getNotOkayObj = () => ({
-        ENV_enum: `${2}`,
-        ENV_decimal: `${222.222}`,
-        ENV_intMin: `${4}`,
-        ENV_intMax: `${6}`,
-        ENV_smallDateTime: '2022-12--04',
-        ENV_varChar: '12',
-    })
-
-    it('Validations (Okay)', async () => {
-        const okayObj = getOkayObj()
-
-        const value = await model.validate(okayObj)
-
-        assert.strictEqual(value.errors, undefined)
-        assert.deepEqual(value.value, okayObj)
-    })
-
-    it('Validations (Not Okay)', async () => {
-        const notOkayObj = getNotOkayObj()
-
-        const value = await model.validate(notOkayObj)
-
-        assert.notStrictEqual(value.errors, undefined)
-        assert.strictEqual(
-            value.errors?.length,
-            Object.keys(model.template).length, 
-            value.errors?.map(e => `${e.errorID} - ${e.msg}`).join('\n')
-        )
-    })
+import { describe, it, before } from "node:test"
+import assert from "node:assert"
+import { loadRuntimeLibs } from "../bin/runtime/_setupRuntime"
+import { PlataModels } from ".."
+
+describe('PlataModels.env', () => {
+    const plataPromise = (async () => {
+        const g = global as any
+    
+        g.Plata = await loadRuntimeLibs()
+    })()
+
+    before(async () => {
+        await plataPromise
+    })
+
+    const model = new PlataModels.ModelTemplateEnv({
+        ENV_enum: [ PlataModels.Enum([ 0, 1 ]) ],
+        ENV_decimal: [ PlataModels.Decimal(2,2) ],
+        ENV_intMin: [ PlataModels.Int(5) ],
+        ENV_intMax: [ PlataModels.Int(undefined, 5) ],
+        ENV_intRequired: [ PlataModels.Required(), PlataModels.Int() ],
+        ENV_smallDateTime: [ PlataModels.SmallDateTime() ],
+        ENV_varChar: [ PlataModels.VarChar(1) ],
+    })
+
+    const getOkayObj = () => ({
+        ENV_enum: `${0}`,
+        ENV_decimal: `${22.22}`,
+        ENV_intMin: `${5}`,
+        ENV_intMax: `${5}`,
+        ENV_intRequired: `${6}`,
+        ENV_smallDateTime: '2022-12-04',
+        ENV_varChar: '1',
+    })
+
+    const getNotOkayObj = () => ({
+        ENV_enum: `${2}`,
+        ENV_decimal: `${222.222}`,
+        ENV_intMin: `${4}`,
+        ENV_intMax: `${6}`,
+        ENV_smallDateTime: '2022-12--04',
+        ENV_varChar: '12',
+    })
+
+    it('Validations (Okay)', async () => {
+        const okayObj = getOkayObj()
+
+        const value = await model.validate(okayObj)
+
+        assert.strictEqual(value.errors, undefined)
+        assert.deepEqual(value.value, okayObj)
+    })
+
+    it('Validations (Not Okay)', async () => {
+        const notOkayObj = getNotOkayObj()
+
+        const value = await model.validate(notOkayObj)
+
+        assert.notStrictEqual(value.errors, undefined)
+        assert.strictEqual(
+            value.errors?.length,
+            Object.keys(model.template).length, 
+            value.errors?.map(e => `${e.errorID} - ${e.msg}`).join('\n')
+        )
+    })
 })

package/src/tests/model.test.ts

@@ -1,142 +1,142 @@
-import { describe, it, before } from "node:test"
-import assert from "node:assert"
-import { PlataModels } from ".."
-import { loadRuntimeLibs } from "../bin/runtime/_setupRuntime"
-
-describe('PlataModels', () => {
-    const plataPromise = (async () => {
-        const g = global as any
-    
-        g.Plata = await loadRuntimeLibs()
-    })()
-    
-    before(async () => {
-        await plataPromise
-    })
-
-    const objOkay: typeof modelValidations.type = {
-        enum: 0,
-        stringDateTime: '2022-12-04T02:06:22',
-        dateTime: new Date(),
-        decimal: 99.99,
-        intMin: 5,
-        intMax: 5,
-        intRequired: 1,
-        smallDateTime: '2022-12-04',
-        telefone: '99-999999999',
-        telefoneDDI: '+055 99-999999999',
-        varCharMin: '1',
-        varChar: '1',
-        useModel: {
-            array: [],
-            array_objects: [],
-            object:  {
-                param: new Date()
-            },
-            param: 1,
-            subModel: {
-                required: 1,
-                optional: null
-            },
-            subModelArray: []
-        }
-    }
-
-    const objNotOkay = {
-        enum: 2,
-        stringDateTime: '',
-        dateTime: '',
-        decimal: 5.666666666666,
-        intMin: 1,
-        intMax: 6,
-        intRequired: null,
-        smallDateTime: '',
-        telefone: '',
-        telefoneDDI: '',
-        varCharMin: '',
-        varChar: '11',
-        useModel: {}
-    }
-
-    const modelStruct = new PlataModels.ModelTemplate({
-        param: [ PlataModels.Required(), PlataModels.Int() ],
-        object: {
-            param: [ PlataModels.Required(), PlataModels.DateTime() ],
-        },
-        subModel: [ PlataModels.useModel(new PlataModels.ModelTemplate({ 
-            optional: [ PlataModels.Optional(), PlataModels.Int() ],
-            required: [ PlataModels.Required(), PlataModels.Int() ],
-        } as const , {})) ],
-        subModelArray: [[ PlataModels.useModel(new PlataModels.ModelTemplate({ 
-            optional: [ PlataModels.Optional(), PlataModels.Int() ],
-            required: [ PlataModels.Required(), PlataModels.Int() ],
-        } as const , {})) ]],
-        array: [ [ PlataModels.VarChar(30) ] ],
-        array_objects: [{
-            param: [ PlataModels.Optional(), PlataModels.Decimal(10,2) ]
-        }]
-    } as const, {})
-
-    const modelValidations = new PlataModels.ModelTemplate({
-        enum: [ PlataModels.Enum([ 0,1 ]) ],
-        stringDateTime: [ PlataModels.StringDateTime() ],
-        dateTime: [ PlataModels.DateTime() ],
-        decimal: [ PlataModels.Decimal(2,2) ],
-        intMin: [ PlataModels.Int(5) ],
-        intMax: [ PlataModels.Int(undefined, 5) ],
-        intRequired:  [ PlataModels.Required(), PlataModels.Int() ],
-        smallDateTime: [ PlataModels.SmallDateTime() ],
-        telefone: [ PlataModels.Telefone() ],
-        telefoneDDI: [ PlataModels.TelefoneDDI() ],
-        varCharMin: [ PlataModels.VarChar(1, 1) ],
-        varChar:  [ PlataModels.VarChar(1) ],
-        useModel: [ PlataModels.useModel(modelStruct) ],
-    } as const, {})
-
-    it('Struct Filter', () => {
-        const InitObj = {
-            array_objects: [{ param: '123' }],
-            subModelArray: [{ required: 1 }]
-        }
-
-        const FilteredObj = modelStruct.filter(InitObj)
-
-        assert.deepEqual(FilteredObj, {
-            param: null,
-            object: {
-                param: null,
-            },
-            subModel: {
-                required: null,
-                optional: null,
-            },
-            subModelArray: [{
-                required: 1,
-                optional: null,
-            }],
-            array: [],
-            array_objects: [{
-                param: '123'
-            }]
-        })
-    })
-
-    it('Validations (Okay)', async () => {
-        const { errors, value } = await modelValidations.validate(objOkay)
-
-        assert.strictEqual(errors, undefined)
-        assert.deepEqual(value, objOkay)
-    })
-
-    it('Validations (Not Okay)', async () => {
-        const { errors, value } = await modelValidations.validate(objNotOkay)
-
-        assert.notStrictEqual(errors, undefined)
-        assert.strictEqual(
-            errors?.length,
-            Object.keys(modelValidations.template).length, 
-            errors?.map(e => `${e.errorID} - ${e.msg}`).join('\n')
-        )
-        assert.deepEqual(value, objNotOkay)
-    })
+import { describe, it, before } from "node:test"
+import assert from "node:assert"
+import { PlataModels } from ".."
+import { loadRuntimeLibs } from "../bin/runtime/_setupRuntime"
+
+describe('PlataModels', () => {
+    const plataPromise = (async () => {
+        const g = global as any
+    
+        g.Plata = await loadRuntimeLibs()
+    })()
+    
+    before(async () => {
+        await plataPromise
+    })
+
+    const objOkay: typeof modelValidations.type = {
+        enum: 0,
+        stringDateTime: '2022-12-04T02:06:22',
+        dateTime: new Date(),
+        decimal: 99.99,
+        intMin: 5,
+        intMax: 5,
+        intRequired: 1,
+        smallDateTime: '2022-12-04',
+        telefone: '99-999999999',
+        telefoneDDI: '+055 99-999999999',
+        varCharMin: '1',
+        varChar: '1',
+        useModel: {
+            array: [],
+            array_objects: [],
+            object:  {
+                param: new Date()
+            },
+            param: 1,
+            subModel: {
+                required: 1,
+                optional: null
+            },
+            subModelArray: []
+        }
+    }
+
+    const objNotOkay = {
+        enum: 2,
+        stringDateTime: '',
+        dateTime: '',
+        decimal: 5.666666666666,
+        intMin: 1,
+        intMax: 6,
+        intRequired: null,
+        smallDateTime: '',
+        telefone: '',
+        telefoneDDI: '',
+        varCharMin: '',
+        varChar: '11',
+        useModel: {}
+    }
+
+    const modelStruct = new PlataModels.ModelTemplate({
+        param: [ PlataModels.Required(), PlataModels.Int() ],
+        object: {
+            param: [ PlataModels.Required(), PlataModels.DateTime() ],
+        },
+        subModel: [ PlataModels.useModel(new PlataModels.ModelTemplate({ 
+            optional: [ PlataModels.Optional(), PlataModels.Int() ],
+            required: [ PlataModels.Required(), PlataModels.Int() ],
+        } as const , {})) ],
+        subModelArray: [[ PlataModels.useModel(new PlataModels.ModelTemplate({ 
+            optional: [ PlataModels.Optional(), PlataModels.Int() ],
+            required: [ PlataModels.Required(), PlataModels.Int() ],
+        } as const , {})) ]],
+        array: [ [ PlataModels.VarChar(30) ] ],
+        array_objects: [{
+            param: [ PlataModels.Optional(), PlataModels.Decimal(10,2) ]
+        }]
+    } as const, {})
+
+    const modelValidations = new PlataModels.ModelTemplate({
+        enum: [ PlataModels.Enum([ 0,1 ]) ],
+        stringDateTime: [ PlataModels.StringDateTime() ],
+        dateTime: [ PlataModels.DateTime() ],
+        decimal: [ PlataModels.Decimal(2,2) ],
+        intMin: [ PlataModels.Int(5) ],
+        intMax: [ PlataModels.Int(undefined, 5) ],
+        intRequired:  [ PlataModels.Required(), PlataModels.Int() ],
+        smallDateTime: [ PlataModels.SmallDateTime() ],
+        telefone: [ PlataModels.Telefone() ],
+        telefoneDDI: [ PlataModels.TelefoneDDI() ],
+        varCharMin: [ PlataModels.VarChar(1, 1) ],
+        varChar:  [ PlataModels.VarChar(1) ],
+        useModel: [ PlataModels.useModel(modelStruct) ],
+    } as const, {})
+
+    it('Struct Filter', () => {
+        const InitObj = {
+            array_objects: [{ param: '123' }],
+            subModelArray: [{ required: 1 }]
+        }
+
+        const FilteredObj = modelStruct.filter(InitObj)
+
+        assert.deepEqual(FilteredObj, {
+            param: null,
+            object: {
+                param: null,
+            },
+            subModel: {
+                required: null,
+                optional: null,
+            },
+            subModelArray: [{
+                required: 1,
+                optional: null,
+            }],
+            array: [],
+            array_objects: [{
+                param: '123'
+            }]
+        })
+    })
+
+    it('Validations (Okay)', async () => {
+        const { errors, value } = await modelValidations.validate(objOkay)
+
+        assert.strictEqual(errors, undefined)
+        assert.deepEqual(value, objOkay)
+    })
+
+    it('Validations (Not Okay)', async () => {
+        const { errors, value } = await modelValidations.validate(objNotOkay)
+
+        assert.notStrictEqual(errors, undefined)
+        assert.strictEqual(
+            errors?.length,
+            Object.keys(modelValidations.template).length, 
+            errors?.map(e => `${e.errorID} - ${e.msg}`).join('\n')
+        )
+        assert.deepEqual(value, objNotOkay)
+    })
 })