ES6数据模型类

时间:2016-01-31 04:56:42

标签: javascript api model-view-controller ecmascript-6 models

我正在尝试使用ES6类在我正在构建的API中构建数据模型(来自MySQL数据库)。我不喜欢使用ORM / ODM库,因为这将是一个非常基本的简单API。但是,我很难理解如何定义这些模型。

我的数据实体(这些只是一些简化的例子):

CUSTOMER

数据模型

id
name
groupId
status (enum of: active, suspended, closed)

私人方法

_getState(status) {
    var state = (status  == 'active' ? 'good' : 'bad');
    return state;
}

我希望能够做到:

  • findById:提供单个customer.id,返回该特定客户的数据,即SELECT * FROM customers WHERE id = ?

  • findByGroupId:提供group.id,返回属于该组的所有客户(在一个对象数组中)的数据,即SELECT * FROM customers WHERE groupId = ?

响应有效负载

对于每个客户对象,我想像这样返回JSON:

findById(1);

[{
    "id" : 1,
    "name" : "John Doe",
    "groupId" : 2,
    "status" : "active",
    "state" : "good"
}]

findByGroupId(2);

[{
    "id" : 1,
    "name" : "John Doe",
    "groupId" : 2,
    "status" : "active",
    "state" : "good"
},
{
    "id" : 4,
    "name" : "Pete Smith",
    "groupId" : 2,
    "status" : "suspended",
    "state" : "bad"
}]

数据模型

id
title

我希望能够做到:

  • findById:提供单个group.id,返回该特定组的数据,即SELECT * FROM groups WHERE id = ?

响应有效负载

对于每个组对象,我想像这样返回JSON:

findById(2);

{
    "id" : 2,
    "title" : "This is Group 2",
    "customers" : [{
        "id" : 1,
        "name" : "John Doe",
        "groupId" : 2,
        "status" : "active",
        "state" : "good"
    },
    {
        "id" : 4,
        "name" : "Pete Smith",
        "groupId" : 2,
        "status" : "suspended",
        "state" : "bad"
    }]
}

<小时/>

的要求:

  • 必须使用ES6课程
  • 要导出的每个模型(例如customer.js

<小时/>

的问题:

我的主要问题是:

  1. 我在哪里定义数据结构,包括需要数据转换的字段,使用私有方法(例如_getState()
  2. findByIdfindByGroupId等是否应该在班级范围内定义?或者,它们应该通过单独的方法(在与该类相同的文件中)来实例化对象吗?
  3. 我应该如何处理一个对象是另一个对象的孩子的情况,例如:将属于 Group 对象的 Customer 对象作为 Group findById中的对象数组返回?
  4. 应该在哪里定义连接到数据库的SQL查询?在getByIdgetByGroupId等?
  5. UPDATE !!

    这就是我想出的 - (如果有人可以评论和评论,会很棒):

    CUSTOMER模型

    'use strict';
    
    class Cust {
      constructor (custData) {
        this.id = custData.id;
        this.name = custData.name;
        this.groupId = custData.groupId;
        this.status = custData.status;
        this.state = this._getState(custData.status);
      }
    
      _getState(status) {
        let state = (status  == 'active' ? 'good' : 'bad');
        return state;
      }
    }
    
    exports.findById = ((id) => {
      return new Promise ((resolve, reject) => {
        let custData = `do the MySQL query here`;
        let cust = new Cust (custData);
        let Group = require(appDir + process.env.PATH_API + process.env.PATH_MODELS + 'group');
        Group.findById(cust.groupId).then(
          (group) => {
            cust.group = group;
            resolve (cust)
          },
          (err) => {
            resolve (cust);
          }
        );
      });
    });
    

    GROUP模型

    'use strict';
    
    class Group {
      constructor (groupData) {
        this.id = groupData.id;
        this.title = groupData.title;
      }
    }
    
    exports.findById = ((id) => {
      return new Promise ((resolve, reject) => {
        let groupData = `do the MySQL query here`;
        if (id != 2){
          reject('group - no go');
        };
        let group = new Group (groupData);
        resolve (group);
      });
    });
    

    CUSTOMER控制器(实例化客户模型)

    'use strict';
    
    var Cust = require(appDir + process.env.PATH_API + process.env.PATH_MODELS + 'cust');
    
    class CustController {
      constructor () {
      }
    
      getCust (req, res) {
        Cust.findById(req.params.id).then(
          (cust) => {
            res(cust);
          },
          (err) => {
            res(err);
          }
        )
      }
    }
    
    module.exports = CustController;
    

    这似乎运作良好,我已经能够使用ClassPromiselet使其更加符合ES6。

    所以,我想对我的方法有所了解。另外,我是否在此上下文中正确使用了exportrequired功能?

1 个答案:

答案 0 :(得分:2)

这是另一种方法,

我在哪里定义数据结构,包括需要数据转换的字段,使用私有方法(例如_getState())

您应该在扩展顶级模型的模型类中定义这些字段,关系。例如:

class Group extends Model {
    attributes() {
        return {
            id: {
                type: 'integer',
                primary: true
            },
            title: {
                type: 'string'
            }
        };
    }

    relationships() {
        return {
            'Customer': {
                type: 'hasMany',
                foreignKey: 'groupId'
            }
        };
    }
}

应该在类的范围内定义findById,findByGroupId等吗?或者,这些应该通过单独的方法(在与该类相同的文件中)来实例化对象吗?

在模型示例中使用findByAttribute(attr)而不是使用许多函数:

static findByAttribute(attr) {
    return new Promise((resolve, reject) => {
        var query = this._convertObjectToQueriesArray(attr);
        query = query.join(" and ");
        let records = `SELECT * from ${this.getResourceName()} where ${query}`;
        var result = this.run(records);
        // Note: Only support 'equals' and 'and' operator
        if (!result) {
            reject('Could not found records');
        } else {
            var data = [];
            result.forEach(function(record) {
                data.push(new this(record));
            });
            resolve(data);
        }
    });
}

/**
 * Convert Object of key value to sql filters
 * 
 * @param  {Object} Ex: {id:1, name: "John"}
 * @return {Array of String} ['id=1', 'name=John']
 */
static _convertObjectToQueriesArray(attrs) {
    var queryArray = [];
    for (var key in attrs) {
        queryArray.push(key + " = " + attrs[key]);
    }
    return queryArray;
}

/**
 * Returns table name or resource name.
 * 
 * @return {String}
 */
static getResourceName() {
    if (this.resourceName) return this.resourceName();
    if (this.constructor.name == "Model") {
        throw new Error("Model is not initialized");
    }
    return this.constructor.name.toLowerCase();
}

我应该如何处理一个对象是另一个对象的孩子的情况,例如:将属于Group对象的Customer对象作为组的findById中的对象数组返回?

如果是关系,你应该有findRelations,getRelatedRecords等方法。

var customer1 = new Customer({ id: 1, groupId: 3});
customer1.getRelatedRecords('Group');

class Model {
 ...

  getRelatedRecords(reln) {
    var targetRelationship = this.relationships()[reln];
    if (!targetRelationship) {
        throw new Error("No relationship found.");
    }
    var primaryKey = this._getPrimaryKey();

    var relatedObject = eval(reln);
    var attr = {};
    if (targetRelationship.type == "hasOne") {
        console.log(this.values);
        attr[relatedObject.prototype._getPrimaryKey()] = this.values[targetRelationship.foreignKey];
    } else if (targetRelationship.type == "hasMany") {
        attr[targetRelationship.foreignKey] = this.values[this._getPrimaryKey()];
    }

    relatedObject.findByAttribute(attr).then(function(records) {
        // this.values[reln] = records;
    });
   }
 ...
}

应该在哪里定义连接到数据库的SQL查询?在getById,getByGroupId等?

这个很棘手,但是因为你希望你的解决方案很简单,所以将查询放在find方法中。理想的情况是拥有自己的QueryBuilder类。

检查以下完整代码,解决方案功能不完全,但您明白了。我还在模型中添加了引擎变量,您可以使用它来增强获取机制。所有其他设计理念都符合你的想象:)

完整代码:

var config = {
  engine: 'db' // Ex: rest, db
};
class Model {

  constructor(values) {
    this.values = values;
    this.engine = config.engine;
  }

  toObj() {
    var data = {};
    for (var key in this.values) {
      if (this.values[key] instanceof Model) {
        data[key] = this.values[key].toObj();
      } else if (this.values[key] instanceof Array) {
        data[key] = this.values[key].map(x => x.toObj());
      } else {
        data[key] = this.values[key];
      }
    }
    return data;
  }

  static findByAttribute(attr) {
    return new Promise((resolve, reject) => {
      var query = this._convertObjectToQueriesArray(attr);
      query = query.join(" and ");
      let records = `SELECT * from ${this.getResourceName()} where ${query}`;
      var result = this.run(records);
      // Note: Only support 'equals' and 'and' operator
      if (!result) {
        reject('Could not found records');
      } else {
        var data = [];
        result.forEach(function(record) {
          data.push(new this(record));
        });
        resolve(data);
      }
    });
  }

  getRelatedRecords(reln) {
    var targetRelationship = this.relationships()[reln];
    if (!targetRelationship) {
      throw new Error("No relationship found.");
    }
    var primaryKey = this._getPrimaryKey();

    var relatedObject = eval(reln);
    var attr = {};
    if (targetRelationship.type == "hasOne") {
      console.log(this.values);
      attr[relatedObject.prototype._getPrimaryKey()] = this.values[targetRelationship.foreignKey];
    } else if (targetRelationship.type == "hasMany") {
      attr[targetRelationship.foreignKey] = this.values[this._getPrimaryKey()];
    }

    relatedObject.findByAttribute(attr).then(function(records) {
      // this.values[reln] = records;
    });
  }

  /**
   * Test function to show what queries are being ran.
   */
  static run(query) {
    console.log(query);
    return [];
  }

  _getPrimaryKey() {
    for (var key in this.attributes()) {
      if (this.attributes()[key].primary) {
        return key;
      }
    }
  }

  /**
   * Convert Object of key value to sql filters
   * 
   * @param  {Object} Ex: {id:1, name: "John"}
   * @return {Array of String} ['id=1', 'name=John']
   */
  static _convertObjectToQueriesArray(attrs) {
    var queryArray = [];
    for (var key in attrs) {
      queryArray.push(key + " = " + attrs[key]);
    }
    return queryArray;
  }

  /**
   * Returns table name or resource name.
   * 
   * @return {String}
   */
  static getResourceName() {
    if (this.resourceName) return this.resourceName();
    if (this.constructor.name == "Model") {
      throw new Error("Model is not initialized");
    }
    return this.constructor.name.toLowerCase();
  }
}

class Customer extends Model {
  attributes() {
    return {
      id: {
        type: 'integer',
        primary: true
      },
      name: {
        type: 'string'
      },
      groupId: {
        type: 'integer'
      },
      status: {
        type: 'string'
      },
      state: {
        type: 'string'
      }
    };
  }

  relationships() {
    return {
      'Group': {
        type: 'hasOne',
        foreignKey: 'groupId'
      }
    };
  }
}

class Group extends Model {
  attributes() {
    return {
      id: {
        type: 'integer',
        primary: true
      },
      title: {
        type: 'string'
      }
    };
  }

  relationships() {
    return {
      'Customer': {
        type: 'hasMany',
        foreignKey: 'groupId'
      }
    };
  }
}

var cust = new Customer({
  id: 1,
  groupId: 3
});
cust.getRelatedRecords('Group');

var group = new Group({
  id: 3,
  title: "Awesome Group"
});
group.getRelatedRecords('Customer');

var groupData = new Group({
  "id": 2,
  "title": "This is Group 2",
  "customers": [new Customer({
      "id": 1,
      "name": "John Doe",
      "groupId": 2,
      "status": "active",
      "state": "good"
    }),
    new Customer({
      "id": 4,
      "name": "Pete Smith",
      "groupId": 2,
      "status": "suspended",
      "state": "bad"
    })
  ]
});

console.log(groupData.toObj());