org-core-js 0.0.1 → 0.0.2

package/cjs/core/index.js

@@ -361,7 +361,8 @@ var _default = ({}) => {
           repository: app.repository,
           entity: app.entity,
           util: app.util,
-          lib: app.lib
+          lib: app.lib,
+          job: app.job
         });
       },
       async job(path_, params, obj = {}) {

package/cjs/core/plugins/auth.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//jwt.verify(token,'shhhhh');
+var _default = ({
+  lib
+}) => ({
+  async tokenRSA(data, v) {
+    // const key = ((await lib("cryptojs").decrypt(process.env.JWT_SECRET_PRIVATE, process.env.JWT_SECRET)) || '').replaceAll("__n__", "\n")
+    const key = lib("cryptojs").decodeBase64(process.env.JWT_SECRET_PRIVATE);
+    return _jsonwebtoken.default.sign(data, key, {
+      algorithm: 'RS256',
+      expiresIn: v ? v : '24h'
+    });
+  },
+  async verifyRSA(token) {
+    // const key = ((await lib("cryptojs").decrypt(process.env.JWT_SECRET_PUBLIC, process.env.JWT_SECRET)) || '').replaceAll("__n__", "\n")
+    const key = lib("cryptojs").decodeBase64(process.env.JWT_SECRET_PUBLIC);
+    return _jsonwebtoken.default.verify(token, key);
+  },
+  auth_info(roles) {
+    return async (ctx, reply) => {
+      try {
+        const token = String(ctx?.headers?.get("authorization") || ctx?.request.headers?.get("authorization") || ' ').split(' ')[1] || String(ctx?.query?.token || '') || '';
+        const info = await this.verifyRSA(token);
+        ctx.user = info.user || info.info || info.data || info.code || info;
+        if (!ctx?.user) {
+          ctx.status_ = 401;
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+        if (roles.length == 0) {} else if (!roles.find(role => ctx.user.role == role)) {
+          ctx.status_ = 401;
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+      } catch (error) {
+        if (roles.length > 0) {
+          ctx.status_ = 401;
+          return reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+        ctx.user = {};
+      }
+    };
+  },
+  auth(roles) {
+    return async (ctx, reply) => {
+      try {
+        const token = String(ctx?.headers?.get("authorization") || ctx?.request.headers?.get("authorization") || ' ').split(' ')[1] || String(ctx?.query?.token || '') || '';
+        const info = await this.verifyRSA(token);
+        ctx.user = info.user || info.info || info.data || info.code || info;
+        const userInfo = JSON.parse((await lib("redis").client.get("user::" + ctx.user.id)) || "{}");
+        ctx.user.teams = userInfo?.teams || [];
+        if (!ctx?.user) {
+          ctx.status_ = 401;
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+        if (roles.length == 0) {} else if (!roles.find(role => (ctx?.user?.teams || []).find(team => team.role == role))) {
+          ctx.status_ = 401;
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+      } catch (error) {
+        console.log(error);
+        if (roles.length > 0) {
+          ctx.status_ = 401;
+          return reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+        ctx.user = {};
+      }
+    };
+  },
+  permission_invite(roles) {
+    return async (ctx, reply) => {
+      try {
+        const token = String(ctx?.headers?.get("authorization") || ctx?.request.headers?.get("authorization") || ' ').split(' ')[1] || String(ctx?.query?.token || '') || '';
+        const info = await this.verifyRSA(token);
+        ctx.user = info.user || info.info || info.data || info.code || info;
+        const userInfo = JSON.parse((await lib("redis").client.get("user::" + ctx.user.id)) || "{}");
+        ctx.user.teams = userInfo?.teams || [];
+        if (roles.length == 0) {
+          return;
+        }
+        const {
+          data
+        } = ctx.body;
+        ctx.user.teams = ctx.user.teams.filter(team => data.teams.find(t => t.id == team.id && data.schoolId == team.schoolId));
+        ctx.body.data.teams == ctx.body.data.teams.filter(team => {
+          const t = ctx.user.teams.find(t => t.id == team.id && roles.find(r => r == t.role));
+          return !!t;
+        });
+        if (!ctx?.user) {
+          ctx.status_ = 401;
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+        if (!roles.find(role => (ctx?.user?.teams || []).find(team => team.role == role))) {
+          ctx.status_ = 401;
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+      } catch (error) {
+        console.log(error);
+        if (roles.length > 0) {
+          ctx.status_ = 401;
+          return reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+        ctx.user = {};
+      }
+    };
+  },
+  auth1(roles) {
+    return async (request, reply) => {
+      try {
+        const token = String(request.headers['authorization']).split(' ')[1];
+        const info = await this.verifyRSA(token);
+        request.user = info.user || info.info || info.data || info.code || info;
+        if (!request?.user) {
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+        if (roles.length == 0) {} else if (!roles.find(role => request.user.role == role)) {
+          reply.code(401).send({
+            error: '401 Unauthorized'
+          });
+        }
+      } catch (error) {
+        reply.code(401).send({
+          error: '401 Unauthorized'
+        });
+      }
+    };
+  },
+  qrcode() {
+    return async (request, reply) => {
+      const infoStr = String(request.query['identifier'] || '');
+      const res = "U2FsdGVkX182xxWCbg9dZxlmmhdMcGGs2xzfdfAXv9FUr/odoyBb4T/yWBQip45iQg5NZmRrrUgRKI3JjL2o5c3rQmKhl7fkKDETT3pF9aorvAYTllBElYq7lUgczSpUhyxPtkpCbrOhgbvHuX8pwCeEnptiEL4CZgorj26jQUO17IlSk1AY2bjwlNgAQuKEgrfacJVcNyn9LtKHHHIQP5LYKxxB5P1oXNEc540n8tcu7+og5x/Pnb9pnm79ZKXH";
+      const decrypt = lib("cryptojs").decrypt(res);
+      console.log(infoStr, 'd', decrypt);
+      if (!decrypt) {
+        reply.code(401).send({
+          error: '401 Unauthorized'
+        });
+      }
+      request.user = JSON.parse(decrypt).identifier || {};
+      if (!request.user.code) {
+        reply.code(401).send({
+          error: '401 Unauthorized'
+        });
+      }
+    };
+  },
+  async forgot(info, e = 5 * 60 * 60 + "s", n = 6) {
+    const verificationCode = lib('generate').number(n);
+    return {
+      verificationCode,
+      verificationJwt: await this.tokenRSA({
+        code: {
+          verificationCode,
+          password: true,
+          ...info,
+          userId: info.id
+        }
+      }, e)
+    };
+  },
+  async code(user, e = 5 * 60 * 60 + "s") {
+    return await this.tokenRSA({
+      user,
+      login: true
+    }, e);
+  }
+});
+exports.default = _default;

package/cjs/core/plugins/ws.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.adapterElysia = void 0;
+// websocket-manager.js
+/**
+ * Cria um gerenciador de WebSockets.
+ * Este gerenciador armazena a configuração das rotas WS (autenticação, conexão, etc.)
+ * e a sincroniza com um adaptador específico (como o do Elysia).
+ *
+ * @param {object} adapter - O adaptador que irá lidar com a implementação do WebSocket (ex: adapterElysia).
+ * @returns {object} - Um objeto com métodos para configurar e sincronizar as rotas WS.
+ */
+var _default = ({
+  adapter
+}) => {
+  // Armazena a configuração de cada path de WebSocket.
+  // Estrutura: { "/path": { connections: {}, events: {}, rooms: {}, room_handlers: {}, auth_fn, connection_fn } }
+  const wsConfig = {};
+  return {
+    /**
+     * Sincroniza todas as configurações de rotas definidas com `of()` com o adaptador.
+     * Deve ser chamado após todas as rotas terem sido definidas.
+     */
+    async sync() {
+      for (const [path, config] of Object.entries(wsConfig)) {
+        adapter.addWs(path, config);
+      }
+    },
+    /**
+     * Define uma nova rota de WebSocket.
+     * @param {string} path - O caminho da rota (ex: "/chat").
+     * @returns {object} - Um objeto com métodos para configurar a rota (auth, connection, to, broadcast).
+     */
+    of(path = "/") {
+      if (!wsConfig[path]) {
+        wsConfig[path] = {
+          connections: {},
+          events: {},
+          rooms: {},
+          room_handlers: {}
+        };
+      }
+      const output = {
+        auth(fn) {
+          wsConfig[path].auth_fn = fn;
+          return output;
+        },
+        connection(fn) {
+          wsConfig[path].connection_fn = fn;
+          return output;
+        },
+        to(roomName) {
+          const roomInterface = {
+            on(eventName, fn) {
+              if (!wsConfig[path].room_handlers[roomName]) {
+                wsConfig[path].room_handlers[roomName] = {};
+              }
+              if (!wsConfig[path].room_handlers[roomName][eventName]) {
+                wsConfig[path].room_handlers[roomName][eventName] = new Map();
+              }
+              wsConfig[path].room_handlers[roomName][eventName].set(fn, fn);
+              return roomInterface;
+            },
+            off(eventName, fn) {
+              const handlers = wsConfig[path].room_handlers[roomName]?.[eventName];
+              if (handlers && handlers.has(fn)) {
+                handlers.delete(fn);
+                if (handlers.size === 0) {
+                  delete wsConfig[path].room_handlers[roomName][eventName];
+                }
+              }
+              return roomInterface;
+            },
+            emit(eventName, data) {
+              const members = wsConfig[path].rooms[roomName];
+              if (!members) return;
+              members.forEach(memberId => {
+                const targetSocket = wsConfig[path].connections[memberId];
+                if (targetSocket) {
+                  targetSocket.emit(eventName, data);
+                }
+              });
+            }
+          };
+          return roomInterface;
+        },
+        /**
+         * NOVO: Envia um evento (broadcast) do servidor para TODOS os clientes conectados nesta rota.
+         * @param {string} eventName - O nome do evento a ser enviado.
+         * @param {any} data - Os dados do evento.
+         * @returns {object} - Retorna `output` para permitir encadeamento.
+         */
+        emit(eventName, data) {
+          const allConnections = wsConfig[path].connections;
+          // Itera sobre todos os sockets conectados a este path
+          for (const socket of Object.values(allConnections)) {
+            // Usa o método emit do socket individual para garantir a formatação correta
+            socket.emit(eventName, data);
+          }
+          return output;
+        }
+      };
+      return output;
+    }
+  };
+};
+/**
+ * Adaptador para integrar o gerenciador de WebSockets com o framework Elysia.
+ * @param {object} server - A instância do servidor Elysia.
+ * @returns {object} - Um objeto com o método `addWs` para registrar as rotas.
+ */
+exports.default = _default;
+const adapterElysia = server => {
+  return {
+    async addWs(path, config) {
+      server.ws(path, {
+        async open(ws) {
+          let isAuthenticated = true;
+          const socket = {
+            id: ws.id,
+            request: ws.data,
+            close: () => ws.close(),
+            rooms: new Set(),
+            _path: path,
+            send: obj => ws.send(JSON.stringify(obj)),
+            emit(eventName, data) {
+              this.send({
+                event: eventName,
+                data
+              });
+            },
+            on(eventName, fn) {
+              if (!config.events[ws.id]) {
+                config.events[ws.id] = {};
+              }
+              if (!config.events[ws.id][eventName]) {
+                config.events[ws.id][eventName] = [];
+              }
+              config.events[ws.id][eventName].push(fn);
+            },
+            join(roomName) {
+              if (!config.rooms[roomName]) {
+                config.rooms[roomName] = new Set();
+              }
+              config.rooms[roomName].add(this.id);
+              this.rooms.add(roomName);
+            },
+            leave(roomName) {
+              if (config.rooms[roomName]) {
+                config.rooms[roomName].delete(this.id);
+                if (config.rooms[roomName].size === 0) {
+                  delete config.rooms[roomName];
+                }
+              }
+              this.rooms.delete(roomName);
+            },
+            to(roomName) {
+              return {
+                emit: (eventName, data) => {
+                  const members = config.rooms[roomName];
+                  if (!members) return;
+                  members.forEach(memberId => {
+                    if (memberId !== this.id) {
+                      const targetSocket = config.connections[memberId];
+                      if (targetSocket) {
+                        targetSocket.emit(eventName, data);
+                      }
+                    }
+                  });
+                }
+              };
+            }
+          };
+          config.connections[ws.id] = socket;
+          config.events[ws.id] = {};
+          if (config.auth_fn) {
+            try {
+              await config.auth_fn(socket, error => {
+                if (error) {
+                  ws.close();
+                  isAuthenticated = false;
+                }
+              });
+            } catch (error) {
+              console.error("Erro durante a autenticação do WebSocket:", error);
+              ws.close();
+              isAuthenticated = false;
+            }
+          }
+          if (!isAuthenticated) {
+            return;
+          }
+          if (config.connection_fn) {
+            await config.connection_fn(socket);
+          }
+        },
+        async message(ws, message) {
+          try {
+            const event = message;
+            const senderSocket = config.connections[ws.id];
+            if (!senderSocket) return;
+            const connectionEvents = config.events[ws.id];
+            if (connectionEvents && connectionEvents[event.event]) {
+              connectionEvents[event.event].forEach(fn => fn(event.data));
+            }
+            for (const roomName of senderSocket.rooms) {
+              const roomHandlers = config.room_handlers[roomName]?.[event.event];
+              if (roomHandlers) {
+                roomHandlers.forEach(fn => {
+                  fn(senderSocket, event.data);
+                });
+              }
+            }
+          } catch (error) {
+            console.error("Falha ao processar a mensagem do WebSocket:", error);
+          }
+        },
+        close(ws) {
+          const socket = config.connections[ws.id];
+          if (!socket) return;
+          const disconnectListeners = config.events[ws.id]?.disconnect;
+          if (disconnectListeners) {
+            disconnectListeners.forEach(fn => fn({
+              id: ws.id
+            }));
+          }
+          socket.rooms.forEach(roomName => socket.leave(roomName));
+          delete config.events[ws.id];
+          delete config.connections[ws.id];
+        }
+      });
+    }
+  };
+};
+exports.adapterElysia = adapterElysia;

package/cjs/core/plugins.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "adapterElysia", {
+  enumerable: true,
+  get: function () {
+    return _ws.adapterElysia;
+  }
+});
+Object.defineProperty(exports, "ws", {
+  enumerable: true,
+  get: function () {
+    return _ws.default;
+  }
+});
+var _ws = _interopRequireWildcard(require("./plugins/ws"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }

package/cjs/core/repositoryCore.js

@@ -22,7 +22,9 @@ var _default = ({
         if (!obj.dbTest && !obj.getDb) {
           obj.db = await core.fileCore.import(db, {});
         }
-      } catch (error) {}
+      } catch (error) {
+        console.log(error);
+      }
     }
     await core.repositories(paths, path, obj);
   };

package/cjs/core/serverCore.js

@@ -78,8 +78,8 @@ var _default = ({
       const wsServer = await createCoreSocket({}, {});
       try {
         const serve = await core.fileCore.import(rootFile, {
-          util: app.util,
-          lib: app.lib,
+          util: core.app.util,
+          lib: core.app.lib,
           routers,
           ws: wsServer
         });

package/cjs/fileCore.js

@@ -23,5 +23,5 @@ var _default = exports.default = {
     if (!this.exist(paths)) return [];
     return _fs.default.readdirSync(_path.default.resolve(this.path + paths));
   },
-  bin: _fs.default.existsSync(process.cwd() + '/esm') ? '/esm' : '/node_modules/create-org-app/esm'
+  bin: _fs.default.existsSync(process.cwd() + '/esm') ? '/esm' : '/node_modules/org-core-js/esm'
 };

package/esm/core/index.js

@@ -353,7 +353,8 @@ export default ({ }) => {
                     repository: app.repository,
                     entity: app.entity,
                     util: app.util,
-                    lib: app.lib
+                    lib: app.lib,
+                    job: app.job,
                 }))
             },
 

package/esm/core/plugins/auth.js

@@ -0,0 +1,239 @@
+
+import jwt from 'jsonwebtoken';
+//jwt.verify(token,'shhhhh');
+export default ({ lib }) => ({
+    async tokenRSA(data, v) {
+       // const key = ((await lib("cryptojs").decrypt(process.env.JWT_SECRET_PRIVATE, process.env.JWT_SECRET)) || '').replaceAll("__n__", "\n")
+       const key=  lib("cryptojs").decodeBase64(process.env.JWT_SECRET_PRIVATE)
+        return jwt.sign(data, key, { algorithm: 'RS256', expiresIn: v ? v : '24h' });
+    },
+    async verifyRSA(token) {
+       // const key = ((await lib("cryptojs").decrypt(process.env.JWT_SECRET_PUBLIC, process.env.JWT_SECRET)) || '').replaceAll("__n__", "\n")
+       const key=  lib("cryptojs").decodeBase64(process.env.JWT_SECRET_PUBLIC)
+        return jwt.verify(token, key);
+    },
+    auth_info(roles) {
+        return async (ctx, reply) => {
+            try {
+                const token = String(ctx?.headers?.get("authorization")|| ctx?.request.headers?.get("authorization")||' ').split(' ')[1]|| String(ctx?.query?.token||'')||''
+
+   
+                const info = await this.verifyRSA(token)
+                ctx.user = info.user || info.info || info.data||info.code || info
+
+     
+                if (!ctx?.user) {
+                       ctx.status_=401
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }
+                if (roles.length==0) {
+ 
+        
+                } else if (!roles.find(role => ctx.user.role == role)) {
+                       ctx.status_=401
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }   
+            } catch (error) {
+
+                if (roles.length>0) {
+                                  ctx.status_=401
+           
+              return  reply
+                .code(401)
+                .send({ error: '401 Unauthorized' })
+                }
+
+                ctx.user ={}
+
+            }
+ 
+
+        }
+
+    },
+
+   auth(roles) {
+        return async (ctx, reply) => {
+            try {
+                const token = String(ctx?.headers?.get("authorization")|| ctx?.request.headers?.get("authorization")||' ').split(' ')[1]|| String(ctx?.query?.token||'')||''
+                
+                const info = await this.verifyRSA(token)
+                ctx.user = info.user || info.info || info.data||info.code || info
+                const userInfo= JSON.parse((await lib("redis").client.get("user::"+ctx.user.id))||"{}")
+                 ctx.user.teams=userInfo?.teams||[]
+
+                if (!ctx?.user) {
+                       ctx.status_=401
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }
+                if (roles.length==0) {
+ 
+        
+                } else if (!roles.find(role => (ctx?.user?.teams||[]).find(team=>team.role==role))) {
+                       ctx.status_=401
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }   
+            } catch (error) {
+
+                console.log(error)
+
+                if (roles.length>0) {
+                                  ctx.status_=401
+           
+              return  reply
+                .code(401)
+                .send({ error: '401 Unauthorized' })
+                }
+
+                ctx.user ={}
+
+            }
+ 
+
+        }
+
+    },
+
+    permission_invite(roles) {
+        return async (ctx, reply) => {
+            try {
+                const token = String(ctx?.headers?.get("authorization")|| ctx?.request.headers?.get("authorization")||' ').split(' ')[1]|| String(ctx?.query?.token||'')||''
+                
+                const info = await this.verifyRSA(token)
+                ctx.user = info.user || info.info || info.data||info.code || info
+                const userInfo= JSON.parse((await lib("redis").client.get("user::"+ctx.user.id))||"{}")
+                 ctx.user.teams=userInfo?.teams||[]
+                if (roles.length==0) {
+
+                    return
+                }
+                 const {data}=ctx.body
+                 ctx.user.teams=ctx.user.teams.filter((team)=>data.teams.find((t)=>t.id==team.id&& data.schoolId==team.schoolId))
+                 ctx.body.data.teams==ctx.body.data.teams.filter((team)=>{
+                    const t=ctx.user.teams.find((t)=>t.id==team.id && roles.find(r=>r==t.role))
+                    return !!t
+
+                 })
+                
+
+                if (!ctx?.user) {
+                       ctx.status_=401
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }
+         
+ 
+        
+            if (!roles.find(role => (ctx?.user?.teams||[]).find(team=>team.role==role))) {
+                       ctx.status_=401
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }   
+
+
+
+            } catch (error) {
+
+                console.log(error)
+
+                if (roles.length>0) {
+                    ctx.status_=401
+           
+              return  reply
+                .code(401)
+                .send({ error: '401 Unauthorized' })
+                }
+
+                ctx.user ={}
+
+            }
+ 
+
+        }
+
+    },
+    auth1(roles) {
+
+       
+
+        return async (request, reply) => {
+            try {
+                const token = String(request.headers['authorization']).split(' ')[1]
+                const info = await this.verifyRSA(token)
+                request.user = info.user || info.info || info.data||info.code || info
+
+     
+                if (!request?.user) {
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }
+                if (roles.length==0) {
+ 
+        
+                } else if (!roles.find(role => request.user.role == role)) {
+                    reply
+                        .code(401)
+                        .send({ error: '401 Unauthorized' })
+                }   
+            } catch (error) {
+           
+                reply
+                .code(401)
+                .send({ error: '401 Unauthorized' })
+            }
+ 
+
+        }
+
+    },
+    qrcode() {
+
+        return async (request, reply) => {
+            const infoStr = String(request.query['identifier'] || '')
+            const res = "U2FsdGVkX182xxWCbg9dZxlmmhdMcGGs2xzfdfAXv9FUr/odoyBb4T/yWBQip45iQg5NZmRrrUgRKI3JjL2o5c3rQmKhl7fkKDETT3pF9aorvAYTllBElYq7lUgczSpUhyxPtkpCbrOhgbvHuX8pwCeEnptiEL4CZgorj26jQUO17IlSk1AY2bjwlNgAQuKEgrfacJVcNyn9LtKHHHIQP5LYKxxB5P1oXNEc540n8tcu7+og5x/Pnb9pnm79ZKXH"
+
+            const decrypt = lib("cryptojs").decrypt(res)
+            console.log(infoStr, 'd', decrypt)
+            if (!decrypt) {
+                reply
+                    .code(401)
+                    .send({ error: '401 Unauthorized' })
+            }
+
+            request.user = (JSON.parse(decrypt)).identifier || {}
+            if (!request.user.code) {
+                reply
+                    .code(401)
+                    .send({ error: '401 Unauthorized' })
+            }
+
+
+        }
+
+    },
+    async forgot(info, e = (5 * 60 * 60) + "s",n=6) {
+        const verificationCode = lib('generate').number(n)
+        return {
+            verificationCode,
+            verificationJwt: await this.tokenRSA({
+                code: { verificationCode, password: true,...info, userId: info.id }
+            }, e)
+        }
+    },
+    async code(user, e = (5 * 60 * 60) + "s") {
+        return await this.tokenRSA({ user, login: true }, e)
+
+    }
+
+})

package/esm/core/plugins/ws.js

@@ -0,0 +1,247 @@
+// websocket-manager.js
+
+/**
+ * Cria um gerenciador de WebSockets.
+ * Este gerenciador armazena a configuração das rotas WS (autenticação, conexão, etc.)
+ * e a sincroniza com um adaptador específico (como o do Elysia).
+ *
+ * @param {object} adapter - O adaptador que irá lidar com a implementação do WebSocket (ex: adapterElysia).
+ * @returns {object} - Um objeto com métodos para configurar e sincronizar as rotas WS.
+ */
+export default ({ adapter }) => {
+    // Armazena a configuração de cada path de WebSocket.
+    // Estrutura: { "/path": { connections: {}, events: {}, rooms: {}, room_handlers: {}, auth_fn, connection_fn } }
+    const wsConfig = {};
+
+    return {
+        /**
+         * Sincroniza todas as configurações de rotas definidas com `of()` com o adaptador.
+         * Deve ser chamado após todas as rotas terem sido definidas.
+         */
+        async sync() {
+            for (const [path, config] of Object.entries(wsConfig)) {
+                adapter.addWs(path, config);
+            }
+        },
+
+        /**
+         * Define uma nova rota de WebSocket.
+         * @param {string} path - O caminho da rota (ex: "/chat").
+         * @returns {object} - Um objeto com métodos para configurar a rota (auth, connection, to, broadcast).
+         */
+        of(path = "/") {
+            if (!wsConfig[path]) {
+                wsConfig[path] = {
+                    connections: {},
+                    events: {},
+                    rooms: {},
+                    room_handlers: {},
+                };
+            }
+
+            const output = {
+                auth(fn) {
+                    wsConfig[path].auth_fn = fn;
+                    return output;
+                },
+
+                connection(fn) {
+                    wsConfig[path].connection_fn = fn;
+                    return output;
+                },
+
+                to(roomName) {
+                    const roomInterface = {
+                        on(eventName, fn) {
+                            if (!wsConfig[path].room_handlers[roomName]) {
+                                wsConfig[path].room_handlers[roomName] = {};
+                            }
+                            if (!wsConfig[path].room_handlers[roomName][eventName]) {
+                                wsConfig[path].room_handlers[roomName][eventName] = new Map();
+                            }
+                            wsConfig[path].room_handlers[roomName][eventName].set(fn, fn);
+                            return roomInterface;
+                        },
+                        off(eventName, fn) {
+                            const handlers = wsConfig[path].room_handlers[roomName]?.[eventName];
+                            if (handlers && handlers.has(fn)) {
+                                handlers.delete(fn);
+                                if (handlers.size === 0) {
+                                    delete wsConfig[path].room_handlers[roomName][eventName];
+                                }
+                            }
+                            return roomInterface;
+                        },
+                        emit(eventName, data) {
+                            const members = wsConfig[path].rooms[roomName];
+                            if (!members) return;
+                            members.forEach(memberId => {
+                                const targetSocket = wsConfig[path].connections[memberId];
+                                if (targetSocket) {
+                                    targetSocket.emit(eventName, data);
+                                }
+                            });
+                        },
+                    };
+                    return roomInterface;
+                },
+
+                /**
+                 * NOVO: Envia um evento (broadcast) do servidor para TODOS os clientes conectados nesta rota.
+                 * @param {string} eventName - O nome do evento a ser enviado.
+                 * @param {any} data - Os dados do evento.
+                 * @returns {object} - Retorna `output` para permitir encadeamento.
+                 */
+                emit(eventName, data) {
+                    const allConnections = wsConfig[path].connections;
+                    // Itera sobre todos os sockets conectados a este path
+                    for (const socket of Object.values(allConnections)) {
+                        // Usa o método emit do socket individual para garantir a formatação correta
+                        socket.emit(eventName, data);
+                    }
+                    return output;
+                },
+            };
+
+            return output;
+        },
+    };
+};
+
+
+/**
+ * Adaptador para integrar o gerenciador de WebSockets com o framework Elysia.
+ * @param {object} server - A instância do servidor Elysia.
+ * @returns {object} - Um objeto com o método `addWs` para registrar as rotas.
+ */
+export const adapterElysia = (server) => {
+    return {
+        async addWs(path, config) {
+            server.ws(path, {
+                async open(ws) {
+                    let isAuthenticated = true;
+
+                    const socket = {
+                        id: ws.id,
+                        request: ws.data,
+                        close: () => ws.close(),
+                        rooms: new Set(),
+                        _path: path,
+
+                        send: (obj) => ws.send(JSON.stringify(obj)),
+                        emit(eventName, data) {
+                            this.send({ event: eventName, data });
+                        },
+                        on(eventName, fn) {
+                            if (!config.events[ws.id]) {
+                                config.events[ws.id] = {};
+                            }
+                            if (!config.events[ws.id][eventName]) {
+                                config.events[ws.id][eventName] = [];
+                            }
+                            config.events[ws.id][eventName].push(fn);
+                        },
+                        join(roomName) {
+                            if (!config.rooms[roomName]) {
+                                config.rooms[roomName] = new Set();
+                            }
+                            config.rooms[roomName].add(this.id);
+                            this.rooms.add(roomName);
+                        },
+                        leave(roomName) {
+                            if (config.rooms[roomName]) {
+                                config.rooms[roomName].delete(this.id);
+                                if (config.rooms[roomName].size === 0) {
+                                    delete config.rooms[roomName];
+                                }
+                            }
+                            this.rooms.delete(roomName);
+                        },
+                        to(roomName) {
+                            return {
+                                emit: (eventName, data) => {
+                                    const members = config.rooms[roomName];
+                                    if (!members) return;
+                                    members.forEach(memberId => {
+                                        if (memberId !== this.id) {
+                                            const targetSocket = config.connections[memberId];
+                                            if (targetSocket) {
+                                                targetSocket.emit(eventName, data);
+                                            }
+                                        }
+                                    });
+                                },
+                            };
+                        },
+                    };
+
+                    config.connections[ws.id] = socket;
+                    config.events[ws.id] = {};
+
+                    if (config.auth_fn) {
+                        try {
+                            await config.auth_fn(socket, (error) => {
+                                if (error) {
+                                    ws.close();
+                                    isAuthenticated = false;
+                                }
+                            });
+                        } catch (error) {
+                            console.error("Erro durante a autenticação do WebSocket:", error);
+                            ws.close();
+                            isAuthenticated = false;
+                        }
+                    }
+
+                    if (!isAuthenticated) {
+                        return;
+                    }
+
+                    if (config.connection_fn) {
+                        await config.connection_fn(socket);
+                    }
+                },
+
+                async message(ws, message) {
+                    try {
+                        const event = message;
+                        const senderSocket = config.connections[ws.id];
+                        if (!senderSocket) return;
+
+                        const connectionEvents = config.events[ws.id];
+                        if (connectionEvents && connectionEvents[event.event]) {
+                            connectionEvents[event.event].forEach(fn => fn(event.data));
+                        }
+
+                        for (const roomName of senderSocket.rooms) {
+                            const roomHandlers = config.room_handlers[roomName]?.[event.event];
+                            if (roomHandlers) {
+                                roomHandlers.forEach(fn => {
+                                    fn(senderSocket, event.data);
+                                });
+                            }
+                        }
+
+                    } catch (error) {
+                        console.error("Falha ao processar a mensagem do WebSocket:", error);
+                    }
+                },
+
+                close(ws) {
+                    const socket = config.connections[ws.id];
+                    if (!socket) return;
+
+                    const disconnectListeners = config.events[ws.id]?.disconnect;
+                    if (disconnectListeners) {
+                        disconnectListeners.forEach(fn => fn({ id: ws.id }));
+                    }
+
+                    socket.rooms.forEach(roomName => socket.leave(roomName));
+
+                    delete config.events[ws.id];
+                    delete config.connections[ws.id];
+                },
+            });
+        },
+    };
+};

package/esm/core/plugins.js

@@ -0,0 +1,4 @@
+import ws,{adapterElysia} from "./plugins/ws";
+
+
+export {ws,adapterElysia}

package/esm/core/repositoryCore.js

@@ -15,7 +15,7 @@ export default ({ core }) => {
                 }
 
             } catch (error) {
-
+console.log(error)
             }
         }
 

package/esm/core/serverCore.js

@@ -67,12 +67,14 @@ export default ({ core }) => {
             }
 
             const routers = await createCoreRouter({}, {})
+
+          
             const wsServer = await createCoreSocket({}, {})
             try {
 
                 const serve = (await core.fileCore.import(rootFile, {
-                    util: app.util,
-                    lib: app.lib,
+                    util:  core.app.util,
+                    lib:  core.app.lib,
                     routers,
                     ws: wsServer
                 }))

package/esm/fileCore.js

@@ -15,5 +15,5 @@ export default {
         if (!this.exist(paths)) return []
         return fs.readdirSync(path.resolve(this.path + paths))
     },
-    bin: fs.existsSync(process.cwd() + '/esm') ? '/esm' : '/node_modules/create-org-app/esm',
+    bin: fs.existsSync(process.cwd() + '/esm') ? '/esm' : '/node_modules/org-core-js/esm',
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "org-core-js",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "main": "src/start.js",
   "scripts": {
@@ -28,6 +28,10 @@
     "./forawait": {
       "import": "./esm/forawait.js",
       "require": "./cjs/forawait.js"
+    },
+      "./plugins": {
+      "import": "./esm/core/plugins.js",
+      "require": "./cjs/core/plugins.js"
     },
     "./fileCore": {
       "import": "./esm/fileCore.js",