skyguard-js 1.1.1 → 1.1.2

package/README.md

@@ -165,17 +165,17 @@ app.staticFiles(join(__dirname, "..", "static"));
 
 ## ⛔ Data Validation
 
-Skyguard.js provides a **declarative validation system** using schemas.
+To validate data in the body of client requests, the framework provides the creation of validation schemas, which are created as follows:
 
 ```ts
-import { validator } from "skyguard-js/validation";
-
-const userSchema = validator.schema({
-  name: validator.string({ maxLength: 60 }),
-  email: validator.email().required(),
-  age: validator.number({ min: 18 }),
-  active: validator.boolean().required(),
-  birthdate: validator.date({ max: new Date() }),
+import { v, schema } from "skyguard-js";
+
+const userSchema = schema({
+  name: v.string({ maxLength: 60 }),
+  email: v.email(),
+  age: v.number({ min: 18 }),
+  active: v.boolean().default(false),
+  birthdate: v.date({ max: new Date() }),
 });
 
 app.post("/users", (request: Request) => {
@@ -188,6 +188,8 @@ app.post("/users", (request: Request) => {
 });
 ```
 
+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:
 
 - Fail-fast per field

package/dist/crypto/jwt.js

@@ -85,7 +85,7 @@ const verifyJWT = (token, secret) => {
             return null;
         return payload;
     }
-    catch (error) {
+    catch {
         return null;
     }
 };
@@ -105,7 +105,7 @@ const decodeJWT = (token) => {
         const payload = JSON.parse(base64UrlDecode(parts[1]));
         return { header, payload };
     }
-    catch (error) {
+    catch {
         return null;
     }
 };

package/dist/http/logger.js

@@ -13,7 +13,7 @@ class Logger {
         const diff = process.hrtime.bigint() - startTime;
         const responseTime = (Number(diff) / 1_000_000).toFixed(3);
         const coloredStatus = this.colorizeStatus(res.statusCode);
-        const logLine = `${method} ${url} ${coloredStatus} ${responseTime} ms - ${contentLength}`;
+        const logLine = `${method} ${url} ${coloredStatus} ${responseTime} ms - ${contentLength.toString()}`;
         this.stream.write(logLine + "\n");
     }
     colorizeStatus(statusCode) {

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 { validator } from "./validators/validationSchema";
+export { v, schema } from "./validators/validationSchema";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validator = exports.StorageType = exports.createUploader = exports.HttpMethods = exports.MemorySessionStorage = exports.FileSessionStorage = exports.RouterGroup = exports.Response = exports.Request = exports.createApp = void 0;
+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");
@@ -18,4 +18,5 @@ Object.defineProperty(exports, "createUploader", { enumerable: true, get: functi
 var types_1 = require("./storage/types");
 Object.defineProperty(exports, "StorageType", { enumerable: true, get: function () { return types_1.StorageType; } });
 var validationSchema_1 = require("./validators/validationSchema");
-Object.defineProperty(exports, "validator", { enumerable: true, get: function () { return validationSchema_1.validator; } });
+Object.defineProperty(exports, "v", { enumerable: true, get: function () { return validationSchema_1.v; } });
+Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return validationSchema_1.schema; } });

package/dist/sessions/fileSessionStorage.js

@@ -213,10 +213,7 @@ class FileSessionStorage {
             }
             catch {
                 // Corrupt/unreadable → best-effort cleanup
-                try {
-                    await (0, promises_1.unlink)(full);
-                }
-                catch { }
+                await (0, promises_1.unlink)(full);
             }
         }));
     }
@@ -280,7 +277,9 @@ class FileSessionStorage {
         try {
             await (0, promises_1.unlink)(path);
         }
-        catch { }
+        catch {
+            /** eslint-disable-next-line no-empty */
+        }
     }
     /**
      * Generates a cryptographically strong session id (64 hex chars).

package/dist/sessions/sessionStorage.d.ts

@@ -67,7 +67,7 @@ export interface SessionStorage {
      * Removes all associated data and invalidates the session
      * for subsequent requests.
      */
-    destroy(): void;
+    destroy(): void | Promise<void>;
 }
 /**
  * Internal representation of persisted session data.

package/dist/static/contentDisposition.js

@@ -59,7 +59,12 @@ class ContentDisposition {
     }
     sanitizeFilename(filename) {
         return filename
-            .replace(/[\x00-\x1F\x7F-\x9F]/g, "")
+            .split("")
+            .filter(char => {
+            const code = char.charCodeAt(0);
+            return !(code <= 0x1f || (code >= 0x7f && code <= 0x9f));
+        })
+            .join("")
             .replace(/["\r\n]/g, "")
             .replace(/[/\\]/g, "")
             .replace(/\s+/g, " ")

package/dist/storage/storage.js

@@ -91,10 +91,7 @@ class DiskStorage {
      */
     async removeFile(file) {
         if (file.path) {
-            try {
-                await (0, promises_1.unlink)(file.path);
-            }
-            catch { }
+            await (0, promises_1.unlink)(file.path);
         }
     }
     /**

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

@@ -4,13 +4,8 @@ export interface ArrayRuleOptions extends RuleOptions {
     minLength?: number;
     maxLength?: number;
 }
-export declare class ArrayRule extends BaseValidationRule {
-    constructor();
-    validate(context: ValidationContext, options?: ArrayRuleOptions): ValidationError | null;
-    string(message?: string): this;
-    number(message?: string): this;
-}
-export declare class ArrayNumberRule extends BaseValidationRule {
-    constructor();
+export declare class ArrayRule extends BaseValidationRule<Array<unknown>> {
+    private readonly typeValid?;
+    constructor(typeValid?: BaseValidationRule);
     validate(context: ValidationContext, options?: ArrayRuleOptions): ValidationError | null;
 }

package/dist/validators/rules/arrayRule.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayNumberRule = exports.ArrayRule = void 0;
+exports.ArrayRule = void 0;
 const validationRule_1 = require("../validationRule");
 class ArrayRule extends validationRule_1.BaseValidationRule {
-    constructor() {
+    typeValid;
+    constructor(typeValid) {
         super("array");
+        this.typeValid = typeValid;
     }
     validate(context, options) {
         const { field, value } = context;
@@ -17,50 +19,22 @@ class ArrayRule extends validationRule_1.BaseValidationRule {
         if (options?.maxLength && value.length > options.maxLength) {
             return this.createError(field, `${field} must have at most ${options.maxLength} items`, value);
         }
-        return null;
-    }
-    string(message) {
-        this.rules.push({
-            rule: new ArrayStringRule(),
-            options: { message },
-        });
-        return this;
-    }
-    number(message) {
-        this.rules.push({
-            rule: new ArrayNumberRule(),
-            options: { message },
-        });
-        return this;
-    }
-}
-exports.ArrayRule = ArrayRule;
-class ArrayStringRule extends validationRule_1.BaseValidationRule {
-    constructor() {
-        super("arrayString");
-    }
-    validate(context, options) {
-        const { field, value } = context;
-        for (let i = 0; i < value.length; i++) {
-            if (typeof value[i] !== "string") {
-                return this.createError(field, options?.message || `${field} must be an array of strings`, value);
+        if (!this.typeValid)
+            return null;
+        const itemRules = this.typeValid.rules.length
+            ? this.typeValid.rules
+            : [{ rule: this.typeValid, options: undefined }];
+        for (const [index, item] of value.entries()) {
+            for (const { rule, options: itemOptions } of itemRules) {
+                const error = rule.validate({
+                    field: `${field}[${index}]`,
+                    value: item,
+                }, itemOptions);
+                if (error)
+                    return error;
             }
         }
         return null;
     }
 }
-class ArrayNumberRule extends validationRule_1.BaseValidationRule {
-    constructor() {
-        super("arrayNumber");
-    }
-    validate(context, options) {
-        const { field, value } = context;
-        for (let i = 0; i < value.length; i++) {
-            if (typeof value[i] !== "number") {
-                return this.createError(field, options?.message || `${field} must be an array of numbers`, value);
-            }
-        }
-        return null;
-    }
-}
-exports.ArrayNumberRule = ArrayNumberRule;
+exports.ArrayRule = ArrayRule;

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

@@ -0,0 +1,20 @@
+import type { ValidationContext, RuleOptions, ValidationError } from "../types";
+import { BaseValidationRule } from "../validationRule";
+export interface BigIntRuleOptions extends RuleOptions {
+    gt?: bigint;
+    gte?: bigint;
+    lt?: bigint;
+    lte?: bigint;
+    positive?: boolean;
+    negative?: boolean;
+}
+export declare class BigIntRule extends BaseValidationRule<bigint> {
+    constructor();
+    validate(context: ValidationContext, options?: BigIntRuleOptions): ValidationError | null;
+    gt(limit: bigint, message?: string): this;
+    gte(limit: bigint, message?: string): this;
+    lt(limit: bigint, message?: string): this;
+    lte(limit: bigint, message?: string): this;
+    positive(message?: string): this;
+    negative(message?: string): this;
+}

package/dist/validators/rules/bigIntRule.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntRule = void 0;
+const validationRule_1 = require("../validationRule");
+class BigIntRule extends validationRule_1.BaseValidationRule {
+    constructor() {
+        super("bigint");
+    }
+    validate(context, options) {
+        const { field, value } = context;
+        if (typeof value !== "bigint") {
+            return this.createError(field, options?.message || `${field} must be an bigint`, value);
+        }
+        if (options?.positive && value <= 0n)
+            return this.createError(field, `${field} must be positive`, value);
+        if (options?.negative && value >= 0n)
+            return this.createError(field, `${field} must be negative`, value);
+        if (options?.gt && value <= options.gt)
+            return this.createError(field, `${field} must be greater than ${options.gt}`, value);
+        if (options?.gte && value < options.gte)
+            return this.createError(field, `${field} must be greater than or equal to ${options.gte}`, value);
+        if (options?.lt && value >= options.lt)
+            return this.createError(field, `${field} must be less than ${options.lt}`, value);
+        if (options?.lte && value > options.lte)
+            return this.createError(field, `${field} must be less than or equal to ${options.lte}`, value);
+        return null;
+    }
+    gt(limit, message) {
+        this.rules.push({ rule: this, options: { gt: limit, message } });
+        return this;
+    }
+    gte(limit, message) {
+        this.rules.push({ rule: this, options: { gte: limit, message } });
+        return this;
+    }
+    lt(limit, message) {
+        this.rules.push({ rule: this, options: { lt: limit, message } });
+        return this;
+    }
+    lte(limit, message) {
+        this.rules.push({ rule: this, options: { lte: limit, message } });
+        return this;
+    }
+    positive(message) {
+        this.rules.push({ rule: this, options: { positive: true, message } });
+        return this;
+    }
+    negative(message) {
+        this.rules.push({ rule: this, options: { negative: true, message } });
+        return this;
+    }
+}
+exports.BigIntRule = BigIntRule;

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

@@ -5,7 +5,7 @@ import { BaseValidationRule } from "../validationRule";
  *
  * Validates that a value is a boolean (`true` or `false`).
  */
-export declare class BooleanRule extends BaseValidationRule {
+export declare class BooleanRule extends BaseValidationRule<boolean> {
     constructor();
     validate(context: ValidationContext, options?: RuleOptions): ValidationError | null;
 }

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

@@ -10,7 +10,7 @@ export interface DateRuleOptions extends RuleOptions {
  *
  * Validates that a value represents a valid date.
  */
-export declare class DateRule extends BaseValidationRule {
+export declare class DateRule extends BaseValidationRule<Date> {
     constructor();
     validate(context: ValidationContext, options?: DateRuleOptions): ValidationError | null;
 }

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

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

package/dist/validators/rules/index.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiteralRule = exports.ArrayRule = exports.StringRule = exports.RequiredRule = exports.NumberRule = exports.DateRule = exports.BooleanRule = void 0;
+exports.BigIntRule = exports.UnionRule = exports.ObjectRule = exports.LiteralRule = exports.ArrayRule = exports.StringRule = exports.NumberRule = exports.DateRule = exports.BooleanRule = void 0;
 var booleanRule_1 = require("./booleanRule");
 Object.defineProperty(exports, "BooleanRule", { enumerable: true, get: function () { return booleanRule_1.BooleanRule; } });
 var dateRule_1 = require("./dateRule");
 Object.defineProperty(exports, "DateRule", { enumerable: true, get: function () { return dateRule_1.DateRule; } });
 var numberRule_1 = require("./numberRule");
 Object.defineProperty(exports, "NumberRule", { enumerable: true, get: function () { return numberRule_1.NumberRule; } });
-var requiredRule_1 = require("./requiredRule");
-Object.defineProperty(exports, "RequiredRule", { enumerable: true, get: function () { return requiredRule_1.RequiredRule; } });
 var stringRule_1 = require("./stringRule");
 Object.defineProperty(exports, "StringRule", { enumerable: true, get: function () { return stringRule_1.StringRule; } });
 var arrayRule_1 = require("./arrayRule");
 Object.defineProperty(exports, "ArrayRule", { enumerable: true, get: function () { return arrayRule_1.ArrayRule; } });
 var literalRule_1 = require("./literalRule");
 Object.defineProperty(exports, "LiteralRule", { enumerable: true, get: function () { return literalRule_1.LiteralRule; } });
+var objectRule_1 = require("./objectRule");
+Object.defineProperty(exports, "ObjectRule", { enumerable: true, get: function () { return objectRule_1.ObjectRule; } });
+var unionRule_1 = require("./unionRule");
+Object.defineProperty(exports, "UnionRule", { enumerable: true, get: function () { return unionRule_1.UnionRule; } });
+var bigIntRule_1 = require("./bigIntRule");
+Object.defineProperty(exports, "BigIntRule", { enumerable: true, get: function () { return bigIntRule_1.BigIntRule; } });

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

@@ -12,7 +12,7 @@ export interface NumberRuleOptions extends RuleOptions {
  *
  * Validates that a value is a number.
  */
-export declare class NumberRule extends BaseValidationRule {
+export declare class NumberRule extends BaseValidationRule<number> {
     constructor();
     validate(context: ValidationContext, options?: NumberRuleOptions): ValidationError | null;
 }

package/dist/validators/rules/numberRule.js

@@ -13,18 +13,17 @@ class NumberRule extends validationRule_1.BaseValidationRule {
     }
     validate(context, options) {
         const { field, value } = context;
-        const num = typeof value === "string" ? Number(value) : value;
-        if (typeof num !== "number" || isNaN(num))
+        if (typeof value !== "number")
             return this.createError(field, options?.message || `${field} must be a number`, value);
-        if (options?.integer && !Number.isInteger(num))
+        if (options?.integer && !Number.isInteger(value))
             return this.createError(field, `${field} must be an integer`, value);
-        if (options?.positive && num <= 0)
+        if (options?.positive && value <= 0)
             return this.createError(field, `${field} must be positive`, value);
-        if (options?.negative && num >= 0)
+        if (options?.negative && value >= 0)
             return this.createError(field, `${field} must be negative`, value);
-        if (options?.min && num < options.min)
+        if (options?.min && value < options.min)
             return this.createError(field, `${field} must be at least ${options.min}`, value);
-        if (options?.max && num > options.max)
+        if (options?.max && value > options.max)
             return this.createError(field, `${field} must be at most ${options.max}`, value);
         return null;
     }

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

@@ -0,0 +1,7 @@
+import type { FieldDefinition, RuleOptions, ValidationContext, ValidationError } from "../types";
+import { BaseValidationRule } from "../validationRule";
+export declare class ObjectRule extends BaseValidationRule<Record<string, unknown>> {
+    private readonly objectSchema;
+    constructor(objectSchema: Map<string, FieldDefinition>);
+    validate(context: ValidationContext, options?: RuleOptions): ValidationError | null;
+}

package/dist/validators/rules/objectRule.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectRule = void 0;
+const validator_1 = require("../validator");
+const validationRule_1 = require("../validationRule");
+class ObjectRule extends validationRule_1.BaseValidationRule {
+    objectSchema;
+    constructor(objectSchema) {
+        super("object");
+        this.objectSchema = objectSchema;
+    }
+    validate(context, options) {
+        const { field, value } = context;
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            return this.createError(field, options?.message || `${field} must be an object`, value);
+        }
+        const nestedResult = validator_1.Validator.validate(value, this.objectSchema);
+        if (nestedResult.errors.length === 0)
+            return null;
+        const firstError = nestedResult.errors[0];
+        return {
+            ...firstError,
+            field: `${field}.${firstError.field}`,
+        };
+    }
+}
+exports.ObjectRule = ObjectRule;

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

@@ -4,14 +4,14 @@ export interface StringRuleOptions extends RuleOptions {
     isEmpty?: boolean;
     minLength?: number;
     maxLength?: number;
-    pattern?: RegExp;
+    length?: number;
 }
 /**
  * String validation rule.
  *
  * Validates that a value is a string.
  */
-export declare class StringRule extends BaseValidationRule {
+export declare class StringRule extends BaseValidationRule<string> {
     constructor();
     validate(context: ValidationContext, options?: StringRuleOptions): ValidationError | null;
     /**
@@ -46,6 +46,7 @@ export declare class StringRule extends BaseValidationRule {
      * validator.string().uuid()
      */
     uuid(message?: string): this;
+    regex(pattern: RegExp, message?: string): this;
 }
 /**
  * Email validation rule.
@@ -72,3 +73,11 @@ export declare class UuidRule extends BaseValidationRule {
     constructor();
     validate(context: ValidationContext, options?: RuleOptions): ValidationError | null;
 }
+/**
+ * UUID validation rule
+ */
+export declare class RegExRule extends BaseValidationRule {
+    private readonly regex;
+    constructor(pattern: RegExp);
+    validate(context: ValidationContext, options?: RuleOptions): ValidationError | null;
+}

package/dist/validators/rules/stringRule.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UuidRule = exports.UrlRule = exports.EmailRule = exports.StringRule = void 0;
+exports.RegExRule = exports.UuidRule = exports.UrlRule = exports.EmailRule = exports.StringRule = void 0;
 const validationRule_1 = require("../validationRule");
 /**
  * String validation rule.
@@ -15,15 +15,14 @@ class StringRule extends validationRule_1.BaseValidationRule {
         const { field, value } = context;
         if (typeof value !== "string")
             return this.createError(field, options?.message || `${field} must be a string`, value);
-        let str = value;
-        if (options?.isEmpty && str === "")
+        if (options?.isEmpty && value === "")
             return this.createError(field, `${field} cannot be empty`, value);
-        if (options?.minLength && str.length < options.minLength)
+        if (options?.minLength && value.length < options.minLength)
             return this.createError(field, `${field} must be at least ${options.minLength} characters`, value);
-        if (options?.maxLength && str.length > options.maxLength)
+        if (options?.maxLength && value.length > options.maxLength)
             return this.createError(field, `${field} must be at most ${options.maxLength} characters`, value);
-        if (options?.pattern && !options.pattern.test(str))
-            return this.createError(field, options?.message || `${field} format is invalid`, value);
+        if (options?.length && value.length !== options.length)
+            return this.createError(field, `${field} must be exactly ${options.length} characters`, value);
         return null;
     }
     /**
@@ -76,6 +75,13 @@ class StringRule extends validationRule_1.BaseValidationRule {
         });
         return this;
     }
+    regex(pattern, message) {
+        this.rules.push({
+            rule: new RegExRule(pattern),
+            options: { message },
+        });
+        return this;
+    }
 }
 exports.StringRule = StringRule;
 /**
@@ -132,3 +138,21 @@ class UuidRule extends validationRule_1.BaseValidationRule {
     }
 }
 exports.UuidRule = UuidRule;
+/**
+ * UUID validation rule
+ */
+class RegExRule extends validationRule_1.BaseValidationRule {
+    regex;
+    constructor(pattern) {
+        super("regex");
+        this.regex = pattern;
+    }
+    validate(context, options) {
+        const { field, value } = context;
+        if (!this.regex.test(value)) {
+            return this.createError(field, options?.message || `${field} format is invalid`, value);
+        }
+        return null;
+    }
+}
+exports.RegExRule = RegExRule;

package/dist/validators/rules/{requiredRule.d.ts → unionRule.d.ts}

@@ -1,11 +1,7 @@
 import type { RuleOptions, ValidationContext, ValidationError } from "../types";
 import { BaseValidationRule } from "../validationRule";
-/**
- * Required field validation rule.
- *
- * Validates that a value is present and not empty.
- */
-export declare class RequiredRule extends BaseValidationRule {
-    constructor();
+export declare class UnionRule extends BaseValidationRule {
+    private readonly unionRules;
+    constructor(unionRules: BaseValidationRule[]);
     validate(context: ValidationContext, options?: RuleOptions): ValidationError | null;
 }

package/dist/validators/rules/unionRule.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionRule = void 0;
+const validationRule_1 = require("../validationRule");
+class UnionRule extends validationRule_1.BaseValidationRule {
+    unionRules;
+    constructor(unionRules) {
+        super("union");
+        this.unionRules = unionRules;
+    }
+    validate(context, options) {
+        const { field, value } = context;
+        for (const unionRule of this.unionRules) {
+            const rules = unionRule.rules.length
+                ? unionRule.rules
+                : [{ rule: unionRule, options: undefined }];
+            let hasError = false;
+            for (const { rule, options: ruleOptions } of rules) {
+                const error = rule.validate({ field, value }, ruleOptions);
+                if (error) {
+                    hasError = true;
+                    break;
+                }
+            }
+            if (!hasError)
+                return null;
+        }
+        return this.createError(field, options?.message || `${field} must match at least one union rule`, value);
+    }
+}
+exports.UnionRule = UnionRule;

package/dist/validators/types.d.ts

@@ -16,12 +16,10 @@ export interface ValidationError {
  * Full validation result.
  */
 export interface ValidationResult {
-    /** Indicates whether the validation passed */
-    valid: boolean;
     /** List of validation errors */
     errors: ValidationError[];
     /** Optional validated data */
-    data?: unknown;
+    data: Record<string, unknown>;
 }
 /**
  * Options for a validation rule.
@@ -40,8 +38,6 @@ export interface ValidationContext {
     field: string;
     /** Field value */
     value: unknown;
-    /** Full input data */
-    data: unknown;
 }
 /**
  * Field definition used by the validation engine.
@@ -52,4 +48,5 @@ export interface FieldDefinition {
         options?: RuleOptions;
     }>;
     optional: boolean;
+    defaultValue?: unknown;
 }

package/dist/validators/validationRule.d.ts

@@ -8,10 +8,6 @@ import type { RuleOptions, ValidationContext, ValidationError } from "./types";
  * A rule must only evaluate the value and return an error when validation fails.
  */
 export interface ValidationRule {
-    /**
-     * Unique rule name.
-     */
-    readonly name: string;
     /**
      * Executes the rule validation.
      *
@@ -26,30 +22,25 @@ export interface ValidationRule {
 /**
  * Abstract base class for implementing validation rules.
  */
-export declare abstract class BaseValidationRule implements ValidationRule {
-    readonly name: string;
+export declare abstract class BaseValidationRule<T = any> implements ValidationRule {
+    private readonly name;
     readonly rules: Array<{
         rule: ValidationRule;
         options?: RuleOptions;
     }>;
-    _optional: boolean;
+    hasOptional: boolean;
+    defaultValue?: T;
     constructor(name: string, rules?: Array<{
         rule: ValidationRule;
         options?: RuleOptions;
     }>);
     abstract validate(context: ValidationContext, options?: RuleOptions): ValidationError | null;
-    /**
-     * Marks the field as required.
-     *
-     * @param message - Optional custom error message
-     * @returns This rule instance for chaining
-     */
-    required(message?: string): this;
     /**
      * Marks the field as optional.
      *
      * @returns This rule instance for chaining
      */
     optional(): this;
+    default(value: T): this;
     protected createError(field: string, message: string, value?: unknown): ValidationError;
 }

package/dist/validators/validationRule.js

@@ -1,36 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseValidationRule = void 0;
-const rules_1 = require("./rules");
 /**
  * Abstract base class for implementing validation rules.
  */
 class BaseValidationRule {
     name;
     rules;
-    _optional = false;
+    hasOptional = false;
+    defaultValue = undefined;
     constructor(name, rules = []) {
         this.name = name;
         this.rules = rules;
     }
-    /**
-     * Marks the field as required.
-     *
-     * @param message - Optional custom error message
-     * @returns This rule instance for chaining
-     */
-    required(message) {
-        this._optional = false;
-        this.rules.push({ rule: new rules_1.RequiredRule(), options: { message } });
-        return this;
-    }
     /**
      * Marks the field as optional.
      *
      * @returns This rule instance for chaining
      */
     optional() {
-        this._optional = true;
+        this.hasOptional = true;
+        return this;
+    }
+    default(value) {
+        this.defaultValue = value;
+        this.hasOptional = true;
         return this;
     }
     createError(field, message, value) {

package/dist/validators/validationSchema.d.ts

@@ -1,6 +1,6 @@
-import type { FieldDefinition } from "./types";
+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 } from "./rules";
+import { BooleanRule, DateRule, type DateRuleOptions, NumberRule, type NumberRuleOptions, StringRule, type StringRuleOptions, ArrayRule, type ArrayRuleOptions, LiteralRule, ObjectRule, BigIntRule, UnionRule } from "./rules";
 /**
  * Main validator class - provides factory methods for creating validators
  */
@@ -25,6 +25,16 @@ declare class Validator {
      * validator.number({ min: 18, max: 65 })
      */
     number(options?: NumberRuleOptions): NumberRule;
+    /**
+     * Creates a bigint validator.
+     *
+     * @param message - Optional custom error message
+     * @returns BigIntRule instance
+     *
+     * @example
+     * validator.bigint()
+     */
+    bigint(message?: string): BigIntRule;
     /**
      * Creates a boolean validator
      *
@@ -32,7 +42,7 @@ declare class Validator {
      * @returns BooleanValidator instance
      *
      * @example
-     * validator.boolean().required()
+     * validator.boolean()
      */
     boolean(message?: string): BooleanRule;
     /**
@@ -54,32 +64,60 @@ declare class Validator {
      * @example
      * validator.array({ minLength: 1 }).string()
      */
-    array(options?: ArrayRuleOptions): ArrayRule;
+    array(typeValid?: BaseValidationRule, options?: ArrayRuleOptions): ArrayRule;
     /**
-     * Creates a literal value validator
+     * Creates an object validator with a nested schema.
      *
-     * @param value - The literal value to validate against
-     * @param message - Optional custom error message
-     * @returns LiteralRule instance
+     * @param objectSchemaDefinition - Record mapping field names to their validators
+     * @param options - Optional rule options (message, etc.)
+     * @returns ObjectRule instance
      *
      * @example
-     * validator.literal("admin").required()
+     * validator.object({
+     *   id: validator.number(),
+     *   name: validator.string({ maxLength: 100 })
+     * })
      */
-    literal(value: unknown, message?: string): LiteralRule;
+    object(objectSchemaDefinition: Record<string, BaseValidationRule>, options?: RuleOptions): ObjectRule;
     /**
-     * Creates a validation schema from a field definition object
+     * Creates a union validator that passes if any of the supplied rules pass.
      *
-     * @param schemaDefinition - Object mapping field names to validators
-     * @returns ValidationSchema instance
+     * @param unionRules - Array of validation rules to try in order
+     * @param options - Optional rule options (message, etc.)
+     * @returns UnionRule instance
      *
      * @example
-     * const userSchema = validator.schema({
-     *   name: validator.string({ maxLength: 60 }),
-     *   email: validator.email().required(),
-     *   age: validator.number({ min: 18 })
-     * })
+     * validator.union([
+     *   validator.string(),
+     *   validator.number()
+     * ])
      */
-    schema(schemaDefinition: Record<string, BaseValidationRule>): Map<string, FieldDefinition>;
+    union(unionRules: BaseValidationRule[], options?: RuleOptions): UnionRule;
+    /**
+     * Creates a literal value validator
+     *
+     * @param value - The literal value to validate against
+     * @param message - Optional custom error message
+     * @returns LiteralRule instance
+     *
+     * @example
+     * validator.literal("admin")
+     */
+    literal(value: unknown, message?: string): LiteralRule;
 }
-export declare const validator: Validator;
+/**
+ * Creates a validation schema from a field definition object
+ *
+ * @param schemaDefinition - Object mapping field names to validators
+ * @returns ValidationSchema instance
+ *
+ * @example
+ * const userSchema = validator.schema({
+ *   name: validator.string({ maxLength: 60 }),
+ *   email: validator.email(),
+ *   age: validator.number({ min: 18 })
+ * })
+ */
+export declare const schema: (schemaDefinition: Record<string, BaseValidationRule>) => Map<string, FieldDefinition>;
+export declare const v: Validator;
 export {};

package/dist/validators/validationSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validator = void 0;
+exports.v = exports.schema = void 0;
 const rules_1 = require("./rules");
 /**
  * Main validator class - provides factory methods for creating validators
@@ -34,6 +34,20 @@ class Validator {
         numberRule.rules.push({ rule: numberRule, options });
         return numberRule;
     }
+    /**
+     * Creates a bigint validator.
+     *
+     * @param message - Optional custom error message
+     * @returns BigIntRule instance
+     *
+     * @example
+     * validator.bigint()
+     */
+    bigint(message) {
+        const bigIntRule = new rules_1.BigIntRule();
+        bigIntRule.rules.push({ rule: bigIntRule, options: { message } });
+        return bigIntRule;
+    }
     /**
      * Creates a boolean validator
      *
@@ -41,7 +55,7 @@ class Validator {
      * @returns BooleanValidator instance
      *
      * @example
-     * validator.boolean().required()
+     * validator.boolean()
      */
     boolean(message) {
         const booleanRule = new rules_1.BooleanRule();
@@ -71,11 +85,48 @@ class Validator {
      * @example
      * validator.array({ minLength: 1 }).string()
      */
-    array(options) {
-        const arrayRule = new rules_1.ArrayRule();
+    array(typeValid, options) {
+        const arrayRule = new rules_1.ArrayRule(typeValid);
         arrayRule.rules.push({ rule: arrayRule, options });
         return arrayRule;
     }
+    /**
+     * Creates an object validator with a nested schema.
+     *
+     * @param objectSchemaDefinition - Record mapping field names to their validators
+     * @param options - Optional rule options (message, etc.)
+     * @returns ObjectRule instance
+     *
+     * @example
+     * validator.object({
+     *   id: validator.number(),
+     *   name: validator.string({ maxLength: 100 })
+     * })
+     */
+    object(objectSchemaDefinition, options) {
+        const objectSchema = (0, exports.schema)(objectSchemaDefinition);
+        const objectRule = new rules_1.ObjectRule(objectSchema);
+        objectRule.rules.push({ rule: objectRule, options });
+        return objectRule;
+    }
+    /**
+     * Creates a union validator that passes if any of the supplied rules pass.
+     *
+     * @param unionRules - Array of validation rules to try in order
+     * @param options - Optional rule options (message, etc.)
+     * @returns UnionRule instance
+     *
+     * @example
+     * validator.union([
+     *   validator.string(),
+     *   validator.number()
+     * ])
+     */
+    union(unionRules, options) {
+        const unionRule = new rules_1.UnionRule(unionRules);
+        unionRule.rules.push({ rule: unionRule, options });
+        return unionRule;
+    }
     /**
      * Creates a literal value validator
      *
@@ -84,7 +135,7 @@ class Validator {
      * @returns LiteralRule instance
      *
      * @example
-     * validator.literal("admin").required()
+     * validator.literal("admin")
      */
     literal(value, message) {
         const literalRule = new rules_1.LiteralRule(value);
@@ -94,29 +145,6 @@ class Validator {
         });
         return literalRule;
     }
-    /**
-     * Creates a validation schema from a field definition object
-     *
-     * @param schemaDefinition - Object mapping field names to validators
-     * @returns ValidationSchema instance
-     *
-     * @example
-     * const userSchema = validator.schema({
-     *   name: validator.string({ maxLength: 60 }),
-     *   email: validator.email().required(),
-     *   age: validator.number({ min: 18 })
-     * })
-     */
-    schema(schemaDefinition) {
-        const schema = new ValidationSchema();
-        for (const [fieldName, validator] of Object.entries(schemaDefinition)) {
-            schema.addField(fieldName, {
-                rules: validator.rules,
-                optional: validator._optional,
-            });
-        }
-        return schema.build();
-    }
 }
 /**
  * ValidationSchema - Internal representation of validation rules
@@ -145,23 +173,31 @@ class ValidationSchema {
     build() {
         return this.fields;
     }
-    /**
-     * Gets a specific field definition
-     *
-     * @param name - Field name
-     * @returns Field definition or undefined
-     */
-    getField(name) {
-        return this.fields.get(name);
-    }
-    /**
-     * Gets all field names in the schema
-     *
-     * @returns Array of field names
-     */
-    getFieldNames() {
-        return Array.from(this.fields.keys());
-    }
 }
+/**
+ * Creates a validation schema from a field definition object
+ *
+ * @param schemaDefinition - Object mapping field names to validators
+ * @returns ValidationSchema instance
+ *
+ * @example
+ * const userSchema = validator.schema({
+ *   name: validator.string({ maxLength: 60 }),
+ *   email: validator.email(),
+ *   age: validator.number({ min: 18 })
+ * })
+ */
+const schema = (schemaDefinition) => {
+    const schema = new ValidationSchema();
+    for (const [fieldName, validator] of Object.entries(schemaDefinition)) {
+        schema.addField(fieldName, {
+            rules: validator.rules,
+            optional: validator.hasOptional,
+            defaultValue: validator.defaultValue,
+        });
+    }
+    return schema.build();
+};
+exports.schema = schema;
 // Export a singleton instance for convenience
-exports.validator = new Validator();
+exports.v = new Validator();

package/dist/validators/validator.d.ts

@@ -47,9 +47,9 @@ export declare class Validator {
      * @throws {ValidationException} When validation fails
      *
      * @example
-     * const schema = ValidationSchema.create()
-     *   .field("email").required().string().email()
-     *   .build();
+     * const schema = schema({
+     *   email: validator.string().emaiil().required()
+     * })
      *
      * const data = Validator.validateOrFail({ email: "a@b.com" }, schema);
      * // `data` is the original input when valid

package/dist/validators/validator.js

@@ -43,14 +43,20 @@ class Validator {
     static validate(data, schema) {
         const errors = [];
         for (const [fieldName, fieldDef] of schema.entries()) {
-            const value = data[fieldName];
             const context = {
                 field: fieldName,
-                value,
-                data,
+                value: data[fieldName],
             };
-            if (fieldDef.optional && value === undefined)
+            if (fieldDef.optional && data[fieldName] === undefined)
                 continue;
+            if (data[fieldName] === undefined || data[fieldName] === null) {
+                errors.push({
+                    field: fieldName,
+                    message: `${fieldName} is required`,
+                    rule: "required",
+                });
+                continue;
+            }
             for (const { rule, options } of fieldDef.rules) {
                 const error = rule.validate(context, options);
                 if (error) {
@@ -60,7 +66,6 @@ class Validator {
             }
         }
         return {
-            valid: errors.length === 0,
             errors,
             data: errors.length === 0 ? data : undefined,
         };
@@ -74,17 +79,21 @@ class Validator {
      * @throws {ValidationException} When validation fails
      *
      * @example
-     * const schema = ValidationSchema.create()
-     *   .field("email").required().string().email()
-     *   .build();
+     * const schema = schema({
+     *   email: validator.string().emaiil().required()
+     * })
      *
      * const data = Validator.validateOrFail({ email: "a@b.com" }, schema);
      * // `data` is the original input when valid
      */
     static validateOrFail(data, schema) {
         const result = this.validate(data, schema);
-        if (!result.valid)
+        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)
+                result.data[fieldName] = fieldDef.defaultValue;
+        }
         return result.data;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skyguard-js",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A lightweight, dependency-free TypeScript backend framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -72,19 +72,19 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@eslint/js": "9.39.2",
+    "@eslint/js": "10.0.1",
     "@jest/globals": "30.2.0",
     "@types/jest": "30.0.0",
-    "@types/node": "25.0.8",
-    "eslint": "9.39.2",
+    "@types/node": "25.3.0",
+    "eslint": "10.0.2",
     "eslint-config-prettier": "10.1.8",
-    "globals": "17.2.0",
+    "globals": "17.3.0",
     "jest": "30.2.0",
-    "nodemon": "3.1.11",
+    "nodemon": "3.1.14",
     "prettier": "3.8.1",
     "ts-jest": "29.4.6",
     "ts-node": "10.9.2",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.53.0"
+    "typescript-eslint": "8.56.1"
   }
 }

package/dist/validators/rules/requiredRule.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequiredRule = void 0;
-const validationRule_1 = require("../validationRule");
-/**
- * Required field validation rule.
- *
- * Validates that a value is present and not empty.
- */
-class RequiredRule extends validationRule_1.BaseValidationRule {
-    constructor() {
-        super("required");
-    }
-    validate(context, options) {
-        const { field, value } = context;
-        if (value === null || value === undefined)
-            return this.createError(field, options?.message || `${field} is required`, value);
-        return null;
-    }
-}
-exports.RequiredRule = RequiredRule;