@synchjs/ewb 1.0.0 → 1.0.2

package/dist/Components/Server.js

@@ -9,10 +9,12 @@ import rateLimit from "express-rate-limit";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import { MetadataStorage } from "../Decorations";
-import * as jwt from "jsonwebtoken";
-import { AUTH_METADATA_KEY, PUBLIC_METADATA_KEY, } from "../Decorations/Authorized";
+import { createServer } from "http";
+import { Server as SocketServer } from "socket.io";
+import { PUBLIC_METADATA_KEY, ROLES_METADATA_KEY, } from "../Decorations/Authorized";
 import { SECURITY_METADATA_KEY, } from "../Decorations/Security";
 import { TAILWIND_METADATA_KEY, } from "../Decorations/Tailwind";
+import { SERVE_HTML_METADATA_KEY } from "../Decorations/Serve";
 import { ServeMemoryStore } from "./ServeMemoryStore";
 import boxen from "boxen";
 import pc from "picocolors";
@@ -20,6 +22,7 @@ export class Server {
     _app;
     _port;
     _controllersDir;
+    _viewsDir;
     _id;
     _enableSwagger;
     _swaggerPath;
@@ -28,11 +31,15 @@ export class Server {
     _ajv;
     _securityHandlers;
     _container;
+    _roleHandler;
+    _userHandler;
     _serverInstance;
+    _io;
     // Stats
     _controllerCount = 0;
     _routeCount = 0;
     _tailwindEnabled = false;
+    _devMode = false;
     constructor(options) {
         this._port = options.port;
         this._app = express();
@@ -42,28 +49,71 @@ export class Server {
         this._enableLogging =
             options.logging === undefined ? true : options.logging;
         this._controllersDir = options.controllersDir || "controllers";
+        this._viewsDir = options.viewsDir;
         this._securityHandlers = options.securityHandlers || {};
         this._securitySchemes = options.securitySchemes;
         this._container = options.container;
-        // Initialize AJV
-        this._ajv = new Ajv({ allErrors: true, strict: false });
+        this._roleHandler = options.roleHandler;
+        // Initialize AJV with strict mode for better security
+        this._ajv = new Ajv({
+            allErrors: true,
+            strict: true,
+            removeAdditional: true, // Automatically remove properties not in schema
+        });
         addFormats(this._ajv);
         // Security Middleware
-        this._app.use(helmet(options.helmetOptions));
+        const helmetOptions = options.helmetOptions || {};
+        if (process.env.NODE_ENV !== "production") {
+            // Relax CSP for HMR in development
+            helmetOptions.contentSecurityPolicy = {
+                directives: {
+                    defaultSrc: ["'self'"],
+                    scriptSrc: ["'self'", "'unsafe-inline'", "'unsafe-eval'", "blob:"],
+                    connectSrc: ["'self'", "ws:", "wss:", "http:", "https:"],
+                    styleSrc: ["'self'", "'unsafe-inline'"],
+                    imgSrc: ["'self'", "data:", "blob:"],
+                    frameSrc: ["'self'"],
+                },
+            };
+        }
+        this._app.use(helmet(helmetOptions));
         this._app.use(cors(options.corsOptions));
         this._app.use(rateLimit(options.rateLimitOptions || {
             windowMs: 15 * 60 * 1000,
             max: 100,
+            skip: (req) => ServeMemoryStore.instance.getAsset(req.path) !== undefined, // Don't rate limit static assets
         }));
-        this._app.use(express.json());
+        this._app.use(express.json({ limit: "1mb" })); // Protection against large payloads
+        // Clear cache on startup
+        ServeMemoryStore.instance.clearCache();
+        this._devMode = process.env.NODE_ENV !== "production";
+        if (this._devMode) {
+            this.setupHmr();
+        }
         global.servers.set(this._id, this._app);
     }
+    setupHmr() {
+        ServeMemoryStore.instance.setDevMode(true);
+        ServeMemoryStore.instance.onRebuild((data) => {
+            if (data && data.html) {
+                this._io?.emit("rebuild", { html: data.html });
+            }
+            else {
+                this._io?.emit("reload");
+            }
+        });
+        // No redundant global watcher here, we rely on ServeMemoryStore's specific watchers
+        // which rebuild before notifying.
+    }
     log(message) {
         if (this._enableLogging) {
             console.log(message);
         }
     }
     async init() {
+        if (this._userHandler) {
+            this.setupAuthRoutes();
+        }
         await this.loadControllers();
         if (this._enableSwagger) {
             this.setupSwagger();
@@ -74,6 +124,11 @@ export class Server {
                 return next();
             const asset = ServeMemoryStore.instance.getAsset(req.path);
             if (asset) {
+                if (this._devMode) {
+                    res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+                    res.setHeader("Pragma", "no-cache");
+                    res.setHeader("Expires", "0");
+                }
                 res.type(asset.type).send(Buffer.from(asset.content));
                 return;
             }
@@ -81,13 +136,31 @@ export class Server {
         });
         // Global Error Handler
         this._app.use((err, req, res, next) => {
-            console.error(`[${this._id}] Error:`, err);
+            const isProd = process.env.NODE_ENV === "production";
+            if (!isProd) {
+                console.error(`[${this._id}] Error:`, err);
+            }
             res.status(err.status || 500).json({
                 error: "Internal Server Error",
-                message: "An unexpected error occurred",
+                message: isProd
+                    ? "An unexpected error occurred"
+                    : err.message || "An unexpected error occurred",
+                // Mask stack trace in production
+                stack: isProd ? undefined : err.stack,
             });
         });
-        this._serverInstance = this._app.listen(this._port, () => {
+        this._serverInstance = createServer(this._app);
+        if (this._devMode) {
+            this._io = new SocketServer(this._serverInstance, {
+                cors: {
+                    origin: [/localhost/, /127\.0\.0\.1/], // Restrict HMR to local development origin
+                },
+            });
+            this._io.on("connection", (socket) => {
+                // Disconnected client log
+            });
+        }
+        this._serverInstance.listen(this._port, () => {
             if (this._enableLogging) {
                 this.printStartupMessage();
             }
@@ -103,7 +176,11 @@ export class Server {
             `${pc.bold(pad("Controllers:"))}${this._controllerCount}`,
             `${pc.bold(pad("Routes:"))}${this._routeCount}`,
             `${pc.bold(pad("Tailwind:"))}${this._tailwindEnabled ? pc.blue("Enabled") : pc.dim("Disabled")}`,
+            `${pc.bold(pad("HMR:"))}${this._devMode ? pc.cyan("Active") : pc.dim("Inactive")}`,
         ];
+        if (this._viewsDir) {
+            lines.push(`${pc.bold(pad("Views:"))}${this._viewsDir}`);
+        }
         if (this._enableSwagger) {
             lines.push(`${pc.bold(pad("Swagger:"))}http://localhost:${this._port}${this._swaggerPath}`);
         }
@@ -124,6 +201,40 @@ export class Server {
         }
         global.servers.delete(this._id);
     }
+    setUserHandler(handler) {
+        this._userHandler = handler;
+    }
+    setupAuthRoutes() {
+        if (!this._userHandler)
+            return;
+        this._app.post("/auth/signin", async (req, res, next) => {
+            try {
+                const result = await this._userHandler.signin(req, res);
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this._app.post("/auth/signup", async (req, res, next) => {
+            try {
+                const result = await this._userHandler.signup(req, res);
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this._app.post("/auth/logout", async (req, res, next) => {
+            try {
+                const result = await this._userHandler.logout(req, res);
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+    }
     async loadControllers() {
         const absoluteControllersPath = path.resolve(process.cwd(), this._controllersDir);
         if (!fs.existsSync(absoluteControllersPath)) {
@@ -151,28 +262,18 @@ export class Server {
             const instance = this._container?.get
                 ? this._container.get(controller.target)
                 : new controller.target();
-            // Check class level auth
-            const classAuthInfo = Reflect.getMetadata(AUTH_METADATA_KEY, controller.target);
             for (const route of controller.routes) {
                 const fullPath = (controller.path + "/" + route.path).replace(/\/+/g, "/");
                 const middlewares = [];
-                // Check method level metadata
-                const methodAuthInfo = Reflect.getMetadata(AUTH_METADATA_KEY, controller.target.prototype, route.handlerName);
+                // Check ROLES metadata
+                const classRoles = Reflect.getMetadata(ROLES_METADATA_KEY, controller.target);
+                const methodRoles = Reflect.getMetadata(ROLES_METADATA_KEY, controller.target.prototype, route.handlerName);
+                const requiredRoles = methodRoles || classRoles;
                 const isPublic = Reflect.getMetadata(PUBLIC_METADATA_KEY, controller.target.prototype, route.handlerName);
-                // Determine if auth is required and which secret to use
-                let authSecret;
-                if (isPublic) {
-                    authSecret = undefined;
-                }
-                else if (methodAuthInfo) {
-                    authSecret = methodAuthInfo.secret || process.env.JWT_SECRET;
-                }
-                else if (classAuthInfo) {
-                    authSecret = classAuthInfo.secret || process.env.JWT_SECRET;
-                }
-                // 1. Auth Middleware (New Decorator Logic)
-                if (authSecret) {
-                    middlewares.push(this.createJwtMiddleware(authSecret));
+                // 1. Auth & Role Middlewares
+                if (!isPublic) {
+                    // If not public, we always run the role check (which might include authentication via UserHandler)
+                    middlewares.push(this.createRoleMiddleware(requiredRoles || []));
                     // Inject Swagger security definition automatically
                     if (!route.swagger) {
                         route.swagger = {
@@ -192,7 +293,8 @@ export class Server {
                         route.swagger.security.push({ bearerAuth: [] });
                     }
                 }
-                // 2. Generic Security Middleware (@Security, @OAuth, etc)
+                // 1.1 Role Middlewares - now handled above for non-public routes
+                // 2. Generic Security Middleware (@Security, @ApiKey, etc)
                 const classGenericSecurity = Reflect.getMetadata(SECURITY_METADATA_KEY, controller.target) || [];
                 const methodGenericSecurity = Reflect.getMetadata(SECURITY_METADATA_KEY, controller.target.prototype, route.handlerName) || [];
                 let genericRequirements = [];
@@ -274,9 +376,17 @@ export class Server {
                     middlewares.push(...route.middlewares);
                 }
                 // 3. Route Handler
-                const handler = (req, res, next) => {
+                const handler = async (req, res, next) => {
                     try {
-                        const result = instance[route.handlerName](req, res, next);
+                        const user = this._userHandler
+                            ? await this._userHandler.authenticate(req, res)
+                            : req.user;
+                        const result = instance[route.handlerName]({
+                            req,
+                            res,
+                            user,
+                            next,
+                        });
                         const handleResult = (val) => {
                             if (val !== undefined && !res.headersSent) {
                                 if (typeof val === "string") {
@@ -300,25 +410,58 @@ export class Server {
                 };
                 this._app[route.method](fullPath, ...middlewares, handler);
                 this._routeCount++;
+                // Pre-build if @Serve is used
+                const htmlPath = Reflect.getMetadata(SERVE_HTML_METADATA_KEY, controller.target.prototype, route.handlerName);
+                if (htmlPath) {
+                    // Silent pre-build
+                    await ServeMemoryStore.instance.buildAndCache(htmlPath, tailwindOptions);
+                }
             }
         }
     }
-    createJwtMiddleware(secret) {
-        return (req, res, next) => {
-            const authHeader = req.headers.authorization;
-            if (!authHeader || !authHeader.startsWith("Bearer ")) {
-                return res
-                    .status(401)
-                    .json({ error: "Unauthorized: Missing Bearer token" });
+    createRoleMiddleware(roles) {
+        return async (req, res, next) => {
+            const user = this._userHandler
+                ? await this._userHandler.authenticate(req, res)
+                : req.user;
+            if (!user) {
+                return res.status(401).json({ error: "Unauthorized: No user found" });
+            }
+            // If no specific roles required, but it's not public, just authentication is enough
+            if (roles.length === 0) {
+                return next();
+            }
+            if (!this._roleHandler) {
+                // Default role check behavior
+                const userRoles = Array.isArray(user.roles)
+                    ? user.roles
+                    : user.role
+                        ? [user.role]
+                        : [];
+                const hasRole = roles.some((role) => userRoles.includes(role));
+                if (!hasRole) {
+                    return res.status(403).json({
+                        error: "Forbidden: You do not have the required permissions",
+                    });
+                }
+                return next();
             }
-            const token = authHeader.split(" ")[1];
             try {
-                const decoded = jwt.verify(token, secret);
-                req.user = decoded; // Attach user to request
-                next();
+                const result = await this._roleHandler(req, roles);
+                if (result) {
+                    // Assuming 'result' is a boolean indicating success
+                    next();
+                }
+                else {
+                    // The provided snippet seems to be for serving HTML, which is out of context for a role middleware.
+                    // Applying the original logic for role failure.
+                    res.status(403).json({
+                        error: "Forbidden: You do not have the required permissions",
+                    });
+                }
             }
             catch (err) {
-                return res.status(403).json({ error: "Forbidden: Invalid token" });
+                next(err);
             }
         };
     }

package/dist/Components/UserHandler.d.ts

@@ -0,0 +1,21 @@
+import { Request, Response } from "express";
+export declare abstract class UserHandler {
+    /**
+     * Optional: Logic to authenticate the request and return the user object.
+     * If this is not implemented, 'user' will be undefined in route parameters.
+     */
+    authenticate(req: Request, res: Response): Promise<any | null>;
+    /**
+     * Sign in logic. Usually returns a token or user info.
+     */
+    abstract signin(req: Request, res: Response): Promise<any> | any;
+    /**
+     * Sign up logic.
+     */
+    abstract signup(req: Request, res: Response): Promise<any> | any;
+    /**
+     * Logout logic.
+     */
+    abstract logout(req: Request, res: Response): Promise<any> | any;
+}
+//# sourceMappingURL=UserHandler.d.ts.map

package/dist/Components/UserHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserHandler.d.ts","sourceRoot":"","sources":["../../src/Components/UserHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAgB,MAAM,SAAS,CAAC;AAE1D,8BAAsB,WAAW;IAC/B;;;OAGG;IACU,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC;IAI3E;;OAEG;aACa,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG;IAEvE;;OAEG;aACa,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG;IAEvE;;OAEG;aACa,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG;CACxE"}

package/dist/Components/UserHandler.js

@@ -0,0 +1,9 @@
+export class UserHandler {
+    /**
+     * Optional: Logic to authenticate the request and return the user object.
+     * If this is not implemented, 'user' will be undefined in route parameters.
+     */
+    async authenticate(req, res) {
+        return req.user;
+    }
+}

package/dist/Decorations/Authorized.d.ts

@@ -1,8 +1,5 @@
-export declare const AUTH_METADATA_KEY = "auth:info";
 export declare const PUBLIC_METADATA_KEY = "auth:public";
-export interface AuthInfo {
-    secret?: string;
-}
-export declare function BearerAuth(secret?: string): MethodDecorator & ClassDecorator;
+export declare const ROLES_METADATA_KEY = "auth:roles";
+export declare function Authorized(roles?: string[]): MethodDecorator & ClassDecorator;
 export declare function Public(): MethodDecorator;
 //# sourceMappingURL=Authorized.d.ts.map

package/dist/Decorations/Authorized.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Authorized.d.ts","sourceRoot":"","sources":["../../src/Decorations/Authorized.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAC7C,eAAO,MAAM,mBAAmB,gBAAgB,CAAC;AAEjD,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,cAAc,CAmB5E;AAED,wBAAgB,MAAM,IAAI,eAAe,CAQxC"}
+{"version":3,"file":"Authorized.d.ts","sourceRoot":"","sources":["../../src/Decorations/Authorized.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,gBAAgB,CAAC;AACjD,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAE/C,wBAAgB,UAAU,CACxB,KAAK,GAAE,MAAM,EAAO,GACnB,eAAe,GAAG,cAAc,CAclC;AAED,wBAAgB,MAAM,IAAI,eAAe,CAQxC"}

package/dist/Decorations/Authorized.js

@@ -1,15 +1,15 @@
 // Key to store auth metadata
-export const AUTH_METADATA_KEY = "auth:info";
 export const PUBLIC_METADATA_KEY = "auth:public";
-export function BearerAuth(secret) {
+export const ROLES_METADATA_KEY = "auth:roles";
+export function Authorized(roles = []) {
     return function (target, propertyKey, descriptor) {
-        // If used on a method
         if (propertyKey) {
-            Reflect.defineMetadata(AUTH_METADATA_KEY, { secret }, target, propertyKey);
+            Reflect.defineMetadata(ROLES_METADATA_KEY, roles, target, propertyKey);
+            // Explicitly mark as not public to prevent bypass if @Public() is also used
+            Reflect.defineMetadata(PUBLIC_METADATA_KEY, false, target, propertyKey);
         }
         else {
-            // If used on a class
-            Reflect.defineMetadata(AUTH_METADATA_KEY, { secret }, target);
+            Reflect.defineMetadata(ROLES_METADATA_KEY, roles, target);
         }
     };
 }

package/dist/Decorations/Security.d.ts

@@ -4,6 +4,5 @@ export interface SecurityRequirement {
     [name: string]: string[];
 }
 export declare function Security(name: string, scopes?: string[]): MethodDecorator & ClassDecorator;
-export declare function OAuth(scopes?: string[]): MethodDecorator & ClassDecorator;
 export declare function ApiKey(name: string): MethodDecorator & ClassDecorator;
 //# sourceMappingURL=Security.d.ts.map

package/dist/Decorations/Security.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Security.d.ts","sourceRoot":"","sources":["../../src/Decorations/Security.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,eAAO,MAAM,qBAAqB,eAAqB,CAAC;AAExD,MAAM,WAAW,mBAAmB;IAClC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,MAAM,EAAO,GACpB,eAAe,GAAG,cAAc,CAyBlC;AAED,wBAAgB,KAAK,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,eAAe,GAAG,cAAc,CAE7E;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,cAAc,CAErE"}
+{"version":3,"file":"Security.d.ts","sourceRoot":"","sources":["../../src/Decorations/Security.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,eAAO,MAAM,qBAAqB,eAAqB,CAAC;AAExD,MAAM,WAAW,mBAAmB;IAClC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,MAAM,EAAO,GACpB,eAAe,GAAG,cAAc,CAyBlC;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,cAAc,CAErE"}

package/dist/Decorations/Security.js

@@ -16,9 +16,6 @@ export function Security(name, scopes = []) {
         }
     };
 }
-export function OAuth(scopes = []) {
-    return Security("oauth2", scopes);
-}
 export function ApiKey(name) {
     return Security(name, []);
 }

package/dist/Decorations/Serve.d.ts

@@ -1,2 +1,3 @@
+export declare const SERVE_HTML_METADATA_KEY = "serve:html";
 export declare function Serve(htmlPath: string): MethodDecorator;
 //# sourceMappingURL=Serve.d.ts.map

package/dist/Decorations/Serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Serve.d.ts","sourceRoot":"","sources":["../../src/Decorations/Serve.ts"],"names":[],"mappings":"AAIA,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CA2CvD"}
+{"version":3,"file":"Serve.d.ts","sourceRoot":"","sources":["../../src/Decorations/Serve.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB,eAAe,CAAC;AAEpD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAwEvD"}

package/dist/Decorations/Serve.js

@@ -1,12 +1,17 @@
 import { ServeMemoryStore } from "../Components/ServeMemoryStore";
 import { TAILWIND_METADATA_KEY } from "./Tailwind";
+export const SERVE_HTML_METADATA_KEY = "serve:html";
 export function Serve(htmlPath) {
     return function (target, propertyKey, descriptor) {
+        // Store the HTML path in metadata for pre-building
+        Reflect.defineMetadata(SERVE_HTML_METADATA_KEY, htmlPath, target, propertyKey);
         const originalMethod = descriptor.value;
-        descriptor.value = async function (req, res, next) {
+        descriptor.value = async function ({ req, res, user, next, }) {
             try {
                 // Execute the original method
-                const result = await originalMethod.apply(this, [req, res, next]);
+                const result = await originalMethod.apply(this, [
+                    { req, res, user, next },
+                ]);
                 // Check if response has been sent or if result is not undefined/void
                 if (res.headersSent || result !== undefined) {
                     return result;
@@ -16,14 +21,25 @@ export function Serve(htmlPath) {
                 // If no response, build and serve the HTML
                 const html = await ServeMemoryStore.instance.buildAndCache(htmlPath, tailwindOptions);
                 if (html) {
+                    const devMode = process.env.NODE_ENV === "development";
+                    if (devMode) {
+                        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+                        res.setHeader("Pragma", "no-cache");
+                        res.setHeader("Expires", "0");
+                    }
                     res.type("html").send(html);
                 }
-                else {
+                else if (next) {
                     next(); // No HTML found?
                 }
             }
             catch (error) {
-                next(error);
+                if (next) {
+                    next(error);
+                }
+                else {
+                    throw error;
+                }
             }
         };
         return descriptor;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import "./globals";
 export * from "./Components/Server";
 export * from "./Components/ServeMemoryStore";
+export * from "./Components/UserHandler";
 export * from "./Decorations";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,CAAC;AACnB,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,CAAC;AACnB,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -2,4 +2,5 @@ global.servers = new Map();
 import "./globals";
 export * from "./Components/Server";
 export * from "./Components/ServeMemoryStore";
+export * from "./Components/UserHandler";
 export * from "./Decorations";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synchjs/ewb",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "publishConfig": {
     "access": "public"
   },
@@ -26,26 +26,29 @@
     "example": "bun run --watch example/index.ts"
   },
   "dependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/express-serve-static-core": "^5.1.1",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/socket.io": "^3.0.2",
+    "@types/swagger-jsdoc": "^6.0.4",
+    "@types/swagger-ui-express": "^4.1.8",
     "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",
     "boxen": "^8.0.1",
     "bun-plugin-tailwind": "^0.1.2",
+    "cheerio": "^1.2.0",
     "cors": "^2.8.6",
     "express": "^5.2.1",
     "express-rate-limit": "^8.2.1",
     "helmet": "^8.1.0",
     "jsonwebtoken": "^9.0.3",
+    "openapi-types": "^12.1.3",
     "picocolors": "^1.1.1",
     "reflect-metadata": "^0.2.2",
+    "socket.io": "^4.8.3",
     "swagger-jsdoc": "^6.2.8",
     "swagger-ui-express": "^5.0.1",
-    "tailwindcss": "^4.1.18",
-    "openapi-types": "^12.1.3",
-    "@types/express": "^5.0.6",
-    "@types/cors": "^2.8.19",
-    "@types/jsonwebtoken": "^9.0.10",
-    "@types/swagger-jsdoc": "^6.0.4",
-    "@types/swagger-ui-express": "^4.1.8",
-    "@types/express-serve-static-core": "^5.1.1"
+    "tailwindcss": "^4.1.18"
   }
 }