@avleon/core 0.0.45 → 0.0.48

package/dist/testing.js

@@ -1,196 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvleonTestBuilder = exports.AvleonTestUtility = void 0;
-exports.UnitTest = UnitTest;
-require("reflect-metadata");
-const typedi_1 = require("typedi");
-const typeorm_1 = require("typeorm");
-const icore_1 = require("./icore");
-// Enhanced Test Utilities
-class AvleonTestUtility {
-    /**
-     * Initialize test environment
-     */
-    static async init(options) {
-        // Reset container if specified
-        if (options === null || options === void 0 ? void 0 : options.resetContainer) {
-            this.testContainer = typedi_1.Container;
-            this.testContainer.reset();
-        }
-        // Initialize test database if options provided
-        if (options === null || options === void 0 ? void 0 : options.dataSourceOptions) {
-            this.testDataSource = new typeorm_1.DataSource({
-                ...options.dataSourceOptions,
-                logging: false, // Disable logging during tests
-            });
-            await this.testDataSource.initialize();
-            await this.testDataSource.synchronize(true); // Create schema
-        }
-        return this;
-    }
-    /**
-     * Mock a dependency for testing
-     * @param token Dependency token
-     * @param mockImplementation Mock implementation
-     */
-    static mockDependency(token, mockImplementation) {
-        typedi_1.Container.set(token, mockImplementation);
-        return mockImplementation;
-    }
-    /**
-     * Create an isolated test instance of a class
-     * @param ClassType Class to instantiate
-     * @param overrides Optional property overrides
-     */
-    static createTestInstance(ClassType, overrides = {}) {
-        const instance = typedi_1.Container.get(ClassType);
-        // Apply overrides
-        Object.keys(overrides).forEach((key) => {
-            instance[key] = overrides[key];
-        });
-        return instance;
-    }
-    /**
-     * Cleanup test environment
-     */
-    static async cleanup() {
-        if (this.testDataSource) {
-            await this.testDataSource.dropDatabase();
-            await this.testDataSource.destroy();
-            this.testDataSource = null;
-        }
-        // Reset container
-        typedi_1.Container.reset();
-    }
-}
-exports.AvleonTestUtility = AvleonTestUtility;
-AvleonTestUtility.testDataSource = null;
-// Enhanced Test Builder
-class AvleonTestBuilder {
-    constructor() {
-        this.controllers = [];
-        this.testOptions = {};
-        this.mocks = new Map();
-    }
-    /**
-     * Add controllers for testing
-     * @param controllers Controllers to add
-     */
-    addControllers(...controllers) {
-        this.controllers.push(...controllers);
-        return this;
-    }
-    /**
-     * Mock a dependency
-     * @param token Dependency token
-     * @param mockImplementation Mock implementation
-     */
-    mockDependency(token, mockImplementation) {
-        this.mocks.set(token, mockImplementation);
-        return this;
-    }
-    /**
-     * Set test options
-     * @param options Test configuration options
-     */
-    setOptions(options) {
-        this.testOptions = { ...this.testOptions, ...options };
-        return this;
-    }
-    /**
-     * Build test application
-     */
-    async build() {
-        // Apply mocks
-        this.mocks.forEach((mock, token) => {
-            typedi_1.Container.set(token, mock);
-        });
-        // Initialize test utility
-        await AvleonTestUtility.init({
-            dataSourceOptions: this.testOptions.dataSourceOptions,
-            resetContainer: true,
-        });
-        // Create test application
-        const app = icore_1.AvleonApplication.getInternalApp({
-            dataSourceOptions: this.testOptions.dataSourceOptions,
-        });
-        // Map controllers
-        app.useControllers(this.controllers);
-        // Get test application
-        return app.getTestApp();
-    }
-}
-exports.AvleonTestBuilder = AvleonTestBuilder;
-// Example Usage Decorator
-function UnitTest() {
-    return (target, propertyKey, descriptor) => {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            try {
-                // Pre-test setup
-                await AvleonTestUtility.init();
-                // Execute test
-                const result = await originalMethod.apply(this, args);
-                // Post-test cleanup
-                await AvleonTestUtility.cleanup();
-                return result;
-            }
-            catch (error) {
-                // Ensure cleanup even if test fails
-                await AvleonTestUtility.cleanup();
-                throw error;
-            }
-        };
-        return descriptor;
-    };
-}
-//
-// // Example of Unit and Integration Test
-// class UserServiceTest {
-//   @UnitTest()
-//   async testUserCreation() {
-//     // Mock UserRepository
-//     const mockRepo = AvleonTestUtility.mockDependency(
-//       UserRepository,
-//       { create: jest.fn() }
-//     );
-//
-//     // Create test instance
-//     const userService = AvleonTestUtility.createTestInstance(UserService);
-//
-//     // Perform test
-//     const result = await userService.createUser({
-//       name: 'Test User',
-//       email: 'test@example.com'
-//     });
-//
-//     // Assertions
-//     expect(mockRepo.create).toHaveBeenCalledWith(expect.any(Object));
-//   }
-// }
-//
-// // Enhanced E2E Testing Example
-// class E2EUserControllerTest {
-//   async testUserRegistration() {
-//     // Build test application
-//     const testApp = await new AvleonTestBuilder()
-//       .addControllers(UserController)
-//       .mockDependency(AuthService, mockAuthService)
-//       .setOptions({
-//         dataSourceOptions: testDatabaseConfig
-//       })
-//       .build();
-//
-//     // Perform HTTP request
-//     const response = await testApp.post('/users/register', {
-//       payload: {
-//         name: 'John Doe',
-//         email: 'john@example.com'
-//       }
-//     });
-//
-//     // Assertions
-//     expect(response.statusCode).toBe(201);
-//     expect(response.json()).toHaveProperty('userId');
-//   }
-// }

package/dist/types/app-builder.interface.d.ts

@@ -1,15 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import { IApplication } from "./application.interface";
-export interface IAppBuilder {
-    createBuilder(): IAppBuilder;
-    /**
-     * @description will create a application instace
-     * @returns IApplication
-     */
-    builder: () => IApplication;
-}

package/dist/types/app-builder.interface.js

@@ -1,8 +0,0 @@
-"use strict";
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/application.interface.d.ts

@@ -1,8 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface IApplication {
-}

package/dist/types/application.interface.js

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

package/dist/utils/hash.d.ts

@@ -1,4 +0,0 @@
-export declare const hashPasswordSync: (password: string) => string;
-export declare const matchPasswordSync: (password: string, hash: string) => boolean;
-export declare const hashPassword: (password: string) => Promise<string>;
-export declare const matchPassword: (password: string, hash: string) => Promise<boolean>;

package/dist/utils/hash.js

@@ -1,15 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchPassword = exports.hashPassword = exports.matchPasswordSync = exports.hashPasswordSync = void 0;
-const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const hashPasswordSync = (password) => bcryptjs_1.default.hashSync(password, 12);
-exports.hashPasswordSync = hashPasswordSync;
-const matchPasswordSync = (password, hash) => bcryptjs_1.default.compareSync(password, hash);
-exports.matchPasswordSync = matchPasswordSync;
-const hashPassword = (password) => bcryptjs_1.default.hash(password, 12);
-exports.hashPassword = hashPassword;
-const matchPassword = (password, hash) => bcryptjs_1.default.compare(password, hash);
-exports.matchPassword = matchPassword;

package/dist/utils/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./hash";
-export * from "./optional-require";

package/dist/utils/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hash"), exports);
-__exportStar(require("./optional-require"), exports);

package/dist/utils/optional-require.d.ts

@@ -1,8 +0,0 @@
-export declare function optionalRequire<T = any>(moduleName: string, options?: {
-    failOnMissing?: boolean;
-    customMessage?: string;
-}): T | undefined;
-export declare function optionalImport<T = any>(moduleName: string, options?: {
-    failOnMissing?: boolean;
-    customMessage?: string;
-}): Promise<T | undefined>;

package/dist/utils/optional-require.js

@@ -1,70 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.optionalRequire = optionalRequire;
-exports.optionalImport = optionalImport;
-function optionalRequire(moduleName, options = {}) {
-    try {
-        return require(moduleName);
-    }
-    catch (err) {
-        if (err.code === "MODULE_NOT_FOUND" && err.message.includes(moduleName)) {
-            if (options.failOnMissing) {
-                throw new Error(options.customMessage ||
-                    `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`);
-            }
-            return undefined;
-        }
-        throw err;
-    }
-}
-async function optionalImport(moduleName, options = {}) {
-    try {
-        const mod = await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
-        return mod;
-    }
-    catch (err) {
-        if ((err.code === "ERR_MODULE_NOT_FOUND" ||
-            err.code === "MODULE_NOT_FOUND") &&
-            err.message.includes(moduleName)) {
-            if (options.failOnMissing) {
-                throw new Error(options.customMessage ||
-                    `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`);
-            }
-            return undefined;
-        }
-        throw err;
-    }
-}

package/dist/validation.d.ts

@@ -1,39 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-type BaseRule = {
-    required?: boolean;
-    optional?: boolean;
-    message?: string;
-};
-type StringRule = BaseRule & {
-    type: "string";
-};
-type NumberRule = BaseRule & {
-    type: "number";
-    min?: number;
-    max?: number;
-    exact?: number;
-};
-type BooleanRule = BaseRule & {
-    type: "boolean";
-};
-export type ValidationRule = StringRule | NumberRule | BooleanRule;
-export type ValidationProps = {
-    [key: string]: ValidationRule;
-};
-export type ValidateOptons = {
-    location?: "header" | "queryparam" | "param" | "body" | "custom";
-};
-export declare class Validator {
-    private rules;
-    private options;
-    constructor(obj: ValidationProps, options?: ValidateOptons);
-    private init;
-    validate(obj: any | Array<any>, options?: ValidateOptons): any[];
-}
-export declare function validateOrThrow<T extends {}>(obj: T, rules: ValidationProps, options?: ValidateOptons): any;
-export {};

package/dist/validation.js

@@ -1,111 +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 (typeof val === "number") {
-    //   return val !== 0; // Common convention: 0 → false, any other number → true
-    // }
-    if (parseInt(val) == 1)
-        return true;
-    if (typeof val === "string") {
-        const normalized = val.trim().toLowerCase();
-        return normalized === "true";
-    }
-    return false; // Default for unsupported types (null, undefined, objects, etc.)
-};
-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,7 +0,0 @@
-export declare class AvleonSocketIo {
-    private io?;
-    sendToAll(): void;
-    sendOnly(): void;
-    sendRoom(): void;
-    receive(channel: string): void;
-}

package/dist/websocket.js

@@ -1,20 +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 = void 0;
-const typedi_1 = require("typedi");
-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();
-    });
-});