zyket 1.2.11 → 1.2.13

package/src/kernel/index.js

@@ -1,79 +1,79 @@
-const {ContainerBuilder} = require("node-dependency-injection");
-const EnvManager = require("../utils/EnvManager");
-const fs = require("fs");
-const path = require("path");
-const HTTPServer = require("./HTTPServer");
-const Extension = require("../extensions/Extension");
-
-module.exports = class Kernel {
-  container;
-  #services;
-  #onSocketConnection;
-  #httpServer;
-  #extensions = [];
-
-  constructor({ 
-    services = [],
-    extensions = [],
-  } = { }) {
-    this.container = new ContainerBuilder();
-    this.#services = services;
-    this.#extensions = extensions;
-
-    // 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");
-    this.#httpServer = new HTTPServer({ port: Number(process.env.PORT) || 3000 });
-    await this.#httpServer.start();
-
-    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({
-        httpServer: this.#httpServer.server,
-      });
-    }
-
-    for (const extension of this.#extensions) {
-      if (!(extension instanceof Extension)) {
-        throw new Error(`Extension ${extension.name} is not an instance of Extension class`);
-      }
-      this.container.get('logger').debug(`Loading extension ${extension.name}`);
-      await extension.load(this.container);
-    }
-
-
-
-    return this;
-  }
-
-  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();
-  }
-
-  async #loadExtensions() {
-    // Load extensions if any
-  }
+const {ContainerBuilder} = require("node-dependency-injection");
+const EnvManager = require("../utils/EnvManager");
+const fs = require("fs");
+const path = require("path");
+const HTTPServer = require("./HTTPServer");
+const Extension = require("../extensions/Extension");
+
+module.exports = class Kernel {
+  container;
+  #services;
+  #onSocketConnection;
+  #httpServer;
+  #extensions = [];
+
+  constructor({ 
+    services = [],
+    extensions = [],
+  } = { }) {
+    this.container = new ContainerBuilder();
+    this.#services = services;
+    this.#extensions = extensions;
+
+    // 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");
+    this.#httpServer = new HTTPServer({ port: Number(process.env.PORT) || 3000 });
+    await this.#httpServer.start();
+
+    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({
+        httpServer: this.#httpServer.server,
+      });
+    }
+
+    for (const extension of this.#extensions) {
+      if (!(extension instanceof Extension)) {
+        throw new Error(`Extension ${extension.name} is not an instance of Extension class`);
+      }
+      this.container.get('logger').debug(`Loading extension ${extension.name}`);
+      await extension.load(this.container);
+    }
+
+
+
+    return this;
+  }
+
+  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();
+  }
+
+  async #loadExtensions() {
+    // Load extensions if any
+  }
 }

package/src/services/Service.js

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

package/src/services/auth/auth.js

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

package/src/services/auth/index.js

@@ -1,200 +1,200 @@
-const Service = require('../Service');
-const { toNodeHandler } = require('better-auth/node');
-const { betterAuth } = require("better-auth");
-const { admin, bearer, organization } = require("better-auth/plugins");
-const { Pool } = require("pg");
-const path = require("path");
-
-module.exports = class AuthService extends Service {
-  #container;
-  client;
-
-  constructor(container) {
-    super('AuthService');
-    this.#container = container;
-  }
-
-  async boot() {
-    if (!['postgresql', 'sqlite'].includes(process.env.DATABASE_DIALECT)) {
-      throw new Error("AuthService only supports PostgreSQL and SQLite as database dialects");
-    }
-    this.#addAuthEnvVariables();
-    this.client = this.auth;
-    const express = this.#container.get('express');
-    express.regiterRawAllRoutes("/api/auth/*splat", toNodeHandler(this.auth));
-  }
-
-  #addAuthEnvVariables() {
-    const EnvManager = require('../../utils/EnvManager');
-    const envPath = path.join(process.cwd(), '.env');
-    
-    const secretAdded = EnvManager.addEnvVariable(envPath, 'AUTH_SECRET', 'change-this-secret-in-production');
-    if (secretAdded) {
-      this.#container.get('logger').info('Added AUTH_SECRET to .env file');
-    }
-
-    const originsAdded = EnvManager.addEnvVariable(envPath, 'TRUSTED_ORIGINS', 'http://localhost:5173,http://localhost:3000');
-    if (originsAdded) {
-      this.#container.get('logger').info('Added TRUSTED_ORIGINS to .env file');
-    }
-
-    const betterAuthUrlAdded = EnvManager.addEnvVariable(envPath, 'BETTER_AUTH_URL', 'http://localhost:3000');
-    if (betterAuthUrlAdded) {
-      this.#container.get('logger').info('Added BETTER_AUTH_URL to .env file');
-    }
-  }
-
-  #getDatabaseConnection() {
-    const dialect = process.env.DATABASE_DIALECT;
-
-    if (dialect === 'sqlite') {
-      const Database = require('better-sqlite3');
-      const dbPath = process.env.DATABASE_URL || path.join(process.cwd(), 'database.sqlite');
-      return new Database(dbPath);
-    } else if (dialect === 'postgresql') {
-      return new Pool({
-        connectionString: process.env.DATABASE_URL || null,
-      });
-    }
-
-    throw new Error(`Unsupported database dialect: ${dialect}`);
-  }
-
-  get plugins() {
-    return [];
-  }
-
-  get socialProviders() {
-    return {}
-  }
-
-  get userAdditionalFields() {
-    return {};
-  }
-
-  get memberAdditionalFields() {
-    return {};
-  }
-
-  get organizationAdditionalFields() {
-    return {};
-  }
-
-  get hooks() {
-    return {};
-  }
-
-  async sendResetPasswordEmail({ user, url, token }, request) {
-    throw new Error("sendResetPasswordEmail method not implemented");
-  }
-
-  async sendVerificationEmail({ user, url, token }, request) {
-    throw new Error("sendVerificationEmail method not implemented");
-  }
-
-  async sendInvitationEmail(data) {
-    throw new Error("sendInvitationEmail method not implemented");
-  }
-
-  async allowUserToCreateOrganization(user) {
-    throw new Error("allowUserToCreateOrganization method not implemented");
-  }
-
-  get auth() {
-    const cache = this.#container.get('cache');
-    return betterAuth({
-      hooks: this.hooks,
-      plugins: [
-        admin(),
-        bearer(),
-        organization({
-          schema: {
-            organization: {
-              additionalFields: this.organizationAdditionalFields
-            },
-            member: { 
-              additionalFields: this.memberAdditionalFields
-            }
-          },
-          allowUserToCreateOrganization: async (user) => {
-            return await this.allowUserToCreateOrganization(user);
-          },
-          async sendInvitationEmail(data) {
-            return await this.sendInvitationEmail(data);
-          }
-        }),
-        ...this.plugins,
-      ],
-      socialProviders: this.socialProviders,
-      database: this.#getDatabaseConnection(),
-      advanced: {
-        crossSubDomainCookies: {
-          enabled: true,
-        },
-        cookie: {
-          sameSite: "none",
-          secure: true,
-          path: "/",
-          state: {
-            attributes: {
-              sameSite: "none",
-              secure: true,
-            }
-          }
-        },
-        defaultCookieAttributes: {
-          secure: true,
-          sameSite: "none",
-        },
-        cookies: {
-          state: {
-            attributes: {
-              sameSite: "none",
-              secure: true,
-            }
-          }
-        }
-      },
-      secondaryStorage: {
-        get: async (key) => {
-          return await cache.get(key);
-        },
-        set: async (key, value, ttl) => {
-          await cache.set(key, value);
-          if(ttl) await cache.expire(key, ttl);
-        },
-        delete: async (key) => {
-          await cache.del(key);
-        }
-      },
-      emailAndPassword: {
-        enabled: true,
-        requireEmailVerification: false,
-        sendResetPassword: async ({ user, url, token }, request) => this.sendResetPasswordEmail({ user, url, token }, request),
-      },
-      emailVerification: {
-        sendVerificationEmail: async ({ user, url, token }, request) => this.sendVerificationEmail({ user, url, token }, request),
-        sendOnSignIn: true,
-        autoSignInAfterVerification: true,
-      },
-      user: {
-        additionalFields: this.userAdditionalFields
-      },
-      account: {
-        accountLinking: { enabled: true },
-        skipStateCookieCheck: true,
-      },
-      session: {
-        expiresIn: 60 * 60 * 24 * 7,
-        updateAge: 60 * 60 * 24
-      },
-      baseURL: process.env.BETTER_AUTH_URL || 'http://localhost:3000',
-      secret: process.env.AUTH_SECRET || 'your-secret-key-change-in-production',
-      trustedOrigins: process.env.TRUSTED_ORIGINS?.split(',') || ['http://localhost:5173', 'http://localhost:6632']
-    })
-  }
-
-  get client() {
-    return this.client;
-  }
+const Service = require('../Service');
+const { toNodeHandler } = require('better-auth/node');
+const { betterAuth } = require("better-auth");
+const { admin, bearer, organization } = require("better-auth/plugins");
+const { Pool } = require("pg");
+const path = require("path");
+
+module.exports = class AuthService extends Service {
+  #container;
+  client;
+
+  constructor(container) {
+    super('AuthService');
+    this.#container = container;
+  }
+
+  async boot() {
+    if (!['postgresql', 'sqlite'].includes(process.env.DATABASE_DIALECT)) {
+      throw new Error("AuthService only supports PostgreSQL and SQLite as database dialects");
+    }
+    this.#addAuthEnvVariables();
+    this.client = this.auth;
+    const express = this.#container.get('express');
+    express.regiterRawAllRoutes("/api/auth/*splat", toNodeHandler(this.auth));
+  }
+
+  #addAuthEnvVariables() {
+    const EnvManager = require('../../utils/EnvManager');
+    const envPath = path.join(process.cwd(), '.env');
+    
+    const secretAdded = EnvManager.addEnvVariable(envPath, 'AUTH_SECRET', 'change-this-secret-in-production');
+    if (secretAdded) {
+      this.#container.get('logger').info('Added AUTH_SECRET to .env file');
+    }
+
+    const originsAdded = EnvManager.addEnvVariable(envPath, 'TRUSTED_ORIGINS', 'http://localhost:5173,http://localhost:3000');
+    if (originsAdded) {
+      this.#container.get('logger').info('Added TRUSTED_ORIGINS to .env file');
+    }
+
+    const betterAuthUrlAdded = EnvManager.addEnvVariable(envPath, 'BETTER_AUTH_URL', 'http://localhost:3000');
+    if (betterAuthUrlAdded) {
+      this.#container.get('logger').info('Added BETTER_AUTH_URL to .env file');
+    }
+  }
+
+  #getDatabaseConnection() {
+    const dialect = process.env.DATABASE_DIALECT;
+
+    if (dialect === 'sqlite') {
+      const Database = require('better-sqlite3');
+      const dbPath = process.env.DATABASE_URL || path.join(process.cwd(), 'database.sqlite');
+      return new Database(dbPath);
+    } else if (dialect === 'postgresql') {
+      return new Pool({
+        connectionString: process.env.DATABASE_URL || null,
+      });
+    }
+
+    throw new Error(`Unsupported database dialect: ${dialect}`);
+  }
+
+  get plugins() {
+    return [];
+  }
+
+  get socialProviders() {
+    return {}
+  }
+
+  get userAdditionalFields() {
+    return {};
+  }
+
+  get memberAdditionalFields() {
+    return {};
+  }
+
+  get organizationAdditionalFields() {
+    return {};
+  }
+
+  get hooks() {
+    return {};
+  }
+
+  async sendResetPasswordEmail({ user, url, token }, request) {
+    throw new Error("sendResetPasswordEmail method not implemented");
+  }
+
+  async sendVerificationEmail({ user, url, token }, request) {
+    throw new Error("sendVerificationEmail method not implemented");
+  }
+
+  async sendInvitationEmail(data) {
+    throw new Error("sendInvitationEmail method not implemented");
+  }
+
+  async allowUserToCreateOrganization(user) {
+    throw new Error("allowUserToCreateOrganization method not implemented");
+  }
+
+  get auth() {
+    const cache = this.#container.get('cache');
+    return betterAuth({
+      hooks: this.hooks,
+      plugins: [
+        admin(),
+        bearer(),
+        organization({
+          schema: {
+            organization: {
+              additionalFields: this.organizationAdditionalFields
+            },
+            member: { 
+              additionalFields: this.memberAdditionalFields
+            }
+          },
+          allowUserToCreateOrganization: async (user) => {
+            return await this.allowUserToCreateOrganization(user);
+          },
+          sendInvitationEmail: async (data) => {
+            return await this.sendInvitationEmail(data);
+          }
+        }),
+        ...this.plugins,
+      ],
+      socialProviders: this.socialProviders,
+      database: this.#getDatabaseConnection(),
+      advanced: {
+        crossSubDomainCookies: {
+          enabled: true,
+        },
+        cookie: {
+          sameSite: "none",
+          secure: true,
+          path: "/",
+          state: {
+            attributes: {
+              sameSite: "none",
+              secure: true,
+            }
+          }
+        },
+        defaultCookieAttributes: {
+          secure: true,
+          sameSite: "none",
+        },
+        cookies: {
+          state: {
+            attributes: {
+              sameSite: "none",
+              secure: true,
+            }
+          }
+        }
+      },
+      secondaryStorage: {
+        get: async (key) => {
+          return await cache.get(key);
+        },
+        set: async (key, value, ttl) => {
+          await cache.set(key, value);
+          if(ttl) await cache.expire(key, ttl);
+        },
+        delete: async (key) => {
+          await cache.del(key);
+        }
+      },
+      emailAndPassword: {
+        enabled: true,
+        requireEmailVerification: false,
+        sendResetPassword: async ({ user, url, token }, request) => this.sendResetPasswordEmail({ user, url, token }, request),
+      },
+      emailVerification: {
+        sendVerificationEmail: async ({ user, url, token }, request) => this.sendVerificationEmail({ user, url, token }, request),
+        sendOnSignIn: true,
+        autoSignInAfterVerification: true,
+      },
+      user: {
+        additionalFields: this.userAdditionalFields
+      },
+      account: {
+        accountLinking: { enabled: true },
+        skipStateCookieCheck: true,
+      },
+      session: {
+        expiresIn: 60 * 60 * 24 * 7,
+        updateAge: 60 * 60 * 24
+      },
+      baseURL: process.env.BETTER_AUTH_URL || 'http://localhost:3000',
+      secret: process.env.AUTH_SECRET || 'your-secret-key-change-in-production',
+      trustedOrigins: process.env.TRUSTED_ORIGINS?.split(',') || ['http://localhost:5173', 'http://localhost:6632']
+    })
+  }
+
+  get client() {
+    return this.client;
+  }
 }

package/src/services/bullmq/Worker.js

@@ -1,8 +1,8 @@
-module.exports = class Worker {
-  name;
-  queueName = null;
-  
-  constructor(name) {
-    this.name = name;
-  }
+module.exports = class Worker {
+  name;
+  queueName = null;
+  
+  constructor(name) {
+    this.name = name;
+  }
 }