zyket 1.2.11 → 1.2.13

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/services/vite/builder.js

@@ -0,0 +1,29 @@
+const path = require("path");
+
+/**
+ * Builds the Vite frontend for production using Vite's JS API.
+ *
+ * @param {Object} options
+ * @param {string} options.root        Absolute path to the Vite project root.
+ * @param {string|false} options.configFile  Resolved vite config file, or false.
+ * @returns {Promise<string>} Absolute path to the generated output directory.
+ */
+module.exports = async function buildViteApp({ root, configFile } = {}) {
+  const { build, resolveConfig } = await import("vite");
+
+  // Resolve config first so we know the real outDir (respects custom config).
+  const resolved = await resolveConfig(
+    { root, configFile },
+    "build",
+    "production"
+  );
+  const outDir = path.resolve(root, resolved.build.outDir);
+
+  await build({
+    root,
+    configFile,
+    logLevel: "warn",
+  });
+
+  return outDir;
+};

package/src/services/vite/index.js

@@ -2,26 +2,40 @@ const Service = require("../Service");
 const path = require("path");
 const fs = require("fs");
 const EnvManager = require("../../utils/EnvManager");
+const buildViteApp = require("./builder");
 
 module.exports = class Vite extends Service {
   #container;
   #viteServer;
   #root;
   #port;
+  #isProduction;
+  #outDir;
 
   constructor(container, root, port) {
     super("vite");
     this.#container = container;
     this.#root = path.resolve(process.cwd(), root || process.cwd());
     this.#port = port || 5173;
+    this.#isProduction = process.env.NODE_ENV === "production";
   }
 
   async boot() {
     await this.#loadViteFolder();
-    const { createServer } = await import("vite");
 
     const configFile = this.#resolveConfigFile();
 
+    // In production we build the frontend once and let Express serve the
+    // generated static files. No dev server is started.
+    if (this.#isProduction) {
+      this.#container.get("logger").info("Building Vite frontend for production...");
+      this.#outDir = await buildViteApp({ root: this.#root, configFile });
+      this.#container.get("logger").info(`Vite build complete (output: ${this.#outDir})`);
+      return;
+    }
+
+    const { createServer } = await import("vite");
+
     this.#viteServer = await createServer({
       root: this.#root,
       configFile,
@@ -115,4 +129,12 @@ module.exports = class Vite extends Service {
   server() {
     return this.#viteServer;
   }
+
+  isProduction() {
+    return this.#isProduction;
+  }
+
+  outDir() {
+    return this.#outDir;
+  }
 };

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>)