signup-service 0.0.1

package/README.md

@@ -0,0 +1 @@
+# signup

package/lib/index.js

@@ -0,0 +1,360 @@
+"use strict";
+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) {
+    function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+    function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+    function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+  var _ = { label: 0, sent: function () { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0: case 1: t = op; break;
+        case 4: _.label++; return { value: op[1], done: false };
+        case 5: _.label++; y = op[1]; op = [0]; continue;
+        case 7: op = _.ops.pop(); _.trys.pop(); continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+          if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+          if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+          if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+          if (t[2]) _.ops.pop();
+          _.trys.pop(); continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var resources = (function () {
+  function resources() {
+  }
+  resources.email = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*(\.[a-zA-Z]{2,4})$/i;
+  resources.phone = /^\d{5,14}$/;
+  resources.password = /^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$/;
+  return resources;
+}());
+exports.resources = resources;
+function initStatus(s) {
+  var error = (s && s.error ? s.error : 0);
+  var success = (s && s.success ? s.success : 1);
+  var username = (s && s.username ? s.username : 2);
+  var contact = (s && s.contact ? s.contact : 2);
+  var format_username = (s && s.format_username ? s.format_username : -1);
+  var format_contact = (s && s.format_contact ? s.format_contact : -2);
+  var format_password = (s && s.format_password ? s.format_password : -3);
+  return { error: error, success: success, username: username, contact: contact, format_username: format_username, format_contact: format_contact, format_password: format_password };
+}
+exports.initStatus = initStatus;
+exports.initializeStatus = initStatus;
+var SignupService = (function () {
+  function SignupService(status, repository, generateId, comparator, passcodeComparator, passcodeRepository, send, gen, expires, validate, checkContact) {
+    this.status = status;
+    this.repository = repository;
+    this.generateId = generateId;
+    this.comparator = comparator;
+    this.passcodeComparator = passcodeComparator;
+    this.passcodeRepository = passcodeRepository;
+    this.send = send;
+    this.expires = expires;
+    this.validate = validate;
+    this.checkContact = checkContact;
+    this.generate = gen;
+    this.register = this.register.bind(this);
+    this.signup = this.signup.bind(this);
+    this.verify = this.verify.bind(this);
+    this.check = this.check.bind(this);
+    this.createConfirmCode = this.createConfirmCode.bind(this);
+  }
+  SignupService.prototype.register = function (info) {
+    return this.signup(info);
+  };
+  SignupService.prototype.signup = function (info) {
+    return __awaiter(this, void 0, void 0, function () {
+      var errors, out, _i, errors_1, err, f, u, c, hashPassword, userId, ok, res;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (this.validate) {
+              errors = this.validate(info);
+              if (errors && errors.length > 0) {
+                out = false;
+                for (_i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
+                  err = errors_1[_i];
+                  f = err.field;
+                  if (f !== 'username' && f !== 'contact' && f !== 'password') {
+                    out = true;
+                  }
+                  else {
+                    if (f === 'username') {
+                      return [2, this.status.format_username];
+                    }
+                    else if (f === 'contact') {
+                      return [2, this.status.format_contact];
+                    }
+                    else if (f === 'password') {
+                      return [2, this.status.format_password];
+                    }
+                  }
+                }
+                if (!out) {
+                  return [2, { status: this.status.error, errors: errors }];
+                }
+              }
+            }
+            return [4, this.repository.checkUsername(info.username)];
+          case 1:
+            u = _a.sent();
+            if (u) {
+              return [2, this.status.username];
+            }
+            if (!this.checkContact) return [3, 3];
+            return [4, this.checkContact(info.contact)];
+          case 2:
+            c = _a.sent();
+            if (c) {
+              return [2, this.status.contact];
+            }
+            _a.label = 3;
+          case 3: return [4, this.comparator.hash(info.password)];
+          case 4:
+            hashPassword = _a.sent();
+            info.password = hashPassword;
+            userId = this.generateId();
+            return [4, this.repository.save(userId, info)];
+          case 5:
+            ok = _a.sent();
+            if (!ok) {
+              return [2, this.status.error];
+            }
+            return [4, this.createConfirmCode(userId, info)];
+          case 6:
+            res = _a.sent();
+            return [2, res ? this.status.success : this.status.error];
+        }
+      });
+    });
+  };
+  SignupService.prototype.createConfirmCode = function (userId, info) {
+    return __awaiter(this, void 0, void 0, function () {
+      var codeSendToEmail, codeHashed, expiredAt, saved, sent, ok;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            codeSendToEmail = this.generate();
+            return [4, this.passcodeComparator.hash(codeSendToEmail)];
+          case 1:
+            codeHashed = _a.sent();
+            expiredAt = addSeconds(new Date(), this.expires);
+            return [4, this.passcodeRepository.save(userId, codeHashed, expiredAt)];
+          case 2:
+            saved = _a.sent();
+            if (saved <= 0) {
+              return [2, false];
+            }
+            return [4, this.send('', codeSendToEmail, expiredAt, info.contact)];
+          case 3:
+            sent = _a.sent();
+            if (!sent) return [3, 5];
+            return [4, this.repository.verify(userId)];
+          case 4:
+            ok = _a.sent();
+            if (ok) {
+              return [2, true];
+            }
+            else {
+              return [2, false];
+            }
+            return [3, 6];
+          case 5: return [2, false];
+          case 6: return [2];
+        }
+      });
+    });
+  };
+  SignupService.prototype.verify = function (userId, code, password) {
+    var _this = this;
+    return this.check(userId, code).then(function (valid) {
+      if (!valid) {
+        return false;
+      }
+      else {
+        if (!password || password.length === 0) {
+          _this.passcodeRepository.delete(userId);
+          return _this.repository.activate(userId);
+        }
+        else {
+          return _this.comparator.hash(password).then(function (hashPassword) {
+            _this.passcodeRepository.delete(userId);
+            return _this.repository.activate(userId, hashPassword);
+          });
+        }
+      }
+    });
+  };
+  SignupService.prototype.check = function (userId, code) {
+    var _this = this;
+    return this.passcodeRepository.load(userId).then(function (pass) {
+      if (after(new Date, pass.expiredAt)) {
+        return false;
+      }
+      else {
+        return _this.passcodeComparator.compare(code, pass.code);
+      }
+    });
+  };
+  return SignupService;
+}());
+exports.SignupService = SignupService;
+exports.UserRegistrationService = SignupService;
+function addSeconds(date, number) {
+  var newDate = new Date(date);
+  newDate.setSeconds(newDate.getSeconds() + number);
+  return newDate;
+}
+exports.addSeconds = addSeconds;
+function after(date1, date2) {
+  if (!date1 || !date2) {
+    return false;
+  }
+  if (date1.getTime() - date2.getTime() > 0) {
+    return true;
+  }
+  return false;
+}
+exports.after = after;
+function generate(length, pad) {
+  if (!length) {
+    length = 6;
+  }
+  return padLeft(Math.floor(Math.random() * Math.floor(Math.pow(10, length) - 1)).toString(), length, pad);
+}
+exports.generate = generate;
+function padLeft(str, length, pad) {
+  if (!str) {
+    return str;
+  }
+  if (typeof str !== 'string') {
+    str = '' + str;
+  }
+  if (str.length >= length) {
+    return str;
+  }
+  if (!pad) {
+    pad = '0';
+  }
+  var str2 = str;
+  while (str2.length < length) {
+    str2 = pad + str2;
+  }
+  return str2;
+}
+exports.padLeft = padLeft;
+var Tel = (function () {
+  function Tel() {
+  }
+  Tel.isPhone = function (str) {
+    if (!str || str.length === 0 || str === '+') {
+      return false;
+    }
+    if (str.charAt(0) !== '+') {
+      return resources.phone.test(str);
+    }
+    else {
+      var phoneNumber = str.substring(1);
+      if (!resources.phonecodes) {
+        return resources.phone.test(phoneNumber);
+      }
+      else {
+        if (resources.phone.test(phoneNumber)) {
+          for (var degit = 1; degit <= 3; degit++) {
+            var countryCode = phoneNumber.substr(0, degit);
+            if (countryCode in resources.phonecodes) {
+              return true;
+            }
+          }
+          return false;
+        }
+        else {
+          return false;
+        }
+      }
+    }
+  };
+  return Tel;
+}());
+exports.Tel = Tel;
+exports.tel = Tel;
+function isPhone(str) {
+  return Tel.isPhone(str);
+}
+exports.isPhone = isPhone;
+function isEmail(email) {
+  if (!email || email.length === 0) {
+    return false;
+  }
+  return resources.email.test(email);
+}
+exports.isEmail = isEmail;
+function isUsername(u) {
+  if (isEmail(u)) {
+    return true;
+  }
+  if (isPhone(u)) {
+    return true;
+  }
+  var v = u + '@gmail.com';
+  return isEmail(v);
+}
+exports.isUsername = isUsername;
+function isPassword(password) {
+  return resources.password.test(password);
+}
+exports.isPassword = isPassword;
+var Validator = (function () {
+  function Validator(checkUsername, checkContact, passwordRequired, min, max) {
+    this.max = max;
+    this.min = (min !== undefined && min != null ? min : 6);
+    this.passwordRequired = (passwordRequired !== undefined && passwordRequired != null ? passwordRequired : true);
+    this.checkUsername = (checkUsername ? checkUsername : isUsername);
+    this.checkContact = (checkContact ? checkContact : isEmail);
+    this.validate = this.validate.bind(this);
+  }
+  Validator.prototype.validate = function (u) {
+    var errs = [];
+    if (!this.checkUsername(u.username)) {
+      errs.push({ field: 'username', code: 'username', message: 'username is not valid' });
+    }
+    else {
+      if (u.username.length < this.min) {
+        errs.push({ field: 'username', code: 'username', message: 'username must have at least ' + this.min + 'characters' });
+      }
+      else if (this.max && u.username.length > this.max) {
+        errs.push({ field: 'username', code: 'username', message: 'username must be less than ' + this.max + 'characters' });
+      }
+    }
+    if (!this.checkContact(u.contact)) {
+      errs.push({ field: 'contact', code: 'contact', message: 'contact is not valid' });
+    }
+    if (this.passwordRequired) {
+      if (!isPassword(u.password)) {
+        errs.push({ field: 'password', code: 'password', message: 'password is not valid' });
+      }
+    }
+    return errs;
+  };
+  return Validator;
+}());
+exports.Validator = Validator;
+exports.SignupValidator = Validator;
+exports.UserRegistrationValidator = Validator;

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "signup-service",
+  "version": "0.0.1",
+  "description": "signup",
+  "main": "./lib/index.js",
+  "types": "./src/index.ts",
+  "scripts": {
+    "build:lib": "tsc",
+    "clean:lib": "rimraf lib"
+  },
+  "devDependencies": {
+    "tslint": "5.10.0",
+    "typescript": "^3.8.3"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com/core-ts/signup"
+  },
+  "keywords": [
+    "signup"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,393 @@
+// tslint:disable-next-line:class-name
+export class resources {
+  static phonecodes?: Phones;
+  static email = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*(\.[a-zA-Z]{2,4})$/i;
+  static phone = /^\d{5,14}$/;
+  static password = /^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$/;
+}
+export interface User {
+  username: string;
+  password: string;
+  contact: string;
+  /*
+  email?: string;
+  phone?: string;
+  dateOfBirth?: Date;
+  gender?: string;
+  givenName?: string;
+  middleName?: string;
+  familyName?: string;
+  */
+}
+export type Info = User;
+export type Signup = User;
+export interface ErrorMessage {
+  field: string;
+  code: string;
+  message?: string;
+}
+export interface Result {
+  status: number|string;
+  errors?: ErrorMessage[];
+  message?: string;
+}
+export interface Status {
+  success: string|number;
+  username: string|number;
+  contact: string|number;
+  error: string|number;
+  format_username: string|number;
+  format_contact: string|number;
+  format_password: string|number;
+}
+export interface StatusConf {
+  error?: string|number;
+  success?: string|number;
+  username?: string|number;
+  contact?: string|number;
+  format_username: string|number;
+  format_contact: string|number;
+  format_password: string|number;
+}
+export function initStatus(s?: StatusConf): Status {
+  const error: number | string = (s && s.error ? s.error : 0);
+  const success: number | string = (s && s.success ? s.success : 1);
+  const username: number | string = (s && s.username ? s.username : 2);
+  const contact: number | string = (s && s.contact ? s.contact : 2);
+  const format_username: number | string = (s && s.format_username ? s.format_username : -1);
+  const format_contact: number | string = (s && s.format_contact ? s.format_contact : -2);
+  const format_password: number | string = (s && s.format_password ? s.format_password : -3);
+  return { error, success, username, contact, format_username, format_contact, format_password };
+}
+export const initializeStatus = initStatus;
+export interface UserStatus {
+  registered: string;
+  codeSent: string;
+  activated: string;
+}
+export interface FieldConfig {
+  username?: string;
+  contact?: string;
+  password?: string;
+  status?: string;
+  maxPasswordAge?: string;
+}
+export interface Track {
+  createdAt: string;
+  createdBy: string;
+  updatedAt: string;
+  updatedBy: string;
+  version?: string;
+}
+export interface StringMap {
+  [key: string]: string;
+}
+export interface SignupConf {
+  status?: StatusConf;
+  expires: number;
+  userStatus: UserStatus;
+  maxPasswordAge?: number;
+  map?: StringMap;
+  track?: Track;
+  fields?: FieldConfig;
+  url?: string;
+}
+export interface SignupConfig {
+  user?: string;
+  password?: string;
+}
+export interface SignUpConfirmationConfig {
+  expires: number;
+  domain: string;
+  port: number;
+  secure: string;
+}
+export interface Repository<ID, T extends User> {
+  checkUsername(username: string): Promise<boolean>;
+  checkContact(contact: string): Promise<boolean>;
+  save(id: ID, info: T): Promise<boolean>;
+  verify(id: ID): Promise<boolean>;
+  activate(id: ID, password?: string): Promise<boolean>;
+}
+export interface Comparator {
+  compare(data: string, encrypted: string): Promise<boolean>;
+  hash(plaintext: string): Promise<string>;
+}
+export interface Passcode {
+  expiredAt: Date;
+  code: string;
+}
+export interface PasscodeRepository<ID> {
+  save(id: ID, passcode: string, expireAt: Date): Promise<number>;
+  load(id: ID): Promise<Passcode>;
+  delete(id: ID): Promise<number>;
+}
+/*
+export interface PasscodeSender {
+  send(to: string, passcode: string, expireAt: Date, params: any): Promise<boolean>;
+}
+export interface PasscodeGenerator {
+  generate(): string;
+}
+export interface Validator {
+  validate(model: any): ErrorMessage[];
+}
+*/
+// tslint:disable-next-line:max-classes-per-file
+export class SignupService<ID, T extends User> {
+  constructor(
+    public status: Status,
+    public repository: Repository<ID, T>,
+    public generateId: () => ID,
+    public comparator: Comparator,
+    public passcodeComparator: Comparator,
+    public passcodeRepository: PasscodeRepository<ID>,
+    public send: (to: string, passcode: string, expireAt: Date, params?: any) => Promise<boolean>,
+    gen: () => string,
+    public expires: number,
+    public validate?: (model: User) => ErrorMessage[],
+    public checkContact?: (username: string) => Promise<boolean>
+  ) {
+    this.generate = gen;
+    this.register = this.register.bind(this);
+    this.signup = this.signup.bind(this);
+    this.verify = this.verify.bind(this);
+    this.check = this.check.bind(this);
+    this.createConfirmCode = this.createConfirmCode.bind(this);
+  }
+  public generate: () => string;
+  register(info: T): Promise<Result|string|number> {
+    return this.signup(info);
+  }
+  async signup(info: T): Promise<Result|string|number> {
+    if (this.validate) {
+      const errors = this.validate(info);
+      if (errors && errors.length > 0) {
+        let out = false;
+        for (const err of errors) {
+          const f = err.field;
+          if (f !== 'username' && f !== 'contact' && f !== 'password') {
+            out = true;
+          } else {
+            if (f === 'username') {
+              return this.status.format_username;
+            } else if (f === 'contact') {
+              return this.status.format_contact;
+            } else if (f === 'password') {
+              return this.status.format_password;
+            }
+          }
+        }
+        if (!out) {
+          return { status: this.status.error, errors };
+        }
+      }
+    }
+
+    const u = await this.repository.checkUsername(info.username);
+    if (u) {
+      return this.status.username;
+    }
+    if (this.checkContact) {
+      const c = await this.checkContact(info.contact);
+      if (c) {
+        return this.status.contact;
+      }
+    }
+    const hashPassword = await this.comparator.hash(info.password);
+    info.password = hashPassword;
+
+    const userId = this.generateId();
+    const ok = await this.repository.save(userId, info);
+
+    if (!ok) {
+      return this.status.error;
+    }
+
+    const res = await this.createConfirmCode(userId, info);
+    return res ? this.status.success : this.status.error;
+  }
+
+  private async createConfirmCode(userId: ID, info: User): Promise<boolean> {
+    const codeSendToEmail = this.generate();
+    const codeHashed = await this.passcodeComparator.hash(codeSendToEmail);
+
+    const expiredAt = addSeconds(new Date(), this.expires);
+    const saved = await this.passcodeRepository.save(userId, codeHashed, expiredAt);
+    if (saved <= 0) {
+      return false;
+    }
+
+    const sent = await this.send('', codeSendToEmail, expiredAt, info.contact);
+    if (sent) {
+      const ok = await this.repository.verify(userId);
+      if (ok) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  verify(userId: ID, code: string, password: string): Promise<boolean> {
+    return this.check(userId, code).then(valid => {
+      if (!valid) {
+        return false;
+      } else {
+        if (!password || password.length === 0) {
+          this.passcodeRepository.delete(userId);
+          return this.repository.activate(userId);
+        } else {
+          return this.comparator.hash(password).then(hashPassword => {
+            this.passcodeRepository.delete(userId);
+            return this.repository.activate(userId, hashPassword);
+          });
+        }
+      }
+    });
+  }
+  private check(userId: ID, code: string): Promise<boolean> {
+    return this.passcodeRepository.load(userId).then(pass => {
+      if (after(new Date, pass.expiredAt)) {
+        return false;
+      } else {
+        return this.passcodeComparator.compare(code, pass.code);
+      }
+    });
+  }
+}
+export const UserRegistrationService = SignupService;
+export function addSeconds(date: Date, number: number) {
+  const newDate = new Date(date);
+  newDate.setSeconds(newDate.getSeconds() + number);
+  return newDate;
+}
+export function after(date1?: Date, date2?: Date): boolean {
+  if (!date1 || !date2) {
+    return false;
+  }
+  if (date1.getTime() - date2.getTime() > 0) {
+    return true;
+  }
+  return false;
+}
+
+export function generate(length?: number, pad?: string): string {
+  if (!length) {
+    length = 6;
+  }
+  return padLeft(Math.floor(Math.random() * Math.floor(Math.pow(10, length) - 1)).toString(), length, pad);
+}
+export function padLeft(str: string, length: number, pad?: string) {
+  if (!str) {
+    return str;
+  }
+  if (typeof str !== 'string') {
+    str = '' + str;
+  }
+  if (str.length >= length) {
+    return str;
+  }
+  if (!pad) {
+    pad = '0';
+  }
+  let str2 = str;
+  while (str2.length < length) {
+    str2 = pad + str2;
+  }
+  return str2;
+}
+export interface Phones {
+  [key: string]: string;
+}
+
+// tslint:disable-next-line:max-classes-per-file
+export class Tel {
+  static isPhone(str: string|null|undefined): boolean {
+    if (!str || str.length === 0 || str === '+') {
+      return false;
+    }
+    if (str.charAt(0) !== '+') {
+      return resources.phone.test(str);
+    } else {
+      const phoneNumber = str.substring(1);
+      if (!resources.phonecodes) {
+        return resources.phone.test(phoneNumber);
+      } else {
+        if (resources.phone.test(phoneNumber)) {
+          for (let degit = 1; degit <= 3; degit++) {
+            const countryCode = phoneNumber.substr(0, degit);
+            if (countryCode in resources.phonecodes) {
+              return true;
+            }
+          }
+          return false;
+        } else {
+          return false;
+        }
+      }
+    }
+  }
+}
+export const tel = Tel;
+export function isPhone(str: string|null|undefined): boolean {
+  return Tel.isPhone(str);
+}
+export function isEmail(email: string|null|undefined): boolean {
+  if (!email || email.length === 0) {
+    return false;
+  }
+  return resources.email.test(email);
+}
+export function isUsername(u: string|null|undefined): boolean {
+  if (isEmail(u)) {
+    return true;
+  }
+  if (isPhone(u)) {
+    return true;
+  }
+  const v = u + '@gmail.com';
+  return isEmail(v);
+}
+export function isPassword(password: string): boolean {
+  return resources.password.test(password);
+}
+// tslint:disable-next-line:max-classes-per-file
+export class Validator<T extends User> {
+  min: number;
+  passwordRequired: boolean;
+  checkContact: (u: string|null|undefined) => boolean;
+  checkUsername: (u: string|null|undefined) => boolean;
+  constructor(checkUsername?: (u: string|null|undefined) => boolean, checkContact?: (u: string|null|undefined) => boolean, passwordRequired?: boolean, min?: number, public max?: number) {
+    this.min = (min !== undefined && min != null ? min : 6);
+    this.passwordRequired = (passwordRequired !== undefined && passwordRequired != null ? passwordRequired : true);
+    this.checkUsername = (checkUsername ? checkUsername : isUsername);
+    this.checkContact = (checkContact ? checkContact : isEmail);
+    this.validate = this.validate.bind(this);
+  }
+  validate(u: T): ErrorMessage[] {
+    const errs: ErrorMessage[] = [];
+    if (!this.checkUsername(u.username)) {
+      errs.push({field: 'username', code: 'username', message: 'username is not valid'});
+    } else {
+      if (u.username.length < this.min) {
+        errs.push({field: 'username', code: 'username', message: 'username must have at least ' + this.min + 'characters'});
+      } else if (this.max && u.username.length > this.max) {
+        errs.push({field: 'username', code: 'username', message: 'username must be less than ' + this.max + 'characters'});
+      }
+    }
+    if (!this.checkContact(u.contact)) {
+      errs.push({field: 'contact', code: 'contact', message: 'contact is not valid'});
+    }
+    if (this.passwordRequired) {
+      if (!isPassword(u.password)) {
+        errs.push({field: 'password', code: 'password', message: 'password is not valid'});
+      }
+    }
+    return errs;
+  }
+}
+export const SignupValidator = Validator;
+export const UserRegistrationValidator = Validator;

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "target": "es5",
+    "baseUrl": "./src",
+    "outDir": "./lib",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "strict": true,
+    "pretty": true,
+    "sourceMap": false,
+    "declaration": false,
+    "experimentalDecorators": false,
+    "removeComments": true,
+    "lib": [
+      "es5",
+      "es6"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}