zyket 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyket",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/services/index.js

@@ -4,7 +4,7 @@ const S3 = require("./s3");
 const { SocketIO } = require("./socketio");
 
 module.exports = [
-  ["logger", require("./Logger"), ["@service_container", process.env.LOG_DIRECTORY || `${process.cwd()}/logs`, process.env.DEBUG === "true"]],
+  ["logger", require("./logger"), ["@service_container", process.env.LOG_DIRECTORY || `${process.cwd()}/logs`, process.env.DEBUG === "true"]],
   ["template-manager", require("./template-manager"), []],
   process.env.DATABASE_URL ? ["database", Database, ["@service_container", process.env.DATABASE_URL]] : null,
   process.env.CACHE_URL ? ["cache", Cache, ["@service_container", process.env.CACHE_URL]] : null,

package/src/services/template-manager/index.js

@@ -50,6 +50,9 @@ module.exports = class TemplateManager extends Service {
     }
   }
 
+  uninstallTemplate(templateName) {
+  }
+
   getTemplates() {
     const uniqueTemplates = new Set();
     for (const template of Object.keys(this.templates)) {

package/src/templates/auth/src/db-models/User.js

@@ -0,0 +1,53 @@
+module.exports = ({sequelize, container, Sequelize}) => {
+  const User = sequelize.define('user', {
+    id: {
+      type: Sequelize.UUID,
+      defaultValue: Sequelize.UUIDV4,
+      allowNull: false,
+      primaryKey: true
+    },
+    email: {
+      type: Sequelize.STRING,
+      allowNull: false
+    },
+    password: {
+      type: Sequelize.STRING,
+      allowNull: false
+    },
+  }, {
+    timestamps: true,
+    createdAt: 'created_at',
+    updatedAt: 'updated_at',
+    indexes: [
+      {
+        unique: true,
+        fields: ['email']
+      }
+    ]
+  });
+
+  User.associate = models => {
+    // User is associated to an application through ApplicationUser
+    User.belongsToMany(models.Application, {
+      through: models.ApplicationUser,
+      as: 'applications',
+      foreignKey: 'user_id',
+      otherKey: 'application_id'
+    });
+
+    User.addScope('defaultScope', {
+      attributes: { exclude: ['password'] },
+      include: [
+        {
+          model: models.Application,
+          as: 'applications',
+          through: { attributes: [] }
+        }
+      ]
+    });
+  }
+
+  require('./hooks/User')(User, container);
+
+  return User;
+}

package/src/templates/auth/src/db-models/hooks/User.js

@@ -0,0 +1,46 @@
+/* eslint-disable no-async-promise-executor */
+const crypto = require('crypto')
+
+module.exports = (User, container) => {
+  User.beforeCreate(async (user, options) => {
+    const salt = process.env.ENCRYPTION_SALT || ''
+    user.password = crypto.pbkdf2Sync(user.password, salt, 1000, 64, 'sha512').toString('hex')
+  })
+
+  /**
+   * Verify if the password is valid
+   * @param {string} password - The password to verify
+   * @returns {Boolean} - Boolean
+  */
+  User.prototype.isValidPassword = async function (password) {
+    const { User } = container.get('database').models
+    const user = await User.findByPk(this.id, {
+      attributes: ['password']
+    })
+    const hash = crypto.pbkdf2Sync(password, process.env.ENCRYPTION_SALT, 1000, 64, 'sha512').toString('hex')
+    return user.password === hash
+  }
+
+  User.prototype.generateAuthToken = async function () {
+    const token = crypto.randomBytes(32).toString('hex')
+    const cache = container.get('cache')
+    await cache.set(`auth:${token}`, JSON.stringify({
+      ...this.toJSON()
+    }))
+    await cache.expire(`auth:${token}`, 60 * 60 * 24 * 7)
+    return token
+  }
+
+  User.prototype.removeAuthToken = function (token) {
+    return new Promise((resolve, reject) => {
+      try {
+        const cache = container.get('cache')
+        cache.del(`auth:${token}`).then(() => {
+          resolve()
+        }).catch(err => reject(err))
+      } catch (err) {
+        reject(err)
+      }
+    })
+  }
+}

package/src/templates/auth/src/handlers/auth/login.js

@@ -0,0 +1,21 @@
+const { Handler } = require("zyket");
+
+module.exports = class LoginHandler extends Handler {
+  middleware = [];
+  
+  async handle({ container, socket, data, io }) {
+    const {email, password} = data
+    const { User } = container.get('database').models
+    const user = await User.findOne({ where: { email } })
+
+    if(!user) return socket.emit("auth.login", { error: "User not found" })
+    if(!await user.isValidPassword(password)) return socket.emit("auth.login", { error: "Invalid password" })
+
+    const token = await user.generateAuthToken()
+
+    socket.user = user
+    socket.token = token
+
+    socket.emit("auth.login", { ...user.toJSON(), token })
+  }
+};

package/src/templates/auth/src/handlers/auth/logout.js

@@ -0,0 +1,22 @@
+const { Handler } = require("zyket");
+
+module.exports = class LogoutHandler extends Handler {
+  middleware = [];
+  
+  async handle({ container, socket, data, io }) {
+    if(!socket.user) return socket.emit('auth.logout', { error: 'Not authenticated' });
+    const { token } = socket;
+    if (!token) return socket.emit('auth.logout', { error: 'Not authenticated' });
+
+    const cache = container.get('cache');
+    const tokenData = await cache.get(`auth:${token}`);
+    if (!tokenData) return socket.emit('auth.logout', { error: 'Not authenticated' });
+
+    try {
+      await cache.del(`auth:${token}`);
+      socket.emit('auth.logout', { success: true });
+    } catch (error) {
+      socket.emit('auth.logout', { error: error.message });
+    }
+  }
+};

package/src/templates/auth/src/handlers/auth/register.js

@@ -0,0 +1,30 @@
+const { Handler } = require("zyket");
+const validator = require('validator');
+
+module.exports = class RegisterHandler extends Handler {
+  middleware = [];
+  
+  async handle({ container, socket, data, io }) {
+    const { email, password } = data;
+
+    if(!email) return socket.emit('auth.register', { error: 'Email is required' });
+    if(validator.isEmpty(email)) return socket.emit('auth.register', { error: 'Email is invalid' });
+    if(!validator.isEmail(email)) return socket.emit('auth.register', { error: 'Email is invalid' });
+
+    if(!password) return socket.emit('auth.register', { error: 'Password is required' });
+    if(validator.isEmpty(password)) return socket.emit('auth.register', { error: 'Password is invalid' });
+    if(!validator.isLength(password, { min: 6 })) return socket.emit('auth.register', { error: 'Password must be at least 6 characters' });
+
+    const { User } = container.get('database').models;
+
+    try {
+      await User.create({ email, password })
+    } catch (error) {
+      return socket.emit('auth.register', { error: 'Email already exists' });
+    }
+
+    const user = await User.findOne({ where: { email } });
+
+    socket.emit('auth.register', { user });
+  }
+};