feat(models): Add ability to define a default value for model props

Author: digitalsadhu

src/classes/model.ts

@@ -36,16 +36,16 @@ export default class Model extends Base {
           return that[name]
         }
         if (
-          typeof that.state[name] === 'undefined' ||
-          that.state[name] === null
+          typeof target.state[name] === 'undefined' ||
+          target.state[name] === null
         ) {
           return null
         }
-        return Ctor.runTypeHook(name, that.state[name], 'access')
+        return Ctor.runTypeHook(name, target.state[name], 'access')
       },
       set(target, name, value) {
         if (Ctor.meta.attributes[name]) {
-          that.state[name] = Ctor.runTypeHook(name, value, 'modify')
+          target.state[name] = Ctor.runTypeHook(name, value, 'modify')
         }
         that[name] = value
         return true
@@ -109,7 +109,7 @@ export default class Model extends Base {
 
   static attachTypes(types: { [name: string]: Type }) {
     Object.keys(this.meta.attributeDefinition).forEach(attr => {
-      let typeName = this.meta.attributeDefinition[attr]
+      let typeName = this.meta.attributeDefinition[attr].type
       if (types[`${this.modelName}:${typeName}`]) {
         typeName = `${this.modelName}:${typeName}`
       }
@@ -123,7 +123,7 @@ export default class Model extends Base {
     serializers: { default: Serializer; [name: string]: Serializer }
   ) {
     if (!this.meta.attributeDefinition[this.idField]) {
-      this.meta.attributeDefinition[this.idField] = 'number'
+      this.meta.attributeDefinition[this.idField] = { type: 'number' }
     }
     this.attachAdapters(adapters)
     this.attachSerializers(serializers)
@@ -182,7 +182,8 @@ export default class Model extends Base {
   ): Promise<T['prototype'] | null> {
     const result = await this.adapter.oneById(this, id, options)
     if (!result) return null
-    return this.hydrate(result)
+    const instance = this.hydrate(result)
+    return instance
   }
 
   static async oneBySql<T extends typeof Model>(
@@ -235,21 +236,28 @@ export default class Model extends Base {
     for (const prop of Reflect.ownKeys(props)) {
       if (!Reflect.ownKeys(this.meta.attributes).includes(prop)) {
         throw new Error(`
-          Invalid key '${prop}' defined on 'props' given to 'Model.createOne'.
-            Included properties must be defined on model class
-            Valid properties '${Reflect.ownKeys(this.meta.attributes).join(
-              "', '"
-            )}'
-            Instead got '${Reflect.ownKeys(props).join("', '")}'
+        Invalid key '${prop}' defined on 'props' given to 'Model.createOne'.
+        Included properties must be defined on model class
+        Valid properties '${Reflect.ownKeys(this.meta.attributes).join("', '")}'
+        Instead got '${Reflect.ownKeys(props).join("', '")}'
         `)
       }
     }
-    const result = await this.adapter.createRecord(this, props)
+    const defaults: props = {}
+    for (const [key, value] of Object.entries(this.meta.attributeDefinition)) {
+      if (value && value.default) {
+        defaults[key] = value.default
+      }
+    }
+    const data = Object.assign({}, defaults, props)
+    const result = await this.adapter.createRecord(this, data)
     return this.hydrate(result)
   }
 
   static async createSome(records: props[]): Promise<number> {
-    for (const [index, props] of records.entries()) {
+    // TODO:: clean up code method body as currently both poor readability
+    // and looping through the data 2 times
+    for (let [index, props] of records.entries()) {
       for (const prop of Reflect.ownKeys(props)) {
         if (!Reflect.ownKeys(this.meta.attributes).includes(prop)) {
           throw new Error(`
@@ -263,7 +271,20 @@ export default class Model extends Base {
         }
       }
     }
-    return this.adapter.createSome(this, records)
+    return this.adapter.createSome(
+      this,
+      records.map(record => {
+        const defaults: props = {}
+        for (const [key, value] of Object.entries(
+          this.meta.attributeDefinition
+        )) {
+          if (value && value.default) {
+            defaults[key] = value.default
+          }
+        }
+        return Object.assign({}, defaults, record)
+      })
+    )
   }
 
   static deleteAll(): Promise<number> {
@@ -453,8 +474,8 @@ export default class Model extends Base {
     const json: { [key: string]: any } = {}
     const { attributes } = this.ctor.meta
     for (const [property, type] of Object.entries(attributes)) {
-      if (attributes[property] && this[property]) {
-        json[property] = type.access(this[property])
+      if (attributes[property] && this.state[property]) {
+        json[property] = type.access(this.state[property])
       }
     }
     return json
@@ -526,7 +547,9 @@ export type relationship = {
 }
 
 export type modelMeta = {
-  attributeDefinition: { [attrName: string]: string }
+  attributeDefinition: {
+    [attrName: string]: { type: string; default?: string }
+  }
   attributes: { [attrName: string]: Type }
   relationships: { [relName: string]: relationship }
 }

src/decorators/type.ts

@@ -1,9 +1,10 @@
 import Model from '../classes/model'
 
 export default function type(
-  typeName: string
+  typeName: string,
+  options?: { [name: string]: any }
 ): (target: Model, propertyKey: string) => void {
-  return function typeDecorator(target: Model, propertyKey: string): void {
+  return function typeDecorator(target: any, propertyKey: string): void {
     const Ctor = target.constructor as typeof Model
     const meta = {
       attributeDefinition: {},
@@ -17,6 +18,9 @@ export default function type(
       })
     }
 
-    Ctor.meta.attributeDefinition[propertyKey] = typeName
+    Ctor.meta.attributeDefinition[propertyKey] = { type: typeName }
+    if (options && options.default) {
+      Ctor.meta.attributeDefinition[propertyKey].default = options.default
+    }
   }
 }

tests/integration/working-with-models.test.ts

@@ -254,6 +254,18 @@ describe('Working with models', () => {
     return Cat.adapter.destroy()
   })
 
+  test('Statically create a single record: defaults used', async () => {
+    class Cat extends Model {
+      @type('string', { default: 'Toffee' })
+      name: string
+    }
+    setupModel(Cat)
+    const cat = await Cat.createOne({})
+    expect(cat.id).toBeTruthy()
+    expect(cat.name).toBe('Toffee')
+    return Cat.adapter.destroy()
+  })
+
   test('Statically create multiple records', async () => {
     class Cat extends Model {
       @type('string') name: string
@@ -266,4 +278,18 @@ describe('Working with models', () => {
     expect(cats).toBe(2)
     return Cat.adapter.destroy()
   })
+
+  test('Statically create multiple records: defaults used', async () => {
+    class Cat extends Model {
+      @type('string', { default: 'Colonel McFluffins' })
+      name: string
+    }
+    setupModel(Cat)
+    const num = await Cat.createSome([{}, { name: 'Dog' }])
+    expect(num).toBe(2)
+    const cats = await Cat.all()
+    expect(cats[2].name).toBe('Colonel McFluffins')
+    expect(cats[3].name).toBe('Dog')
+    return Cat.adapter.destroy()
+  })
 })

tests/unit/decorators/type.test.ts

@@ -11,10 +11,10 @@ describe('@type() decorator', () => {
     }
 
     expect(Cat.meta.attributeDefinition).toEqual({
-      str: 'string',
-      num: 'number',
-      dat: 'date',
-      bol: 'boolean'
+      str: { type: 'string' },
+      num: { type: 'number' },
+      dat: { type: 'date' },
+      bol: { type: 'boolean' }
     })
 
     expect(Model.meta.attributeDefinition).toEqual({})