我正在尝试使用 ES6 类在我正在构建的 API 中构建数据模型(来自 MySQL 数据库)。我不喜欢使用 ORM/ODM 库,因为这将是一个非常基本、简单的 API。但是,我正在努力思考如何定义这些模型。
我的数据实体是(这些只是一些简化的例子):
客户
数据模型
id
name
groupId
status (enum of: active, suspended, closed)
私有(private)方法
_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
)中导出
问题:
我的主要问题是:
- 我在哪里定义数据结构,包括需要数据转换的字段,使用私有(private)方法(例如
_getState()
) findById
、findByGroupId
等是否应该在类的范围内定义?或者,它们是否应该通过单独的方法(在与类相同的文件中)来实例化对象?- 我应该如何处理一个对象是另一个对象的子对象的情况,例如返回属于 Group 对象的 Customer 对象作为 Group 的
findById
中的对象数组? - 应该在哪里定义将连接到数据库的 SQL 查询?在
getById
,getByGroupId
等?
更新!!
这就是我想出的 - (如果有人可以评论和评论那就太棒了):
客户模型
'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);
}
);
});
});
集团模式
'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 Controller(实例化 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
功能?
最佳答案
这是另一种方法,
我应该在哪里定义数据结构,包括需要数据转换的字段,使用私有(private)方法(例如 _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 对象作为 Group 的 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 等?
这很棘手,但由于您希望解决方案简单,所以请将查询放在查找方法中。理想的场景是拥有自己的 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());
关于javascript - 数据模型的 ES6 类,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/35110505/