@avleon/core 0.0.40 → 0.0.43

package/dist/queue.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const queue_1 = require("./queue");
+const fs_1 = require("fs");
+const path_1 = require("path");
+jest.mock("fs", () => ({
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+    },
+}));
+const mockQueueFile = (0, path_1.join)(__dirname, "testqueue.json");
+describe("FileQueueAdapter", () => {
+    const jobs = [{ id: "1", data: "foo" }, { id: "2", data: "bar" }];
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should load jobs from file", async () => {
+        fs_1.promises.readFile.mockResolvedValue(JSON.stringify(jobs));
+        const adapter = new queue_1.FileQueueAdapter("testqueue");
+        const loaded = await adapter.loadJobs();
+        expect(loaded).toEqual(jobs);
+        expect(fs_1.promises.readFile).toHaveBeenCalledWith(mockQueueFile, "utf-8");
+    });
+    it("should return empty array if file does not exist", async () => {
+        fs_1.promises.readFile.mockRejectedValue(new Error("not found"));
+        const adapter = new queue_1.FileQueueAdapter("testqueue");
+        const loaded = await adapter.loadJobs();
+        expect(loaded).toEqual([]);
+    });
+    it("should save jobs to file", async () => {
+        const adapter = new queue_1.FileQueueAdapter("testqueue");
+        await adapter.saveJobs(jobs);
+        expect(fs_1.promises.writeFile).toHaveBeenCalledWith(mockQueueFile, JSON.stringify(jobs, null, 2), "utf-8");
+    });
+});
+describe("QueueManager and SimpleQueue", () => {
+    let adapter;
+    // let queueManager: QueueManager;
+    let handler;
+    // beforeEach(() => {
+    //     jest.clearAllMocks();
+    //     adapter = new FileQueueAdapter("testqueue");
+    //     queueManager = QueueManager.getInstance(adapter);
+    //     handler = jest.fn().mockResolvedValue(undefined);
+    //     (fs.readFile as jest.Mock).mockResolvedValue("[]");
+    //     (fs.writeFile as jest.Mock).mockResolvedValue(undefined);
+    // });
+    // it("should create a queue and add a job", async () => {
+    //     const queue = queueManager.createQueue(handler);
+    //     await queue.addJob({ foo: "bar" });
+    //     expect(fs.readFile).toHaveBeenCalled();
+    //     expect(fs.writeFile).toHaveBeenCalled();
+    // });
+    // it("should process jobs using handler", async () => {
+    //     (fs.readFile as jest.Mock)
+    //         .mockResolvedValueOnce("[]")
+    //         .mockResolvedValueOnce(JSON.stringify([{ id: "1", data: "baz" }]))
+    //         .mockResolvedValueOnce("[]");
+    //     const queue = queueManager.createQueue(handler);
+    //     await queue.addJob("baz");
+    //     expect(handler).toHaveBeenCalled();
+    // });
+    // it("should requeue job if handler throws", async () => {
+    //     handler.mockRejectedValueOnce(new Error("fail"));
+    //     (fs.readFile as jest.Mock)
+    //         .mockResolvedValueOnce("[]")
+    //         .mockResolvedValueOnce(JSON.stringify([{ id: "1", data: "baz" }]))
+    //         .mockResolvedValueOnce(JSON.stringify([{ id: "1", data: "baz" }]));
+    //     const queue = queueManager.createQueue(handler);
+    //     await queue.addJob("baz");
+    //     expect(handler).toHaveBeenCalled();
+    //     expect(fs.writeFile).toHaveBeenCalledTimes(2);
+    // });
+    // it("QueueManager should be singleton", () => {
+    //     const another = QueueManager.getInstance(adapter);
+    //     expect(another).toBe(queueManager);
+    // });
+});

package/dist/route-methods.test.d.ts

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

package/dist/route-methods.test.js

@@ -0,0 +1,129 @@
+"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 route_methods_1 = require("./route-methods");
+describe("Route Decorators", () => {
+    class TestController {
+        getMethod() { }
+        postMethod() { }
+        putMethod() { }
+        deleteMethod() { }
+        patchMethod() { }
+        optionsMethod() { }
+        allMethod() { }
+        customRouteMethod() { }
+    }
+    __decorate([
+        (0, route_methods_1.Get)("/get"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "getMethod", null);
+    __decorate([
+        (0, route_methods_1.Post)({ path: "/post", name: "customPost" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "postMethod", null);
+    __decorate([
+        (0, route_methods_1.Put)("/put", { name: "putMethod" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "putMethod", null);
+    __decorate([
+        (0, route_methods_1.Delete)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "deleteMethod", null);
+    __decorate([
+        (0, route_methods_1.Patch)({ name: "patchMethod" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "patchMethod", null);
+    __decorate([
+        (0, route_methods_1.Options)("/options"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "optionsMethod", null);
+    __decorate([
+        (0, route_methods_1.All)({ path: "/all" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "allMethod", null);
+    __decorate([
+        (0, route_methods_1.Route)("GET", "/custom", { name: "customRoute" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "customRouteMethod", null);
+    it("should define metadata for Get decorator", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "getMethod");
+        expect(meta).toBe("GET");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "getMethod");
+        expect(path).toBe("/get");
+    });
+    // it("should define metadata for Post decorator with options object", () => {
+    //     const meta = Reflect.getMetadata("route:method", TestController.prototype, "postMethod");
+    //     expect(meta).toBe("POST");
+    //     const path = Reflect.getMetadata("route:path", TestController.prototype, "postMethod");
+    //     expect(path).toBe("/post");
+    //     const options = Reflect.getMetadata("route:options", TestController.prototype, "postMethod");
+    //     expect(options).toMatchObject({ path: "/post", name: "customPost" });
+    // });
+    it("should define metadata for Put decorator with path and options", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "putMethod");
+        expect(meta).toBe("PUT");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "putMethod");
+        expect(path).toBe("/put");
+        const options = Reflect.getMetadata("route:options", TestController.prototype, "putMethod");
+        expect(options).toMatchObject({ name: "putMethod" });
+    });
+    it("should define metadata for Delete decorator with default path", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "deleteMethod");
+        expect(meta).toBe("DELETE");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "deleteMethod");
+        expect(path).toBe("/");
+    });
+    it("should define metadata for Patch decorator with options object", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "patchMethod");
+        expect(meta).toBe("PATCH");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "patchMethod");
+        expect(path).toBe("patchMethod");
+        const options = Reflect.getMetadata("route:options", TestController.prototype, "patchMethod");
+        expect(options).toMatchObject({ name: "patchMethod" });
+    });
+    it("should define metadata for Options decorator with path", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "optionsMethod");
+        expect(meta).toBe("OPTIONS");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "optionsMethod");
+        expect(path).toBe("/options");
+    });
+    it("should define metadata for All decorator with options object", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "allMethod");
+        expect(meta).toBe("ALL");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "allMethod");
+        expect(path).toBe("/all");
+    });
+    it("should define metadata for generic Route decorator", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "customRouteMethod");
+        expect(meta).toBe("GET");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "customRouteMethod");
+        expect(path).toBe("/custom");
+        const options = Reflect.getMetadata("route:options", TestController.prototype, "customRouteMethod");
+        expect(options).toMatchObject({ name: "customRoute" });
+    });
+});

package/dist/swagger-schema.d.ts

@@ -1 +1,43 @@
+export declare function OpenApiProperty(options?: {
+    type?: any;
+    description?: string;
+    deprecated?: boolean;
+    example?: any;
+    enum?: any[];
+    format?: string;
+    default?: any;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    oneOf?: any[];
+    allOf?: any[];
+    anyOf?: any[];
+    exclude?: boolean;
+    isArray?: boolean;
+    items?: Record<string, any>;
+}): (target: any, propertyKey: string) => void;
+export declare function CreateSwaggerObjectSchema(classType: any): any;
 export declare function generateSwaggerSchema(classType: any): any;
+export declare function OpenApiResponse(code: number | undefined, model: any, description?: string): {
+    description: string;
+    content: {
+        "application/json": {
+            schema: {
+                type: string;
+                properties: {
+                    code: {
+                        type: string;
+                        example: number;
+                    };
+                    status: {
+                        type: string;
+                        example: string;
+                    };
+                    data: any;
+                };
+            };
+        };
+    };
+};

package/dist/swagger-schema.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenApiProperty = OpenApiProperty;
+exports.CreateSwaggerObjectSchema = CreateSwaggerObjectSchema;
 exports.generateSwaggerSchema = generateSwaggerSchema;
+exports.OpenApiResponse = OpenApiResponse;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -8,6 +11,241 @@ exports.generateSwaggerSchema = generateSwaggerSchema;
  * @url https://github.com/xtareq
  */
 const class_validator_1 = require("class-validator");
+// Decorator to add OpenAPI metadata to properties
+function OpenApiProperty(options) {
+    return function (target, propertyKey) {
+        var _a;
+        let meta = options ? { ...options } : {};
+        if (meta.format === "binary") {
+            if (meta.isArray) {
+                meta = {
+                    ...meta,
+                    type: "array",
+                    items: (_a = meta.items) !== null && _a !== void 0 ? _a : { type: "string", format: "binary" },
+                    description: meta.description || "Array of files",
+                };
+            }
+            else {
+                meta = {
+                    ...meta,
+                    type: "string",
+                    format: "binary",
+                    description: meta.description || "File upload",
+                };
+            }
+        }
+        Reflect.defineMetadata("property:openapi", meta, target, propertyKey);
+    };
+}
+function extractOpenApiFields(meta) {
+    const result = {};
+    const jsonSchemaFields = [
+        "description",
+        "deprecated",
+        "example",
+        "enum",
+        "format",
+        "default",
+        "minimum",
+        "maximum",
+        "minLength",
+        "maxLength",
+        "pattern",
+        "oneOf",
+        "allOf",
+        "anyOf",
+    ];
+    // Valid JSON Schema formats
+    const validFormats = [
+        "date-time",
+        "date",
+        "time",
+        "duration",
+        "email",
+        "idn-email",
+        "hostname",
+        "idn-hostname",
+        "ipv4",
+        "ipv6",
+        "uri",
+        "uri-reference",
+        "iri",
+        "iri-reference",
+        "uuid",
+        "uri-template",
+        "json-pointer",
+        "relative-json-pointer",
+        "regex",
+        "int32",
+        "int64",
+        "float",
+        "double",
+        "byte",
+        "binary",
+        "password",
+    ];
+    jsonSchemaFields.forEach((field) => {
+        if (meta[field] !== undefined) {
+            // Validate format field
+            if (field === "format") {
+                const formatValue = meta[field];
+                // Only add format if it's a valid format string
+                if (validFormats.includes(formatValue)) {
+                    result[field] = formatValue;
+                }
+                // Skip invalid formats
+            }
+            else {
+                result[field] = meta[field];
+            }
+        }
+    });
+    return result;
+}
+function CreateSwaggerObjectSchema(classType) {
+    const metadataStorage = (0, class_validator_1.getMetadataStorage)();
+    const validationMetadata = metadataStorage.getTargetValidationMetadatas(classType, "", true, false);
+    const schema = {
+        type: "object",
+        properties: {},
+        required: [],
+    };
+    const prototype = classType.prototype;
+    const propertyKeys = new Set();
+    // Collect property names
+    Object.getOwnPropertyNames(prototype).forEach((k) => propertyKeys.add(k));
+    Object.keys(prototype).forEach((k) => propertyKeys.add(k));
+    validationMetadata.forEach((m) => propertyKeys.add(m.propertyName));
+    try {
+        const instance = new classType();
+        Reflect.ownKeys(instance).forEach((k) => {
+            if (typeof k === "string")
+                propertyKeys.add(k);
+        });
+    }
+    catch (_) { }
+    propertyKeys.forEach((propertyName) => {
+        var _a;
+        if (!propertyName || propertyName === "constructor")
+            return;
+        // Get decorator metadata
+        const openApiMeta = Reflect.getMetadata("property:openapi", prototype, propertyName);
+        if (openApiMeta === null || openApiMeta === void 0 ? void 0 : openApiMeta.exclude)
+            return;
+        // Get TypeScript type
+        const propertyType = Reflect.getMetadata("design:type", prototype, propertyName);
+        let swaggerProperty = {};
+        switch (propertyType) {
+            case String:
+                swaggerProperty.type = "string";
+                break;
+            case Number:
+                swaggerProperty.type = "number";
+                break;
+            case Boolean:
+                swaggerProperty.type = "boolean";
+                break;
+            case Date:
+                swaggerProperty.type = "string";
+                swaggerProperty.format = "date-time";
+                break;
+            case Array:
+                swaggerProperty.type = "array";
+                swaggerProperty.items = { type: "string" }; // fallback
+                break;
+            case Object:
+                swaggerProperty = CreateSwaggerObjectSchema(propertyType);
+                break;
+            default:
+                if (propertyType && typeof propertyType === "function") {
+                    swaggerProperty.$ref = `#/components/schemas/${propertyType.name}`;
+                }
+                else {
+                    swaggerProperty.type = ((_a = propertyType === null || propertyType === void 0 ? void 0 : propertyType.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "string";
+                }
+        }
+        if (openApiMeta) {
+            swaggerProperty = {
+                ...swaggerProperty,
+                ...openApiMeta,
+                ...extractOpenApiFields(openApiMeta),
+            };
+            // 🪄 Auto-handle file uploads
+            if (openApiMeta.format === "binary") {
+                if (openApiMeta.isArray || propertyType === Array) {
+                    swaggerProperty = {
+                        type: "array",
+                        items: { type: "string", format: "binary" },
+                        description: openApiMeta.description || "Array of files",
+                    };
+                }
+                else {
+                    swaggerProperty = {
+                        type: "string",
+                        format: "binary",
+                        description: openApiMeta.description || "File upload",
+                    };
+                }
+            }
+        }
+        schema.properties[propertyName] = swaggerProperty;
+    });
+    // Handle validation decorators
+    validationMetadata.forEach((meta) => {
+        const propertyName = meta.propertyName;
+        const property = schema.properties[propertyName];
+        if (!property)
+            return;
+        switch (meta.name) {
+            case "isNotEmpty":
+            case "isDefined":
+                if (!schema.required.includes(propertyName)) {
+                    schema.required.push(propertyName);
+                }
+                break;
+            case "isOptional":
+                schema.required = schema.required.filter((item) => item !== propertyName);
+                break;
+            case "minLength":
+                property.minLength = meta.constraints[0];
+                break;
+            case "maxLength":
+                property.maxLength = meta.constraints[0];
+                break;
+            case "min":
+                property.minimum = meta.constraints[0];
+                break;
+            case "max":
+                property.maximum = meta.constraints[0];
+                break;
+            case "isEmail":
+                property.format = "email";
+                break;
+            case "isDate":
+                property.format = "date-time";
+                break;
+            case "isIn":
+                property.enum = meta.constraints[0];
+                break;
+            case "isNumber":
+                property.type = "number";
+                break;
+            case "isInt":
+                property.type = "integer";
+                break;
+            case "isBoolean":
+                property.type = "boolean";
+                break;
+            case "isString":
+                property.type = "string";
+                break;
+        }
+    });
+    if (schema.required.length === 0) {
+        delete schema.required;
+    }
+    return schema;
+}
 function generateSwaggerSchema(classType) {
     const metadataStorage = (0, class_validator_1.getMetadataStorage)();
     const validationMetadata = metadataStorage.getTargetValidationMetadatas(classType, "", true, false);
@@ -117,63 +355,98 @@ function generateSwaggerSchema(classType) {
     });
     return schema;
 }
-function extractOpenApiFields(meta) {
-    const result = {};
-    const fields = [
-        "description",
-        "summary",
-        "deprecated",
-        "example",
-        "enum",
-        "format",
-        "default",
-        "minimum",
-        "maximum",
-        "minLength",
-        "maxLength",
-        "pattern",
-        "oneOf",
-        "allOf",
-        "anyOf",
-    ];
-    fields.forEach((field) => {
-        if (meta[field] !== undefined) {
-            result[field] = meta[field];
+function OpenApiResponse(code = 200, model, description = "Successful response") {
+    let dataSchema;
+    if (typeof model === "function") {
+        // Class or constructor
+        dataSchema = generateSwaggerSchema(model);
+    }
+    else if (model && typeof model === "object") {
+        // Example object
+        dataSchema = inferSchemaFromExample(model);
+    }
+    else {
+        // Fallback
+        dataSchema = { type: "string" };
+    }
+    let message = "OK";
+    switch (code) {
+        case 400:
+            message = "Error";
+            description = "Error: Bad Request";
+            break;
+        case 401:
+            message = "Error";
+            description = "Error: Unauthorized";
+            break;
+        case 403:
+            message = "Error";
+            description = "Error: Forbidden";
+            break;
+        case 201:
+            message = "Created";
+            description = "Success: Created";
+            break;
+        case 500:
+            message = "Error";
+            description = "Error: InternalError";
+            break;
+    }
+    return {
+        description,
+        content: {
+            "application/json": {
+                schema: {
+                    type: "object",
+                    properties: {
+                        code: { type: "number", example: code },
+                        status: { type: "string", example: message },
+                        data: dataSchema,
+                    },
+                },
+            },
+        },
+    };
+}
+/**
+ * Infer a basic JSON schema from a plain JavaScript object.
+ */
+function inferSchemaFromExample(obj) {
+    var _a;
+    if (Array.isArray(obj)) {
+        return {
+            type: "array",
+            items: inferSchemaFromExample((_a = obj[0]) !== null && _a !== void 0 ? _a : {}),
+        };
+    }
+    if (obj && typeof obj === "object") {
+        const properties = {};
+        for (const [key, value] of Object.entries(obj)) {
+            properties[key] = inferType(value);
         }
-    });
-    return result;
+        return { type: "object", properties };
+    }
+    return inferType(obj);
+}
+/**
+ * Infer primitive schema type
+ */
+function inferType(value) {
+    const type = typeof value;
+    switch (type) {
+        case "string":
+            return { type: "string", example: value };
+        case "number":
+            return { type: "number", example: value };
+        case "boolean":
+            return { type: "boolean", example: value };
+        case "object":
+            if (Array.isArray(value))
+                return inferSchemaFromExample(value);
+            if (value === null)
+                return { type: "null" };
+            return inferSchemaFromExample(value);
+        default:
+            return { type: "string" };
+    }
 }
-// export function generateSwaggerSchema(classType: any) {
-//   const { getMetadataStorage } = require("class-validator");
-//   const { plainToInstance } = require("class-transformer");
-//   const metadataStorage = getMetadataStorage();
-//   const validationMetadata = metadataStorage.getTargetValidationMetadatas(
-//     classType,
-//     "",
-//     true,
-//   );
-//   const schema: any = {
-//     type: "object",
-//     properties: {},
-//     required: [],
-//   };
-//   validationMetadata.forEach((meta: any) => {
-//     const propertyName = meta.propertyName;
-//     // Infer the type dynamically using Reflect metadata
-//     const propertyType = Reflect.getMetadata(
-//       "design:type",
-//       classType.prototype,
-//       propertyName,
-//     );
-//     schema.properties[propertyName] = {
-//       type: propertyType?.name.toLowerCase() || "string", // Default to string if type cannot be inferred
-//     };
-//     if (meta.name === "isNotEmpty") {
-//       schema.required.push(propertyName);
-//     }
-//     if (meta.name === "minLength") {
-//       schema.properties[propertyName].minLength = meta.constraints[0];
-//     }
-//   });
-//   return schema;
-// }

package/dist/swagger-schema.test.d.ts

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