skyguard-js 1.2.2 → 1.2.4

package/README.md

@@ -6,7 +6,6 @@
 
 [![NPM Version](https://img.shields.io/npm/v/skyguard-js)](https://www.npmjs.com/package/skyguard-js)
 [![Deployment Pipeline](https://github.com/Pipe930/Skyguard-js/actions/workflows/pipeline.yml/badge.svg)](https://github.com/Pipe930/Skyguard-js/actions/workflows/pipeline.yml)
-[![Socket Badge](https://badge.socket.dev/npm/package/skyguard-js/1.1.8)](https://badge.socket.dev/npm/package/skyguard-js/1.1.8)
 
 **Skyguard.js** is a **lightweight, dependency-free web framework** built entirely with **TypeScript**.
 
@@ -41,6 +40,7 @@ Skyguard.js currently delivers a solid core that includes **routing**, **type-sa
 - File uploads (via middleware)
 - Static file serving
 - Session handling (via middleware)
+- Supported runtimes: [Bun](https://bun.com/) and [Deno](https://deno.com/)
 
 ---
 
@@ -84,20 +84,12 @@ app.run();
 
 ---
 
-## 🔮 Roadmap (Tentative)
+## 📚 Documentation
 
-- Middleware system (✅)
-- Template engines supported (✅)
-- Context abstraction (✅)
-- Data validation (✅)
-- Error handling improvements (✅)
-- Sessions & cookies (✅)
-- Passoword hashing & JWT tokens (✅)
-- File uploads (✅)
-- Database & ORM integration
-- Authentication & authorization
-- WebSockets
+Full documentation is available on the [Official Website](https://pipe930.github.io/skyguard-documentation/). A section with examples or use cases will follow.
 
-## License
+---
+
+## 📜 License
 
-MIT
+Licensed under the [MIT License](https://github.com/Pipe930/Skyguard-js/blob/main/LICENSE).

package/dist/app.js

@@ -8,10 +8,10 @@ const validationException_1 = require("./exceptions/validationException");
 const node_path_1 = require("node:path");
 const node_fs_1 = require("node:fs");
 const fileStaticHandler_1 = require("./static/fileStaticHandler");
-const node_http_1 = require("node:http");
 const httpExceptions_1 = require("./exceptions/httpExceptions");
 const engineTemplate_1 = require("./views/engineTemplate");
 const container_1 = require("./container/container");
+const createRuntimeServer_1 = require("./server/createRuntimeServer");
 /**
  * The `App` class acts as the **execution kernel** and **lifecycle orchestrator**
  * of the framework.
@@ -148,13 +148,17 @@ class App {
      *
      * @param port - TCP port to listen on
      */
-    run(port = 3000, callback, hostname = "localhost") {
-        (0, node_http_1.createServer)((req, res) => {
-            const adapter = new http_1.NodeHttpAdapter(req, res, this.loggerOptions);
-            void this.handle(adapter);
-        }).listen(port, hostname, () => {
-            if (callback)
-                callback();
+    run(port = 3000, callback, hostname) {
+        const runtimeServer = (0, createRuntimeServer_1.createRuntimeServer)(this.loggerOptions);
+        runtimeServer.listen(async (adapter) => {
+            await this.handle(adapter);
+        }, {
+            port,
+            hostname,
+            callback: () => {
+                if (callback)
+                    callback();
+            },
         });
     }
     /**
@@ -171,7 +175,7 @@ class App {
      * app.logger("common");
      * app.logger("combined", "./logs/http.log");
      */
-    logger(format = "dev", filePath) {
+    logger(format, filePath) {
         this.loggerOptions = {
             ...this.loggerOptions,
             format,

package/dist/http/index.d.ts

@@ -2,7 +2,8 @@ export { Response } from "./response";
 export { Request } from "./request";
 export { Context } from "./context";
 export { NodeHttpAdapter } from "./nodeNativeHttp";
+export { WebHttpAdapter } from "./webHttp";
 export { HttpMethods } from "./httpMethods";
-export { HttpAdapter } from "./httpAdapter";
+export type { HttpAdapter } from "./httpAdapter";
 export { Logger } from "./logger";
 export type { LogFormat, LoggerOptions } from "./logger";

package/dist/http/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.HttpMethods = exports.NodeHttpAdapter = exports.Context = exports.Request = exports.Response = void 0;
+exports.Logger = exports.HttpMethods = exports.WebHttpAdapter = exports.NodeHttpAdapter = exports.Context = exports.Request = exports.Response = void 0;
 var response_1 = require("./response");
 Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return response_1.Response; } });
 var request_1 = require("./request");
@@ -9,6 +9,8 @@ var context_1 = require("./context");
 Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });
 var nodeNativeHttp_1 = require("./nodeNativeHttp");
 Object.defineProperty(exports, "NodeHttpAdapter", { enumerable: true, get: function () { return nodeNativeHttp_1.NodeHttpAdapter; } });
+var webHttp_1 = require("./webHttp");
+Object.defineProperty(exports, "WebHttpAdapter", { enumerable: true, get: function () { return webHttp_1.WebHttpAdapter; } });
 var httpMethods_1 = require("./httpMethods");
 Object.defineProperty(exports, "HttpMethods", { enumerable: true, get: function () { return httpMethods_1.HttpMethods; } });
 var logger_1 = require("./logger");

package/dist/http/logger.d.ts

@@ -2,8 +2,12 @@ import { IncomingMessage, ServerResponse } from "node:http";
 export type LogFormat = "combined" | "common" | "dev" | "short" | "tiny";
 export type LoggerOptions = {
     format?: LogFormat;
-    stream?: NodeJS.WritableStream;
-    fileStream?: NodeJS.WritableStream;
+    stream?: {
+        write(chunk: string): unknown;
+    };
+    fileStream?: {
+        write(chunk: string): unknown;
+    };
 };
 /**
  * Minimal HTTP request logger.
@@ -45,7 +49,9 @@ export declare class Logger {
      * @param startTime - High-resolution timestamp captured at request start using `process.hrtime.bigint()`.
      */
     log(req: IncomingMessage, res: ServerResponse, startTime: bigint): void;
+    logWeb(req: globalThis.Request, res: globalThis.Response, startTimeMs: number): void;
     private buildLogLine;
+    private buildWebLogLine;
     /**
      * Applies ANSI color codes to an HTTP status code for terminal output.
      *
@@ -60,4 +66,5 @@ export declare class Logger {
      * @returns Colorized status code string suitable for terminal output.
      */
     private colorizeStatus;
+    private getDefaultStream;
 }

package/dist/http/logger.js

@@ -22,7 +22,7 @@ class Logger {
     fileStream;
     format;
     constructor(options = {}) {
-        this.stream = options.stream || process.stdout;
+        this.stream = options.stream || this.getDefaultStream();
         this.fileStream = options.fileStream;
         this.format = options.format || "dev";
     }
@@ -54,6 +54,15 @@ class Logger {
             this.fileStream.write(fileLine + "\n");
         }
     }
+    logWeb(req, res, startTimeMs) {
+        const responseTime = (performance.now() - startTimeMs).toFixed(3);
+        const consoleLine = this.buildWebLogLine(req, res, responseTime, true);
+        const fileLine = this.buildWebLogLine(req, res, responseTime, false);
+        this.stream.write(consoleLine + "\n");
+        if (this.fileStream) {
+            this.fileStream.write(fileLine + "\n");
+        }
+    }
     buildLogLine(req, res, responseTime, useColor) {
         const method = req.method || "-";
         const url = req.url || "-";
@@ -86,6 +95,32 @@ class Logger {
         }
         return `${method} ${url} ${statusCode} ${responseTime} ms - ${contentLength}`;
     }
+    buildWebLogLine(req, res, responseTime, useColor) {
+        const method = req.method || "-";
+        const url = new URL(req.url).pathname || "-";
+        const statusCode = useColor
+            ? this.colorizeStatus(res.status)
+            : String(res.status);
+        const contentLength = res.headers.get("content-length") || "-";
+        const remoteAddr = req.headers.get("x-forwarded-for") || "-";
+        const httpVersion = "1.1";
+        const referrer = req.headers.get("referer") || req.headers.get("referrer") || "-";
+        const userAgent = req.headers.get("user-agent") || "-";
+        const date = new Date().toUTCString();
+        if (this.format === "tiny") {
+            return `${method} ${url} ${statusCode} ${contentLength} - ${responseTime} ms`;
+        }
+        if (this.format === "short") {
+            return `${remoteAddr} ${method} ${url} ${statusCode} ${contentLength} - ${responseTime} ms`;
+        }
+        if (this.format === "common") {
+            return `${remoteAddr} - - [${date}] "${method} ${url} HTTP/${httpVersion}" ${statusCode} ${contentLength}`;
+        }
+        if (this.format === "combined") {
+            return `${remoteAddr} - - [${date}] "${method} ${url} HTTP/${httpVersion}" ${statusCode} ${contentLength} "${referrer}" "${userAgent}"`;
+        }
+        return `${method} ${url} ${statusCode} ${responseTime} ms - ${contentLength}`;
+    }
     /**
      * Applies ANSI color codes to an HTTP status code for terminal output.
      *
@@ -115,5 +150,18 @@ class Logger {
         }
         return statusStr;
     }
+    getDefaultStream() {
+        const maybeProcess = globalThis;
+        if (maybeProcess.process?.stdout?.write) {
+            return maybeProcess.process.stdout;
+        }
+        return {
+            write: (chunk) => {
+                // Use console fallback on runtimes without Node process/stdout.
+                // eslint-disable-next-line no-console
+                console.log(chunk.trimEnd());
+            },
+        };
+    }
 }
 exports.Logger = Logger;

package/dist/http/nodeNativeHttp.d.ts

@@ -42,4 +42,5 @@ export declare class NodeHttpAdapter implements HttpAdapter {
      * @param response - Framework response to be sent to the client
      */
     sendResponse(response: Response): void;
+    private getProtocol;
 }

package/dist/http/nodeNativeHttp.js

@@ -42,12 +42,13 @@ class NodeHttpAdapter {
      * @returns A fully constructed {@link Context} instance
      */
     async getContext() {
-        const url = new URL(this.req.url || "", `http://${this.req.headers.host}`);
+        const protocol = this.getProtocol();
+        const url = new URL(this.req.url ?? "/", `${protocol}://${this.req.headers.host}`);
         const request = new request_1.Request(url.pathname);
-        request.setMethod(this.req.method || httpMethods_1.HttpMethods.get);
+        request.setMethod(this.req.method ?? httpMethods_1.HttpMethods.get);
         request.setQuery(Object.fromEntries(url.searchParams.entries()));
         request.setHeaders(this.req.headers);
-        request.setRemoteAddress(this.req.socket?.remoteAddress);
+        request.setRemoteAddress(this.req.socket.remoteAddress);
         if (request.method === httpMethods_1.HttpMethods.post ||
             request.method === httpMethods_1.HttpMethods.put ||
             request.method === httpMethods_1.HttpMethods.patch) {
@@ -81,5 +82,15 @@ class NodeHttpAdapter {
         }
         this.res.end(response.content);
     }
+    getProtocol() {
+        const forwarded = this.req.headers["x-forwarded-proto"];
+        if (typeof forwarded === "string") {
+            return forwarded.split(",")[0].trim();
+        }
+        if (this.req.socket.encrypted) {
+            return "https";
+        }
+        return "http";
+    }
 }
 exports.NodeHttpAdapter = NodeHttpAdapter;

package/dist/http/response.js

@@ -71,7 +71,7 @@ class Response {
     /**
      * Sets a cookie in the `Set-Cookie` response header.
      */
-    setCookie(name, value, options = {}) {
+    setCookie(name, value, options) {
         const cookie = (0, cookies_1.serializeCookie)(name, value, options);
         const current = this._headers["Set-Cookie"];
         if (!current) {
@@ -88,7 +88,7 @@ class Response {
     /**
      * Clears a cookie by setting an empty value and immediate expiration.
      */
-    removeCookie(name, options = {}) {
+    removeCookie(name, options) {
         return this.setCookie(name, "", {
             ...options,
             maxAge: 0,

package/dist/http/webHttp.d.ts

@@ -0,0 +1,19 @@
+import type { HttpAdapter } from "./httpAdapter";
+import { Response } from "./response";
+import { Context } from "./context";
+import { type LoggerOptions } from "./logger";
+type WebRequest = globalThis.Request;
+type WebResponse = globalThis.Response;
+export declare class WebHttpAdapter implements HttpAdapter {
+    private readonly req;
+    private contentParser;
+    private logger;
+    private startTimeMs;
+    private runtimeResponse;
+    constructor(req: WebRequest, loggerOptions?: LoggerOptions);
+    getContext(): Promise<Context>;
+    sendResponse(response: Response): void;
+    toWebResponse(): WebResponse;
+    private buildHeaders;
+}
+export {};

package/dist/http/webHttp.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebHttpAdapter = void 0;
+const httpMethods_1 = require("./httpMethods");
+const request_1 = require("./request");
+const context_1 = require("./context");
+const contentParserManager_1 = require("../parsers/contentParserManager");
+const httpExceptions_1 = require("../exceptions/httpExceptions");
+const node_stream_1 = require("node:stream");
+const logger_1 = require("./logger");
+class WebHttpAdapter {
+    req;
+    contentParser;
+    logger;
+    startTimeMs;
+    runtimeResponse = null;
+    constructor(req, loggerOptions = {}) {
+        this.req = req;
+        this.contentParser = new contentParserManager_1.ContentParserManager();
+        this.logger = new logger_1.Logger(loggerOptions);
+        this.startTimeMs = performance.now();
+    }
+    async getContext() {
+        const url = new URL(this.req.url);
+        const request = new request_1.Request(url.pathname);
+        request.setMethod((this.req.method || "GET").toUpperCase() ||
+            httpMethods_1.HttpMethods.get);
+        request.setQuery(Object.fromEntries(url.searchParams.entries()));
+        request.setHeaders(this.buildHeaders());
+        if (request.method === httpMethods_1.HttpMethods.post ||
+            request.method === httpMethods_1.HttpMethods.put ||
+            request.method === httpMethods_1.HttpMethods.patch) {
+            const parsedData = await this.contentParser.parse(this.req);
+            request.setBody(parsedData);
+        }
+        return new context_1.Context(request);
+    }
+    sendResponse(response) {
+        response.prepare();
+        const headers = new Headers();
+        for (const [header, value] of Object.entries(response.headers)) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    headers.append(header, entry);
+                }
+                continue;
+            }
+            if (typeof value !== "undefined") {
+                headers.set(header, String(value));
+            }
+        }
+        if (!response.content) {
+            headers.delete("content-type");
+            this.runtimeResponse = new globalThis.Response(null, {
+                status: response.statusCode,
+                headers,
+            });
+            this.logger.logWeb(this.req, this.runtimeResponse, this.startTimeMs);
+            return;
+        }
+        if (response.content instanceof node_stream_1.Readable) {
+            throw new httpExceptions_1.NotImplementedError("Node.js Readable stream responses are not supported in this runtime");
+        }
+        const body = typeof response.content === "string"
+            ? response.content
+            : new Uint8Array(response.content);
+        this.runtimeResponse = new globalThis.Response(body, {
+            status: response.statusCode,
+            headers,
+        });
+        this.logger.logWeb(this.req, this.runtimeResponse, this.startTimeMs);
+    }
+    toWebResponse() {
+        return (this.runtimeResponse ||
+            new globalThis.Response("No response generated", {
+                status: 500,
+            }));
+    }
+    buildHeaders() {
+        const headers = Object.create(null);
+        for (const [key, value] of this.req.headers.entries()) {
+            if (typeof headers[key] === "undefined") {
+                headers[key] = value;
+                continue;
+            }
+            if (Array.isArray(headers[key])) {
+                headers[key] = [...headers[key], value];
+                continue;
+            }
+            headers[key] = [headers[key], value];
+        }
+        return headers;
+    }
+}
+exports.WebHttpAdapter = WebHttpAdapter;

package/dist/parsers/contentParserManager.d.ts

@@ -26,14 +26,16 @@ export declare class ContentParserManager {
      * @param req - Native incoming HTTP request
      * @returns Parsed body content or raw body
      */
-    parse(req: IncomingMessage): Promise<unknown>;
+    parse(req: IncomingMessage | globalThis.Request): Promise<unknown>;
     /**
      * Reads the raw request body.
      *
      * @param req - Native incoming HTTP request
      * @returns A promise that resolves to the full body buffer
      */
-    private readBody;
+    private readNodeBody;
+    private readWebBody;
+    private isWebRequest;
     /**
      * Finds a parser capable of handling the given content type.
      *

package/dist/parsers/contentParserManager.js

@@ -43,10 +43,15 @@ class ContentParserManager {
      * @returns Parsed body content or raw body
      */
     async parse(req) {
-        const body = await this.readBody(req);
+        const isWebRequest = this.isWebRequest(req);
+        const body = isWebRequest
+            ? await this.readWebBody(req)
+            : await this.readNodeBody(req);
         if (body.length <= 0)
             return {};
-        const contentType = req.headers["content-type"] || "text/plain";
+        const contentType = isWebRequest
+            ? req.headers.get("content-type") || "text/plain"
+            : req.headers["content-type"] || "text/plain";
         const parser = this.findParser(contentType);
         if (!parser)
             return Buffer.isBuffer(body) ? body : Buffer.from(body);
@@ -58,7 +63,7 @@ class ContentParserManager {
      * @param req - Native incoming HTTP request
      * @returns A promise that resolves to the full body buffer
      */
-    readBody(req) {
+    readNodeBody(req) {
         return new Promise((resolve, reject) => {
             const chunks = [];
             req.on("data", (chunk) => {
@@ -72,6 +77,20 @@ class ContentParserManager {
             });
         });
     }
+    async readWebBody(req) {
+        try {
+            const arrayBuffer = await req.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        catch {
+            throw new httpExceptions_1.UnprocessableContentError("Failed to read request body");
+        }
+    }
+    isWebRequest(req) {
+        const candidate = req;
+        return (typeof candidate.arrayBuffer === "function" &&
+            typeof candidate.headers?.get === "function");
+    }
     /**
      * Finds a parser capable of handling the given content type.
      *

package/dist/server/bunRuntimeServer.d.ts

@@ -0,0 +1,7 @@
+import type { LoggerOptions } from "../http/logger";
+import type { AdapterHandler, RuntimeListenOptions, RuntimeServer } from "./types";
+export declare class BunRuntimeServer implements RuntimeServer {
+    private readonly loggerOptions;
+    constructor(loggerOptions?: LoggerOptions);
+    listen(handler: AdapterHandler, options: RuntimeListenOptions): void;
+}

package/dist/server/bunRuntimeServer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunRuntimeServer = void 0;
+const webHttp_1 = require("../http/webHttp");
+class BunRuntimeServer {
+    loggerOptions;
+    constructor(loggerOptions = {}) {
+        this.loggerOptions = loggerOptions;
+    }
+    listen(handler, options) {
+        const bun = globalThis.Bun;
+        if (!bun) {
+            throw new Error("Bun runtime not detected");
+        }
+        bun.serve({
+            hostname: options.hostname,
+            port: options.port,
+            fetch: async (request) => {
+                const adapter = new webHttp_1.WebHttpAdapter(request, this.loggerOptions);
+                await handler(adapter);
+                return adapter.toWebResponse();
+            },
+        });
+        if (options.callback)
+            options.callback();
+    }
+}
+exports.BunRuntimeServer = BunRuntimeServer;

package/dist/server/createRuntimeServer.d.ts

@@ -0,0 +1,4 @@
+import type { LoggerOptions } from "../http/logger";
+import type { RuntimeKind, RuntimeServer } from "./types";
+export declare const createRuntimeServer: (loggerOptions?: LoggerOptions, runtime?: RuntimeKind) => RuntimeServer;
+export declare const createRuntimeServerByKind: (runtime: RuntimeKind, loggerOptions?: LoggerOptions) => RuntimeServer;

package/dist/server/createRuntimeServer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeServerByKind = exports.createRuntimeServer = void 0;
+const bunRuntimeServer_1 = require("./bunRuntimeServer");
+const denoRuntimeServer_1 = require("./denoRuntimeServer");
+const nodeRuntimeServer_1 = require("./nodeRuntimeServer");
+const runtimeDetector_1 = require("./runtimeDetector");
+const createRuntimeServer = (loggerOptions = {}, runtime = (0, runtimeDetector_1.detectRuntime)()) => {
+    switch (runtime) {
+        case "bun":
+            return new bunRuntimeServer_1.BunRuntimeServer(loggerOptions);
+        case "deno":
+            return new denoRuntimeServer_1.DenoRuntimeServer(loggerOptions);
+        case "node":
+        default:
+            return new nodeRuntimeServer_1.NodeRuntimeServer(loggerOptions);
+    }
+};
+exports.createRuntimeServer = createRuntimeServer;
+const createRuntimeServerByKind = (runtime, loggerOptions = {}) => {
+    return (0, exports.createRuntimeServer)(loggerOptions, runtime);
+};
+exports.createRuntimeServerByKind = createRuntimeServerByKind;

package/dist/server/denoRuntimeServer.d.ts

@@ -0,0 +1,7 @@
+import type { LoggerOptions } from "../http/logger";
+import type { AdapterHandler, RuntimeListenOptions, RuntimeServer } from "./types";
+export declare class DenoRuntimeServer implements RuntimeServer {
+    private readonly loggerOptions;
+    constructor(loggerOptions?: LoggerOptions);
+    listen(handler: AdapterHandler, options: RuntimeListenOptions): void;
+}

package/dist/server/denoRuntimeServer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DenoRuntimeServer = void 0;
+const webHttp_1 = require("../http/webHttp");
+class DenoRuntimeServer {
+    loggerOptions;
+    constructor(loggerOptions = {}) {
+        this.loggerOptions = loggerOptions;
+    }
+    listen(handler, options) {
+        const deno = globalThis.Deno;
+        if (!deno) {
+            throw new Error("Deno runtime not detected");
+        }
+        deno.serve({
+            hostname: options.hostname,
+            port: options.port,
+        }, async (request) => {
+            const adapter = new webHttp_1.WebHttpAdapter(request, this.loggerOptions);
+            await handler(adapter);
+            return adapter.toWebResponse();
+        });
+        if (options.callback)
+            options.callback();
+    }
+}
+exports.DenoRuntimeServer = DenoRuntimeServer;

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+export { createRuntimeServer, createRuntimeServerByKind, } from "./createRuntimeServer";
+export { detectRuntime, isBunRuntime, isDenoRuntime } from "./runtimeDetector";
+export { NodeRuntimeServer } from "./nodeRuntimeServer";
+export { BunRuntimeServer } from "./bunRuntimeServer";
+export { DenoRuntimeServer } from "./denoRuntimeServer";
+export type { AdapterHandler, RuntimeKind, RuntimeListenOptions, RuntimeServer, } from "./types";
+export { getModulePathInfo, resolveFromModuleUrl, type ModulePathInfo, } from "./modulePath";

package/dist/server/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFromModuleUrl = exports.getModulePathInfo = exports.DenoRuntimeServer = exports.BunRuntimeServer = exports.NodeRuntimeServer = exports.isDenoRuntime = exports.isBunRuntime = exports.detectRuntime = exports.createRuntimeServerByKind = exports.createRuntimeServer = void 0;
+var createRuntimeServer_1 = require("./createRuntimeServer");
+Object.defineProperty(exports, "createRuntimeServer", { enumerable: true, get: function () { return createRuntimeServer_1.createRuntimeServer; } });
+Object.defineProperty(exports, "createRuntimeServerByKind", { enumerable: true, get: function () { return createRuntimeServer_1.createRuntimeServerByKind; } });
+var runtimeDetector_1 = require("./runtimeDetector");
+Object.defineProperty(exports, "detectRuntime", { enumerable: true, get: function () { return runtimeDetector_1.detectRuntime; } });
+Object.defineProperty(exports, "isBunRuntime", { enumerable: true, get: function () { return runtimeDetector_1.isBunRuntime; } });
+Object.defineProperty(exports, "isDenoRuntime", { enumerable: true, get: function () { return runtimeDetector_1.isDenoRuntime; } });
+var nodeRuntimeServer_1 = require("./nodeRuntimeServer");
+Object.defineProperty(exports, "NodeRuntimeServer", { enumerable: true, get: function () { return nodeRuntimeServer_1.NodeRuntimeServer; } });
+var bunRuntimeServer_1 = require("./bunRuntimeServer");
+Object.defineProperty(exports, "BunRuntimeServer", { enumerable: true, get: function () { return bunRuntimeServer_1.BunRuntimeServer; } });
+var denoRuntimeServer_1 = require("./denoRuntimeServer");
+Object.defineProperty(exports, "DenoRuntimeServer", { enumerable: true, get: function () { return denoRuntimeServer_1.DenoRuntimeServer; } });
+var modulePath_1 = require("./modulePath");
+Object.defineProperty(exports, "getModulePathInfo", { enumerable: true, get: function () { return modulePath_1.getModulePathInfo; } });
+Object.defineProperty(exports, "resolveFromModuleUrl", { enumerable: true, get: function () { return modulePath_1.resolveFromModuleUrl; } });

package/dist/server/modulePath.d.ts

@@ -0,0 +1,6 @@
+export type ModulePathInfo = {
+    filename: string;
+    dirname: string;
+};
+export declare const getModulePathInfo: (metaUrl: string) => ModulePathInfo;
+export declare const resolveFromModuleUrl: (metaUrl: string, ...segments: string[]) => string;

package/dist/server/modulePath.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFromModuleUrl = exports.getModulePathInfo = void 0;
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const getModulePathInfo = (metaUrl) => {
+    const filename = (0, node_url_1.fileURLToPath)(metaUrl);
+    return {
+        filename,
+        dirname: (0, node_path_1.dirname)(filename),
+    };
+};
+exports.getModulePathInfo = getModulePathInfo;
+const resolveFromModuleUrl = (metaUrl, ...segments) => {
+    const { dirname: moduleDirname } = (0, exports.getModulePathInfo)(metaUrl);
+    return (0, node_path_1.join)(moduleDirname, ...segments);
+};
+exports.resolveFromModuleUrl = resolveFromModuleUrl;

package/dist/server/nodeRuntimeServer.d.ts

@@ -0,0 +1,7 @@
+import type { LoggerOptions } from "../http/logger";
+import type { RuntimeListenOptions, RuntimeServer, AdapterHandler } from "./types";
+export declare class NodeRuntimeServer implements RuntimeServer {
+    private readonly loggerOptions;
+    constructor(loggerOptions?: LoggerOptions);
+    listen(handler: AdapterHandler, options: RuntimeListenOptions): void;
+}

package/dist/server/nodeRuntimeServer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeRuntimeServer = void 0;
+const node_http_1 = require("node:http");
+const nodeNativeHttp_1 = require("../http/nodeNativeHttp");
+class NodeRuntimeServer {
+    loggerOptions;
+    constructor(loggerOptions = {}) {
+        this.loggerOptions = loggerOptions;
+    }
+    listen(handler, options) {
+        (0, node_http_1.createServer)((req, res) => {
+            const adapter = new nodeNativeHttp_1.NodeHttpAdapter(req, res, this.loggerOptions);
+            void handler(adapter);
+        }).listen(options.port, options.hostname, () => {
+            if (options.callback)
+                options.callback();
+        });
+    }
+}
+exports.NodeRuntimeServer = NodeRuntimeServer;

package/dist/server/runtimeDetector.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeKind } from "./types";
+export declare const isBunRuntime: () => boolean;
+export declare const isDenoRuntime: () => boolean;
+export declare const detectRuntime: () => RuntimeKind;

package/dist/server/runtimeDetector.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRuntime = exports.isDenoRuntime = exports.isBunRuntime = void 0;
+const isBunRuntime = () => typeof globalThis.Bun !== "undefined";
+exports.isBunRuntime = isBunRuntime;
+const isDenoRuntime = () => typeof globalThis.Deno !== "undefined";
+exports.isDenoRuntime = isDenoRuntime;
+const detectRuntime = () => {
+    if ((0, exports.isBunRuntime)())
+        return "bun";
+    if ((0, exports.isDenoRuntime)())
+        return "deno";
+    return "node";
+};
+exports.detectRuntime = detectRuntime;

package/dist/server/types.d.ts

@@ -0,0 +1,11 @@
+import type { HttpAdapter } from "../http/httpAdapter";
+export type RuntimeKind = "node" | "bun" | "deno";
+export interface RuntimeListenOptions {
+    port: number;
+    hostname?: string;
+    callback?: VoidFunction;
+}
+export type AdapterHandler = (adapter: HttpAdapter) => Promise<void>;
+export interface RuntimeServer {
+    listen(handler: AdapterHandler, options: RuntimeListenOptions): void;
+}

package/dist/server/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sessions/cookies.js

@@ -57,17 +57,17 @@ function parseCookies(cookieHeader) {
  *
  * @returns A properly formatted `Set-Cookie` header string.
  */
-function serializeCookie(name, value, options = {}) {
+function serializeCookie(name, value, options) {
     const parts = [`${name}=${encodeURIComponent(value)}`];
-    if (typeof options.maxAge === "number")
+    if (typeof options?.maxAge === "number")
         parts.push(`Max-Age=${options.maxAge}`);
-    if (options.path)
+    if (options?.path)
         parts.push(`Path=${options.path}`);
-    if (options.sameSite)
+    if (options?.sameSite)
         parts.push(`SameSite=${options.sameSite}`);
-    if (options.httpOnly)
+    if (options?.httpOnly)
         parts.push("HttpOnly");
-    if (options.secure)
+    if (options?.secure)
         parts.push("Secure");
     return parts.join("; ");
 }

package/dist/sessions/index.d.ts

@@ -1,6 +1,6 @@
 export { MemorySessionStorage } from "./memorySessionStorage";
 export { FileSessionStorage } from "./fileSessionStorage";
-export { DatabaseSessionStorage, SessionDatabaseAdapter, } from "./databaseSessionStorage";
+export { DatabaseSessionStorage, type SessionDatabaseAdapter, } from "./databaseSessionStorage";
 export { Session } from "./session";
-export { SessionStorage } from "./sessionStorage";
+export type { SessionStorage } from "./sessionStorage";
 export { parseCookies, serializeCookie } from "./cookies";

package/dist/validators/index.d.ts

@@ -1,4 +1,4 @@
-export { ValidationRule } from "./validationRule";
+export type { ValidationRule } from "./validationRule";
 export { Validator } from "./validator";
 export * from "./rules";
-export { RuleOptions, ValidationContext, ValidationError, ValidationResult, FieldDefinition, } from "./types";
+export type { RuleOptions, ValidationContext, ValidationError, ValidationResult, FieldDefinition, } from "./types";

package/dist/validators/rules/index.d.ts

@@ -1,9 +1,9 @@
 export { BooleanRule } from "./booleanRule";
-export { DateRule, DateRuleOptions } from "./dateRule";
-export { NumberRule, NumberRuleOptions } from "./numberRule";
-export { StringRule, StringRuleOptions } from "./stringRule";
-export { ArrayRule, ArrayRuleOptions } from "./arrayRule";
+export { DateRule, type DateRuleOptions } from "./dateRule";
+export { NumberRule, type NumberRuleOptions } from "./numberRule";
+export { StringRule, type StringRuleOptions } from "./stringRule";
+export { ArrayRule, type ArrayRuleOptions } from "./arrayRule";
 export { LiteralRule } from "./literalRule";
 export { ObjectRule } from "./objectRule";
 export { UnionRule } from "./unionRule";
-export { BigIntRule, BigIntRuleOptions } from "./bigIntRule";
+export { BigIntRule, type BigIntRuleOptions } from "./bigIntRule";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skyguard-js",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "A lightweight, dependency-free TypeScript backend framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -57,18 +57,17 @@
   "license": "MIT",
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@jest/globals": "30.2.0",
+    "@jest/globals": "30.3.0",
     "@types/jest": "30.0.0",
-    "@types/node": "25.3.0",
-    "eslint": "10.0.2",
+    "@types/node": "25.6.0",
+    "eslint": "10.2.0",
     "eslint-config-prettier": "10.1.8",
-    "globals": "17.3.0",
-    "jest": "30.2.0",
+    "globals": "17.5.0",
+    "jest": "30.3.0",
     "nodemon": "3.1.14",
-    "prettier": "3.8.1",
-    "ts-jest": "29.4.6",
+    "ts-jest": "29.4.9",
     "ts-node": "10.9.2",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.56.1"
+    "typescript": "6.0.2",
+    "typescript-eslint": "8.58.2"
   }
 }