zyket 1.0.6 → 1.0.8

package/bin/cli.js

@@ -1,33 +1,51 @@
 #!/usr/bin/env node
 const prompts = require('prompts');
+const TemplateManager = require('../src/services/template-manager');
+const templateManager = new TemplateManager();
 
 (async () => {
 	process.stdout.write("\u001b[2J\u001b[0;0H");
+	await templateManager.boot();
   const response = await prompts({
 		type: 'select',
 		name: 'value',
 		message: '[ZYKET] What do you want to do?',
 		choices: [
 			{ title: 'Install Template', value: 'install-template', description: 'Install a new template', disabled: false },
-			{ title: 'Remove Template', value: 'remove-template', description: 'Remove an existing template', disabled: false }
+			/*{ title: 'Remove Template', value: 'remove-template', description: 'Remove an existing template', disabled: false },*/
 		],
 		initial: 0
 	});
 
   const actions = {
 		'install-template': async () => {
-			console.log('Installing template');
+			const templates = templateManager.getTemplates();
+			const response = await prompts({
+				type: 'select',
+				name: 'templateToInstall',
+				message: '[ZYKET] What template would you like to install?',
+				choices: [
+					...templates.map((template) => ({ title: template.toUpperCase(), value: template, description: '', disabled: false })),
+				],
+				initial: 0
+			});
+			if(!templateManager.exists(response.templateToInstall)) throw new Error(`Template ${response.templateToInstall} not found`);
+			templateManager.installTemplate(response.templateToInstall);
 		},
-		'remove-template': async () => {
-			console.log('Removing template');
-		}
+		/*'remove-template': async () => {
+			const response = await prompts({
+				type: 'select',
+				name: 'templateToRemove',
+				message: '[ZYKET] What template would you like to remove?',
+				choices: [
+					{ title: 'Auth', value: 'auth', description: 'Authentication template', disabled: false },
+					{ title: 'Chat', value: 'chat', description: 'Chat template', disabled: false },
+				],
+				initial: 0
+			});
+			console.log(`Removing template: ${response.templateToRemove}`);
+		}*/
 	};
 
 	await actions[response.value]();
-
-	await new Promise((resolve) => {
-		setTimeout(() => {
-			resolve();
-		}, 2000);
-	});
 })();

package/package.json

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

package/src/services/index.js

@@ -5,7 +5,7 @@ const { SocketIO } = require("./socketio");
 
 module.exports = [
   ["logger", require("./Logger"), ["@service_container", process.env.LOG_DIRECTORY || `${process.cwd()}/logs`, process.env.DEBUG === "true"]],
-  ["template-manager", require("./template-manager"), ["@service_container"]],
+  ["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,
   (process.env.S3_ENDPOINT && process.env.S3_ACCESS_KEY && process.env.S3_SECRET_KEY) ? ["s3", S3, ["@service_container", process.env.S3_ENDPOINT, process.env.S3_PORT, process.env.S3_USE_SSL === "true", process.env.S3_ACCESS_KEY, process.env.S3_SECRET_KEY]] : null,

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

@@ -4,12 +4,10 @@ const path = require('path');
 const fs = require('fs');
 
 module.exports = class TemplateManager extends Service {
-  #container;
   templates = {}
 
-  constructor(container) {
+  constructor() {
     super('template-manager');
-    this.#container = container;
   }
 
   async boot() {
@@ -17,19 +15,19 @@ module.exports = class TemplateManager extends Service {
       cwd: path.join(__dirname, '../../templates'),
     });
     for (const template of zyketTemplates) {
-      // need to copy full file  and relation with the name on templates variable
       const templatePath = path.join(__dirname, '../../templates', template);
       const templateContent = fs.readFileSync(templatePath, 'utf-8');
-      this.templates[template.replace('.js', '')] = templateContent;   
+      this.templates[template.replace('.js', '')] = {
+        route: template,
+        content: templateContent
+      };   
     }
-
-    this.#container.get('logger').info(`Loaded ${this.templates.length} templates`);
   }
 
   installFile(fileName, location) {
     const template = this.templates[fileName];
     if (!template) throw new Error(`Template ${fileName} not found`);
-    return fs.writeFileSync(location, template);
+    return fs.writeFileSync(location, template?.content);
   }
 
   installTemplate(templateName) {
@@ -38,19 +36,23 @@ module.exports = class TemplateManager extends Service {
     const files = this.getTemplate(templateName);
     
     for (const file of files) {
-      const fileName = file.split('/').slice(1).join('/');
+      const fileName = file?.route.split('/').slice(1).join('/');
       const fileLocation = path.join(process.cwd(), fileName);
       if (fs.existsSync(fileLocation)) throw new Error(`File ${file} already exists`);
     }
 
     for (const file of files) {
-      const fileName = file.split('/').slice(1).join('/');
-      const template = this.templates[file];
+      const fileName = file?.route.split('/').slice(1).join('/');
       const fileLocation = path.join(process.cwd(), fileName);
-      fs.writeFileSync(fileLocation, template);
+      const folderLocation = path.join(process.cwd(), fileName.split('/').slice(0, -1).join('/'));
+      fs.mkdirSync(folderLocation, { recursive: true });
+      fs.writeFileSync(fileLocation, file?.content);
     }
   }
 
+  uninstallTemplate(templateName) {
+  }
+
   getTemplates() {
     const uniqueTemplates = new Set();
     for (const template of Object.keys(this.templates)) {
@@ -62,6 +64,10 @@ module.exports = class TemplateManager extends Service {
   getTemplate(templateName) {
     const files = Object.keys(this.templates).filter((t) => t.startsWith(templateName));
     if (files.length === 0) throw new Error(`Template ${templateName} not found`);
-    return files
+    return files.map((file) => this.templates[file]);
+  }
+
+  exists(templateName) {
+    return this.getTemplates().some((t) => t === templateName);
   }
 }

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,15 @@
+module.exports = async ({ container, socket, data }) => {
+  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,18 @@
+const validator = require('validator');
+
+module.exports = async ({ container, socket, data }) => {
+  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,25 @@
+const validator = require('validator');
+
+module.exports = async ({ container, socket, data }) => {
+  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 });
+};