rate-core 0.0.6 → 0.5.2

package/lib/index.js

@@ -1,4 +1,17 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+  var extendStatics = function (d, b) {
+    extendStatics = Object.setPrototypeOf ||
+      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+      function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+  };
+  return function (d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
   function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
   return new (P || (P = Promise))(function (resolve, reject) {
@@ -40,15 +53,14 @@ function __export(m) {
 }
 Object.defineProperty(exports, "__esModule", { value: true });
 __export(require("./rate"));
-var RateService = (function () {
-  function RateService(find, repository, infoRepository, commentRepository, rateReactionRepository, queryURL) {
+var ReactionService = (function () {
+  function ReactionService(find, repository, infoRepository, commentRepository, reactionRepository, queryURL) {
     this.find = find;
     this.repository = repository;
     this.infoRepository = infoRepository;
     this.commentRepository = commentRepository;
-    this.rateReactionRepository = rateReactionRepository;
+    this.reactionRepository = reactionRepository;
     this.queryURL = queryURL;
-    this.rate = this.rate.bind(this);
     this.search = this.search.bind(this);
     this.load = this.load.bind(this);
     this.getRate = this.getRate.bind(this);
@@ -60,48 +72,7 @@ var RateService = (function () {
     this.getComments = this.getComments.bind(this);
     this.getComment = this.getComment.bind(this);
   }
-  RateService.prototype.rate = function (rate) {
-    return __awaiter(this, void 0, void 0, function () {
-      var info, r0, exist, r1, sr, history, res;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            rate.time = new Date();
-            return [4, this.infoRepository.load(rate.id)];
-          case 1:
-            info = _a.sent();
-            if (!!info) return [3, 3];
-            return [4, this.repository.insert(rate, true)];
-          case 2:
-            r0 = _a.sent();
-            return [2, r0];
-          case 3: return [4, this.repository.load(rate.id, rate.author)];
-          case 4:
-            exist = _a.sent();
-            if (!!exist) return [3, 6];
-            return [4, this.repository.insert(rate)];
-          case 5:
-            r1 = _a.sent();
-            return [2, r1];
-          case 6:
-            sr = { review: exist.review, rate: exist.rate, time: exist.time };
-            if (exist.histories && exist.histories.length > 0) {
-              history = exist.histories;
-              history.push(sr);
-              rate.histories = history;
-            }
-            else {
-              rate.histories = [sr];
-            }
-            return [4, this.repository.update(rate, exist.rate)];
-          case 7:
-            res = _a.sent();
-            return [2, res];
-        }
-      });
-    });
-  };
-  RateService.prototype.search = function (s, limit, offset, fields) {
+  ReactionService.prototype.search = function (s, limit, offset, fields) {
     var _this = this;
     return this.find(s, limit, offset, fields).then(function (res) {
       if (!_this.queryURL) {
@@ -131,19 +102,19 @@ var RateService = (function () {
       }
     });
   };
-  RateService.prototype.load = function (id, author) {
+  ReactionService.prototype.load = function (id, author) {
     return this.repository.load(id, author);
   };
-  RateService.prototype.getRate = function (id, author) {
+  ReactionService.prototype.getRate = function (id, author) {
     return this.repository.load(id, author);
   };
-  RateService.prototype.setUseful = function (id, author, userId) {
-    return this.rateReactionRepository.save(id, author, userId, 1);
+  ReactionService.prototype.setUseful = function (id, author, userId) {
+    return this.reactionRepository.save(id, author, userId, 1);
   };
-  RateService.prototype.removeUseful = function (id, author, userId) {
-    return this.rateReactionRepository.remove(id, author, userId);
+  ReactionService.prototype.removeUseful = function (id, author, userId) {
+    return this.reactionRepository.remove(id, author, userId);
   };
-  RateService.prototype.comment = function (comment) {
+  ReactionService.prototype.comment = function (comment) {
     var _this = this;
     return this.repository.load(comment.id, comment.author).then(function (checkRate) {
       if (!checkRate) {
@@ -155,7 +126,7 @@ var RateService = (function () {
       }
     });
   };
-  RateService.prototype.removeComment = function (commentId, userId) {
+  ReactionService.prototype.removeComment = function (commentId, userId) {
     var _this = this;
     return this.commentRepository.load(commentId).then(function (comment) {
       if (comment) {
@@ -171,7 +142,7 @@ var RateService = (function () {
       }
     });
   };
-  RateService.prototype.updateComment = function (comment) {
+  ReactionService.prototype.updateComment = function (comment) {
     var _this = this;
     return this.commentRepository.load(comment.commentId).then(function (exist) {
       if (!exist) {
@@ -195,63 +166,164 @@ var RateService = (function () {
       }
     });
   };
-  RateService.prototype.getComments = function (id, author, limit) {
-    return this.commentRepository.getComments(id, author, limit);
-  };
-  RateService.prototype.getComment = function (id) {
-    return this.commentRepository.load(id);
-  };
-  return RateService;
-}());
-exports.RateService = RateService;
-var CommentQuery = (function () {
-  function CommentQuery(find, repository, queryURL) {
-    this.find = find;
-    this.repository = repository;
-    this.queryURL = queryURL;
-    this.load = this.load.bind(this);
-    this.search = this.search.bind(this);
-    this.getComments = this.getComments.bind(this);
-  }
-  CommentQuery.prototype.load = function (id, ctx) {
-    return this.repository.load(id, ctx);
-  };
-  CommentQuery.prototype.getComments = function (id, author, limit) {
-    return this.repository.getComments(id, author, limit);
-  };
-  CommentQuery.prototype.search = function (s, limit, offset, fields) {
+  ReactionService.prototype.getComments = function (id, author, limit) {
     var _this = this;
-    return this.find(s, limit, offset, fields).then(function (res) {
-      if (!_this.queryURL) {
-        return res;
+    return this.commentRepository.getComments(id, author, limit).then(function (comments) {
+      if (_this.queryURL) {
+        var ids = [];
+        for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+          var comment = comments_1[_i];
+          ids.push(comment.userId);
+        }
+        return _this.queryURL(ids).then(function (urls) {
+          for (var _i = 0, comments_2 = comments; _i < comments_2.length; _i++) {
+            var comment = comments_2[_i];
+            var i = binarySearch(urls, comment.userId);
+            if (i >= 0) {
+              comment.userURL = urls[i].url;
+            }
+          }
+          return comments;
+        });
       }
       else {
-        if (res.list && res.list.length > 0) {
-          var ids = [];
-          for (var _i = 0, _a = res.list; _i < _a.length; _i++) {
-            var rate = _a[_i];
-            ids.push(rate.userId);
+        return comments;
+      }
+    });
+  };
+  ReactionService.prototype.getComment = function (id) {
+    var _this = this;
+    return this.commentRepository.load(id).then(function (comment) {
+      if (comment && _this.queryURL) {
+        return _this.queryURL([id]).then(function (urls) {
+          var i = binarySearch(urls, comment.userId);
+          if (i >= 0) {
+            comment.userURL = urls[i].url;
           }
-          return _this.queryURL(ids).then(function (urls) {
-            for (var _i = 0, _a = res.list; _i < _a.length; _i++) {
-              var rate = _a[_i];
-              var i = binarySearch(urls, rate.userId);
-              if (i >= 0) {
-                rate.userURL = urls[i].url;
-              }
+          return comment;
+        });
+      }
+      else {
+        return comment;
+      }
+    });
+  };
+  return ReactionService;
+}());
+exports.ReactionService = ReactionService;
+var RateService = (function (_super) {
+  __extends(RateService, _super);
+  function RateService(find, repository, infoRepository, commentRepository, reactionRepository, queryURL) {
+    var _this = _super.call(this, find, repository, infoRepository, commentRepository, reactionRepository, queryURL) || this;
+    _this.rate = _this.rate.bind(_this);
+    return _this;
+  }
+  RateService.prototype.rate = function (rate) {
+    return __awaiter(this, void 0, void 0, function () {
+      var info, r0, exist, r1, sr, history, res;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            rate.time = new Date();
+            return [4, this.infoRepository.exist(rate.id)];
+          case 1:
+            info = _a.sent();
+            if (!!info) return [3, 3];
+            return [4, this.repository.insert(rate, true)];
+          case 2:
+            r0 = _a.sent();
+            return [2, r0];
+          case 3: return [4, this.repository.load(rate.id, rate.author)];
+          case 4:
+            exist = _a.sent();
+            if (!!exist) return [3, 6];
+            return [4, this.repository.insert(rate)];
+          case 5:
+            r1 = _a.sent();
+            return [2, r1];
+          case 6:
+            sr = { review: exist.review, rate: exist.rate, time: exist.time };
+            if (exist.histories && exist.histories.length > 0) {
+              history = exist.histories;
+              history.push(sr);
+              rate.histories = history;
             }
-            return res;
-          });
+            else {
+              rate.histories = [sr];
+            }
+            return [4, this.repository.update(rate, exist.rate)];
+          case 7:
+            res = _a.sent();
+            return [2, res];
         }
-        else {
-          return res;
+      });
+    });
+  };
+  return RateService;
+}(ReactionService));
+exports.RateService = RateService;
+function avg(n) {
+  var sum = 0;
+  for (var _i = 0, n_1 = n; _i < n_1.length; _i++) {
+    var s = n_1[_i];
+    sum = sum + s;
+  }
+  return sum / n.length;
+}
+exports.avg = avg;
+var RatesService = (function (_super) {
+  __extends(RatesService, _super);
+  function RatesService(find, repository, infoRepository, commentRepository, reactionRepository, queryURL) {
+    var _this = _super.call(this, find, repository, infoRepository, commentRepository, reactionRepository, queryURL) || this;
+    _this.rate = _this.rate.bind(_this);
+    return _this;
+  }
+  RatesService.prototype.rate = function (rate) {
+    return __awaiter(this, void 0, void 0, function () {
+      var info, r0, exist, r1, sr, history, res;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0: return [4, this.infoRepository.exist(rate.id)];
+          case 1:
+            info = _a.sent();
+            if (rate.rates && rate.rates.length > 0) {
+              rate.rate = avg(rate.rates);
+            }
+            rate.time = new Date();
+            if (!!info) return [3, 3];
+            return [4, this.repository.insert(rate, true)];
+          case 2:
+            r0 = _a.sent();
+            return [2, r0];
+          case 3: return [4, this.repository.load(rate.id, rate.author)];
+          case 4:
+            exist = _a.sent();
+            if (!!exist) return [3, 6];
+            return [4, this.repository.insert(rate)];
+          case 5:
+            r1 = _a.sent();
+            return [2, r1];
+          case 6:
+            sr = { review: exist.review, rates: exist.rates, time: exist.time };
+            if (exist.histories && exist.histories.length > 0) {
+              history = exist.histories;
+              history.push(sr);
+              rate.histories = history;
+            }
+            else {
+              rate.histories = [sr];
+            }
+            return [4, this.repository.update(rate, exist.rate)];
+          case 7:
+            res = _a.sent();
+            return [2, res];
         }
-      }
+      });
     });
   };
-  return CommentQuery;
-}());
-exports.CommentQuery = CommentQuery;
+  return RatesService;
+}(ReactionService));
+exports.RatesService = RatesService;
 function binarySearch(ar, el) {
   var m = 0;
   var n = ar.length - 1;
@@ -312,6 +384,38 @@ var RateValidator = (function () {
   return RateValidator;
 }());
 exports.RateValidator = RateValidator;
+var RatesValidator = (function () {
+  function RatesValidator(attributes, check, max, length) {
+    this.attributes = attributes;
+    this.check = check;
+    this.max = max;
+    this.length = length;
+    this.validate = this.validate.bind(this);
+  }
+  RatesValidator.prototype.validate = function (rate) {
+    var errs = this.check(rate, this.attributes);
+    if (!rate.rates || rate.rates.length === 0) {
+      var err = createError('rates', 'required');
+      errs.push(err);
+      return Promise.resolve(errs);
+    }
+    if (rate.rates.length !== this.length) {
+      var err = createError('rates', 'length', this.length);
+      errs.push(err);
+      return Promise.resolve(errs);
+    }
+    for (var _i = 0, _a = rate.rates; _i < _a.length; _i++) {
+      var r = _a[_i];
+      if (r > this.max) {
+        var err = createError('rates', 'max', this.max);
+        errs.push(err);
+      }
+    }
+    return Promise.resolve(errs);
+  };
+  return RatesValidator;
+}());
+exports.RatesValidator = RatesValidator;
 function createError(field, code, param) {
   if (!code) {
     code = 'string';

package/lib/rate.js

@@ -116,3 +116,38 @@ exports.info10Model = {
     type: 'number',
   }
 };
+exports.rateInfoModel = {
+  id: {
+    key: true
+  },
+  rate: {
+    type: 'number',
+  },
+  count: {
+    type: 'integer',
+  },
+  score: {
+    type: 'number',
+  }
+};
+exports.ratesModel = {
+  id: {
+    key: true,
+    match: 'equal'
+  },
+  author: {
+    key: true,
+    match: 'equal'
+  },
+  rate: {
+    type: 'number'
+  },
+  rates: {
+    required: true,
+    type: 'integers'
+  },
+  time: {
+    type: 'datetime'
+  },
+  review: {},
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rate-core",
-  "version": "0.0.6",
+  "version": "0.5.2",
   "description": "rate",
   "main": "./lib/index.js",
   "types": "./src/index.ts",
@@ -17,9 +17,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com/core-ts/rate"
+    "url": "git@github.com/core-ts/reaction"
   },
   "keywords": [
+    "reaction",
+    "reaction core",
     "rate",
     "rate core"
   ]

package/src/core.ts

@@ -78,7 +78,7 @@ export interface ViewRepository<T, ID> {
   keys?(): string[];
   all?(ctx?: any): Promise<T[]>;
   load(id: ID, ctx?: any): Promise<T|null>;
-  exist?(id: ID, ctx?: any): Promise<boolean>;
+  exist(id: ID, ctx?: any): Promise<boolean>;
 }
 export interface Repository<T, ID> extends ViewRepository<T, ID> {
   insert(obj: T, ctx?: any): Promise<number>;

package/src/index.ts

@@ -1,7 +1,7 @@
 import { Attributes, Search, SearchResult } from './core';
 import {
-  Comment, CommentFilter, InfoRepository, Rate, RateCommentQuery, RateCommentRepository, RateFilter, Rater,
-  RateReactionRepository, RateRepository, ShortComment, ShortRate
+  BaseRate, BaseRepository, Comment, InfoRepository, Rate, RateCommentRepository, RateFilter, Rater, RateReactionRepository,
+  Rates, RatesFilter, ShortComment, ShortRate, ShortRates
 } from './rate';
 
 export * from './rate';
@@ -10,14 +10,13 @@ export interface URL {
   id: string;
   url: string;
 }
-export class RateService<O> implements Rater {
-  constructor(protected find: Search<Rate, RateFilter>,
-    public repository: RateRepository,
-    private infoRepository: InfoRepository<O>,
-    private commentRepository: RateCommentRepository,
-    private rateReactionRepository: RateReactionRepository,
-    private queryURL?: (ids: string[]) => Promise<URL[]>) {
-    this.rate = this.rate.bind(this);
+export class ReactionService<R extends BaseRate, F, O> {
+  constructor(protected find: Search<R, F>,
+    public repository: BaseRepository<R>,
+    protected infoRepository: InfoRepository<O>,
+    protected commentRepository: RateCommentRepository,
+    protected reactionRepository: RateReactionRepository,
+    protected queryURL?: (ids: string[]) => Promise<URL[]>) {
     this.search = this.search.bind(this);
     this.load = this.load.bind(this);
     this.getRate = this.getRate.bind(this);
@@ -29,30 +28,7 @@ export class RateService<O> implements Rater {
     this.getComments = this.getComments.bind(this);
     this.getComment = this.getComment.bind(this);
   }
-  async rate(rate: Rate): Promise<number> {
-    rate.time = new Date();
-    const info = await this.infoRepository.load(rate.id);
-    if (!info) {
-      const r0 = await this.repository.insert(rate, true);
-      return r0;
-    }
-    const exist = await this.repository.load(rate.id, rate.author);
-    if (!exist) {
-      const r1 = await this.repository.insert(rate);
-      return r1;
-    }
-    const sr: ShortRate = { review: exist.review, rate: exist.rate, time: exist.time };
-    if (exist.histories && exist.histories.length > 0) {
-      const history = exist.histories;
-      history.push(sr);
-      rate.histories = history;
-    } else {
-      rate.histories = [sr];
-    }
-    const res = await this.repository.update(rate, exist.rate);
-    return res;
-  }
-  search(s: RateFilter, limit?: number, offset?: number | string, fields?: string[]): Promise<SearchResult<Rate>> {
+  search(s: F, limit?: number, offset?: number | string, fields?: string[]): Promise<SearchResult<R>> {
     return this.find(s, limit, offset, fields).then(res => {
       if (!this.queryURL) {
         return res;
@@ -77,17 +53,17 @@ export class RateService<O> implements Rater {
       }
     });
   }
-  load(id: string, author: string): Promise<Rate | null> {
+  load(id: string, author: string): Promise<R | null> {
     return this.repository.load(id, author);
   }
-  getRate(id: string, author: string): Promise<Rate | null> {
+  getRate(id: string, author: string): Promise<R | null> {
     return this.repository.load(id, author);
   }
   setUseful(id: string, author: string, userId: string): Promise<number> {
-    return this.rateReactionRepository.save(id, author, userId, 1);
+    return this.reactionRepository.save(id, author, userId, 1);
   }
   removeUseful(id: string, author: string, userId: string): Promise<number> {
-    return this.rateReactionRepository.remove(id, author, userId);
+    return this.reactionRepository.remove(id, author, userId);
   }
   comment(comment: Comment): Promise<number> {
     return this.repository.load(comment.id, comment.author).then(checkRate => {
@@ -128,75 +104,146 @@ export class RateService<O> implements Rater {
           exist.histories = [c];
         }
         exist.comment = comment.comment;
-        const res =  this.commentRepository.update(exist);
+        const res = this.commentRepository.update(exist);
         return res;
       }
     });
   }
   getComments(id: string, author: string, limit?: number): Promise<Comment[]> {
-    return this.commentRepository.getComments(id, author, limit);
+    return this.commentRepository.getComments(id, author, limit).then(comments => {
+      if (this.queryURL) {
+        const ids: string[] = [];
+        for (const comment of comments) {
+          ids.push(comment.userId);
+        }
+        return this.queryURL(ids).then(urls => {
+          for (const comment of comments) {
+            const i = binarySearch(urls, comment.userId);
+            if (i >= 0) {
+              comment.userURL = urls[i].url;
+            }
+          }
+          return comments;
+        });
+      } else {
+        return comments;
+      }
+    });
   }
-  getComment(id: string): Promise<Comment|null> {
-    return this.commentRepository.load(id);
+  getComment(id: string): Promise<Comment | null> {
+    return this.commentRepository.load(id).then(comment => {
+      if (comment && this.queryURL) {
+        return this.queryURL([id]).then(urls => {
+          const i = binarySearch(urls, comment.userId);
+          if (i >= 0) {
+            comment.userURL = urls[i].url;
+          }
+          return comment;
+        });
+      } else {
+        return comment;
+      }
+    });
   }
 }
 export interface CommentRepository {
-  load(commentId: string, ctx?: any): Promise<Comment|null>;
+  load(commentId: string, ctx?: any): Promise<Comment | null>;
   getComments(id: string, author: string, limit?: number): Promise<Comment[]>;
 }
 // tslint:disable-next-line:max-classes-per-file
-export class CommentQuery implements RateCommentQuery {
-  constructor(protected find: Search<Comment, CommentFilter>, protected repository: CommentRepository, private queryURL?: (ids: string[]) => Promise<URL[]>) {
-    this.load = this.load.bind(this);
-    this.search = this.search.bind(this);
-    this.getComments = this.getComments.bind(this);
+export class RateService<O> extends ReactionService<Rate, RateFilter, O> implements Rater<Rate, RateFilter> {
+  constructor(find: Search<Rate, RateFilter>,
+    repository: BaseRepository<Rate>,
+    infoRepository: InfoRepository<O>,
+    commentRepository: RateCommentRepository,
+    reactionRepository: RateReactionRepository,
+    queryURL?: (ids: string[]) => Promise<URL[]>) {
+    super(find, repository, infoRepository, commentRepository, reactionRepository, queryURL);
+    this.rate = this.rate.bind(this);
   }
-  load(id: string, ctx?: any): Promise<Comment|null> {
-    return this.repository.load(id, ctx);
+  async rate(rate: Rate): Promise<number> {
+    rate.time = new Date();
+    const info = await this.infoRepository.exist(rate.id);
+    if (!info) {
+      const r0 = await this.repository.insert(rate, true);
+      return r0;
+    }
+    const exist = await this.repository.load(rate.id, rate.author);
+    if (!exist) {
+      const r1 = await this.repository.insert(rate);
+      return r1;
+    }
+    const sr: ShortRate = { review: exist.review, rate: exist.rate, time: exist.time };
+    if (exist.histories && exist.histories.length > 0) {
+      const history = exist.histories;
+      history.push(sr);
+      rate.histories = history;
+    } else {
+      rate.histories = [sr];
+    }
+    const res = await this.repository.update(rate, exist.rate);
+    return res;
   }
-  getComments(id: string, author: string, limit?: number): Promise<Comment[]> {
-    return this.repository.getComments(id, author, limit);
+}
+export function avg(n: number[]): number {
+  let sum = 0;
+  for (const s of n) {
+    sum = sum + s;
   }
-  search(s: CommentFilter, limit?: number, offset?: number | string, fields?: string[]): Promise<SearchResult<Comment>> {
-    return this.find(s, limit, offset, fields).then(res => {
-      if (!this.queryURL) {
-        return res;
-      } else {
-        if (res.list && res.list.length > 0) {
-          const ids: string[] = [];
-          for (const rate of res.list) {
-            ids.push(rate.userId);
-          }
-          return this.queryURL(ids).then(urls => {
-            for (const rate of res.list) {
-              const i = binarySearch(urls, rate.userId);
-              if (i >= 0) {
-                rate.userURL = urls[i].url;
-              }
-            }
-            return res;
-          });
-        } else {
-          return res;
-        }
-      }
-    });
+  return sum / n.length;
+}
+// tslint:disable-next-line:max-classes-per-file
+export class RatesService<O> extends ReactionService<Rates, RatesFilter, O> implements Rater<Rates, RatesFilter> {
+  constructor(find: Search<Rates, RatesFilter>,
+    repository: BaseRepository<Rates>,
+    infoRepository: InfoRepository<O>,
+    commentRepository: RateCommentRepository,
+    reactionRepository: RateReactionRepository,
+    queryURL?: (ids: string[]) => Promise<URL[]>) {
+    super(find, repository, infoRepository, commentRepository, reactionRepository, queryURL);
+    this.rate = this.rate.bind(this);
+  }
+  async rate(rate: Rates): Promise<number> {
+    const info = await this.infoRepository.exist(rate.id);
+    if (rate.rates && rate.rates.length > 0) {
+      rate.rate = avg(rate.rates);
+    }
+    rate.time = new Date();
+    if (!info) {
+      const r0 = await this.repository.insert(rate, true);
+      return r0;
+    }
+    const exist = await this.repository.load(rate.id, rate.author);
+    if (!exist) {
+      const r1 = await this.repository.insert(rate);
+      return r1;
+    }
+    const sr: ShortRates = { review: exist.review, rates: exist.rates, time: exist.time };
+    if (exist.histories && exist.histories.length > 0) {
+      const history = exist.histories;
+      history.push(sr);
+      rate.histories = history;
+    } else {
+      rate.histories = [sr];
+    }
+    const res = await this.repository.update(rate, exist.rate);
+    return res;
   }
 }
 function binarySearch(ar: URL[], el: string): number {
   let m = 0;
   let n = ar.length - 1;
   while (m <= n) {
-      // tslint:disable-next-line:no-bitwise
-      const k = (n + m) >> 1;
-      const cmp = compare(el, ar[k].id);
-      if (cmp > 0) {
-          m = k + 1;
-      } else if (cmp < 0) {
-          n = k - 1;
-      } else {
-          return k;
-      }
+    // tslint:disable-next-line:no-bitwise
+    const k = (n + m) >> 1;
+    const cmp = compare(el, ar[k].id);
+    if (cmp > 0) {
+      m = k + 1;
+    } else if (cmp < 0) {
+      n = k - 1;
+    } else {
+      return k;
+    }
   }
   return -m - 1;
 }
@@ -206,7 +253,7 @@ function compare(s1: string, s2: string): number {
 interface ErrorMessage {
   field: string;
   code: string;
-  param?: string|number|Date;
+  param?: string | number | Date;
   message?: string;
 }
 // tslint:disable-next-line:max-classes-per-file
@@ -239,6 +286,32 @@ export class RateValidator {
     }
   }
 }
+// tslint:disable-next-line:max-classes-per-file
+export class RatesValidator {
+  constructor(protected attributes: Attributes, protected check: (obj: any, attributes: Attributes) => ErrorMessage[], protected max: number, protected length: number) {
+    this.validate = this.validate.bind(this);
+  }
+  validate(rate: Rates): Promise<ErrorMessage[]> {
+    const errs = this.check(rate, this.attributes);
+    if (!rate.rates || rate.rates.length === 0) {
+      const err = createError('rates', 'required');
+      errs.push(err);
+      return Promise.resolve(errs);
+    }
+    if (rate.rates.length !== this.length) {
+      const err = createError('rates', 'length', this.length);
+      errs.push(err);
+      return Promise.resolve(errs);
+    }
+    for (const r of rate.rates) {
+      if (r > this.max) {
+        const err = createError('rates', 'max', this.max);
+        errs.push(err);
+      }
+    }
+    return Promise.resolve(errs);
+  }
+}
 function createError(field: string, code?: string, param?: string | number | Date): ErrorMessage {
   if (!code) {
     code = 'string';

package/src/rate.ts

@@ -4,12 +4,13 @@ export interface RateId {
   id: string;
   author: string;
 }
-
-export interface Rate {
-  id: string;
+export interface BaseRate {
   author: string;
   authorURL?: string;
   rate: number;
+}
+export interface Rate extends BaseRate {
+  id: string;
   time: Date;
   review: string;
   usefulCount: number;
@@ -30,24 +31,56 @@ export interface RateFilter extends Filter {
   usefulCount?: number;
   replyCount?: number;
 }
-
-export interface RateRepository {
+export interface RateInfo {
+  id: string;
+  rate: number;
+  count: number;
+  score: number;
+}
+export interface ShortRates {
+  rates: number[];
+  time: Date;
+  review: string;
+}
+export interface Rates extends BaseRate {
+  id: string;
+  rates: number[];
+  time: Date;
+  review: string;
+  usefulCount: number;
+  replyCount: number;
+  histories?: ShortRates[];
+}
+export interface RatesFilter extends RateFilter {
+  rates?: number[];
+  rate1: number;
+  rate2: number;
+  rate3: number;
+  rate4: number;
+  rate5: number;
+  rate6: number;
+  rate7: number;
+  rate8: number;
+  rate9: number;
+  rate10: number;
+}
+export interface BaseRepository<R> {
   // save(obj: Rate, info?: T, ctx?: any): Promise<number>;
-  insert(rate: Rate, newInfo?: boolean): Promise<number>;
-  update(rate: Rate, oldRate: number): Promise<number>;
-  load(id: string, author: string): Promise<Rate | null>;
-}
-export interface Rater {
-  search(s: RateFilter, limit?: number, offset?: number | string, fields?: string[], ctx?: any): Promise<SearchResult<Rate>>;
-  load(id: string, author: string): Promise<Rate | null>;
-  rate(rate: Rate): Promise<number>;
+  insert(rate: R, newInfo?: boolean): Promise<number>;
+  update(rate: R, oldRate: number): Promise<number>;
+  load(id: string, author: string): Promise<R | null>;
+}
+export interface Rater<R, F extends Filter> {
+  search(s: F, limit?: number, offset?: number | string, fields?: string[], ctx?: any): Promise<SearchResult<R>>;
+  load(id: string, author: string): Promise<R | null>;
+  rate(rate: R): Promise<number>;
   setUseful(id: string, author: string, userId: string, ctx?: any): Promise<number>;
   removeUseful(id: string, author: string, userId: string, ctx?: any): Promise<number>;
   comment(comment: Comment): Promise<number>;
   removeComment(id: string, author: string, ctx?: any): Promise<number>;
   updateComment(comment: Comment): Promise<number>;
   getComments(id: string, author: string, limit?: number): Promise<Comment[]>;
-  getComment(id: string): Promise<Comment|null>;
+  getComment(id: string): Promise<Comment | null>;
 }
 export interface RateReactionRepository {
   remove(id: string, author: string, userId: string, ctx?: any): Promise<number>;
@@ -60,9 +93,9 @@ export interface RateCommentRepository extends Repository<Comment, string> {
 }
 
 export interface Query<T, ID, S> {
-  search: (s: S, limit?: number, skip?: number|string, fields?: string[]) => Promise<SearchResult<T>>;
-  metadata?(): Attributes|undefined;
-  load(id: ID, ctx?: any): Promise<T|null>;
+  search: (s: S, limit?: number, skip?: number | string, fields?: string[]) => Promise<SearchResult<T>>;
+  metadata?(): Attributes | undefined;
+  load(id: ID, ctx?: any): Promise<T | null>;
 }
 export interface RateCommentQuery extends Query<Comment, string, CommentFilter> {
   getComments(id: string, author: string, limit?: number): Promise<Comment[]>;
@@ -247,3 +280,40 @@ export interface CommentFilter extends Filter {
   time?: Date;
   updatedAt?: Date;
 }
+
+export const rateInfoModel: Attributes = {
+  id: {
+    key: true
+  },
+  rate: {
+    type: 'number',
+  },
+  count: {
+    type: 'integer',
+  },
+  score: {
+    type: 'number',
+  }
+};
+
+export const ratesModel: Attributes = {
+  id: {
+    key: true,
+    match: 'equal'
+  },
+  author: {
+    key: true,
+    match: 'equal'
+  },
+  rate: {
+    type: 'number'
+  },
+  rates: {
+    required: true,
+    type: 'integers'
+  },
+  time: {
+    type: 'datetime'
+  },
+  review: {},
+};