functional-models 1.0.28 → 1.1.0

package/test/src/{properties.test.js → properties.test.ts}

@@ -1,9 +1,10 @@
-const assert = require('chai').assert
-const sinon = require('sinon')
-const {
+import { assert } from 'chai'
+import sinon from 'sinon'
+import {
   UniqueId,
   Property,
   DateProperty,
+  BooleanProperty,
   ReferenceProperty,
   ArrayProperty,
   ConstantValueProperty,
@@ -12,16 +13,19 @@ const {
   TextProperty,
   IntegerProperty,
   EmailProperty,
-} = require('../../src/properties')
-const { TYPE_PRIMATIVES, arrayType } = require('../../src/validation')
-const { Model } = require('../../src/models')
+} from '../../src/properties'
+import { TYPE_PRIMITIVES, arrayType } from '../../src/validation'
+import { BaseModel } from '../../src/models'
+import { ModelInstance } from '../../src/interfaces'
 
-const TestModel1 = Model('TestModel1', {
-  id: UniqueId(),
-  name: TextProperty(),
+type TestModelType = { name: string }
+const TestModel1 = BaseModel<TestModelType>('TestModel1', {
+  properties: {
+    name: TextProperty(),
+  },
 })
 
-describe('/src/properties.js', () => {
+describe('/src/properties.ts', () => {
   describe('#EmailProperty()', () => {
     describe('#createGetter()', () => {
       it('should be able to create without a config', () => {
@@ -42,7 +46,26 @@ describe('/src/properties.js', () => {
         const PropertyInstance = EmailProperty({})
         const getter = PropertyInstance.createGetter('testme@email.com')
         const validator = PropertyInstance.getValidator(getter)
-        const actual = await validator()
+        // @ts-ignore
+        const actual = await validator(null, {})
+        const expected = 0
+        assert.equal(actual.length, expected)
+      })
+    })
+  })
+  describe('#BooleanProperty()', () => {
+    it('should be able to create without a config', () => {
+      assert.doesNotThrow(() => {
+        BooleanProperty()
+      })
+    })
+    describe('#getValidator()', () => {
+      it('should return and validate successful with basic input', async () => {
+        const PropertyInstance = BooleanProperty({})
+        const getter = PropertyInstance.createGetter(true)
+        const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
+        const actual = await validator(null, {})
         const expected = 0
         assert.equal(actual.length, expected)
       })
@@ -63,7 +86,8 @@ describe('/src/properties.js', () => {
         const PropertyInstance = ConstantValueProperty('constant')
         const getter = PropertyInstance.createGetter('changed')
         const validator = PropertyInstance.getValidator(getter)
-        const actual = await validator()
+        // @ts-ignore
+        const actual = await validator(null, {})
         const expected = 0
         assert.equal(actual.length, expected)
       })
@@ -95,7 +119,8 @@ describe('/src/properties.js', () => {
           complex: { it: 'is' },
         })
         const validator = PropertyInstance.getValidator(getter)
-        const actual = await validator()
+        // @ts-ignore
+        const actual = await validator(null, {})
         const expected = 0
         assert.equal(actual.length, expected)
       })
@@ -109,6 +134,12 @@ describe('/src/properties.js', () => {
           NumberProperty()
         })
       })
+      it('should be able to create even with a null config', () => {
+        assert.doesNotThrow(() => {
+          // @ts-ignore
+          NumberProperty(null)
+        })
+      })
       it('should be able to get the number passed in', async () => {
         const PropertyInstance = NumberProperty({})
         const getter = PropertyInstance.createGetter(5)
@@ -129,7 +160,8 @@ describe('/src/properties.js', () => {
         const PropertyInstance = NumberProperty({})
         const getter = PropertyInstance.createGetter(5)
         const validator = PropertyInstance.getValidator(getter)
-        const actual = await validator()
+        // @ts-ignore
+        const actual = await validator(null, {})
         const expected = 0
         assert.equal(actual.length, expected)
       })
@@ -137,15 +169,18 @@ describe('/src/properties.js', () => {
         const PropertyInstance = NumberProperty({})
         const getter = PropertyInstance.createGetter(5.123)
         const validator = PropertyInstance.getValidator(getter)
-        const actual = await validator()
+        // @ts-ignore
+        const actual = await validator(null, {})
         const expected = 0
         assert.equal(actual.length, expected)
       })
       it('should return with errors with a non integer input', async () => {
         const PropertyInstance = NumberProperty({})
+        // @ts-ignore
         const getter = PropertyInstance.createGetter('string')
         const validator = PropertyInstance.getValidator(getter)
-        const actual = await validator()
+        // @ts-ignore
+        const actual = await validator(null, {})
         const expected = 1
         assert.equal(actual.length, expected)
       })
@@ -153,6 +188,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = NumberProperty({ maxValue: 3 })
         const getter = PropertyInstance.createGetter(5)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -161,6 +197,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = NumberProperty({ minValue: 3 })
         const getter = PropertyInstance.createGetter(2)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -169,6 +206,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = NumberProperty({ minValue: 3, maxValue: 3 })
         const getter = PropertyInstance.createGetter(3)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 0
         assert.equal(actual.length, expected)
@@ -177,6 +215,12 @@ describe('/src/properties.js', () => {
   })
 
   describe('#IntegerProperty()', () => {
+    it('should be able to create even with a null config', () => {
+      assert.doesNotThrow(() => {
+        // @ts-ignore
+        IntegerProperty(null)
+      })
+    })
     describe('#createGetter()', () => {
       it('should be able to create without a config', () => {
         assert.doesNotThrow(() => {
@@ -196,6 +240,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = IntegerProperty({})
         const getter = PropertyInstance.createGetter(5)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 0
         assert.equal(actual.length, expected)
@@ -204,14 +249,17 @@ describe('/src/properties.js', () => {
         const PropertyInstance = IntegerProperty({})
         const getter = PropertyInstance.createGetter(5.123)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
       })
       it('should return with errors with a non integer input', async () => {
         const PropertyInstance = IntegerProperty({})
+        // @ts-ignore
         const getter = PropertyInstance.createGetter('string')
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -220,6 +268,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = IntegerProperty({ maxValue: 3 })
         const getter = PropertyInstance.createGetter(5)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -228,6 +277,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = IntegerProperty({ minValue: 3 })
         const getter = PropertyInstance.createGetter(2)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -236,6 +286,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = IntegerProperty({ minValue: 3, maxValue: 3 })
         const getter = PropertyInstance.createGetter(3)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 0
         assert.equal(actual.length, expected)
@@ -244,6 +295,12 @@ describe('/src/properties.js', () => {
   })
 
   describe('#TextProperty()', () => {
+    it('should be able to create even with a null config', () => {
+      assert.doesNotThrow(() => {
+        // @ts-ignore
+        TextProperty(null)
+      })
+    })
     describe('#createGetter()', () => {
       it('should be able to create without a config', () => {
         assert.doesNotThrow(() => {
@@ -263,14 +320,17 @@ describe('/src/properties.js', () => {
         const PropertyInstance = TextProperty({})
         const getter = PropertyInstance.createGetter('basic input')
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 0
         assert.equal(actual.length, expected)
       })
       it('should return with errors with a value=5', async () => {
         const PropertyInstance = TextProperty({})
+        // @ts-ignore
         const getter = PropertyInstance.createGetter(5)
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -279,6 +339,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = TextProperty({ maxLength: 3 })
         const getter = PropertyInstance.createGetter('hello')
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -287,6 +348,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = TextProperty({ minLength: 10 })
         const getter = PropertyInstance.createGetter('hello')
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -295,6 +357,7 @@ describe('/src/properties.js', () => {
         const PropertyInstance = TextProperty({ minLength: 5, maxLength: 5 })
         const getter = PropertyInstance.createGetter('hello')
         const validator = PropertyInstance.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 0
         assert.equal(actual.length, expected)
@@ -320,13 +383,15 @@ describe('/src/properties.js', () => {
       })
       it('should return an empty array if defaultValue is not changed in config and null is passed', async () => {
         const theProperty = ArrayProperty()
+        // @ts-ignore
         const getter = theProperty.createGetter(null)
         const actual = await getter()
-        const expected = []
+        const expected: any[] = []
         assert.deepEqual(actual, expected)
       })
       it('should return the passed in defaultValue if set in config and null is passed', async () => {
         const theProperty = ArrayProperty({ defaultValue: [1, 2, 3] })
+        // @ts-ignore
         const getter = theProperty.createGetter(null)
         const actual = await getter()
         const expected = [1, 2, 3]
@@ -338,16 +403,18 @@ describe('/src/properties.js', () => {
         const theProperty = ArrayProperty({})
         const getter = theProperty.createGetter([1, 2, 3])
         const validator = theProperty.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
-        const expected = []
+        const expected: any[] = []
         assert.deepEqual(actual, expected)
       })
       it('should error an array passed in when it doesnt have the right types', async () => {
         const theProperty = ArrayProperty({
-          validators: [arrayType(TYPE_PRIMATIVES.integer)],
+          validators: [arrayType(TYPE_PRIMITIVES.integer)],
         })
         const getter = theProperty.createGetter([1, 'string', 3])
         const validator = theProperty.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.deepEqual(actual.length, expected)
@@ -356,14 +423,16 @@ describe('/src/properties.js', () => {
         const theProperty = ArrayProperty({ choices: [4, 5, 6] })
         const getter = theProperty.createGetter([4, 4, 5, 5, 6, 6])
         const validator = theProperty.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
-        const expected = []
+        const expected: any[] = []
         assert.deepEqual(actual, expected)
       })
       it('should return errors when an array with [4,4,3,5,5,6,6] when choices are [4,5,6]', async () => {
         const theProperty = ArrayProperty({ choices: [4, 5, 6] })
         const getter = theProperty.createGetter([4, 4, 3, 5, 5, 6, 6])
         const validator = theProperty.getValidator(getter)
+        // @ts-ignore
         const actual = await validator()
         const expected = 1
         assert.equal(actual.length, expected)
@@ -371,8 +440,21 @@ describe('/src/properties.js', () => {
     })
   })
   describe('#Property()', () => {
+    it('should throw an exception if a type is not provided', () => {
+      assert.throws(() => {
+        // @ts-ignore
+        Property(undefined, {})
+      })
+    })
+    it('should throw an exception if a type is not provided, and config is null', () => {
+      assert.throws(() => {
+        // @ts-ignore
+        Property(undefined, null)
+      })
+    })
     it('should throw an exception if config.valueSelector is not a function but is set', () => {
       assert.throws(() => {
+        // @ts-ignore
         Property('MyProperty', { valueSelector: 'blah' })
       })
     })
@@ -381,6 +463,77 @@ describe('/src/properties.js', () => {
         Property('MyProperty', { valueSelector: () => ({}) })
       })
     })
+    it('should not throw an exception if config is null', () => {
+      assert.doesNotThrow(() => {
+        // @ts-ignore
+        Property('MyProperty', null)
+      })
+    })
+    describe('#getConstantValue()', () => {
+      it('should provide undefined if no config', () => {
+        // @ts-ignore
+        const instance = Property('MyTYpe', null)
+        const actual = instance.getConstantValue()
+        const expected = undefined
+        assert.deepEqual(actual, expected)
+      })
+    })
+    describe('#getPropertyType()', () => {
+      it('should use the type that is passed in via config', () => {
+        const instance = Property('OverrideMe', { type: 'ExtendedType' })
+        const actual = instance.getPropertyType()
+        const expected = 'ExtendedType'
+        assert.equal(actual, expected)
+      })
+    })
+    describe('#getConfig()', () => {
+      it('should provide the config that is passed in ', () => {
+        // @ts-ignore
+        const instance = Property('MyTYpe', { custom: 'value' })
+        const actual = instance.getConfig()
+        const expected = { custom: 'value' }
+        assert.deepEqual(actual, expected)
+      })
+      it('should provide {} if no config', () => {
+        // @ts-ignore
+        const instance = Property('MyTYpe', null)
+        const actual = instance.getConfig()
+        const expected = {}
+        assert.deepEqual(actual, expected)
+      })
+    })
+    describe('#getDefaultValue()', () => {
+      it('should provide undefined if no config', () => {
+        // @ts-ignore
+        const instance = Property('MyTYpe', null)
+        const actual = instance.getDefaultValue()
+        const expected = undefined
+        assert.deepEqual(actual, expected)
+      })
+      it('should provide the defaultValue that is passed in if no value', () => {
+        // @ts-ignore
+        const instance = Property('MyTYpe', { defaultValue: 'test-me' })
+        const actual = instance.getDefaultValue()
+        const expected = 'test-me'
+        assert.deepEqual(actual, expected)
+      })
+    })
+    describe('#getChoices()', () => {
+      it('should provide [] if no config', () => {
+        // @ts-ignore
+        const instance = Property('MyTYpe', null)
+        const actual = instance.getChoices()
+        const expected: any[] = []
+        assert.deepEqual(actual, expected)
+      })
+      it('should provide the choices that are passed in ', () => {
+        // @ts-ignore
+        const instance = Property('MyTYpe', { choices: [1, 2, 3] })
+        const actual = instance.getChoices()
+        const expected = [1, 2, 3]
+        assert.deepEqual(actual, expected)
+      })
+    })
     describe('#createGetter()', () => {
       it('should return a function even if config.value is set to a value', () => {
         const instance = Property('MyProperty', { value: 'my-value' })
@@ -411,7 +564,8 @@ describe('/src/properties.js', () => {
     describe('#createGetter()', () => {
       it('should call createUuid only once even if called twice', async () => {
         const uniqueProperty = UniqueId({})
-        const getter = uniqueProperty.createGetter()
+        // @ts-ignore
+        const getter = uniqueProperty.createGetter(undefined)
         const first = await getter()
         const second = await getter()
         assert.deepEqual(first, second)
@@ -428,12 +582,12 @@ describe('/src/properties.js', () => {
   describe('#DateProperty()', () => {
     it('should allow creation without a config', async () => {
       const proto = DateProperty()
-      const instance = proto.createGetter('my-date')
+      const instance = proto.createGetter(new Date())
       assert.isOk(await instance())
     })
     it('should create a new date once when config.autoNow=true and called multiple times', async () => {
       const proto = DateProperty({ autoNow: true })
-      const instance = proto.createGetter()
+      const instance = proto.createGetter(undefined)
       const first = await instance()
       const second = await instance()
       const third = await instance()
@@ -448,103 +602,142 @@ describe('/src/properties.js', () => {
       const expected = date
       assert.deepEqual(actual, expected)
     })
+    it('should return null, if null config is passed and no value created.', async () => {
+      // @ts-ignore
+      const proto = DateProperty(null)
+      const date = null
+      const instance = proto.createGetter(date)
+      const actual = await instance()
+      const expected = null
+      assert.deepEqual(actual, expected)
+    })
   })
 
   describe('#ReferenceProperty()', () => {
     it('should throw an exception if a model value is not passed in', () => {
       assert.throws(() => {
         const input = ['obj-id']
+        // @ts-ignore
         const actual = ReferenceProperty(null, {})
       })
     })
     describe('#meta.getReferencedModel()', () => {
       it('should return the same value passed in as the model', async () => {
         const property = ReferenceProperty(TestModel1)
-        const actual = property.meta.getReferencedModel()
+        const actual = property.getReferencedModel()
         const expected = TestModel1
         assert.deepEqual(actual, expected)
       })
       it('should allow a function input for model to allow delayed creation', async () => {
         const property = ReferenceProperty(() => TestModel1)
-        const actual = property.meta.getReferencedModel()
+        const actual = property.getReferencedModel()
         const expected = TestModel1
         assert.deepEqual(actual, expected)
       })
     })
     describe('#createGetter()', () => {
       it('should return "obj-id" when no fetcher is used', async () => {
-        const input = ['obj-id']
         const actual = await ReferenceProperty(TestModel1, {}).createGetter(
-          ...input
+          'obj-id'
         )()
         const expected = 'obj-id'
         assert.equal(actual, expected)
       })
       it('should allow null as the input', async () => {
-        const input = [null]
         const actual = await ReferenceProperty(TestModel1, {}).createGetter(
-          ...input
+          null
         )()
         const expected = null
         assert.equal(actual, expected)
       })
       it('should return "obj-id" from {}.id when no fetcher is used', async () => {
-        const input = [{ id: 'obj-id' }]
         const actual = await ReferenceProperty(TestModel1, {}).createGetter(
-          ...input
+          // @ts-ignore
+          { id: 'obj-id' }
         )()
         const expected = 'obj-id'
         assert.equal(actual, expected)
       })
+      it('should return 123 from {}.id when no fetcher is used', async () => {
+        const actual = await ReferenceProperty(TestModel1, {}).createGetter(
+          123
+        )()
+        const expected = 123
+        assert.equal(actual, expected)
+      })
       it('should return name:"switch-a-roo" when switch-a-roo fetcher is used', async () => {
-        const input = ['obj-id']
-        const actual = await ReferenceProperty(TestModel1, {
-          fetcher: () => ({ id: 'obj-id', name: 'switch-a-roo' }),
-        }).createGetter(...input)()
+        const actual = (await ReferenceProperty(TestModel1, {
+          fetcher: async () => ({ id: 'obj-id', name: 'switch-a-roo' }),
+        }).createGetter('obj-id')()) as ModelInstance<TestModelType>
         const expected = 'switch-a-roo'
-        assert.deepEqual(await actual.getName(), expected)
+        assert.deepEqual(actual.get.name(), expected)
+      })
+      it('should return "obj-id" if no config passed', async () => {
+        // @ts-ignore
+        const actual = (await ReferenceProperty(TestModel1, null).createGetter(
+          'obj-id'
+        )()) as string
+        const expected = 'obj-id'
+        assert.deepEqual(actual, expected)
+      })
+      it('should return null when fetcher is used, but the instance value passed in is empty', async () => {
+        const actual = (await ReferenceProperty(TestModel1, {
+          fetcher: async () => ({ id: 'obj-id', name: 'switch-a-roo' }),
+        }).createGetter(null)()) as ModelInstance<TestModelType>
+        const expected = null
+        assert.deepEqual(actual, expected)
       })
       it('should provide the passed in model and the instance values when switch-a-roo fetcher is used', async () => {
-        const input = ['obj-id']
+        const input = 'obj-id'
         const fetcher = sinon.stub().callsFake((modelName, id) => ({ id }))
         await ReferenceProperty(TestModel1, {
           fetcher,
-        }).createGetter(...input)()
+        }).createGetter(input)()
         const actual = fetcher.getCall(0).args[0]
         const expected = TestModel1
         assert.deepEqual(actual, expected)
       })
       it('should take the smartObject as a value', async () => {
-        const proto = Model('name', {
-          id: UniqueId({ value: 'obj-id' }),
+        const id = 'obj-id'
+        const proto = BaseModel<TestModelType>('name', {
+          properties: {
+            id: UniqueId({ value: id }),
+            name: TextProperty({}),
+          },
         })
-        const input = [proto.create({ id: 'obj-id' })]
-        const instance = await ReferenceProperty(TestModel1, {}).createGetter(
-          ...input
-        )()
-        const actual = await instance.getId()
+        const input = proto.create({ id, name: 'name' })
+        const instance = (await ReferenceProperty<TestModelType>(
+          TestModel1,
+          {}
+        ).createGetter(input)()) as ModelInstance<TestModelType>
+        const actual = await instance.get.id()
         const expected = 'obj-id'
         assert.deepEqual(actual, expected)
       })
-      describe('#functions.toObj()', () => {
+      describe('#toObj()', () => {
         it('should use the getId of the smartObject passed in when toObj is called', async () => {
-          const proto = Model('name', {
-            id: UniqueId({ value: 'obj-id' }),
+          const proto = BaseModel<TestModelType>('name', {
+            properties: {
+              id: UniqueId({ value: 'obj-id' }),
+              name: TextProperty({}),
+            },
           })
-          const input = [proto.create({ id: 'obj-id' })]
-          const instance = await ReferenceProperty(TestModel1, {}).createGetter(
-            ...input
-          )()
-          const actual = await instance.functions.toObj()
+          const input = proto.create({ id: 'obj-id', name: 'name' })
+          const instance = (await ReferenceProperty<TestModelType>(
+            TestModel1,
+            {}
+          ).createGetter(input)()) as ModelInstance<{}>
+          const actual = await instance.toObj()
           const expected = 'obj-id'
           assert.deepEqual(actual, expected)
         })
         it('should return "obj-id" when switch-a-roo fetcher is used and toObj is called', async () => {
-          const input = ['obj-id']
-          const instance = await ReferenceProperty(TestModel1, {
-            fetcher: () => ({ id: 'obj-id', prop: 'switch-a-roo' }),
-          }).createGetter(...input)()
-          const actual = await instance.functions.toObj()
+          const input = 'obj-id'
+          const instance = (await ReferenceProperty(TestModel1, {
+            fetcher: () =>
+              Promise.resolve({ id: 'obj-id', prop: 'switch-a-roo' }),
+          }).createGetter(input)()) as ModelInstance<{}>
+          const actual = await instance.toObj()
           const expected = 'obj-id'
           assert.deepEqual(actual, expected)
         })