skyguard-js 1.2.1 → 1.2.3

package/dist/routing/routerGroup.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterGroup = void 0;
 const buildFullPath_1 = require("./buildFullPath");
+const routeResolveFunc_1 = require("./routeResolveFunc");
 /**
  * Route group helper.
  *
@@ -64,24 +65,24 @@ class RouterGroup {
         if (totalMiddlewares.length > 0)
             layer.setMiddlewares(totalMiddlewares);
     }
-    /** Registers a GET route within the group. */
-    get(path, action, middlewares) {
+    get(path, handlerOrMiddleware, handler) {
+        const { action, middlewares } = (0, routeResolveFunc_1.normalizeRouteArgs)(handlerOrMiddleware, handler);
         this.addRoute("get", path, action, middlewares);
     }
-    /** Registers a POST route within the group. */
-    post(path, action, middlewares) {
+    post(path, handlerOrMiddleware, handler) {
+        const { action, middlewares } = (0, routeResolveFunc_1.normalizeRouteArgs)(handlerOrMiddleware, handler);
         this.addRoute("post", path, action, middlewares);
     }
-    /** Registers a PUT route within the group. */
-    put(path, action, middlewares) {
+    put(path, handlerOrMiddleware, handler) {
+        const { action, middlewares } = (0, routeResolveFunc_1.normalizeRouteArgs)(handlerOrMiddleware, handler);
         this.addRoute("put", path, action, middlewares);
     }
-    /** Registers a PATCH route within the group. */
-    patch(path, action, middlewares) {
+    patch(path, handlerOrMiddleware, handler) {
+        const { action, middlewares } = (0, routeResolveFunc_1.normalizeRouteArgs)(handlerOrMiddleware, handler);
         this.addRoute("patch", path, action, middlewares);
     }
-    /** Registers a DELETE route within the group. */
-    delete(path, action, middlewares) {
+    delete(path, handlerOrMiddleware, handler) {
+        const { action, middlewares } = (0, routeResolveFunc_1.normalizeRouteArgs)(handlerOrMiddleware, handler);
         this.addRoute("delete", path, action, middlewares);
     }
 }

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/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/storage/storage.d.ts

@@ -1,6 +1,6 @@
 import { type Storage, type StorageOptions } from "./types";
-import { Request } from "../http/request";
 import type { UploadedFile } from "../parsers/parserInterface";
+import { Context } from "../http/context";
 /**
  * Disk-based storage engine responsible for persisting uploaded files
  * to the local filesystem.
@@ -51,7 +51,7 @@ export declare class DiskStorage implements Storage {
      *
      * @throws UploadException if the file cannot be written to disk.
      */
-    handleFile(request: Request, file: Partial<UploadedFile>, fileData: Buffer): Promise<UploadedFile>;
+    handleFile(context: Context, file: Partial<UploadedFile>, fileData: Buffer): Promise<UploadedFile>;
     /**
      * Removes a previously stored file from disk.
      *
@@ -99,6 +99,6 @@ export declare class MemoryStorage implements Storage {
     private ttlMs;
     private computeChecksum;
     constructor(options?: StorageOptions);
-    handleFile(request: Request, file: Partial<UploadedFile>, fileData: Buffer): UploadedFile;
+    handleFile(context: Context, file: Partial<UploadedFile>, fileData: Buffer): UploadedFile;
     removeFile(file: UploadedFile): void;
 }

package/dist/storage/storage.js

@@ -60,10 +60,10 @@ class DiskStorage {
      *
      * @throws UploadException if the file cannot be written to disk.
      */
-    async handleFile(request, file, fileData) {
+    async handleFile(context, file, fileData) {
         try {
-            const destination = await this.resolveDestination(request, file);
-            const filename = await this.filenameGenerator(request, file);
+            const destination = await this.resolveDestination(context, file);
+            const filename = await this.filenameGenerator(context, file);
             const filePath = (0, node_path_1.join)(destination, filename);
             await (0, promises_1.mkdir)(destination, { recursive: true });
             await (0, promises_1.writeFile)(filePath, fileData);
@@ -102,9 +102,9 @@ class DiskStorage {
      * If a resolver function was provided, it will be executed.
      * Otherwise the static directory is returned.
      */
-    async resolveDestination(request, file) {
+    async resolveDestination(context, file) {
         if (typeof this.destination === "function") {
-            return await this.destination(request, file);
+            return await this.destination(context, file);
         }
         return this.destination;
     }
@@ -119,7 +119,7 @@ class DiskStorage {
      * Example:
      *  1700000000000-a3f9b1c2d4e5f678.png
      */
-    generateUniqueFilename(request, file) {
+    generateUniqueFilename(context, file) {
         const timestamp = Date.now();
         const randomString = (0, node_crypto_1.randomBytes)(8).toString("hex");
         const ext = (0, node_path_1.extname)(file.originalname || "");
@@ -151,7 +151,7 @@ class MemoryStorage {
         this.ttlMs = options.memory.ttlMs ?? 0;
         this.computeChecksum = options.memory.computeChecksum ?? false;
     }
-    handleFile(request, file, fileData) {
+    handleFile(context, file, fileData) {
         // Enforce per-file size if configured
         if (this.maxFileSize !== undefined && fileData.length > this.maxFileSize) {
             throw new uploadException_1.UploadException(`File too large. Max size: ${this.maxFileSize} bytes`, types_1.UploadErrorCode.LIMIT_FILE_SIZE, file.fieldName);

package/dist/storage/types.d.ts

@@ -1,5 +1,5 @@
 import type { UploadedFile } from "../parsers/parserInterface";
-import { Request } from "../http/request";
+import { Context } from "../http/context";
 /**
  * Available storage engine types.
  *
@@ -35,12 +35,12 @@ interface DiskStorageOptions {
      * Destination directory or resolver function.
      * If a function is provided, it receives the request and file metadata.
      */
-    destination?: string | ((req: Request, file: Partial<UploadedFile>) => string | Promise<string>);
+    destination?: string | ((ctx: Context, file: Partial<UploadedFile>) => string | Promise<string>);
     /**
      * Custom filename generator.
      * Receives the request and partial file metadata.
      */
-    filename?: (req: Request, file: Partial<UploadedFile>) => string | Promise<string>;
+    filename?: (ctx: Context, file: Partial<UploadedFile>) => string | Promise<string>;
 }
 interface MemoryStoreOptions {
     /** Maximum total bytes allowed to be stored in memory (default: 50MB) */
@@ -76,7 +76,7 @@ export interface Storage {
      * @param fileData Raw file buffer.
      * @returns Final uploaded file metadata.
      */
-    handleFile(request: Request, file: Partial<UploadedFile>, fileData: Buffer): Promise<UploadedFile> | UploadedFile;
+    handleFile(context: Context, file: Partial<UploadedFile>, fileData: Buffer): Promise<UploadedFile> | UploadedFile;
     /**
      * Removes a stored file.
      *
@@ -99,7 +99,7 @@ export type FileFilterCallback = (error: Error | null, acceptFile: boolean) => v
  *
  * The callback must be invoked to accept or reject the file.
  */
-export type FileFilter = (request: Request, file: Partial<UploadedFile>, callback: FileFilterCallback) => void | Promise<void>;
+export type FileFilter = (context: Context, file: Partial<UploadedFile>, callback: FileFilterCallback) => void | Promise<void>;
 /**
  * Global uploader configuration.
  */

package/dist/storage/uploader.d.ts

@@ -43,7 +43,7 @@ declare class Uploader {
      * - If the file field does not exist, it does not error; it only attaches text
      *   fields and continues.
      * - If present, the file is validated, filtered (optional), stored via the
-     *   configured {@link Storage}, and attached as `request.file`.
+     *   configured {@link Storage}, and attached as `ctx.req.files`.
      *
      * @param fieldName Multipart field name expected to contain a file.
      * @returns A framework {@link Middleware} to be used in the route pipeline.
@@ -59,11 +59,11 @@ declare class Uploader {
      *
      * Behavior:
      * - If no multipart payload is present, it passes through.
-     * - If no files exist for the given field, it sets `request.files = []`,
+     * - If no files exist for the given field, it sets `ctx.req.files = []`,
      *   attaches text fields, and continues.
      * - If the number of files exceeds `maxCount`, it throws.
      * - Each file is validated, filtered (optional), stored, and collected into
-     *   `request.files` as an array of {@link UploadedFile}.
+     *   `ctx.req.files` as an array of {@link UploadedFile}.
      *
      * @param fieldName Multipart field name expected to contain files.
      * @param maxCount Maximum number of files allowed for this field.
@@ -82,7 +82,7 @@ declare class Uploader {
      * Behavior:
      * - Rejects any file whose field name is not declared in `fields`.
      * - Enforces `maxCount` per declared field (defaults to 1).
-     * - Aggregates results as `request.files` in a map:
+     * - Aggregates results as `ctx.req.files` in a map:
      *   `{ [fieldName]: UploadedFile[] }`.
      *
      * @param fields List of allowed fields and their per-field maximum counts.
@@ -101,7 +101,7 @@ declare class Uploader {
      *
      * Behavior:
      * - Enforces the global total file limit: `limits.files`.
-     * - Stores all files and attaches them as `request.files` (array).
+     * - Stores all files and attaches them as `ctx.req.files` (array).
      *
      * @returns A framework {@link Middleware}.
      *
@@ -208,10 +208,10 @@ declare class Uploader {
       },
     });
 
-    // Asign middleware a route
-    app.post("/file", (request) => {
-      return json({ file: request.file });
-    }, [uploader.single()])
+    // Assign middleware to a route
+    app.post("/file", [uploader.single("file")], context => {
+      return context.json({ file: context.req.files });
+    })
  */
 export declare const createUploader: (config?: UploaderConfig) => Uploader;
 export {};