@avleon/core 0.0.46 → 0.0.48

package/dist/middleware.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthorizeMiddleware = exports.AvleonMiddleware = void 0;
-exports.CanAuthorize = CanAuthorize;
-exports.AppAuthorization = AppAuthorization;
-exports.Authorized = Authorized;
-exports.AppMiddleware = AppMiddleware;
-exports.UseMiddleware = UseMiddleware;
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-const typedi_1 = require("typedi");
-const container_1 = require("./container");
-class AvleonMiddleware {
-}
-exports.AvleonMiddleware = AvleonMiddleware;
-class AuthorizeMiddleware {
-}
-exports.AuthorizeMiddleware = AuthorizeMiddleware;
-function CanAuthorize(target) {
-    if (typeof target.prototype.authorize !== "function") {
-        throw new Error(`Class "${target.name}" must implement an "authorize" method.`);
-    }
-    (0, typedi_1.Service)()(target);
-}
-function AppAuthorization(target) {
-    if (typeof target.prototype.authorize !== "function") {
-        throw new Error(`Class "${target.name}" must implement an "authorize" method.`);
-    }
-    (0, typedi_1.Service)()(target);
-}
-function Authorized(options = {}) {
-    return function (target, propertyKey, descriptor) {
-        if (propertyKey && descriptor) {
-            Reflect.defineMetadata(container_1.AUTHORIZATION_META_KEY, { authorize: true, options }, target.constructor, propertyKey);
-        }
-        else {
-            Reflect.defineMetadata(container_1.AUTHORIZATION_META_KEY, { authorize: true, options }, target);
-        }
-    };
-}
-function AppMiddleware(target) {
-    if (typeof target.prototype.invoke !== "function") {
-        throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
-    }
-    (0, typedi_1.Service)()(target);
-}
-/**
- * A decorator function that applies one or more middleware to a class or a method.
- *
- * When applied to a class, the middleware are registered for the entire controller.
- * When applied to a method, the middleware are registered for that specific route.
- *
- * @param options - A single middleware instance/class or an array of middleware instances/classes to be applied.
- * @returns A decorator that registers the middleware metadata.
- */
-function UseMiddleware(options) {
-    return function (target, propertyKey, descriptor) {
-        const normalizeMiddleware = (middleware) => typeof middleware === "function" ? new middleware() : middleware;
-        const middlewareList = (Array.isArray(options) ? options : [options]).map(normalizeMiddleware);
-        if (typeof target === "function" && !propertyKey) {
-            const existingMiddlewares = Reflect.getMetadata("controller:middleware", target) || [];
-            Reflect.defineMetadata("controller:middleware", [...existingMiddlewares, ...middlewareList], target);
-        }
-        else if (descriptor) {
-            const existingMiddlewares = Reflect.getMetadata("route:middleware", target, propertyKey) || [];
-            Reflect.defineMetadata("route:middleware", [...existingMiddlewares, ...middlewareList], target, propertyKey);
-        }
-    };
-}

package/dist/middleware.test.d.ts

@@ -1 +0,0 @@
-import "reflect-metadata";

package/dist/middleware.test.js

@@ -1,121 +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;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const middleware_1 = require("./middleware");
-describe("AvleonMiddleware", () => {
-    class TestMiddleware extends middleware_1.AvleonMiddleware {
-        async invoke(req, res) {
-            return req;
-        }
-    }
-    it("should allow AppMiddleware decorator on valid class", () => {
-        expect(() => (0, middleware_1.AppMiddleware)(TestMiddleware)).not.toThrow();
-    });
-    it("should throw error if AppMiddleware is used on class without invoke", () => {
-        class InvalidMiddleware {
-        }
-        expect(() => (0, middleware_1.AppMiddleware)(InvalidMiddleware)).toThrow(/must implement an "invoke" method/);
-    });
-});
-describe("UseMiddleware", () => {
-    class MW1 extends middleware_1.AvleonMiddleware {
-        async invoke(req) {
-            return req;
-        }
-    }
-    class MW2 extends middleware_1.AvleonMiddleware {
-        async invoke(req) {
-            return req;
-        }
-    }
-    it("should attach middleware to class", () => {
-        let TestController = class TestController {
-        };
-        TestController = __decorate([
-            (0, middleware_1.UseMiddleware)([MW1, MW2])
-        ], TestController);
-        const middlewares = Reflect.getMetadata("controller:middleware", TestController);
-        expect(middlewares).toHaveLength(2);
-        expect(middlewares[0]).toBeInstanceOf(MW1);
-        expect(middlewares[1]).toBeInstanceOf(MW2);
-    });
-    it("should attach middleware to method", () => {
-        class TestController {
-            testMethod() { }
-        }
-        __decorate([
-            (0, middleware_1.UseMiddleware)(MW1),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", void 0)
-        ], TestController.prototype, "testMethod", null);
-        const middlewares = Reflect.getMetadata("route:middleware", TestController.prototype, "testMethod");
-        expect(middlewares).toHaveLength(1);
-        expect(middlewares[0]).toBeInstanceOf(MW1);
-    });
-});
-// describe("Authorized decorator", () => {
-// it("should define metadata on class", () => {
-//     @Authorized({ roles: ["admin"] })
-//     class TestClass {}
-//     const meta = Reflect.getMetadata("AUTHORIZATION_META_KEY", TestClass);
-//     expect(meta).toEqual({ authorize: true, options: { roles: ["admin"] } });
-// });
-// it("should define metadata on method", () => {
-//     class TestClass {
-//         @Authorized({ roles: ["user"] })
-//         testMethod() {}
-//     }
-//     const meta = Reflect.getMetadata(
-//         "AUTHORIZATION_META_KEY",
-//         TestClass.constructor,
-//         "testMethod",
-//     );
-//     expect(meta).toEqual({ authorize: true, options: { roles: ["user"] } });
-// });
-describe("CanAuthorize and AppAuthorization", () => {
-    class ValidAuthorize {
-        authorize(req, options) {
-            return req;
-        }
-    }
-    it("should not throw for valid CanAuthorize", () => {
-        expect(() => (0, middleware_1.CanAuthorize)(ValidAuthorize)).not.toThrow();
-    });
-    it("should throw for invalid CanAuthorize", () => {
-        class InvalidAuthorize {
-        }
-        expect(() => (0, middleware_1.CanAuthorize)(InvalidAuthorize)).toThrow(/must implement an "authorize" method/);
-    });
-    it("should not throw for valid AppAuthorization", () => {
-        expect(() => (0, middleware_1.AppAuthorization)(ValidAuthorize)).not.toThrow();
-    });
-    it("should throw for invalid AppAuthorization", () => {
-        class InvalidAuthorize {
-        }
-        expect(() => (0, middleware_1.AppAuthorization)(InvalidAuthorize)).toThrow(/must implement an "authorize" method/);
-    });
-});
-describe("AuthorizeMiddleware", () => {
-    class TestAuthorizeMiddleware extends middleware_1.AuthorizeMiddleware {
-        authorize(roles) {
-            return (req) => req;
-        }
-    }
-    it("should implement authorize method", () => {
-        const mw = new TestAuthorizeMiddleware();
-        const handler = mw.authorize(["admin"]);
-        expect(typeof handler).toBe("function");
-        const req = {};
-        expect(handler(req)).toBe(req);
-    });
-});

package/dist/multipart.d.ts

@@ -1,17 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import { MultipartFile as FsM, SavedMultipartFile } from "@fastify/multipart";
-import { IRequest } from "./core/types";
-export declare function UploadFile(fieldName: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-export declare function UploadFiles(fieldName?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-type Foptions = {
-    saveAs?: string;
-    dest?: true;
-};
-export type MultipartFile = FsM | SavedMultipartFile;
-export declare function UploadFileFromRequest(req: IRequest, options?: Foptions): Promise<any>;
-export {};

package/dist/multipart.js

@@ -1,70 +0,0 @@
-"use strict";
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UploadFile = UploadFile;
-exports.UploadFiles = UploadFiles;
-exports.UploadFileFromRequest = UploadFileFromRequest;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const promises_1 = require("stream/promises");
-const exceptions_1 = require("./exceptions");
-const container_1 = require("./container");
-function UploadFile(fieldName) {
-    return function (target, propertyKey, parameterIndex) {
-        if (!Reflect.hasMetadata(container_1.REQUEST_BODY_FILE_KEY, target, propertyKey)) {
-            Reflect.defineMetadata(container_1.REQUEST_BODY_FILE_KEY, [], target, propertyKey);
-        }
-        const existingMetadata = Reflect.getMetadata(container_1.REQUEST_BODY_FILE_KEY, target, propertyKey);
-        existingMetadata.push({ fieldName, index: parameterIndex });
-        Reflect.defineMetadata(container_1.REQUEST_BODY_FILE_KEY, existingMetadata, target, propertyKey);
-    };
-}
-function UploadFiles(fieldName) {
-    return function (target, propertyKey, parameterIndex) {
-        if (!Reflect.hasMetadata(container_1.REQUEST_BODY_FILES_KEY, target, propertyKey)) {
-            Reflect.defineMetadata(container_1.REQUEST_BODY_FILES_KEY, [], target, propertyKey);
-        }
-        const existingMetadata = Reflect.getMetadata(container_1.REQUEST_BODY_FILES_KEY, target, propertyKey);
-        existingMetadata.push({
-            fieldName: fieldName ? fieldName : "all",
-            index: parameterIndex,
-        });
-        Reflect.defineMetadata(container_1.REQUEST_BODY_FILES_KEY, existingMetadata, target, propertyKey);
-    };
-}
-function UploadFileFromRequest(req, options) {
-    return Promise.resolve(req.file().then(async (f) => {
-        if (f && f.file) {
-            let fname = f.filename;
-            if (options) {
-                if (options.dest) {
-                    fname = options.saveAs
-                        ? options.dest + "/" + options.saveAs
-                        : options.dest + "/" + f.filename;
-                }
-                else {
-                    fname = path_1.default.join(process.cwd(), `public/${options.saveAs ? options.saveAs : f.filename}`);
-                }
-            }
-            else {
-                fname = path_1.default.join(process.cwd(), `public/${f.filename}`);
-            }
-            if (fs_1.default.existsSync(fname)) {
-                throw new exceptions_1.InternalErrorException("File already exists.");
-            }
-            await (0, promises_1.pipeline)(f.file, fs_1.default.createWriteStream(fname));
-            return {
-                ...f,
-                filename: (options === null || options === void 0 ? void 0 : options.saveAs) ? options.saveAs : f.filename,
-            };
-        }
-    }));
-}

package/dist/multipart.test.d.ts

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

package/dist/multipart.test.js

@@ -1,87 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const multipart_1 = require("./multipart");
-const exceptions_1 = require("./exceptions");
-const fs_1 = __importDefault(require("fs"));
-jest.mock("fs");
-jest.mock("stream/promises", () => ({
-    pipeline: jest.fn(() => Promise.resolve()),
-}));
-const mockFileStream = {};
-const mockReq = (fileData) => ({
-    params: {},
-    query: {},
-    body: {},
-    headers: {},
-    method: "POST",
-    url: "/upload",
-    file: jest.fn().mockResolvedValue(fileData),
-    // Add any other required IRequest properties as needed for type compatibility
-});
-describe("UploadFileFromRequest", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        fs_1.default.existsSync.mockReturnValue(false);
-    });
-    // it("should save file to default location", async () => {
-    //     const fileData = {
-    //         file: mockFileStream,
-    //         filename: "test.txt",
-    //     };
-    //     const req = mockReq(fileData);
-    //     const result = await UploadFileFromRequest(req);
-    //     expect(fs.existsSync).toHaveBeenCalled();
-    //     expect(pipeline).toHaveBeenCalledWith(mockFileStream, expect.anything());
-    //     expect(result).toMatchObject({
-    //         ...fileData,
-    //         filename: "test.txt",
-    //     });
-    // });
-    // it("should save file to custom location with saveAs", async () => {
-    //     const fileData = {
-    //         file: mockFileStream,
-    //         filename: "original.txt",
-    //     };
-    //     const req = mockReq(fileData);
-    //     const options = { saveAs: "custom.txt" };
-    //     const result = await UploadFileFromRequest(req, options);
-    //     expect(fs.existsSync).toHaveBeenCalled();
-    //     expect(pipeline).toHaveBeenCalledWith(mockFileStream, expect.anything());
-    //     expect(result).toMatchObject({
-    //         ...fileData,
-    //         filename: "custom.txt",
-    //     });
-    // });
-    // it("should save file to custom dest", async () => {
-    //     const fileData = {
-    //         file: mockFileStream,
-    //         filename: "file.txt",
-    //     };
-    //     const req = mockReq(fileData);
-    //     const options:any = { dest: "/tmp" };
-    //     const result = await UploadFileFromRequest(req, options);
-    //     expect(fs.existsSync).toHaveBeenCalled();
-    //     expect(pipeline).toHaveBeenCalledWith(mockFileStream, expect.anything());
-    //     expect(result).toMatchObject({
-    //         ...fileData,
-    //         filename: "file.txt",
-    //     });
-    // });
-    it("should throw error if file already exists", async () => {
-        fs_1.default.existsSync.mockReturnValue(true);
-        const fileData = {
-            file: mockFileStream,
-            filename: "exists.txt",
-        };
-        const req = mockReq(fileData);
-        await expect((0, multipart_1.UploadFileFromRequest)(req)).rejects.toThrow(exceptions_1.InternalErrorException);
-    });
-    it("should return undefined if no file is present", async () => {
-        const req = mockReq(null);
-        const result = await (0, multipart_1.UploadFileFromRequest)(req);
-        expect(result).toBeUndefined();
-    });
-});