skyguard-js 1.1.4 → 1.1.5

package/README.md

@@ -168,11 +168,12 @@ app.staticFiles(join(__dirname, "..", "static"));
 
 ## ⛔ Data Validation
 
-To validate data in the body of client requests, the framework provides the creation of validation schemas, which are created as follows:
+To validate the data in the body of client requests, the framework provides the creation of validation schemes and a middleware function to validate the body of HTTP requests, used as follows:
 
 ```ts
-import { v, schema } from "skyguard-js";
+import { v, schema, validateData } from "skyguard-js";
 
+// Created Schema
 const userSchema = schema({
   name: v.string({ maxLength: 60 }),
   email: v.email(),
@@ -181,17 +182,26 @@ const userSchema = schema({
   birthdate: v.date({ max: new Date() }),
 });
 
-app.post("/users", (request: Request) => {
-  const validatedData = request.validateData(userSchema);
+// Typing Interface
+interface User {
+  name: string;
+  email: string;
+  age: number;
+  active: boolean;
+  birthdate: Date;
+}
 
-  return Response.json({
-    success: true,
-    data: validatedData,
-  });
-});
+app.post(
+  "/test",
+  (request: Request) => {
+    const data = request.getData<User>();
+    return json(data).setStatusCode(201);
+  },
+  [validateData(userSchema)],
+);
 ```
 
-By default each property you define in the schema is required, to define it optional you use the `.optional()` or `.default(value)` function
+To type the request body, an interface is used and the .getData() method is used, which allows returning the typed bodym. By default each property you define in the schema is required, to define it optional you use the `.optional()` or `.default(value)` function
 
 Validation is:
 

package/dist/app.d.ts

@@ -24,10 +24,6 @@ export declare class App {
     private router;
     /** Static file handler (optional) */
     private staticFileHandler;
-    /** Logger instance for request logging */
-    private logger;
-    /** Timestamp marking the start of request processing (for logging) */
-    private startTime;
     /** View engine for rendering templates (optional) */
     private viewEngine;
     /**

package/dist/app.js

@@ -33,10 +33,6 @@ class App {
     router;
     /** Static file handler (optional) */
     staticFileHandler = null;
-    /** Logger instance for request logging */
-    logger;
-    /** Timestamp marking the start of request processing (for logging) */
-    startTime;
     /** View engine for rendering templates (optional) */
     viewEngine;
     /**
@@ -51,7 +47,6 @@ class App {
     static bootstrap() {
         const app = container_1.Container.singleton(App);
         app.router = container_1.Container.singleton(routing_1.Router);
-        app.logger = container_1.Container.singleton(http_1.Logger);
         app.viewEngine = container_1.Container.singleton(engineTemplate_1.ViewEngine);
         return app;
     }
@@ -149,10 +144,8 @@ class App {
      */
     run(port, callback, hostname = "127.0.0.1") {
         (0, node_http_1.createServer)((req, res) => {
-            this.startTime = process.hrtime.bigint();
             const adapter = new http_1.NodeHttpAdapter(req, res);
             void this.handle(adapter);
-            this.logger.log(req, res, this.startTime);
         }).listen(port, hostname, () => {
             callback();
         });

package/dist/http/nodeNativeHttp.d.ts

@@ -14,6 +14,10 @@ export declare class NodeHttpAdapter implements HttpAdapter {
     private readonly req;
     private readonly res;
     private contentParser;
+    /** Logger instance for request logging */
+    private logger;
+    /** Timestamp marking the start of request processing (for logging) */
+    private startTime;
     /**
      * @param req - Native Node.js incoming request
      * @param res - Native Node.js server response

package/dist/http/nodeNativeHttp.js

@@ -4,6 +4,7 @@ exports.NodeHttpAdapter = void 0;
 const httpMethods_1 = require("./httpMethods");
 const request_1 = require("./request");
 const contentParserManager_1 = require("../parsers/contentParserManager");
+const logger_1 = require("./logger");
 /**
  * Node.js HTTP adapter.
  *
@@ -16,6 +17,10 @@ class NodeHttpAdapter {
     req;
     res;
     contentParser;
+    /** Logger instance for request logging */
+    logger;
+    /** Timestamp marking the start of request processing (for logging) */
+    startTime;
     /**
      * @param req - Native Node.js incoming request
      * @param res - Native Node.js server response
@@ -23,6 +28,8 @@ class NodeHttpAdapter {
     constructor(req, res) {
         this.req = req;
         this.res = res;
+        this.startTime = process.hrtime.bigint();
+        this.logger = new logger_1.Logger();
         this.contentParser = new contentParserManager_1.ContentParserManager();
     }
     /**
@@ -33,10 +40,10 @@ class NodeHttpAdapter {
      */
     async getRequest() {
         const url = new URL(this.req.url || "", `http://${this.req.headers.host}`);
-        const request = new request_1.Request(url.pathname)
-            .setMethod(this.req.method || httpMethods_1.HttpMethods.get)
-            .setQuery(Object.fromEntries(url.searchParams.entries()))
-            .setHeaders(this.req.headers);
+        const request = new request_1.Request(url.pathname);
+        request.setMethod(this.req.method || httpMethods_1.HttpMethods.get);
+        request.setQuery(Object.fromEntries(url.searchParams.entries()));
+        request.setHeaders(this.req.headers);
         if (request.method === httpMethods_1.HttpMethods.post ||
             request.method === httpMethods_1.HttpMethods.put ||
             request.method === httpMethods_1.HttpMethods.patch) {
@@ -63,6 +70,7 @@ class NodeHttpAdapter {
         }
         if (!response.content)
             this.res.removeHeader("Content-Type");
+        this.logger.log(this.req, this.res, this.startTime);
         this.res.end(response.content);
     }
 }

package/dist/http/request.d.ts

@@ -1,6 +1,5 @@
 import { HttpMethods } from "./httpMethods";
 import type { Headers } from "../types";
-import { type FieldDefinition } from "../validators";
 import { Session } from "../sessions";
 import type { UploadedFile } from "../parsers/parserInterface";
 /**
@@ -36,43 +35,30 @@ export declare class Request {
      * This object can be freely used by middlewares and route handlers to store
      * arbitrary data during the request lifecycle.
      */
-    state: Record<string, any>;
-    /** Single uploaded file metadata. */
-    file?: UploadedFile;
+    state: Record<string, unknown>;
     /** Multiple uploaded files metadata. */
-    files?: UploadedFile[] | Record<string, UploadedFile[]>;
+    files?: UploadedFile | UploadedFile[] | Record<string, UploadedFile[]>;
     constructor(url: string);
     get url(): string;
     get method(): HttpMethods;
-    setMethod(method: HttpMethods): this;
+    setMethod(method: HttpMethods): void;
     get headers(): Headers;
-    setHeaders(headers: Headers): this;
+    setHeaders(headers: Headers): void;
     get query(): Record<string, string>;
-    setQuery(query: Record<string, string>): this;
+    setQuery(query: Record<string, string>): void;
     get params(): Record<string, string>;
-    setParams(params: Record<string, string>): this;
-    get data(): Record<string, unknown>;
-    setData(data: Record<string, any>): this;
+    setParams(params: Record<string, string>): void;
+    get data(): Record<string, any>;
+    setData(data: Record<string, any>): void;
+    getData<T>(): Partial<T>;
     get session(): Session;
     setSession(session: Session): void;
     /**
      * Returns all request cookies as a key-value object.
      */
     get cookies(): Record<string, string>;
-    /**
-     * Returns a cookie value by name.
-     */
-    getCookie(name: string): string | undefined;
     /**
      * Checks whether a cookie exists.
      */
     hasCookie(name: string): boolean;
-    /**
-     * Validates the request payload against a validation schema.
-     *
-     * Throws if validation fails.
-     *
-     * @param schema - Validation rules mapped by field name
-     */
-    validateData(schema: Map<string, FieldDefinition>): unknown;
 }

package/dist/http/request.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Request = void 0;
-const validators_1 = require("../validators");
 const cookies_1 = require("../sessions/cookies");
 /**
  * Represents an incoming client request within the framework.
@@ -37,8 +36,6 @@ class Request {
      * arbitrary data during the request lifecycle.
      */
     state = {};
-    /** Single uploaded file metadata. */
-    file;
     /** Multiple uploaded files metadata. */
     files;
     constructor(url) {
@@ -52,35 +49,33 @@ class Request {
     }
     setMethod(method) {
         this._method = method;
-        return this;
     }
     get headers() {
         return this._headers;
     }
     setHeaders(headers) {
         this._headers = headers;
-        return this;
     }
     get query() {
         return this._query;
     }
     setQuery(query) {
         this._query = query;
-        return this;
     }
     get params() {
         return this._params;
     }
     setParams(params) {
         this._params = params;
-        return this;
     }
     get data() {
         return this._data;
     }
     setData(data) {
         this._data = data;
-        return this;
+    }
+    getData() {
+        return this._data;
     }
     get session() {
         return this._session;
@@ -94,27 +89,11 @@ class Request {
     get cookies() {
         return (0, cookies_1.parseCookies)(this._headers?.cookie);
     }
-    /**
-     * Returns a cookie value by name.
-     */
-    getCookie(name) {
-        return this.cookies[name];
-    }
     /**
      * Checks whether a cookie exists.
      */
     hasCookie(name) {
         return name in this.cookies;
     }
-    /**
-     * Validates the request payload against a validation schema.
-     *
-     * Throws if validation fails.
-     *
-     * @param schema - Validation rules mapped by field name
-     */
-    validateData(schema) {
-        return validators_1.Validator.validateOrFail(this.data, schema);
-    }
 }
 exports.Request = Request;

package/dist/http/response.d.ts

@@ -84,7 +84,7 @@ export declare class Response {
      *   return Response.json([{ id: 1 }, { id: 2 }]);
      * });
      */
-    static json<T>(data: T): Response;
+    static json(data: unknown): Response;
     /**
      * Creates a plain text response.
      *

package/dist/index.d.ts

@@ -6,4 +6,4 @@ export { FileSessionStorage, MemorySessionStorage } from "./sessions";
 export { HttpMethods } from "./http/httpMethods";
 export { createUploader } from "./storage/uploader";
 export { StorageType } from "./storage/types";
-export { v, schema } from "./validators/validationSchema";
+export { v, schema, validateData } from "./validators/validationSchema";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema = exports.v = exports.StorageType = exports.createUploader = exports.HttpMethods = exports.MemorySessionStorage = exports.FileSessionStorage = exports.RouterGroup = exports.Response = exports.Request = exports.createApp = void 0;
+exports.validateData = exports.schema = exports.v = exports.StorageType = exports.createUploader = exports.HttpMethods = exports.MemorySessionStorage = exports.FileSessionStorage = exports.RouterGroup = exports.Response = exports.Request = exports.createApp = void 0;
 var app_1 = require("./app");
 Object.defineProperty(exports, "createApp", { enumerable: true, get: function () { return app_1.createApp; } });
 var http_1 = require("./http");
@@ -20,3 +20,4 @@ Object.defineProperty(exports, "StorageType", { enumerable: true, get: function
 var validationSchema_1 = require("./validators/validationSchema");
 Object.defineProperty(exports, "v", { enumerable: true, get: function () { return validationSchema_1.v; } });
 Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return validationSchema_1.schema; } });
+Object.defineProperty(exports, "validateData", { enumerable: true, get: function () { return validationSchema_1.validateData; } });

package/dist/middlewares/cors.js

@@ -14,15 +14,21 @@ const http_1 = require("../http");
 const resolveOrigin = (requestOrigin, config) => {
     if (!requestOrigin)
         return null;
+    const cleanOrigin = (origin) => origin.endsWith("/") ? origin.slice(0, -1) : origin;
     if (typeof config.origin === "function") {
-        const out = config.origin(requestOrigin);
-        return out ? requestOrigin : null;
+        return config.origin(requestOrigin) ? requestOrigin : null;
     }
-    if (Array.isArray(config.origin))
-        return config.origin.includes(requestOrigin) ? requestOrigin : null;
-    if (config.origin === "*")
+    if (Array.isArray(config.origin)) {
+        return config.origin.map(cleanOrigin).includes(cleanOrigin(requestOrigin))
+            ? requestOrigin
+            : null;
+    }
+    if (config.origin === "*") {
         return config.credentials ? requestOrigin : "*";
-    return config.origin;
+    }
+    return cleanOrigin(config.origin) === cleanOrigin(requestOrigin)
+        ? requestOrigin
+        : null;
 };
 /**
  * Native CORS middleware, generates a CORS configuration for the server.

package/dist/routing/layer.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Layer = void 0;
-const escapeRegex = (value) => {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-};
 /**
  * Represents a single route layer in the routing system.
  *
@@ -34,7 +31,7 @@ class Layer {
      */
     constructor(url, action) {
         const paramRegex = /\{([a-zA-Z]+)\}/g;
-        const escapedUrl = escapeRegex(url);
+        const escapedUrl = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const regexSource = escapedUrl.replace(/\\{([a-zA-Z]+)\\}/g, "([a-zA-Z0-9]+)");
         this.url = url;
         this.regex = new RegExp(`^${regexSource}/?$`);

package/dist/storage/uploader.js

@@ -87,7 +87,7 @@ class Uploader {
             this.validateFileSize(fileData);
             await this.applyFileFilter(request, fileData);
             const file = await this.processFile(request, fileData);
-            request.file = file;
+            request.files = file;
             this.attachFieldsToRequest(request, multipartData);
             return await next(request);
         };

package/dist/validators/validationSchema.d.ts

@@ -1,6 +1,7 @@
 import type { FieldDefinition, RuleOptions } from "./types";
 import type { BaseValidationRule } from "./validationRule";
 import { BooleanRule, DateRule, type DateRuleOptions, NumberRule, type NumberRuleOptions, StringRule, type StringRuleOptions, ArrayRule, type ArrayRuleOptions, LiteralRule, ObjectRule, BigIntRule, UnionRule } from "./rules";
+import { Middleware } from "types";
 /**
  * Main validator class - provides factory methods for creating validators
  */
@@ -121,4 +122,12 @@ declare class ValidatorRules {
  */
 export declare const schema: (schemaDefinition: Record<string, BaseValidationRule>) => Map<string, FieldDefinition>;
 export declare const v: ValidatorRules;
+/**
+ * Validates the request payload against a validation schema.
+ *
+ * Throws if validation fails.
+ *
+ * @param schema - Validation rules mapped by field name
+ */
+export declare const validateData: (schema: Map<string, FieldDefinition>) => Middleware;
 export {};

package/dist/validators/validationSchema.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.v = exports.schema = void 0;
+exports.validateData = exports.v = exports.schema = void 0;
 const rules_1 = require("./rules");
+const validator_1 = require("./validator");
 /**
  * Main validator class - provides factory methods for creating validators
  */
@@ -202,3 +203,18 @@ const schema = (schemaDefinition) => {
 exports.schema = schema;
 // Export a singleton instance for convenience
 exports.v = new ValidatorRules();
+/**
+ * Validates the request payload against a validation schema.
+ *
+ * Throws if validation fails.
+ *
+ * @param schema - Validation rules mapped by field name
+ */
+const validateData = (schema) => {
+    return (request, next) => {
+        const validData = validator_1.Validator.validateOrFail(request.data, schema);
+        request.setData(validData);
+        return next(request);
+    };
+};
+exports.validateData = validateData;

package/dist/validators/validator.d.ts

@@ -31,5 +31,5 @@ export declare class Validator {
      * @returns The original data when validation succeeds
      * @throws {ValidationException} When validation fails
      */
-    static validateOrFail(data: Record<string, unknown>, schema: Map<string, FieldDefinition>): unknown;
+    static validateOrFail(data: Record<string, unknown>, schema: Map<string, FieldDefinition>): Record<string, unknown>;
 }

package/dist/validators/validator.js

@@ -68,7 +68,7 @@ class Validator {
         if (result.errors.length !== 0)
             throw new validationException_1.ValidationException(result.errors);
         for (const [fieldName, fieldDef] of schema.entries()) {
-            if (!(fieldName in result) && fieldDef.defaultValue !== undefined)
+            if (!(fieldName in result.data) && fieldDef.defaultValue)
                 result.data[fieldName] = fieldDef.defaultValue;
         }
         return result.data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skyguard-js",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "A lightweight, dependency-free TypeScript backend framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",