@avleon/core 0.0.45 → 0.0.48

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 "./icore";
-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<FsM | undefined>;
-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();
-    });
-});

package/dist/openapi.d.ts

@@ -1,343 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface InfoObject {
-    title: string;
-    description?: string;
-    termsOfService?: string;
-    contact?: ContactObject;
-    license?: LicenseObject;
-    version: string;
-}
-export interface ContactObject {
-    name?: string;
-    url?: string;
-    email?: string;
-}
-export interface LicenseObject {
-    name: string;
-    url?: string;
-}
-export interface ServerObject {
-    url: string;
-    description?: string;
-    variables?: {
-        [variable: string]: ServerVariableObject;
-    };
-}
-export interface ServerVariableObject {
-    enum?: string[];
-    default: string;
-    description?: string;
-}
-export type OpenApiUiOptions = {
-    logo?: any;
-    theme?: any;
-    ui?: "default" | "scalar";
-    openapi?: string;
-    configuration?: any;
-    routePrefix?: string;
-    info?: InfoObject;
-    servers?: ServerObject[];
-    paths?: PathsObject<any>;
-    components?: ComponentsObject;
-    security?: SecurityRequirementObject[];
-    tags?: TagObject[];
-    externalDocs?: any;
-    "x-express-openapi-additional-middleware"?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
-    "x-express-openapi-validation-strict"?: boolean;
-};
-export interface PathsObject<T extends {} = {}, P extends {} = {}> {
-    [pattern: string]: (PathItemObject<T> & P) | undefined;
-}
-declare enum HttpMethods {
-    GET = "get",
-    PUT = "put",
-    POST = "post",
-    DELETE = "delete",
-    OPTIONS = "options",
-    HEAD = "head",
-    PATCH = "patch",
-    TRACE = "trace"
-}
-export type PathItemObject<T extends {} = {}> = {
-    $ref?: string;
-    summary?: string;
-    description?: string;
-    servers?: ServerObject[];
-    parameters?: (ReferenceObject | ParameterObject)[];
-} & {
-    [method in HttpMethods]?: OperationObject<T>;
-};
-export type OperationObject<T extends {} = {}> = {
-    tags?: string[];
-    summary?: string;
-    description?: string;
-    externalDocs?: ExternalDocumentationObject;
-    operationId?: string;
-    parameters?: (ReferenceObject | ParameterObject)[];
-    requestBody?: ReferenceObject | RequestBodyObject;
-    responses: ResponsesObject;
-    callbacks?: {
-        [callback: string]: ReferenceObject | CallbackObject;
-    };
-    deprecated?: boolean;
-    security?: SecurityRequirementObject[];
-    servers?: ServerObject[];
-} & T;
-export interface ExternalDocumentationObject {
-    description?: string;
-    url: string;
-}
-export interface ParameterObject extends ParameterBaseObject {
-    name: string;
-    in: string;
-}
-export interface HeaderObject extends ParameterBaseObject {
-}
-export interface ParameterBaseObject {
-    description?: string;
-    required?: boolean;
-    deprecated?: boolean;
-    allowEmptyValue?: boolean;
-    style?: string;
-    explode?: boolean;
-    allowReserved?: boolean;
-    schema?: ReferenceObject | SchemaObject;
-    example?: any;
-    examples?: {
-        [media: string]: ReferenceObject | ExampleObject;
-    };
-    content?: {
-        [media: string]: MediaTypeObject;
-    };
-}
-export type NonArraySchemaObjectType = "boolean" | "object" | "number" | "string" | "integer";
-export type ArraySchemaObjectType = "array";
-export type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
-export interface ArraySchemaObject extends BaseSchemaObject {
-    type: ArraySchemaObjectType;
-    items: ReferenceObject | SchemaObject;
-}
-export interface NonArraySchemaObject extends BaseSchemaObject {
-    type?: NonArraySchemaObjectType;
-}
-export interface BaseSchemaObject {
-    title?: string;
-    description?: string;
-    format?: string;
-    default?: any;
-    multipleOf?: number;
-    maximum?: number;
-    exclusiveMaximum?: boolean;
-    minimum?: number;
-    exclusiveMinimum?: boolean;
-    maxLength?: number;
-    minLength?: number;
-    pattern?: string;
-    additionalProperties?: boolean | ReferenceObject | SchemaObject;
-    maxItems?: number;
-    minItems?: number;
-    uniqueItems?: boolean;
-    maxProperties?: number;
-    minProperties?: number;
-    required?: string[];
-    enum?: any[];
-    properties?: {
-        [name: string]: ReferenceObject | SchemaObject;
-    };
-    allOf?: (ReferenceObject | SchemaObject)[];
-    oneOf?: (ReferenceObject | SchemaObject)[];
-    anyOf?: (ReferenceObject | SchemaObject)[];
-    not?: ReferenceObject | SchemaObject;
-    nullable?: boolean;
-    discriminator?: DiscriminatorObject;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-    xml?: XMLObject;
-    externalDocs?: ExternalDocumentationObject;
-    example?: any;
-    deprecated?: boolean;
-}
-export interface DiscriminatorObject {
-    propertyName: string;
-    mapping?: {
-        [value: string]: string;
-    };
-}
-export interface XMLObject {
-    name?: string;
-    namespace?: string;
-    prefix?: string;
-    attribute?: boolean;
-    wrapped?: boolean;
-}
-export interface ReferenceObject {
-    $ref: string;
-}
-export interface ExampleObject {
-    summary?: string;
-    description?: string;
-    value?: any;
-    externalValue?: string;
-}
-export interface MediaTypeObject {
-    schema?: ReferenceObject | SchemaObject;
-    example?: any;
-    examples?: {
-        [media: string]: ReferenceObject | ExampleObject;
-    };
-    encoding?: {
-        [media: string]: EncodingObject;
-    };
-}
-export interface EncodingObject {
-    contentType?: string;
-    headers?: {
-        [header: string]: ReferenceObject | HeaderObject;
-    };
-    style?: string;
-    explode?: boolean;
-    allowReserved?: boolean;
-}
-export interface RequestBodyObject {
-    description?: string;
-    content: {
-        [media: string]: MediaTypeObject;
-    };
-    required?: boolean;
-}
-export interface ResponsesObject {
-    [code: string]: ReferenceObject | ResponseObject;
-}
-export interface ResponseObject {
-    description: string;
-    headers?: {
-        [header: string]: ReferenceObject | HeaderObject;
-    };
-    content?: {
-        [media: string]: MediaTypeObject;
-    };
-    links?: {
-        [link: string]: ReferenceObject | LinkObject;
-    };
-}
-export interface LinkObject {
-    operationRef?: string;
-    operationId?: string;
-    parameters?: {
-        [parameter: string]: any;
-    };
-    requestBody?: any;
-    description?: string;
-    server?: ServerObject;
-}
-export interface CallbackObject {
-    [url: string]: PathItemObject;
-}
-export interface SecurityRequirementObject {
-    [name: string]: string[];
-}
-export interface ComponentsObject {
-    schemas?: {
-        [key: string]: ReferenceObject | SchemaObject;
-    };
-    responses?: {
-        [key: string]: ReferenceObject | ResponseObject;
-    };
-    parameters?: {
-        [key: string]: ReferenceObject | ParameterObject;
-    };
-    examples?: {
-        [key: string]: ReferenceObject | ExampleObject;
-    };
-    requestBodies?: {
-        [key: string]: ReferenceObject | RequestBodyObject;
-    };
-    headers?: {
-        [key: string]: ReferenceObject | HeaderObject;
-    };
-    securitySchemes?: {
-        [key: string]: ReferenceObject | SecuritySchemeObject;
-    };
-    links?: {
-        [key: string]: ReferenceObject | LinkObject;
-    };
-    callbacks?: {
-        [key: string]: ReferenceObject | CallbackObject;
-    };
-}
-export type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
-export interface HttpSecurityScheme {
-    type: "http";
-    description?: string;
-    scheme: string;
-    bearerFormat?: string;
-}
-export interface ApiKeySecurityScheme {
-    type: "apiKey";
-    description?: string;
-    name: string;
-    in: string;
-}
-export interface OAuth2SecurityScheme {
-    type: "oauth2";
-    description?: string;
-    flows: {
-        implicit?: {
-            authorizationUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-        password?: {
-            tokenUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-        clientCredentials?: {
-            tokenUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-        authorizationCode?: {
-            authorizationUrl: string;
-            tokenUrl: string;
-            refreshUrl?: string;
-            scopes: {
-                [scope: string]: string;
-            };
-        };
-    };
-}
-export interface OpenIdSecurityScheme {
-    type: "openIdConnect";
-    description?: string;
-    openIdConnectUrl: string;
-}
-export interface TagObject {
-    name: string;
-    description?: string;
-    externalDocs?: ExternalDocumentationObject;
-}
-export type OpenApiOptions = {
-    exclude?: boolean;
-    deprecated?: boolean;
-    tags?: readonly string[];
-    description?: string;
-    summary?: string;
-    components?: ComponentsObject;
-    response?: any;
-    responseBody?: any;
-    requestBody?: any;
-} & any;
-export declare function OpenApi(options: OpenApiOptions): MethodDecorator & ClassDecorator & PropertyDecorator;
-export {};

package/dist/openapi.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenApi = OpenApi;
-var HttpMethods;
-(function (HttpMethods) {
-    HttpMethods["GET"] = "get";
-    HttpMethods["PUT"] = "put";
-    HttpMethods["POST"] = "post";
-    HttpMethods["DELETE"] = "delete";
-    HttpMethods["OPTIONS"] = "options";
-    HttpMethods["HEAD"] = "head";
-    HttpMethods["PATCH"] = "patch";
-    HttpMethods["TRACE"] = "trace";
-})(HttpMethods || (HttpMethods = {}));
-function OpenApi(options) {
-    return function (target, propertyKey, descriptor) {
-        if (typeof target === "function" && !propertyKey) {
-            Reflect.defineMetadata("controller:openapi", options, target);
-        }
-        else if (descriptor) {
-            Reflect.defineMetadata("route:openapi", options, target, propertyKey);
-        }
-        else if (propertyKey) {
-            Reflect.defineMetadata("property:openapi", options, target, propertyKey);
-        }
-    };
-}

package/dist/openapi.test.d.ts

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

package/dist/openapi.test.js

@@ -1,111 +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 openapi_1 = require("./openapi");
-describe('OpenApi Decorator', () => {
-    it('should define metadata on class', () => {
-        let TestController = class TestController {
-        };
-        TestController = __decorate([
-            (0, openapi_1.OpenApi)({ description: 'Test Controller' })
-        ], TestController);
-        const metadata = Reflect.getMetadata('controller:openapi', TestController);
-        expect(metadata).toEqual({ description: 'Test Controller' });
-    });
-    it('should define metadata on method', () => {
-        class TestController {
-            testMethod() { }
-        }
-        __decorate([
-            (0, openapi_1.OpenApi)({ description: 'Test Route' }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", void 0)
-        ], TestController.prototype, "testMethod", null);
-        const metadata = Reflect.getMetadata('route:openapi', TestController.prototype, 'testMethod');
-        expect(metadata).toEqual({ description: 'Test Route' });
-    });
-    it('should define metadata on property', () => {
-        class TestController {
-            constructor() {
-                this.testProperty = '';
-            }
-        }
-        __decorate([
-            (0, openapi_1.OpenApi)({ description: 'Test Property' }),
-            __metadata("design:type", String)
-        ], TestController.prototype, "testProperty", void 0);
-        const metadata = Reflect.getMetadata('property:openapi', TestController.prototype, 'testProperty');
-        expect(metadata).toEqual({ description: 'Test Property' });
-    });
-});
-describe('Type Definitions', () => {
-    it('InfoObject should allow optional description', () => {
-        const info = {
-            title: 'API',
-            version: '1.0.0',
-            description: 'API Description',
-        };
-        expect(info.description).toBe('API Description');
-    });
-    it('ContactObject should allow optional fields', () => {
-        const contact = {
-            name: 'John Doe',
-            email: 'john@example.com',
-        };
-        expect(contact.name).toBe('John Doe');
-        expect(contact.email).toBe('john@example.com');
-    });
-    it('LicenseObject should require name', () => {
-        const license = {
-            name: 'MIT',
-        };
-        expect(license.name).toBe('MIT');
-    });
-    it('ServerObject should allow variables', () => {
-        var _a;
-        const server = {
-            url: 'https://api.example.com',
-            variables: {
-                version: {
-                    default: 'v1',
-                    enum: ['v1', 'v2'],
-                },
-            },
-        };
-        expect((_a = server.variables) === null || _a === void 0 ? void 0 : _a.version.default).toBe('v1');
-    });
-    it('SchemaObject should allow array and non-array types', () => {
-        const arraySchema = {
-            type: 'array',
-            items: { type: 'string' },
-        };
-        expect(arraySchema.type).toBe('array');
-        const nonArraySchema = {
-            type: 'string',
-        };
-        expect(nonArraySchema.type).toBe('string');
-    });
-    it('ComponentsObject should allow schemas and responses', () => {
-        var _a, _b;
-        const components = {
-            schemas: {
-                User: { type: 'object' },
-            },
-            responses: {
-                NotFound: { description: 'Not found' },
-            },
-        };
-        expect((_a = components.schemas) === null || _a === void 0 ? void 0 : _a.User).toBeDefined();
-        expect(((_b = components.responses) === null || _b === void 0 ? void 0 : _b.NotFound).description).toBe('Not found');
-    });
-});

package/dist/params.d.ts

@@ -1,17 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-type ParameterOptions = {
-    required?: boolean;
-    validate?: boolean;
-    type?: any;
-};
-export declare const Param: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const Query: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const Body: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const Header: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export declare const AuthUser: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
-export {};