deploy.sh 0.2.0 → 2.0.0

package/lib/models/request.js

@@ -1,31 +1,32 @@
-/**
- * @module models/request
- */
-
-const mongoose = require('mongoose');
+import mongoose from "mongoose";
 
 const Schema = mongoose.Schema;
 
-const RequestSchema = new Schema({
-  url: String,
-  time: Number,
-  subdomain: String,
-  statusCode: String,
-  userAgent: String,
-  referer: String,
-  method: String,
-  acceptLanguage: String
-}, {
-  minimize: false,
-  timestamps: {
-    createdAt: 'created_at',
-    updatedAt: 'updated_at'
+const RequestSchema = new Schema(
+  {
+    url: String,
+    time: Number,
+    subdomain: String,
+    statusCode: String,
+    userAgent: String,
+    referer: String,
+    method: String,
+    acceptLanguage: String,
+  },
+  {
+    minimize: false,
+    timestamps: {
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
   }
-});
+);
+
+const RequestModel = mongoose.model("Request", RequestSchema);
 
 /**
  * Request definition
- * @class {Object} Request
+ * @class Request
  * @property {String} subdomain - the subdomain of the request
  * @property {String} url - the url that was being accessed
  * @property {Number} time - the time it took to access the resource
@@ -35,56 +36,66 @@ const RequestSchema = new Schema({
  * @property {String} referer - the referer that the user was at before accessing the address
  * @property {String} acceptLanguage - browser based language preferences
  */
-const Request = mongoose.model('Request', RequestSchema);
+class Request {
+  /**
+   * express middleware that logs requests
+   * @method log
+   * @memberof Request
+   * @param  {Object}   req  - express request object
+   * @param  {Object}   res  - express response object
+   * @param  {Function} next - callback function
+   */
+  static log(req, res, next) {
+    const { url, headers, method } = req;
+    const { host } = headers;
 
-/**
- * express middleware that logs requests
- * @method log
- * @param  {Object}   req  - express request object
- * @param  {Object}   res  - express response object
- * @param  {Function} next - callback function
- */
-module.exports.log = function log(req, res, next) {
-  const { url, headers, method } = req;
-  const { host } = headers;
+    const subdomain = host.split(".")[0];
+    const startAt = process.hrtime();
 
-  const subdomain = host.split('.')[0];
-  const startAt = process.hrtime();
+    res.on("finish", () => {
+      const diff = process.hrtime(startAt);
+      const time = diff[0] * 1e3 + diff[1] * 1e-6;
 
-  res.on('finish', () => {
-    const diff = process.hrtime(startAt);
-    const time = diff[0] * 1e3 + diff[1] * 1e-6;
+      const { statusCode } = res;
 
-    const { statusCode } = res;
+      RequestModel.create({
+        url,
+        time,
+        subdomain,
+        method,
+        statusCode,
+        userAgent: headers["user-agent"],
+        referer: headers["referer"],
+        acceptLanguage: headers["accept-language"],
+      });
+    });
 
-    Request.create({
-      url,
-      time,
+    next();
+  }
+  /**
+   * returns the amount of requests for the specified subdomain
+   * @method count
+   * @memberof Request
+   * @param  {string} subdomain - the subdomain of which to get the count of requests for
+   * @return {Promise}
+   */
+  static async count({ subdomain }) {
+    return await RequestModel.count({
       subdomain,
-      method,
-      statusCode,
-      userAgent: headers['user-agent'],
-      referer: headers['referer'],
-      acceptLanguage: headers['accept-language']
     });
-  });
-
-  next();
-};
-
-/**
- * returns the amount of requests for the specified subdomain
- * @method count
- * @param  {string} subdomain - the subdomain of which to get the count of requests for
- * @return {Promise}
- */
-module.exports.count = function count({ subdomain }) {
-  return new Promise(function(resolve, reject) {
-    Request.count({
-      subdomain
-    }, (err, count) => {
-      if(err) return reject(err);
-      return resolve(count);
+  }
+  /**
+   * removes all entries associated with a particular subdomain
+   * @method del
+   * @memberof Request
+   * @param  {String} subdomain - the subdomain that the entries are related to
+   * @return {Promise}
+   */
+  static async del({ subdomain }) {
+    return await RequestModel.deleteMany({
+      subdomain,
     });
-  });
-};
+  }
+}
+
+export default Request;

package/lib/models/user.js

@@ -1,172 +1,147 @@
-/**
- * @module models/user
- */
-
-const mongoose = require('mongoose');
-const crypto = require('crypto');
+import mongoose from "mongoose";
+import crypto from "crypto";
 
 const Schema = mongoose.Schema;
 
-const UserSchema = new Schema({
-  _id: String,
-  username: String,
-  password: String,
-  token: String
-}, {
-  minimize: false,
-  timestamps: {
-    createdAt: 'created_at',
-    updatedAt: 'updated_at'
+const UserSchema = new Schema(
+  {
+    _id: String,
+    username: String,
+    password: String,
+    token: String,
+  },
+  {
+    minimize: false,
+    timestamps: {
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
   }
-});
+);
 
-const User = mongoose.model('User', UserSchema);
+const UserModel = mongoose.model("User", UserSchema);
 
 /**
  * User definition
- * @class {Object} User
+ * @class User
  * @property {String} username - a string that defines the user's accounts
  * @property {String} password - a password for the user
  * @property {String=} token - an access token
  */
-module.exports.User = User;
+class User {
+  /**
+   * middleware to verify the username and token are valid, will then set the user to req.user
+   * @function authenticateMiddleware
+   * @memberof User
+   * @param {Object} req - express request
+   * @param {Object} res - express response
+   * @param {Function} next - callback to go to next middleware
+   */
+  static async authenticateMiddleware(req, res, next) {
+    const username = req.headers["x-deploy-username"];
+    const token = req.headers["x-deploy-token"];
 
-/**
- * middleware to verify the username and token are valid, will then set the user to req.user
- * @function authenticateMiddleware
- * @param {Object} req - express request
- * @param {Object} res - express response
- * @param {Function} next - callback to go to next middleware
- */
-module.exports.authenticateMiddleware = function authenticateMiddleware(req, res, next) {
-  const { headers } = req;
-  const username = headers['x-deploy-username'];
-  const token = headers['x-deploy-token'];
-  if(!username && !token) {
-    res.status(500).send({ error: 'authentication necessary' });
-  }
-  authenticate(username, token)
-    .then((user) => {
-      req.user = user;
-      next();
-    })
-    .catch((error) => res.status(500).send({ error }));
-};
+    if (!username && !token) {
+      res.status(500).send({ error: "authentication necessary" });
+    }
 
-/**
- * verify the username and token are valid
- * @method authenticate
- * @param  {String} token      - the token associated with the username
- * @param  {String} username   - the username of the user
- * @return {Promise}
- */
-var authenticate;
-module.exports.authenticate = authenticate = function authenticate(username, token) {
-  return new Promise(function(resolve, reject) {
-    User.findOne({
+    req.user = await User.authenticate(username, token);
+
+    next();
+  }
+  /**
+   * verify the username and token are valid
+   * @method authenticate
+   * @memberof User
+   * @param  {String} token      - the token associated with the username
+   * @param  {String} username   - the username of the user
+   * @return {Promise}
+   */
+  static async authenticate(username, token) {
+    let user = await UserModel.findOne({
       _id: username,
-      token
-    }, function(err, user) {
-      if(err || !user) return reject('not authenticated');
-      return resolve({
-        username: user.username,
-        token: user.token,
-        depoyments: user.deployments
-      });
+      token,
     });
-  });
-};
 
-/**
- * logs out a user by deleting their token
- * @method logout
- * @param  {String} token      - the token associated with the username
- * @param  {String} username   - the username of the user
- * @return {Promise}
- */
-module.exports.logout = function logout({ token, username }) {
-  return new Promise(function(resolve, reject) {
-    User.findOne({
+    if (!user) throw new Error("not authenticated");
+
+    return {
+      username: user.username,
+      token: user.token,
+    };
+  }
+  /**
+   * logs out a user by deleting their token
+   * @method logout
+   * @memberof User
+   * @param  {String} token      - the token associated with the username
+   * @param  {String} username   - the username of the user
+   * @return {Promise}
+   */
+  static async logout({ token, username }) {
+    let user = await UserModel.findOne({
       _id: username,
-      token
-    }, function(err, user) {
-      if(err || !user) return reject('token and username not valid');
-      user.token = '';
-      user.save((err) => {
-        if(err) return reject('erro removing token from the database');
-        return resolve();
-      });
+      token,
     });
-  });
-};
 
-/**
- * logs in a user and returns
- * @method login
- * @param  {String} username - the username of the user who is logging in
- * @param  {String} password - the password associated with the user
- * @return {Promise}
- */
-module.exports.login = function login({ username, password }) {
-  return new Promise(function(resolve, reject) {
-    User.findOne({
+    if (!user) throw new Error("token and username not valid");
+
+    user.token = "";
+
+    return await user.save();
+  }
+  /**
+   * logs in a user and returns
+   * @method login
+   * @memberof User
+   * @param  {String} username - the username of the user who is logging in
+   * @param  {String} password - the password associated with the user
+   * @return {Promise}
+   */
+  static async login({ username, password }) {
+    let user = await UserModel.findOne({
       _id: username,
-      password: crypto.createHash('sha256').update(password).digest('hex')
-    }, function(err, user) {
-      if(err || !user) return reject('password username combination not correct');
-      user.token = crypto.createHash('sha256').update(Date.now() + password + username).digest('hex');
-      user.save((err) => {
-        if(err) return reject('erro persisting token to database');
-        return resolve({
-          username: user.username,
-          token: user.token
-        });
-      });
+      password: crypto.createHash("sha256").update(password).digest("hex"),
     });
-  });
-};
 
-/**
- * registers a user
- * @method register
- * @param  {String} username - the username of the user who is logging in
- * @param  {String} password - the password associated with the user
- * @return {Promise}
- */
-module.exports.register = function register({ username, password }) {
-  return new Promise(function(resolve, reject) {
-    User.create({
+    if (!user) throw new Error("password username combination not correct");
+
+    user.token = crypto
+      .createHash("sha256")
+      .update(Date.now() + password + username)
+      .digest("hex");
+    await user.save();
+
+    return {
+      username: user.username,
+      token: user.token,
+    };
+  }
+  /**
+   * registers a user
+   * @method register
+   * @memberof User
+   * @param  {String} username - the username of the user who is logging in
+   * @param  {String} password - the password associated with the user
+   * @return {Promise}
+   */
+  static async register({ username, password }) {
+    let user = await UserModel.create({
       _id: username,
       username,
-      password: crypto.createHash('sha256').update(password).digest('hex'),
-      token: crypto.createHash('sha256').update(Date.now() + password + username).digest('hex')
-    }, function(error, user) {
-      if(error) return reject(error);
-      resolve({
-        username: user.username,
-        token: user.token,
-        depoyments: user.deployments
-      });
+      password: crypto.createHash("sha256").update(password).digest("hex"),
+      token: crypto
+        .createHash("sha256")
+        .update(Date.now() + password + username)
+        .digest("hex"),
     });
-  });
-};
 
-/**
- * returns the user if token and username are valid
- * @method get
- * @param  {String} token      - the token associated with the username
- * @param  {String} username   - the username of the user
- * @return {Promise}
- */
-module.exports.get = function get({ token, username }) {
-  return new Promise(function(resolve, reject) {
-      User.findOne({
-        _id: username,
-        token
-      }, function(err, user) {
-        if(err || !user) return reject('token is no longer valid');
-        return resolve(user);
-    });
+    return {
+      username: user.username,
+      token: user.token,
+      depoyments: user.deployments,
+    };
+  }
+}
 
-  });
-};
+export default User;