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. findById，findByGroupId等是否应该在班级范围内定义？或者，它们应该通过单独的方法（在与该类相同的文件中）来实例化对象吗？
  3. 我应该如何处理一个对象是另一个对象的孩子的情况，例如：将属于 Group 对象的 Customer 对象作为 Group 的findById中的对象数组返回？
  4. 应该在哪里定义连接到数据库的SQL查询？在getById，getByGroupId等？

    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;

    这似乎运作良好，我已经能够使用Class，Promise和let使其更加符合ES6。

    所以，我想对我的方法有所了解。另外，我是否在此上下文中正确使用了export和required功能？

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());

相关问题
最新问题