orange-dragonfly-model 0.10.0 → 0.11.1

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+    "env": {
+        "browser": true,
+        "node": true,
+        "commonjs": true,
+        "es2021": true
+    },
+    "extends": [
+        "standard"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 12
+    },
+    "rules": {
+        "camelcase": 0,
+        "no-prototype-builtins": 0
+    }
+}

package/components/model.js

@@ -1,285 +1,329 @@
-const ORM = require('orange-dragonfly-orm')
-const validate = require('orange-dragonfly-validator')
-
-class ValidationException extends Error {
-  info = {}
-}
-
-class Model extends ORM.ActiveRecord {
-
-  static IGNORE_EXTRA_FIELDS = false
-
-  /**
-   * Returns schema for the model (Orange Dragonfly Validator format)
-   * @return object
-   */
-  static get validation_rules () {
-    return {
-      "id": {
-        "required": false,
-        "type": "integer",
-        "min": 1
-      }
-    }
-  }
-
-  /**
-   * Overridden method of ActiveRecord. Returns special fields list based on validation rules
-   * @return {Array}
-   */
-  static get special_fields () {
-    const rules = this.validation_rules
-    const fields = []
-    for (let field of ['created_at', 'updated_at', 'deleted_at']) {
-      rules.hasOwnProperty(field) && fields.push(field)
-    }
-    return fields
-  }
-
-  /**
-   * Returns list of relations restricted for extended output
-   * @return {Array}
-   */
-  static get restricted_for_output () {
-    return []
-  }
-
-  /**
-   * Returns list of fields restricted for lookup
-   * @return {Array}
-   */
-  static get restricted_for_lookup () {
-    return []
-  }
-
-  /**
-   * Returns list of fields restricted for create method
-   * @return {Array}
-   */
-  static get restricted_for_create () {
-    return ['id'].concat(this.special_fields)
-  }
-
-  /**
-   * Returns list of fields restricted for update method
-   * @return {Array}
-   */
-  static get restricted_for_update () {
-    return ['id'].concat(this.special_fields)
-  }
-
-  /**
-   * Lookup method
-   * @param data
-   * @return {SelectQuery}
-   */
-  static lookupQuery (data) {
-    const rules = this.validation_rules
-    const q = this.selectQuery()
-    const filtered_rules = {}
-    for (let field of Object.keys(data)) {
-      if (!rules.hasOwnProperty(field)) {
-        if (this.IGNORE_EXTRA_FIELDS) {
-          continue
-        }
-        const ex = new ValidationException('Parameters error')
-        ex.info[field] = `Field "${field}" is not described for model ${this.name}`
-        throw ex
-      }
-      if (this.restricted_for_lookup.includes(field)) {
-        const ex = new ValidationException('Parameters error')
-        ex.info[field] = `Field "${field}" is restricted for searching model ${this.name}`
-        throw ex
-      }
-      q.where(field, data[field])
-      filtered_rules[field] = Array.isArray(data[field]) ? {'type': 'array', 'children': {'*': rules[field]}} : rules[field]
-    }
-    validate(filtered_rules, data)
-    return q
-  }
-
-  /**
-   * Creates object
-   * @param data
-   * @return {Promise<ActiveRecord>}
-   */
-  static async create (data) {
-    const rules = this.validation_rules
-    const new_data = {}
-    for (let field of Object.keys(data)) {
-      if (!rules.hasOwnProperty(field)) {
-        if (this.IGNORE_EXTRA_FIELDS) {
-          continue
-        }
-        const ex = new ValidationException('Parameters error')
-        ex.info[field] = `Field "${field}" is not described for model ${this.name}`
-        throw ex
-      }
-      if (this.restricted_for_create.includes(field)) {
-        const ex = new ValidationException('Parameters error')
-        ex.info[field] = `Field "${field}" is restricted for creating model ${this.name}`
-        throw ex
-      }
-      new_data[field] = data[field]
-    }
-    return await (new this(new_data)).save()
-  }
-
-  /**
-   * Updates object
-   * @param data
-   * @return {Promise<ActiveRecord>}
-   */
-  async update (data) {
-    if (!this.id) {
-      throw new Error(`You can update saved object only`)
-    }
-    const rules = this.constructor.validation_rules
-    const new_data = {}
-    for (let field of Object.keys(data)) {
-      if (!rules.hasOwnProperty(field)) {
-        if (this.constructor.IGNORE_EXTRA_FIELDS) {
-          continue
-        }
-        const ex = new ValidationException('Parameters error')
-        ex.info[field] = `Field "${field}" is not described for model ${this.constructor.name}`
-        throw ex
-      }
-      if (this.constructor.restricted_for_update.includes(field)) {
-        const ex = new ValidationException('Parameters error')
-        ex.info[field] = `Field "${field}" is restricted for updating model ${this.constructor.name}`
-        throw ex
-      }
-      new_data[field] = data[field]
-    }
-    return await this.save(new_data)
-  }
-
-  async _preSave () {
-    if (this.constructor.IGNORE_EXTRA_FIELDS) {
-      const rules = this.constructor.validation_rules
-      for (let key of Object.keys(this.data).filter(v => !rules.hasOwnProperty(v))) {
-        delete this.data[key]
-      }
-    }
-    await super._preSave();
-    await this.validate()
-  }
-
-  /**
-   * Validate object's data
-   * @return {Promise<void>}
-   */
-  async validate () {
-    const rules = this.constructor.validation_rules
-    if (!rules) {
-      throw new Error(`Validation rules are not defined for mode ${this.constructor.name}`)
-    }
-    // Convert integer 1 or 0 to boolean
-    let types
-    for (let rule_name of Object.keys(rules)) {
-      if (this.data.hasOwnProperty(rule_name)) {
-        if (rules[rule_name].hasOwnProperty('type')) {
-          types = Array.isArray(rules[rule_name]['type']) ? rules[rule_name]['type'] : [rules[rule_name]['type']]
-          if (types.includes('boolean')) {
-            if ((this.data[rule_name] === 1) || (this.data[rule_name] === 0)) {
-              this.data[rule_name] = this.data[rule_name] === 1;
-            }
-          }
-        }
-      }
-    }
-    validate(rules, this.data)
-    let rel
-    const relation_errors = []
-    for (let rel_name of Object.keys(this.constructor.available_relations)) {
-      rel = this.constructor.available_relations[rel_name]
-      if (rel.mode === 'parent') {
-        if (this.data.hasOwnProperty(rel._a_key_by_mode) && (this.data[rel._a_key_by_mode] !== null) && (this.data[rel._a_key_by_mode] !== 0)) {
-          if ((await this.rel(rel_name)) === null) {
-            relation_errors.push(rel._a_key_by_mode)
-          }
-        }
-      }
-      if (relation_errors.length) {
-        const ex = new ValidationException(`Some relations of the ${this.constructor.name} are not found`)
-        for (let param of relation_errors) ex.info[param] = 'Parent object not found'
-        throw ex
-      }
-    }
-  }
-
-  /**
-   * Returns object by ID if it exists and accessible by user
-   * @param id
-   * @param user
-   * @param mode
-   * @return {Promise<ActiveRecord>}
-   */
-  static async findAndCheckAccessOrDie(id, user, mode=null) {
-    const obj = await this.find(id)
-    if (!obj) {
-      throw new Error(`${this.name} #${id} not found`)
-    }
-    if (!(await obj.accessible(user, mode))) {
-      throw new Error(`${this.name} #${id} is not accessible${mode ? ` for ${mode}` : ''}`)
-    }
-    return obj
-  }
-
-  /**
-   * Returns is object accessible by user
-   * @param user
-   * @param mode
-   * @return {Promise<boolean>}
-   */
-  async accessible(user, mode=null) {
-    return mode === null
-  }
-
-  /**
-   * Returns public data of the object
-   * @return Object
-   */
-  get output () {
-    return {
-      'id': this.id
-    }
-  }
-
-  /**
-   * Format output
-   * @param mode
-   * @return {Object}
-   */
-  formatOutput (mode) {
-    return this.output
-  }
-
-  /**
-   * Returns public data of the object with relations
-   * @param required_relations
-   * @param mode
-   * @return {Promise<Object>}
-   */
-  async getExtendedOutput(required_relations=[], mode = null) {
-    const output = this.formatOutput(mode)
-    let rel_data, rel_mode, rel_relations
-    for (let name of required_relations){
-      if (name.split(':').length > 1) continue
-      if (this.constructor.restricted_for_output.includes(name)) {
-        throw new Error(`Relation "${name}" is not allowed for extended output of model ${this.constructor.name}`)
-      }
-      rel_data = await this.rel(name)
-      rel_mode = `relation:${this.constructor.name}.${name}`
-      rel_relations = required_relations.filter(v => v.startsWith(`${name}:`)).map(v => v.substr(name.length + 1))
-      output[`:${name}`] = Array.isArray(rel_data)
-        ? await Promise.all(rel_data.map(v => v.getExtendedOutput(rel_relations, rel_mode)))
-        : (rel_data ? await rel_data.getExtendedOutput(rel_relations, rel_mode) : null)
-    }
-    return output
-  }
-
-}
-
-module.exports = Model
+const ORM = require('orange-dragonfly-orm')
+const validate = require('orange-dragonfly-validator')
+
+class ValidationException extends Error {
+  get info () {
+    return {}
+  }
+}
+
+class Model extends ORM.ActiveRecord {
+  static get IGNORE_EXTRA_FIELDS () {
+    return false
+  }
+
+  /**
+   * Returns list of unique keys
+   * @returns Array[] List of unique keys
+   */
+  static get UNIQUE_KEYS () {
+    return []
+  }
+
+  /**
+   * Returns schema for the model (Orange Dragonfly Validator format)
+   * @return object
+   */
+  static get validation_rules () {
+    return {
+      id: {
+        required: false,
+        type: 'integer',
+        min: 1
+      }
+    }
+  }
+
+  /**
+   * Overridden method of ActiveRecord. Returns special fields list based on validation rules
+   * @return {Array}
+   */
+  static get special_fields () {
+    const rules = this.validation_rules
+    const fields = []
+    for (const field of ['created_at', 'updated_at', 'deleted_at']) {
+      rules.hasOwnProperty(field) && fields.push(field)
+    }
+    return fields
+  }
+
+  /**
+   * Returns list of relations restricted for extended output
+   * @return {Array}
+   */
+  static get restricted_for_output () {
+    return []
+  }
+
+  /**
+   * Returns list of fields restricted for lookup
+   * @return {Array}
+   */
+  static get restricted_for_lookup () {
+    return []
+  }
+
+  /**
+   * Returns list of fields restricted for create method
+   * @return {Array}
+   */
+  static get restricted_for_create () {
+    return ['id'].concat(this.special_fields)
+  }
+
+  /**
+   * Returns list of fields restricted for update method
+   * @return {Array}
+   */
+  static get restricted_for_update () {
+    return ['id'].concat(this.special_fields)
+  }
+
+  /**
+   * Lookup method
+   * @param data
+   * @return {SelectQuery}
+   */
+  static lookupQuery (data) {
+    const rules = this.validation_rules
+    const q = this.selectQuery()
+    const filtered_rules = {}
+    for (const field of Object.keys(data)) {
+      if (!rules.hasOwnProperty(field)) {
+        if (this.IGNORE_EXTRA_FIELDS) {
+          continue
+        }
+        const ex = new ValidationException('Parameters error')
+        ex.info[field] = `Field "${field}" is not described for model ${this.name}`
+        throw ex
+      }
+      if (this.restricted_for_lookup.includes(field)) {
+        const ex = new ValidationException('Parameters error')
+        ex.info[field] = `Field "${field}" is restricted for searching model ${this.name}`
+        throw ex
+      }
+      q.where(field, data[field])
+      filtered_rules[field] = Array.isArray(data[field]) ? { type: 'array', children: { '*': rules[field] } } : rules[field]
+    }
+    validate(filtered_rules, data)
+    return q
+  }
+
+  /**
+   * Creates object
+   * @param data
+   * @return {Promise<ActiveRecord>}
+   */
+  static async create (data) {
+    const rules = this.validation_rules
+    const new_data = {}
+    for (const field of Object.keys(data)) {
+      if (!rules.hasOwnProperty(field)) {
+        if (this.IGNORE_EXTRA_FIELDS) {
+          continue
+        }
+        const ex = new ValidationException('Parameters error')
+        ex.info[field] = `Field "${field}" is not described for model ${this.name}`
+        throw ex
+      }
+      if (this.restricted_for_create.includes(field)) {
+        const ex = new ValidationException('Parameters error')
+        ex.info[field] = `Field "${field}" is restricted for creating model ${this.name}`
+        throw ex
+      }
+      new_data[field] = data[field]
+    }
+    return await (new this(new_data)).save()
+  }
+
+  /**
+   * Updates object
+   * @param data
+   * @return {Promise<ActiveRecord>}
+   */
+  async update (data) {
+    if (!this.id) {
+      throw new Error('You can update saved object only')
+    }
+    const rules = this.constructor.validation_rules
+    const new_data = {}
+    for (const field of Object.keys(data)) {
+      if (!rules.hasOwnProperty(field)) {
+        if (this.constructor.IGNORE_EXTRA_FIELDS) {
+          continue
+        }
+        const ex = new ValidationException('Parameters error')
+        ex.info[field] = `Field "${field}" is not described for model ${this.constructor.name}`
+        throw ex
+      }
+      if (this.constructor.restricted_for_update.includes(field)) {
+        const ex = new ValidationException('Parameters error')
+        ex.info[field] = `Field "${field}" is restricted for updating model ${this.constructor.name}`
+        throw ex
+      }
+      new_data[field] = data[field]
+    }
+    return await this.save(new_data)
+  }
+
+  /**
+   * Checks uniqueness of the object based on UNIQUE_KEYS
+   */
+  async checkUniqueness (exception_mode = false) {
+    for (const fields of this.constructor.UNIQUE_KEYS) {
+      if (!await this.isUnique(fields)) {
+        if (exception_mode) {
+          const ex = new ValidationException('Object is not unique')
+          for (const field of fields) {
+            ex.info[field] = 'Part of the unique key'
+          }
+          throw ex
+        }
+        return false
+      }
+    }
+    return true
+  }
+
+  async _preSave () {
+    if (this.constructor.IGNORE_EXTRA_FIELDS) {
+      const rules = this.constructor.validation_rules
+      for (const key of Object.keys(this.data).filter(v => !rules.hasOwnProperty(v))) {
+        delete this.data[key]
+      }
+    }
+    await super._preSave()
+    await this.checkUniqueness(true)
+    await this.validate()
+  }
+
+  /**
+   * Performs custom validation - returns null (empty object) in case of successful validation or object of validation issues
+   * @return {Promise<null|Object>}
+   */
+  async custom_validation () {
+    return null
+  }
+
+  /**
+   * Validate object's data
+   * @return {Promise<void>}
+   */
+  async validate () {
+    const rules = this.constructor.validation_rules
+    if (!rules) {
+      throw new Error(`Validation rules are not defined for mode ${this.constructor.name}`)
+    }
+    // Convert integer 1 or 0 to boolean
+    let types
+    for (const rule_name of Object.keys(rules)) {
+      if (this.data.hasOwnProperty(rule_name)) {
+        if (rules[rule_name].hasOwnProperty('type')) {
+          types = Array.isArray(rules[rule_name].type) ? rules[rule_name].type : [rules[rule_name].type]
+          if (types.includes('boolean')) {
+            if ((this.data[rule_name] === 1) || (this.data[rule_name] === 0)) {
+              this.data[rule_name] = this.data[rule_name] === 1
+            }
+          }
+        }
+      }
+    }
+    validate(rules, this.data)
+    const custom_validation_errors = await this.custom_validation()
+    if (custom_validation_errors && Object.keys(custom_validation_errors).length) {
+      const ex = new ValidationException('Validation failed')
+      for (const [param, message] of Object.entries(custom_validation_errors)) ex.info[param] = message
+      throw ex
+    }
+    let rel
+    const relation_errors = []
+    for (const rel_name of Object.keys(this.constructor.available_relations)) {
+      rel = this.constructor.available_relations[rel_name]
+      if (rel.mode === 'parent') {
+        if (this.data.hasOwnProperty(rel._a_key_by_mode) && (this.data[rel._a_key_by_mode] !== null) && (this.data[rel._a_key_by_mode] !== 0)) {
+          if ((await this.rel(rel_name, true)) === null) {
+            relation_errors.push(rel._a_key_by_mode)
+          }
+        }
+      }
+      if (relation_errors.length) {
+        const ex = new ValidationException(`Some relations of the ${this.constructor.name} are not found`)
+        for (const param of relation_errors) ex.info[param] = 'Parent object not found'
+        throw ex
+      }
+    }
+  }
+
+  /**
+   * Returns object by ID if it exists and accessible by user
+   * @param id
+   * @param user
+   * @param mode
+   * @return {Promise<ActiveRecord>}
+   */
+  static async findAndCheckAccessOrDie (id, user, mode = null) {
+    const obj = await this.find(id)
+    if (!obj) {
+      throw new Error(`${this.name} #${id} not found`)
+    }
+    if (!(await obj.accessible(user, mode))) {
+      throw new Error(`${this.name} #${id} is not accessible${mode ? ` for ${mode}` : ''}`)
+    }
+    return obj
+  }
+
+  /**
+   * Returns is object accessible by user
+   * @param user
+   * @param mode
+   * @return {Promise<boolean>}
+   */
+  async accessible (user, mode = null) {
+    return mode === null
+  }
+
+  /**
+   * Returns public data of the object
+   * @return Object
+   */
+  get output () {
+    return {
+      id: this.id
+    }
+  }
+
+  /**
+   * Format output
+   * @param mode
+   * @return {Object}
+   */
+  formatOutput (mode) {
+    return this.output
+  }
+
+  /**
+   * Returns public data of the object with relations
+   * @param required_relations
+   * @param mode
+   * @return {Promise<Object>}
+   */
+  async getExtendedOutput (required_relations = [], mode = null) {
+    const output = this.formatOutput(mode)
+    let rel_data, rel_mode, rel_relations
+    for (const name of required_relations) {
+      if (name.split(':').length > 1) continue
+      if (this.constructor.restricted_for_output.includes(name)) {
+        throw new Error(`Relation "${name}" is not allowed for extended output of model ${this.constructor.name}`)
+      }
+      rel_data = await this.rel(name)
+      rel_mode = `relation:${this.constructor.name}.${name}`
+      rel_relations = required_relations.filter(v => v.startsWith(`${name}:`)).map(v => v.substr(name.length + 1))
+      output[`:${name}`] = Array.isArray(rel_data)
+        ? await Promise.all(rel_data.map(v => v.getExtendedOutput(rel_relations, rel_mode)))
+        : (rel_data ? await rel_data.getExtendedOutput(rel_relations, rel_mode) : null)
+    }
+    return output
+  }
+}
+
+module.exports = Model

package/index.js

@@ -1,3 +1,3 @@
 const Model = require('./components/model')
 
-module.exports = Model
+module.exports = Model

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-dragonfly-model",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Orange Dragonfly Model",
   "main": "index.js",
   "repository": {
@@ -8,7 +8,8 @@
     "url": "git+https://github.com/charger88/orange-dragonfly-model.git"
   },
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "lint": "eslint ./"
   },
   "keywords": [
     "framework"
@@ -24,11 +25,15 @@
   },
   "homepage": "https://github.com/charger88/orange-dragonfly-model#readme",
   "dependencies": {
-    "orange-dragonfly-orm": "^0.7.4",
-    "orange-dragonfly-validator": "^0.7.5"
+    "orange-dragonfly-orm": "^0.7.21",
+    "orange-dragonfly-validator": "^0.7.8"
   },
   "devDependencies": {
-    "@babel/plugin-proposal-class-properties": "^7.8.3",
-    "jest": "^25.1.0"
+    "eslint": "^7.32.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.24.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "jest": "^25.5.4"
   }
 }

package/tests/lookup-query.test.js

@@ -1,41 +1,42 @@
+/* eslint-disable no-undef */
+
 const TestModel = require('./test-model')
 
 test('select-id', () => {
   const data = [1]
-  const lookup_data = {'id': data[0]}
+  const lookup_data = { id: data[0] }
   const q = TestModel.lookupQuery(lookup_data).buildRawSQL()
   expect(q.sql).toBe('SELECT * FROM test_model WHERE test_model.id = ?')
   expect(q.params).toEqual(data)
 })
 
 test('select-id-multiple', () => {
-  const data = [1,2,3]
-  const lookup_data = {'id': data}
+  const data = [1, 2, 3]
+  const lookup_data = { id: data }
   const q = TestModel.lookupQuery(lookup_data).buildRawSQL()
   expect(q.sql).toBe('SELECT * FROM test_model WHERE test_model.id IN (?, ?, ?)')
   expect(q.params).toEqual(data)
 })
 
-
 test('select-username', () => {
   const data = ['qwerty']
-  const lookup_data = {'username': data[0]}
+  const lookup_data = { username: data[0] }
   const q = TestModel.lookupQuery(lookup_data).buildRawSQL()
   expect(q.sql).toBe('SELECT * FROM test_model WHERE test_model.username = ?')
   expect(q.params).toEqual(data)
 })
 
 test('select-username-incorrect', () => {
-  const lookup_data = {'username': 123}
+  const lookup_data = { username: 123 }
   expect(() => TestModel.lookupQuery(lookup_data)).toThrow()
 })
 
 test('select-username-wrong-field', () => {
-  const lookup_data = {'wrong-field': 123}
+  const lookup_data = { 'wrong-field': 123 }
   expect(() => TestModel.lookupQuery(lookup_data)).toThrow()
 })
 
 test('select-username-restricted-field', () => {
-  const lookup_data = {'uuid': '1234567890123456789012345678901234567890'}
+  const lookup_data = { uuid: '1234567890123456789012345678901234567890' }
   expect(() => TestModel.lookupQuery(lookup_data)).toThrow()
 })

package/tests/output.test.js

@@ -1,56 +1,58 @@
+/* eslint-disable no-undef */
+
 const TestModel = require('./test-model')
 
 const data = {
-  'id': 1,
-  'username': 'tester',
-  'uuid': '1234567890123456789012345678901234567890'
-};
+  id: 1,
+  username: 'tester',
+  uuid: '1234567890123456789012345678901234567890'
+}
 
 test('output', () => {
   const t = new TestModel(data)
   const o = t.output
-  expect(o['id']).toBe(data['id'])
-  expect(o['username']).toBe(data['username'])
-  expect(o['uuid']).toBe(data['uuid'])
-  expect(o['constant_value']).toBe('QWERTY')
+  expect(o.id).toBe(data.id)
+  expect(o.username).toBe(data.username)
+  expect(o.uuid).toBe(data.uuid)
+  expect(o.constant_value).toBe('QWERTY')
 })
 
 test('output-extended', async () => {
   const t = new TestModel(data)
   const o = await t.getExtendedOutput()
-  expect(o['id']).toBe(data['id'])
-  expect(o['username']).toBe(data['username'])
-  expect(o['uuid']).toBe(data['uuid'])
-  expect(o['constant_value']).toBe('QWERTY')
+  expect(o.id).toBe(data.id)
+  expect(o.username).toBe(data.username)
+  expect(o.uuid).toBe(data.uuid)
+  expect(o.constant_value).toBe('QWERTY')
 })
 
 test('output-extended-rel-empty', async () => {
   const t = new TestModel(data)
-  t.relations['child_test'] = null
+  t.relations.child_test = null
   const o = await t.getExtendedOutput(['child_test'])
-  expect(o['id']).toBe(data['id'])
-  expect(o['username']).toBe(data['username'])
-  expect(o['uuid']).toBe(data['uuid'])
-  expect(o['constant_value']).toBe('QWERTY')
+  expect(o.id).toBe(data.id)
+  expect(o.username).toBe(data.username)
+  expect(o.uuid).toBe(data.uuid)
+  expect(o.constant_value).toBe('QWERTY')
   expect(o[':child_test']).toEqual(null)
 })
 
 test('output-extended-rel-data', async () => {
   const data2 = {
-    'id': 2,
-    'username': 'admin',
-    'uuid': '0987654321098765432109876543210987654321'
-  };
+    id: 2,
+    username: 'admin',
+    uuid: '0987654321098765432109876543210987654321'
+  }
   const t = new TestModel(data)
   const t2 = new TestModel(data2)
-  t.relations['child_test'] = t2
+  t.relations.child_test = t2
   const o = await t.getExtendedOutput(['child_test'])
-  expect(o['id']).toBe(data['id'])
-  expect(o['username']).toBe(data['username'])
-  expect(o['uuid']).toBe(data['uuid'])
-  expect(o['constant_value']).toBe('QWERTY')
-  expect(o[':child_test']['id']).toBe(data2['id'])
-  expect(o[':child_test']['username']).toBe(data2['username'])
-  expect(o[':child_test']['uuid']).toBe(data2['uuid'])
-  expect(o[':child_test']['constant_value']).toBe('QWERTY')
+  expect(o.id).toBe(data.id)
+  expect(o.username).toBe(data.username)
+  expect(o.uuid).toBe(data.uuid)
+  expect(o.constant_value).toBe('QWERTY')
+  expect(o[':child_test'].id).toBe(data2.id)
+  expect(o[':child_test'].username).toBe(data2.username)
+  expect(o[':child_test'].uuid).toBe(data2.uuid)
+  expect(o[':child_test'].constant_value).toBe('QWERTY')
 })

package/tests/test-model.js

@@ -1,31 +1,31 @@
-const Model = require('../components/model')
-const ORM = require('orange-dragonfly-orm')
-
-class TestModel extends Model {
-
-  static get available_relations () {
-    return {
-      'child_test': ORM.Relation.parent(this, this),
-    }
-  }
-
-  static get validation_rules () {
-    return require('./test-model-schema.json')
-  }
-
-  static get restricted_for_lookup () {
-    return ['uuid']
-  }
-
-  get output () {
-    return {
-      'id': this.id,
-      'username': this.data['username'],
-      'uuid': this.data['uuid'],
-      'constant_value': 'QWERTY'
-    }
-  }
-
-}
-
-module.exports = TestModel
+/* eslint-disable no-undef */
+
+const Model = require('../components/model')
+const ORM = require('orange-dragonfly-orm')
+
+class TestModel extends Model {
+  static get available_relations () {
+    return {
+      child_test: ORM.Relation.parent(this, this)
+    }
+  }
+
+  static get validation_rules () {
+    return require('./test-model-schema.json')
+  }
+
+  static get restricted_for_lookup () {
+    return ['uuid']
+  }
+
+  get output () {
+    return {
+      id: this.id,
+      username: this.data.username,
+      uuid: this.data.uuid,
+      constant_value: 'QWERTY'
+    }
+  }
+}
+
+module.exports = TestModel

package/babel.config.json

@@ -1,10 +0,0 @@
-{
-  "plugins": [
-    [
-      "@babel/plugin-proposal-class-properties",
-      {
-        "loose": true
-      }
-    ]
-  ]
-}