zyket 1.2.11 → 1.2.12

package/src/services/socketio/SocketIO.js

@@ -1,133 +1,160 @@
-const Service = require("../Service");
-const { Server } = require("socket.io");
-const fs = require("fs");
-const path = require("path");
-const fg = require('fast-glob');
-const Handler = require("./Handler");
-const Guard = require("./Guard");
-
-
-module.exports = class SocketIO extends Service {
-  #container;
-  io;
-  guards = {};
-  
-  constructor(container) {
-    super("socketio");
-    this.#container = container;
-  }
-
-  async boot({ httpServer } = {}) {
-    const guards = await this.#loadGuardsFromFolder(path.join(process.cwd(), "src", "guards"));
-    for (const guard of guards) {
-      this.guards[guard.name] = guard;
-    }
-    const handlers = await this.#loadHandlersFromFolder(path.join(process.cwd(), "src", "handlers"));
-    const connectionHandler = new (await this.#loadConnectionHandler())();
-
-
-    this.#container.get('logger').debug(`Guards: ${guards.map(mdl => mdl.name).join(", ")}`);
-    this.#container.get('logger').debug(`Handlers: ${handlers.map(hdl => hdl.event).join(", ")}`);
-    
-    this.io = new Server({ cors: { origin: "*" }, maxHttpBufferSize: 10 * 1024 * 1024 });
-
-    this.io.on("connection", async (socket) => {
-      const connectionGuards = (connectionHandler?.guards || []).map(mdl => this.guards[mdl])
-      for (const guard of connectionGuards) {
-        if(!guard) {
-          this.#container.get('logger').warn(`You are using a guard that does not exist`);
-          continue;
-        }
-        guard.handle({ container: this.#container, socket, io: this.io });
-      }
-      try {
-        await connectionHandler.handle({ container: this.#container, socket, io: this.io });
-      } catch(e) {
-        this.#container.get('logger').error(`Error in connection handler for socket ${socket.id}: ${e.message}`);
-        socket.disconnect(true);
-        return;
-      }
-      handlers.forEach((handler) => {
-        const handlerGuards = (handler?.guards || []).map(mdl => this.guards[mdl])
-        socket.on(handler.event, async (data, callback) => {
-          this.#container.get('logger').debug(`[${socket?.id}] Sent ${handler.event} with guards: ${handlerGuards?.map(mdl => mdl?.name).join(", ")}`);
-          for (const guard of handlerGuards) {
-            if(!guard) {
-              this.#container.get('logger').warn(`You are using a guard that does not exist`);
-              continue;
-            }
-            try{
-              await guard.handle({ container: this.#container, socket, io: this.io });
-            } catch(e) {
-              this.#container.get('logger').warn(`Guard ${guard.name} blocked event ${handler.event} from socket ${socket.id}: ${e.message}`);
-              return callback ? callback({ error: e.message }) : null;
-            }
-          }
-          try{
-            if(callback && typeof callback === 'function') {
-              return callback(await handler.handle({ container: this.#container, socket, data, io: this.io }));
-            }
-            return await handler.handle({ container: this.#container, socket, data, io: this.io });
-          } catch(e) {
-            this.#container.get('logger').error(`Error handling event ${handler.event} from socket ${socket.id}: ${e.message}`);
-            return callback ? callback({ error: e.message }) : null;
-          }
-        });
-      });
-    });
-
-    this.io.listen(httpServer);
-    this.#container.get('logger').info(`Socket.IO is running on ws://localhost:${httpServer.address().port}`);
-  }
-
-  async #loadConnectionHandler() {
-    const connectionHandlerExists  = fs.existsSync(path.join(process.cwd(), "src", "handlers", "connection.js"));
-    if(!connectionHandlerExists) {
-      this.#container.get('template-manager').installFile('default/src/handlers/connection', path.join(process.cwd(), "src", "handlers", "connection.js"));
-    }
-    return require(path.join(process.cwd(), "src", "handlers", "connection.js"));
-  }
-
-  async #loadHandlersFromFolder(handlersFolder) {
-    this.#createHandlersFolder(handlersFolder);
-    const handlers = (await fg('**/*.js', { cwd: handlersFolder, ignore: 'connection.js' })).map((hdr) => {
-      const handler = require(path.join(handlersFolder, hdr));
-      if(!(handler.prototype instanceof Handler)) throw new Error(`${hdr} is not a valid handler`);
-      return new handler(hdr.replace('.js', ''));
-    });
-    return handlers;
-  }
-
-  #createHandlersFolder(handlersFolder, overwrite = false) {
-    if (fs.existsSync(handlersFolder) && !overwrite) return;
-    this.#container.get('logger').info(`Creating handlers folder at ${handlersFolder}`);
-    fs.mkdirSync(handlersFolder);
-    this.#container.get('template-manager').installFile('default/src/handlers/message', path.join(handlersFolder, "message.js"));
-  }
-
-  async #loadGuardsFromFolder(guardsFolder) {
-    this.#createGuardsFolder(guardsFolder);
-    const guards = await fg('**/*.js', { cwd: guardsFolder })
-    
-    return guards.map((gd) => {
-      const guard = require(path.join(guardsFolder, gd));
-      if(!(guard.prototype instanceof Guard)) throw new Error(`${gd} is not a valid guard`);
-      return new guard(gd.replace('.js', ''));
-    });
-  }
-
-  #createGuardsFolder(guardsFolder, overwrite = false) {
-    if (fs.existsSync(guardsFolder) && !overwrite) return;
-    this.#container.get('logger').info(`Creating guards folder at ${guardsFolder}`);
-    fs.mkdirSync(guardsFolder);
-    this.#container.get('template-manager').installFile('default/src/guards/default', path.join(guardsFolder, "default.js"));
-  }
-
-  stop() {
-    this.io.close();
-  }
-
-  get sockets() {
-    return Array.from(this.io.sockets.sockets.values());
-  }
+const Service = require("../Service");
+const { Server } = require("socket.io");
+const fs = require("fs");
+const path = require("path");
+const fg = require('fast-glob');
+const Handler = require("./Handler");
+const Guard = require("./Guard");
+
+
+module.exports = class SocketIO extends Service {
+  #container;
+  io;
+  guards = {};
+  
+  constructor(container) {
+    super("socketio");
+    this.#container = container;
+  }
+
+  async boot({ httpServer } = {}) {
+    const guards = await this.#loadGuardsFromFolder(path.join(process.cwd(), "src", "guards"));
+    for (const guard of guards) {
+      this.guards[guard.name] = guard;
+    }
+    const handlers = await this.#loadHandlersFromFolder(path.join(process.cwd(), "src", "handlers"));
+    const connectionHandler = new (await this.#loadConnectionHandler())();
+
+
+    this.#container.get('logger').debug(`Guards: ${guards.map(mdl => mdl.name).join(", ")}`);
+    this.#container.get('logger').debug(`Handlers: ${handlers.map(hdl => hdl.event).join(", ")}`);
+    
+    this.io = new Server({ cors: { origin: "*" }, maxHttpBufferSize: 10 * 1024 * 1024 });
+
+    if (process.env.REDIS_URL) {
+      await this.#attachRedisAdapter();
+    }
+
+    this.io.on("connection", async (socket) => {
+      const connectionGuards = (connectionHandler?.guards || []).map(mdl => this.guards[mdl])
+      for (const guard of connectionGuards) {
+        if(!guard) {
+          this.#container.get('logger').warn(`You are using a guard that does not exist`);
+          continue;
+        }
+        guard.handle({ container: this.#container, socket, io: this.io });
+      }
+      try {
+        await connectionHandler.handle({ container: this.#container, socket, io: this.io });
+      } catch(e) {
+        this.#container.get('logger').error(`Error in connection handler for socket ${socket.id}: ${e.message}`);
+        socket.disconnect(true);
+        return;
+      }
+      handlers.forEach((handler) => {
+        const handlerGuards = (handler?.guards || []).map(mdl => this.guards[mdl])
+        socket.on(handler.event, async (data, callback) => {
+          this.#container.get('logger').debug(`[${socket?.id}] Sent ${handler.event} with guards: ${handlerGuards?.map(mdl => mdl?.name).join(", ")}`);
+          for (const guard of handlerGuards) {
+            if(!guard) {
+              this.#container.get('logger').warn(`You are using a guard that does not exist`);
+              continue;
+            }
+            try{
+              await guard.handle({ container: this.#container, socket, io: this.io });
+            } catch(e) {
+              this.#container.get('logger').warn(`Guard ${guard.name} blocked event ${handler.event} from socket ${socket.id}: ${e.message}`);
+              return callback ? callback({ error: e.message }) : null;
+            }
+          }
+          try{
+            if(callback && typeof callback === 'function') {
+              return callback(await handler.handle({ container: this.#container, socket, data, io: this.io }));
+            }
+            return await handler.handle({ container: this.#container, socket, data, io: this.io });
+          } catch(e) {
+            this.#container.get('logger').error(`Error handling event ${handler.event} from socket ${socket.id}: ${e.message}`);
+            return callback ? callback({ error: e.message }) : null;
+          }
+        });
+      });
+    });
+
+    this.io.listen(httpServer);
+    this.#container.get('logger').info(`Socket.IO is running on ws://localhost:${httpServer.address().port}`);
+  }
+
+  async #loadConnectionHandler() {
+    const connectionHandlerExists  = fs.existsSync(path.join(process.cwd(), "src", "handlers", "connection.js"));
+    if(!connectionHandlerExists) {
+      this.#container.get('template-manager').installFile('default/src/handlers/connection', path.join(process.cwd(), "src", "handlers", "connection.js"));
+    }
+    return require(path.join(process.cwd(), "src", "handlers", "connection.js"));
+  }
+
+  async #loadHandlersFromFolder(handlersFolder) {
+    this.#createHandlersFolder(handlersFolder);
+    const handlers = (await fg('**/*.js', { cwd: handlersFolder, ignore: 'connection.js' })).map((hdr) => {
+      const handler = require(path.join(handlersFolder, hdr));
+      if(!(handler.prototype instanceof Handler)) throw new Error(`${hdr} is not a valid handler`);
+      return new handler(hdr.replace('.js', ''));
+    });
+    return handlers;
+  }
+
+  #createHandlersFolder(handlersFolder, overwrite = false) {
+    if (fs.existsSync(handlersFolder) && !overwrite) return;
+    this.#container.get('logger').info(`Creating handlers folder at ${handlersFolder}`);
+    fs.mkdirSync(handlersFolder);
+    this.#container.get('template-manager').installFile('default/src/handlers/message', path.join(handlersFolder, "message.js"));
+  }
+
+  async #loadGuardsFromFolder(guardsFolder) {
+    this.#createGuardsFolder(guardsFolder);
+    const guards = await fg('**/*.js', { cwd: guardsFolder })
+    
+    return guards.map((gd) => {
+      const guard = require(path.join(guardsFolder, gd));
+      if(!(guard.prototype instanceof Guard)) throw new Error(`${gd} is not a valid guard`);
+      return new guard(gd.replace('.js', ''));
+    });
+  }
+
+  #createGuardsFolder(guardsFolder, overwrite = false) {
+    if (fs.existsSync(guardsFolder) && !overwrite) return;
+    this.#container.get('logger').info(`Creating guards folder at ${guardsFolder}`);
+    fs.mkdirSync(guardsFolder);
+    this.#container.get('template-manager').installFile('default/src/guards/default', path.join(guardsFolder, "default.js"));
+  }
+
+  async #attachRedisAdapter() {
+    let Redis, createAdapter;
+    try {
+      Redis = require("ioredis");
+      ({ createAdapter } = require("@socket.io/redis-adapter"));
+    } catch {
+      throw new Error(
+        "Redis adapter requires 'ioredis' and '@socket.io/redis-adapter'. Run: npm install ioredis @socket.io/redis-adapter"
+      );
+    }
+
+    const pubClient = new Redis(process.env.REDIS_URL);
+    const subClient = pubClient.duplicate();
+
+    await Promise.all([
+      new Promise((resolve, reject) => pubClient.once("ready", resolve).once("error", reject)),
+      new Promise((resolve, reject) => subClient.once("ready", resolve).once("error", reject)),
+    ]);
+
+    this.io.adapter(createAdapter(pubClient, subClient));
+    this.#container.get("logger").info(`Socket.IO Redis adapter connected to ${process.env.REDIS_URL}`);
+  }
+
+  stop() {
+    this.io.close();
+  }
+
+  get sockets() {
+    return Array.from(this.io.sockets.sockets.values());
+  }
 }

package/src/services/socketio/index.js

@@ -1,5 +1,5 @@
-module.exports = {
-  SocketIO: require("./SocketIO"),
-  Handler: require("./Handler"),
-  Guard: require("./Guard")
+module.exports = {
+  SocketIO: require("./SocketIO"),
+  Handler: require("./Handler"),
+  Guard: require("./Guard")
 }

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

@@ -1,74 +1,74 @@
-const fg = require('fast-glob');
-const Service = require('../Service');
-const path = require('path');
-const fs = require('fs');
-
-module.exports = class TemplateManager extends Service {
-  templates = {}
-
-  constructor() {
-    super('template-manager');
-  }
-
-  async boot() {
-    const zyketTemplates = await fg(['**/*'], {
-      cwd: path.join(__dirname, '../../templates'),
-    });
-    console.log('Found templates:', zyketTemplates);
-    for (const template of zyketTemplates) {
-      const templatePath = path.join(__dirname, '../../templates', template);
-      const templateContent = fs.readFileSync(templatePath, 'utf-8');
-      this.templates[template.replace('.jsx', '').replace('.js', '').replace('.html', '').replace('.css', '')] = {
-        route: template,
-        content: templateContent
-      };   
-    }
-  }
-
-  installFile(fileName, location) {
-    const template = this.templates[fileName];
-    if (!template) throw new Error(`Template ${fileName} not found`);
-    return fs.writeFileSync(location, template?.content);
-  }
-
-  installTemplate(templateName) {
-    const template = this.getTemplates().find((t) => t === templateName);
-    if (!template) throw new Error(`Template ${templateName} not found`);
-    const files = this.getTemplate(templateName);
-    
-    for (const file of files) {
-      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?.route.split('/').slice(1).join('/');
-      const fileLocation = path.join(process.cwd(), fileName);
-      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)) {
-      uniqueTemplates.add(template.split('/')[0]);
-    }
-    return Array.from(uniqueTemplates);
-  }
-
-  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.map((file) => this.templates[file]);
-  }
-
-  exists(templateName) {
-    return this.getTemplates().some((t) => t === templateName);
-  }
+const fg = require('fast-glob');
+const Service = require('../Service');
+const path = require('path');
+const fs = require('fs');
+
+module.exports = class TemplateManager extends Service {
+  templates = {}
+
+  constructor() {
+    super('template-manager');
+  }
+
+  async boot() {
+    const zyketTemplates = await fg(['**/*'], {
+      cwd: path.join(__dirname, '../../templates'),
+    });
+    console.log('Found templates:', zyketTemplates);
+    for (const template of zyketTemplates) {
+      const templatePath = path.join(__dirname, '../../templates', template);
+      const templateContent = fs.readFileSync(templatePath, 'utf-8');
+      this.templates[template.replace('.jsx', '').replace('.js', '').replace('.html', '').replace('.css', '')] = {
+        route: template,
+        content: templateContent
+      };   
+    }
+  }
+
+  installFile(fileName, location) {
+    const template = this.templates[fileName];
+    if (!template) throw new Error(`Template ${fileName} not found`);
+    return fs.writeFileSync(location, template?.content);
+  }
+
+  installTemplate(templateName) {
+    const template = this.getTemplates().find((t) => t === templateName);
+    if (!template) throw new Error(`Template ${templateName} not found`);
+    const files = this.getTemplate(templateName);
+    
+    for (const file of files) {
+      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?.route.split('/').slice(1).join('/');
+      const fileLocation = path.join(process.cwd(), fileName);
+      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)) {
+      uniqueTemplates.add(template.split('/')[0]);
+    }
+    return Array.from(uniqueTemplates);
+  }
+
+  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.map((file) => this.templates[file]);
+  }
+
+  exists(templateName) {
+    return this.getTemplates().some((t) => t === templateName);
+  }
 }

package/src/templates/default/config/cors.js

@@ -1,5 +1,5 @@
-module.exports = {
-  origin: process.env.TRUSTED_ORIGINS?.split(',') || ['http://localhost:5173'], // Specify allowed origins
-  methods: ["GET", "POST", "PUT", "DELETE", "PATCH"], // Allowed HTTP methods
-  credentials: true
+module.exports = {
+  origin: process.env.TRUSTED_ORIGINS?.split(',') || ['http://localhost:5173'], // Specify allowed origins
+  methods: ["GET", "POST", "PUT", "DELETE", "PATCH"], // Allowed HTTP methods
+  credentials: true
 };

package/src/templates/default/config/swagger.js

@@ -1,16 +1,16 @@
-const path = require("path");
-
-module.exports = {
-  swaggerDefinition: {
-    openapi: '3.0.0',
-    info: {
-      title: "API Documentation",
-      version: require(path.join(process.cwd(), "package.json")).version || "1.0.0",
-      description: "API Documentation generated by Swagger",
-    },
-    servers: [
-      { url: `http://localhost:3000` }
-    ],
-  },
-  apis: [path.join(process.cwd(), "src", "routes", "**", "*.js")]
+const path = require("path");
+
+module.exports = {
+  swaggerDefinition: {
+    openapi: '3.0.0',
+    info: {
+      title: "API Documentation",
+      version: require(path.join(process.cwd(), "package.json")).version || "1.0.0",
+      description: "API Documentation generated by Swagger",
+    },
+    servers: [
+      { url: `http://localhost:3000` }
+    ],
+  },
+  apis: [path.join(process.cwd(), "src", "routes", "**", "*.js")]
 }

package/src/templates/default/frontend/main.jsx

@@ -1,15 +1,15 @@
-import { createRoot } from 'react-dom/client'
-import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'
-import AuthLayout from './src/layouts/auth'
-import LandingLayout from './src/layouts/landing'
-import './styles.css'
-import PanelLayout from './src/layouts/panel'
-
-createRoot(document.getElementById('root')).render(<BrowserRouter>
-  <Routes>
-    <Route path="/" element={<LandingLayout />} />
-    <Route path="/auth/*" element={<AuthLayout />} />
-    <Route path="/panel/*" element={<PanelLayout />} />
-    <Route path="*" element={<Navigate to="/" replace />} />
-  </Routes>
-</BrowserRouter>)
+import { createRoot } from 'react-dom/client'
+import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'
+import AuthLayout from './src/layouts/auth'
+import LandingLayout from './src/layouts/landing'
+import './styles.css'
+import PanelLayout from './src/layouts/panel'
+
+createRoot(document.getElementById('root')).render(<BrowserRouter>
+  <Routes>
+    <Route path="/" element={<LandingLayout />} />
+    <Route path="/auth/*" element={<AuthLayout />} />
+    <Route path="/panel/*" element={<PanelLayout />} />
+    <Route path="*" element={<Navigate to="/" replace />} />
+  </Routes>
+</BrowserRouter>)

package/src/templates/default/frontend/src/hooks/useAuth.jsx

@@ -1,51 +1,51 @@
-import { useStoreAuth } from "../store";
-
-export default function useAuth() {
-  const context = useStoreAuth();
-  const sessionContext = context?.client?.useSession();
-
-  const { error: sessionError, isPending, isRefetching, refetch } = sessionContext || {};
-  const { user, session } = sessionContext?.data || {};
-
-  const login = async (email, password) => {
-    const { data, error } = await context.client.signIn.email({ email, password });
-    if (error) throw error;
-
-    return data;
-  };
-
-  const register = async ({ email, password, name, image }) => {
-    const payload = { email, password, name, isPublic: true };
-    if (typeof image === "string" && image.trim() !== "") payload.image = image;
-
-    const { data, error } = await context.client.signUp.email(payload);
-    if (error) throw error;
-
-    return data;
-  };
-
-  const logout = async () => {
-    await context.client.signOut({
-      fetchOptions: {
-        onSuccess: () => {
-          localStorage.removeItem('pn');
-          window.location.href = "/auth/login"
-        }
-      },
-    });
-  };
-  
-
-  return {
-    ...context,
-    login,
-    register,
-    logout,
-    error: sessionError,
-    isPending,
-    isRefetching,
-    refetch,
-    user,
-    session,
-  };
-}
+import { useStoreAuth } from "../store";
+
+export default function useAuth() {
+  const context = useStoreAuth();
+  const sessionContext = context?.client?.useSession();
+
+  const { error: sessionError, isPending, isRefetching, refetch } = sessionContext || {};
+  const { user, session } = sessionContext?.data || {};
+
+  const login = async (email, password) => {
+    const { data, error } = await context.client.signIn.email({ email, password });
+    if (error) throw error;
+
+    return data;
+  };
+
+  const register = async ({ email, password, name, image }) => {
+    const payload = { email, password, name, isPublic: true };
+    if (typeof image === "string" && image.trim() !== "") payload.image = image;
+
+    const { data, error } = await context.client.signUp.email(payload);
+    if (error) throw error;
+
+    return data;
+  };
+
+  const logout = async () => {
+    await context.client.signOut({
+      fetchOptions: {
+        onSuccess: () => {
+          localStorage.removeItem('pn');
+          window.location.href = "/auth/login"
+        }
+      },
+    });
+  };
+  
+
+  return {
+    ...context,
+    login,
+    register,
+    logout,
+    error: sessionError,
+    isPending,
+    isRefetching,
+    refetch,
+    user,
+    session,
+  };
+}