zyket 1.0.44 → 1.0.45

package/index.js

@@ -10,6 +10,7 @@ const Worker = require("./src/services/bullmq/Worker");
 const BullBoardExtension = require("./src/extensions/bullboard");
 const Extension = require("./src/extensions/Extension");
 const InteractiveStorageExtension = require("./src/extensions/interactive-storage");
+const AuthService = require("./src/services/auth");
 
 
 module.exports = {
@@ -21,5 +22,6 @@ module.exports = {
   Worker,
   EnvManager,
   BullBoardExtension, InteractiveStorageExtension,
-  Extension
+  Extension,
+  AuthService
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyket",
-  "version": "1.0.44",
+  "version": "1.0.45",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -14,6 +14,7 @@
   "description": "",
   "dependencies": {
     "@bull-board/express": "^6.14.2",
+    "better-auth": "^1.4.18",
     "bullmq": "^5.63.0",
     "colors": "^1.4.0",
     "cors": "^2.8.5",
@@ -25,6 +26,7 @@
     "multer": "^2.0.2",
     "node-cron": "^4.2.1",
     "node-dependency-injection": "^3.2.4",
+    "pg": "^8.18.0",
     "prompts": "^2.4.2",
     "redis": "^5.9.0",
     "sequelize": "^6.37.7",

package/src/services/auth/auth.js

@@ -0,0 +1,8 @@
+const AuthService = require('./index.js');
+
+const auth = new AuthService({
+  get: (serviceName) => {
+  }
+});
+
+module.exports = auth.auth;

package/src/services/auth/index.js

@@ -0,0 +1,140 @@
+const { Service } = require('../Service');
+const { toNodeHandler } = require('better-auth/node');
+const { betterAuth } = require("better-auth");
+const { admin, bearer, organization } = require("better-auth/plugins");
+const { Pool } = require("pg");
+
+module.exports = class AuthService extends Service {
+  #container;
+  client;
+
+  constructor(container) {
+    super('AuthService');
+    this.#container = container;
+  }
+
+  async boot() {
+    if(process.env.DATABASE_DIALECT !== 'postgresql') throw new Error("AuthService only supports PostgreSQL as database dialect");
+    this.client = this.auth;
+    const express = this.#container.get('express');
+    express.regiterRawAllRoutes("/api/*splat", toNodeHandler(this.auth));
+  }
+
+  get plugins() {
+    return [];
+  }
+
+  get socialProviders() {
+    return {}
+  }
+
+  get userAdditionalFields() {
+    return {};
+  }
+
+  async sendResetPasswordEmail({ user, url, token }, request) {
+    throw new Error("sendResetPasswordEmail method not implemented");
+  }
+
+  async sendVerificationEmail({ user, url, token }, request) {
+    throw new Error("sendVerificationEmail method not implemented");
+  }
+
+  async sendInvitationEmail(data) {
+    throw new Error("sendInvitationEmail method not implemented");
+  }
+
+  async allowUserToCreateOrganization(user) {
+    throw new Error("allowUserToCreateOrganization method not implemented");
+  }
+
+  get auth() {
+    const cache = this.#container.get('cache');
+    return betterAuth({
+      plugins: [
+        admin(),
+        bearer(),
+        organization({
+          allowUserToCreateOrganization: async (user) => {
+            return await this.allowUserToCreateOrganization(user);
+          },
+          async sendInvitationEmail(data) {
+            return await this.sendInvitationEmail(data);
+          }
+        }),
+        ...this.plugins,
+      ],
+      socialProviders: this.socialProviders,
+      database: new Pool({
+        connectionString: process.env.DATABASE_URL || null,
+      }),
+      advanced: {
+        crossSubDomainCookies: {
+          enabled: true,
+        },
+        cookie: {
+          sameSite: "none",
+          secure: true,
+          path: "/",
+          state: {
+            attributes: {
+              sameSite: "none",
+              secure: true,
+            }
+          }
+        },
+        defaultCookieAttributes: {
+          secure: true,
+          sameSite: "none",
+        },
+        cookies: {
+          state: {
+            attributes: {
+              sameSite: "none",
+              secure: true,
+            }
+          }
+        }
+      },
+      secondaryStorage: {
+        get: async (key) => {
+          return await cache.get(key);
+        },
+        set: async (key, value, ttl) => {
+          await cache.set(key, value);
+          if(ttl) await cache.expire(key, ttl);
+        },
+        delete: async (key) => {
+          await cache.del(key);
+        }
+      },
+      emailAndPassword: {
+        enabled: true,
+        requireEmailVerification: false,
+        sendResetPassword: async ({ user, url, token }, request) => this.sendResetPasswordEmail({ user, url, token }, request),
+      },
+      emailVerification: {
+        sendVerificationEmail: async ({ user, url, token }, request) => this.sendVerificationEmail({ user, url, token }, request),
+        sendOnSignIn: true,
+        autoSignInAfterVerification: true,
+      },
+      user: {
+        additionalFields: this.userAdditionalFields
+      },
+      account: {
+        accountLinking: { enabled: true },
+        skipStateCookieCheck: true,
+      },
+      session: {
+        expiresIn: 60 * 60 * 24 * 7,
+        updateAge: 60 * 60 * 24
+      },
+      secret: process.env.AUTH_SECRET || 'your-secret-key-change-in-production',
+      trustedOrigins: process.env.TRUSTED_ORIGINS?.split(',') || ['http://localhost:5173', 'http://localhost:6632']
+    })
+  }
+
+  get client() {
+    return this.client;
+  }
+}

package/src/templates/default/src/routes/[test]/message.js

@@ -1,6 +1,12 @@
 const { Route } = require("zyket");
+const DefaultMiddleware = require("../../middlewares/default");
 
 module.exports = class DefaultRoute extends Route {
+  middlewares = {
+    post: [ new DefaultMiddleware() ],
+    get: [ new DefaultMiddleware() ]
+  }
+
   async post({ container, request }) {
     const { test } = request.params;
     container.get("logger").info("Default route GET");

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

@@ -1,53 +0,0 @@
-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

@@ -1,46 +0,0 @@
-/* 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

@@ -1,21 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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 });
-  }
-};