zyket 1.0.1

package/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish Package to npmjs
+on:
+  push:
+    branches:
+      - main
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+      attestations: write
+      id-token: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name:  'Bump version'
+        id: version-bump
+        uses:  'phips28/gh-action-bump-version@master'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          commit-message: 'CI: bumps version to {{version}} [skip ci]' 
+      
+      - name: Publish to npm
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,3 @@
+# ZYKET - Easy Socket.io Framework
+
+Zyket is a framework inspired by Symfony. 

package/index.js

@@ -0,0 +1,12 @@
+const Kernel = require("./src/kernel");
+const Service = require("./src/services/Service");
+const { Handler, Middleware } = require("./src/services/socketio");
+const EnvManager = require("./src/utils/EnvManager");
+
+module.exports = {
+  Kernel,
+  Service,
+  Handler,
+  Middleware,
+  EnvManager
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "zyket",
+  "version": "1.0.1",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "colors": "^1.4.0",
+    "dotenv": "^16.4.7",
+    "fast-glob": "^3.3.3",
+    "mariadb": "^3.4.0",
+    "minio": "^8.0.5",
+    "node-dependency-injection": "^3.2.2",
+    "redis": "^4.7.0",
+    "sequelize": "^6.37.6",
+    "socket.io": "^4.8.1"
+  }
+}

package/src/Middleware.js

@@ -0,0 +1,4 @@
+module.exports = class Middleware {
+  constructor() {
+  }
+}

package/src/kernel/index.js

@@ -0,0 +1,52 @@
+const {ContainerBuilder} = require("node-dependency-injection");
+const EnvManager = require("../utils/EnvManager");
+const fs = require("fs");
+const path = require("path");
+
+module.exports = class Kernel {
+  container;
+  #services;
+  #onSocketConnection;
+
+  constructor({ 
+    services = [],
+    onConnection = () => { },
+  } = { }) {
+    this.container = new ContainerBuilder();
+    this.#services = services;
+
+    // create src folder if not exists
+    if (!fs.existsSync(path.join(process.cwd(), "src"))) {
+      fs.mkdirSync(path.join(process.cwd(), "src"));
+    }
+  }
+
+  async boot(clearConsole = true, secretsPath = `${process.cwd()}/.env`) {
+    EnvManager.load(secretsPath, false);
+    if(clearConsole) process.stdout.write("\u001b[2J\u001b[0;0H");
+    const services = require("../services");
+
+    await this.#registerServices(services);
+    await this.#registerServices(this.#services);
+
+    for (const [name] of [...services, ...this.#services]) {
+      this.container.get('logger').debug(`Booting service ${name}`);
+      await this.container.get(name).boot();
+    }
+  }
+
+  async #registerServices(servicesToRegister = []) {
+    for (const [name, serviceClass, args] of servicesToRegister) {
+      this.container.register(name, serviceClass, args.map(arg => {
+        if(arg === "@service_container") return this.container;
+        if(arg === "@onConnection") return this.#onSocketConnection;
+        return arg
+      }));
+      if(this.container.has("logger")) {
+        this.container.get("logger").debug(`Service ${name} registered`);
+      }
+    }
+
+    this.container.compile();
+  }
+}

package/src/services/Service.js

@@ -0,0 +1,11 @@
+module.exports = class Service {
+  name = null;
+  
+  constructor(name) {
+    this.name = name;
+  }
+
+  async boot() {
+    throw new Error("Method 'boot' must be implemented.");
+  }
+}

package/src/services/cache/index.js

@@ -0,0 +1,38 @@
+const Service = require("../Service");
+const { createClient } = require("redis");
+
+module.exports = class Cache extends Service {
+  #container;
+  client;
+
+  constructor(container, url) {
+    super("cache");
+    this.#container = container;
+    this.client = createClient({ url });
+  }
+
+  async boot() {
+    await this.client.connect();
+  }
+
+  async set(key, value) {
+    return await this.client.set(key, value);
+    
+  }
+
+  async get(key) {
+    return await this.client.get(key);
+  }
+
+  async del(key) {
+    return await this.client.del(key);
+  }
+
+  async keys(pattern) {
+    return await this.client.keys(pattern);
+  }
+
+  async expire(key, seconds) {
+    return await this.client.expire(key, seconds);
+  }
+}

package/src/services/database/index.js

@@ -0,0 +1,69 @@
+const { Sequelize } = require("sequelize");
+const Service = require("../Service");
+const fg = require('fast-glob');
+const fs = require('fs');
+const path = require('path');
+
+module.exports = class Database extends Service {
+  #container;
+  #databaseUrl;
+  sequelize
+  models = {}
+
+  constructor(container, databaseUrl) {
+    super('database');
+    this.#container = container;
+    this.#databaseUrl = databaseUrl;
+  }
+  
+  async boot() {
+    this.#createModelsFolder();
+    this.sequelize = new Sequelize(process.env.DATABASE_URL, {
+      dialect: process.env.DATABASE_DIALECT || 'mariadb',
+      logging: (msg) => this.#container.get('logger').debug(msg),
+      operatorsAliases: 0,
+      pool: {
+        max: 40,
+        min: 0,
+        acquire: 30000,
+        idle: 10000
+      },
+    });
+
+    await this.sequelize.authenticate();
+
+    await this.#loadModels();
+    
+    this.#container.get('logger').debug(`Database modesl loaded: ${Object.keys(this.models).join(", ")}`);
+  }
+
+  async #loadModels() {
+    const models = await fg('*.js', { cwd: path.join(process.cwd(), "src", "models") });
+    for (const model of models) {
+      const modelPath = path.join(process.cwd(), "src", "models", model);
+      const modelFunc = require(modelPath);
+      if (typeof modelFunc !== 'function') {
+        this.#container.get('logger').error(`Model ${model} is not a function`);
+        continue;
+      }
+      const modelInstance = modelFunc({sequelize: this.sequelize, container: this.#container, Sequelize});
+      this.models[model.replace('.js', '')] = modelInstance;
+    }
+
+    for (const model of Object.values(this.models)) {
+      if (model.associate) {
+        model.associate(this.models);
+      }
+    }
+  }
+
+  #createModelsFolder() {
+    const path = 'src/models';
+    if (!fs.existsSync(path)) fs.mkdirSync(path);
+  }
+
+  sync() {
+    return this.sequelize.sync();
+  }
+
+}

package/src/services/index.js

@@ -0,0 +1,12 @@
+const Database = require("./Database");
+const Cache = require("./Cache");
+const S3 = require("./S3");
+const { SocketIO } = require("./socketio");
+
+module.exports = [
+  ["logger", require("./Logger"), ["@service_container", process.env.LOG_DIRECTORY || `${process.cwd()}/logs`, process.env.DEBUG === "true"]],
+  process.env.DATABASE_URL ? ["database", Database, ["@service_container", process.env.DATABASE_URL]] : null,
+  process.env.CACHE_URL ? ["cache", Cache, ["@service_container", process.env.CACHE_URL]] : null,
+  (process.env.S3_ENDPOINT && process.env.S3_ACCESS_KEY && process.env.S3_SECRET_KEY) ? ["s3", S3, ["@service_container", process.env.S3_ENDPOINT, process.env.S3_PORT, process.env.S3_USE_SSL === "true", process.env.S3_ACCESS_KEY, process.env.S3_SECRET_KEY]] : null,
+  ["socketio", SocketIO, ["@service_container", process.env.PORT || 3000]],
+].filter(Boolean);

package/src/services/logger/index.js

@@ -0,0 +1,81 @@
+const fs = require("fs");
+const Service = require("../Service");
+require("colors");
+
+module.exports = class Logger extends Service  {
+  #container
+  #logDirectory;
+  #debugEnabled;
+  messageColors = {
+    log: "white",
+    info: "green",
+    warn: "yellow",
+    error: "red",
+    debug: "blue"
+  };
+  #storeTries = 0;
+
+  constructor(container, logDirectory, debugEnabled) {
+    super("logger");
+    this.#container = container;
+    this.#logDirectory = logDirectory;
+    this.#debugEnabled = debugEnabled;
+  }
+
+  async boot() {
+    if (!fs.existsSync(this.#logDirectory)) fs.mkdirSync(this.#logDirectory);
+    return this;
+  }
+
+  async store(message) {
+    if (this.#storeTries > 10) throw new Error("Failed to store log message");
+    this.#storeTries++;
+    try{
+      fs.appendFileSync(`${this.#logDirectory}/${new Date().toISOString().split("T")[0]}.log`, `${message}\n`);
+      this.#storeTries = 0;
+    } catch (e) {
+      if (!fs.existsSync(this.#logDirectory)) {
+        fs.mkdirSync(this.#logDirectory);
+      }
+
+      if (!fs.existsSync(`${this.#logDirectory}/${new Date().toISOString().split("T")[0]}.log`)) {
+        fs.writeFileSync(`${this.#logDirectory}/${new Date().toISOString().split("T")[0]}.log`, "");
+      }
+      
+      return this.store(message);
+    }
+  }
+
+  getDateTimestamp() {
+    return new Date().toISOString().replace("T", " ").replace("Z", "");
+  }
+
+  buildMessage(type, message) {
+    return `${this.getDateTimestamp()} [${type.toUpperCase()}] ${message}`[this.messageColors[type]];
+  }
+
+  async log(message) {
+    console.log(this.buildMessage("log", message));
+    this.store(this.buildMessage("log", message));
+  }
+
+  async info(message) {
+    console.log(this.buildMessage("info", message));
+    this.store(this.buildMessage("info", message));
+  }
+
+  async warn(message) {
+    console.log(this.buildMessage("warn", message));
+    this.store(this.buildMessage("warn", message));
+  }
+
+  async error(message) {
+    console.log(this.buildMessage("error", message));
+    this.store(this.buildMessage("error", message));
+  }
+
+  async debug(message) {
+    this.#debugEnabled && console.log(this.buildMessage("debug", message));
+    this.store(this.buildMessage("debug", message));
+  }
+}

package/src/services/s3/index.js

@@ -0,0 +1,83 @@
+const Service = require("../Service");
+const MinioService = require('minio')
+
+module.exports = class S3 extends Service {
+  #container
+  #endPoint
+  #port
+  #useSSL
+  #accessKey
+  #secretKey
+
+  constructor(container, endPoint, port, useSSL, accessKey, secretKey) {
+    super('s3')
+    this.#container = container
+    this.#endPoint = endPoint
+    this.#port = port
+    this.#useSSL = useSSL
+    this.#accessKey = accessKey
+    this.#secretKey = secretKey
+  }
+
+  async boot() {
+    this.client = new MinioService.Client({
+      endPoint: this.#endPoint,
+      port: this.#port,
+      useSSL: this.#useSSL,
+      accessKey: this.#accessKey,
+      secretKey: this.#secretKey
+    })
+  }
+
+  async saveFile(bucketName, fileName, file, contentType = 'binary/octet-stream') {
+    this.#container.get('logger').debug(`Saving file ${fileName} to bucket ${bucketName}`);
+    return new Promise((resolve, reject) => {
+      this.client.putObject(
+        bucketName,
+        fileName,
+        file,
+        {
+          "Content-Type": contentType
+        },
+        (err, etag) => {
+          if (err) return reject(err);
+          resolve(etag);
+        }
+      );
+    });
+  }
+
+  async getFile(bucketName, fileName) {
+    return new Promise((resolve, reject) => {
+      let data = ''
+      this.client.getObject(bucketName, fileName, (err, stream) => {
+        if(err) return reject(err)
+        stream.on('data', (chunk) => {
+          data += chunk
+        })
+        stream.on('end', () => {
+          resolve(data)
+        })
+      })
+    })
+  }
+
+  async removeFile(bucketName, fileName) {
+    this.#container.get('logger').debug(`Removing file ${fileName} from bucket ${bucketName}`);
+    return this.client.removeObject(bucketName, fileName)
+  }
+
+  async createBucket(bucketName) {
+    this.#container.get('logger').debug(`Creating bucket ${bucketName}`);
+    return this.client.makeBucket(bucketName, 'us-east-1')
+  }
+
+  listBuckets() {
+    return new Promise((resolve, reject) => {
+      this.client.listBuckets((err, buckets) => {
+        if(err) return reject(err)
+        resolve(buckets)
+      })
+    })
+  }
+}

package/src/services/socketio/Handler.js

@@ -0,0 +1,11 @@
+module.exports = class Handler {
+  event;
+  
+  constructor(event) {
+    this.event = event;
+  }
+
+  handle({ container, socket, data }) {
+    throw new Error("You should implement 'handle()' method on your handler");
+  }
+}

package/src/services/socketio/Middleware.js

@@ -0,0 +1,11 @@
+module.exports = class Middleware {
+  name;
+  
+  constructor(name) {
+    this.name = name;
+  }
+
+  async handle({ container, socket}) {
+    throw new Error("Method 'handle' must be implemented.");
+  }
+}

package/src/services/socketio/SocketIO.js

@@ -0,0 +1,138 @@
+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 Middleware = require("./Middleware");
+
+
+module.exports = class SocketIO extends Service {
+  port;
+  #container;
+  io;
+  middlewares = {};
+  
+  constructor(container, port, onConnection = () => { }) {
+    super("socketio");
+    this.port = port || 3000;
+    this.#container = container;
+  }
+
+  async boot() {
+    const middlewares = await this.#loadMiddlewaresFromFolder(path.join(process.cwd(), "src", "middlewares"));
+    for (const middleware of middlewares) {
+      this.middlewares[middleware.name] = middleware;
+    }
+    const handlers = await this.#loadHandlersFromFolder(path.join(process.cwd(), "src", "handlers"));
+    const connectionHandler = new (await this.#loadConnectionHandler())();
+
+
+    this.#container.get('logger').debug(`Middlewares: ${middlewares.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", (socket) => {
+      const connectionMiddlewares = (connectionHandler?.middlewares || []).map(mdl => this.middlewares[mdl])
+      for (const middleware of connectionMiddlewares) {
+        if(!middleware) {
+          this.#container.get('logger').warn(`You are using a middleware that does not exist`);
+          continue;
+        }
+        middleware.handle({ container: this.#container, socket });
+      }
+      connectionHandler.handle({ container: this.#container, socket });
+      handlers.forEach((handler) => {
+        const handlerMiddlewares = (handler?.middlewares || []).map(mdl => this.middlewares[mdl])
+        socket.on(handler.event, async (data) => {
+          this.#container.get('logger').debug(`[${socket?.id}] Sent ${handler.event} with middlewares: ${handlerMiddlewares?.map(mdl => mdl?.name).join(", ")}`);
+          for (const middleware of handlerMiddlewares) {
+            if(!middleware) {
+              this.#container.get('logger').warn(`You are using a middleware that does not exist`);
+              continue;
+            }
+            await middleware.handle({ container: this.#container, socket });
+          }
+          return await handler.handle({ container: this.#container, socket, data });
+        });
+      });
+    });
+
+    this.io.listen(this.port);
+    this.#container.get('logger').info(`Socket.IO is running on port ws://localhost:${this.port}`);
+  }
+
+  async #loadConnectionHandler() {
+    const connectionHandlerExists  = fs.existsSync(path.join(process.cwd(), "src", "handlers", "connection.js"));
+    /* if exists require, otherwise create a default one */
+    if(!connectionHandlerExists) {
+      fs.writeFileSync(path.join(process.cwd(), "src", "handlers", "connection.js"), `const { Handler } = require("zyket");
+
+module.exports = class ConnectionHandler extends Handler {
+  async handle({ container, socket }) {
+    container.get("logger").info("New connection");
+  }
+};`);
+    }
+    return require(path.join(process.cwd(), "src", "handlers", "connection.js"));
+  }
+
+  async #loadHandlersFromFolder(handlersFolder) {
+    this.#createHandlersFolder(handlersFolder);
+    // need to read all files and subfolders
+    const handlers = (await fg('**/*.js', { cwd: handlersFolder, ignore: 'connection.js' })).map((hdr) => {
+      // should be type handler
+      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);
+    // create a default handler
+    fs.writeFileSync(path.join(handlersFolder, "message.js"), `const { Handler } = require("zyket");
+module.exports = class MessageHandler extends Handler {
+  event = "message";
+  middlewares = ["default"];
+
+  async handle({ container, socket, data }) {
+    container.get("logger").info("Message handler");
+  }
+};`);
+  }
+
+  async #loadMiddlewaresFromFolder(middlewaresFolder) {
+    this.#createMiddlewaresFolder(middlewaresFolder);
+    // need to read all files and subfolders
+    const middlewares = await fg('**/*.js', { cwd: middlewaresFolder })
+    
+    return middlewares.map((mdl) => {
+      // should be type middleware
+      const middleware = require(path.join(middlewaresFolder, mdl));
+      if(!(middleware.prototype instanceof Middleware)) throw new Error(`${mdl} is not a valid middleware`);
+      return new middleware(mdl.replace('.js', ''));
+    });
+  }
+
+  #createMiddlewaresFolder(middlewaresFolder, overwrite = false) {
+    if (fs.existsSync(middlewaresFolder) && !overwrite) return;
+    this.#container.get('logger').info(`Creating middlewares folder at ${middlewaresFolder}`);
+    fs.mkdirSync(middlewaresFolder);
+    // create a default middleware
+    fs.writeFileSync(path.join(middlewaresFolder, "default.js"), `const { Middleware } = require("zyket");
+module.exports = class DefaultMiddleware extends Middleware {
+  async handle({ container, socket }) {
+    container.get("logger").info("Default middleware");
+  }
+};`);
+  }
+
+  stop() {
+    this.io.close();
+  }
+}

package/src/services/socketio/index.js

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

package/src/utils/EnvManager.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+
+module.exports = class EnvManager {
+  static load(secretsPath) {
+    this.createEnvFile(secretsPath);
+    require("dotenv").config({ path: secretsPath });
+  }
+
+  static createEnvFile(secretsPath, overwrite = false) {
+    if (fs.existsSync(secretsPath) && !overwrite) return;
+    fs.writeFileSync(secretsPath, this.getDefaultSecrets());
+  }
+
+  static getDefaultSecrets() {
+    const envsToCreate = {
+      DEBUG: true,
+      PORT: 3000,
+      DATABASE_URL: '',
+      CACHE_URL: '',
+      S3_ENDPOINT: '',
+      S3_PORT: '',
+      S3_USE_SSL: true,
+      S3_ACCESS_KEY: '',
+      S3_SECRET_KEY: '',
+      LOG_DIRECTORY: "./logs"
+    }
+
+    return Object.entries(envsToCreate).reduce((acc, [key, value]) => {
+      return `${acc}${key}=${value}\n`;
+    }, "");
+  }
+}