@avleon/core 0.0.46 → 0.0.48

package/dist/validation.js

@@ -1,108 +0,0 @@
-"use strict";
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = void 0;
-exports.validateOrThrow = validateOrThrow;
-const exceptions_1 = require("./exceptions");
-class PValidationRule {
-    constructor(name, type, message) {
-        this.name = name;
-        this.type = type;
-        this.message = message;
-    }
-}
-class Validator {
-    constructor(obj, options) {
-        this.rules = [];
-        this.options = {};
-        this.init(obj);
-        if (options) {
-            this.options = options;
-        }
-    }
-    init(obj) {
-        Object.keys(obj).forEach((key) => {
-            const rule = obj[key];
-            this.rules.push(new PValidationRule(key, rule.type, rule.message));
-        });
-    }
-    validate(obj, options) {
-        const erors = [];
-        this.rules.forEach((k) => {
-            const r = Object.keys(obj).find((key) => key == k.name);
-            let messages = [];
-            if (!r || obj[r] == undefined || obj[r] == "") {
-                messages.push({
-                    constraint: "required",
-                    message: k.name + " is required",
-                });
-            }
-            if (k.type == "string" && typeof obj[k.name] != "string") {
-                messages.push({
-                    constraint: "type",
-                    message: `${k.name} must be type ${k.type}`,
-                });
-            }
-            if (k.type == "number" && !parseInt(obj[k.name])) {
-                messages.push({
-                    constraint: "type",
-                    message: `${k.name} must be type ${k.type}`,
-                });
-            }
-            if (k.type == "number") {
-                obj[k.name] = parseInt(obj[k.name]);
-            }
-            if (k.type == "boolean" && !isBool(obj[k.name])) {
-                messages.push({
-                    constraint: "type",
-                    message: `${k.name} must be type ${k.type}`,
-                });
-            }
-            if (k.type == "boolean") {
-                obj[k.name] = parseBoolean(obj[k.name]);
-            }
-            if (messages.length > 0) {
-                erors.push({
-                    path: k.name,
-                    ...(this.options.location ? { location: this.options.location } : {}),
-                    constraints: messages,
-                });
-            }
-        });
-        return [erors, obj];
-    }
-}
-exports.Validator = Validator;
-const isBool = (val) => {
-    if (typeof val == "boolean")
-        return true;
-    if (parseInt(val) == 0 || parseInt(val) == 1)
-        return true;
-    if (val == "true" || val == "false")
-        return true;
-    return false;
-};
-const parseBoolean = (val) => {
-    if (typeof val === "boolean")
-        return val;
-    if (parseInt(val) == 1)
-        return true;
-    if (typeof val === "string") {
-        const normalized = val.trim().toLowerCase();
-        return normalized === "true";
-    }
-    return false;
-};
-function validateOrThrow(obj, rules, options) {
-    const valid = new Validator(rules, options);
-    const errors = valid.validate(obj);
-    if (errors[0].length > 0) {
-        throw new exceptions_1.BadRequestException(errors[0]);
-    }
-    return errors[1];
-}

package/dist/validation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/validation.test.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validation_1 = require("./validation");
-describe("Validator.validate", () => {
-    const rules = {
-        username: { type: "string", required: true },
-        age: { type: "number", required: true },
-        isActive: { type: "boolean", required: true },
-    };
-    it("should pass validation for correct types", () => {
-        const validator = new validation_1.Validator(rules);
-        const input = { username: "john", age: 25, isActive: true };
-        const [errors, validated] = validator.validate(input);
-        expect(errors).toEqual([]);
-        expect(validated).toEqual({ username: "john", age: 25, isActive: true });
-    });
-    it("should fail when required fields are missing", () => {
-        const validator = new validation_1.Validator(rules);
-        const input = { age: 30 };
-        const [errors] = validator.validate(input);
-        expect(errors).toEqual(expect.arrayContaining([
-            expect.objectContaining({ path: "username" }),
-            expect.objectContaining({ path: "isActive" }),
-        ]));
-    });
-    it("should fail when types are incorrect", () => {
-        const validator = new validation_1.Validator(rules);
-        const input = { username: 123, age: "notanumber", isActive: "notabool" };
-        const [errors] = validator.validate(input);
-        expect(errors).toEqual(expect.arrayContaining([
-            expect.objectContaining({ path: "username" }),
-            expect.objectContaining({ path: "age" }),
-            expect.objectContaining({ path: "isActive" }),
-        ]));
-    });
-    it("should coerce number and boolean types", () => {
-        const validator = new validation_1.Validator(rules);
-        const input = { username: "john", age: "42", isActive: "true" };
-        const [errors, validated] = validator.validate(input);
-        expect(errors).toEqual([]);
-        expect(validated.age).toBe(42);
-        expect(validated.isActive).toBe(true);
-    });
-    it("should handle boolean values as 0/1 and 'true'/'false'", () => {
-        const validator = new validation_1.Validator(rules);
-        const input1 = { username: "john", age: 20, isActive: 1 };
-        const input2 = { username: "john", age: 20, isActive: "false" };
-        const [errors1, validated1] = validator.validate(input1);
-        const [errors2, validated2] = validator.validate(input2);
-        expect(errors1).toEqual([]);
-        expect(validated1.isActive).toBe(true);
-        expect(errors2).toEqual([]);
-        expect(validated2.isActive).toBe(false);
-    });
-    it("should include location in error if option is set", () => {
-        const validator = new validation_1.Validator(rules, { location: "body" });
-        const input = { age: 30 };
-        const [errors] = validator.validate(input);
-        expect(errors[0]).toHaveProperty("location", "body");
-    });
-});

package/dist/validator-extend.d.ts

@@ -1,7 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export declare function IsArrayNotEmpty(validationOptions?: any): (object: Object, propertyName: string) => void;

package/dist/validator-extend.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsArrayNotEmpty = IsArrayNotEmpty;
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-function IsArrayNotEmpty(validationOptions) {
-    const { registerDecorator, ValidationArguments } = require("class-validator");
-    return function (object, propertyName) {
-        registerDecorator({
-            name: "isArrayWithAtLeastOneElement",
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, args) {
-                    return Array.isArray(value) && value.length > 0;
-                },
-                defaultMessage(args) {
-                    return `${args.property} must contain at least one item.`;
-                },
-            },
-        });
-    };
-}

package/dist/websocket.d.ts

@@ -1,10 +0,0 @@
-import { Server } from "socket.io";
-import { Token } from "typedi";
-export declare const SocketIoServer: Token<Server<import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, any>>;
-export declare class AvleonSocketIo {
-    private io?;
-    sendToAll(): void;
-    sendOnly(): void;
-    sendRoom(): void;
-    receive(channel: string): void;
-}

package/dist/websocket.js

@@ -1,21 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvleonSocketIo = exports.SocketIoServer = void 0;
-const typedi_1 = require("typedi");
-exports.SocketIoServer = new typedi_1.Token("SocketIoServer");
-let AvleonSocketIo = class AvleonSocketIo {
-    sendToAll() { }
-    sendOnly() { }
-    sendRoom() { }
-    receive(channel) { }
-};
-exports.AvleonSocketIo = AvleonSocketIo;
-exports.AvleonSocketIo = AvleonSocketIo = __decorate([
-    (0, typedi_1.Service)()
-], AvleonSocketIo);

package/dist/websocket.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/websocket.test.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const websocket_1 = require("./websocket");
-describe("AvleonSocketIo", () => {
-    let avleonSocketIo;
-    beforeEach(() => {
-        avleonSocketIo = new websocket_1.AvleonSocketIo();
-    });
-    it("should be defined", () => {
-        expect(avleonSocketIo).toBeDefined();
-    });
-    it("should have sendToAll method", () => {
-        expect(typeof avleonSocketIo.sendToAll).toBe("function");
-    });
-    it("should have sendOnly method", () => {
-        expect(typeof avleonSocketIo.sendOnly).toBe("function");
-    });
-    it("should have sendRoom method", () => {
-        expect(typeof avleonSocketIo.sendRoom).toBe("function");
-    });
-    it("should have receive method", () => {
-        expect(typeof avleonSocketIo.receive).toBe("function");
-    });
-    it("receive should accept a channel string", () => {
-        expect(() => avleonSocketIo.receive("test-channel")).not.toThrow();
-    });
-});