@avleon/core 0.0.39 → 0.0.42-rc0.1

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";

package/dist/swagger-schema.test.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const swagger_schema_1 = require("./swagger-schema");
+// Mocks for class-validator metadata
+const mockValidationMetadatas = [
+    { propertyName: "name", name: "isNotEmpty", constraints: [] },
+    { propertyName: "age", name: "isInt", constraints: [] },
+    { propertyName: "email", name: "isEmail", constraints: [] },
+    { propertyName: "tags", name: "isOptional", constraints: [] },
+    { propertyName: "desc", name: "minLength", constraints: [5] },
+    { propertyName: "desc", name: "maxLength", constraints: [100] },
+];
+const mockGetMetadataStorage = jest.fn(() => ({
+    getTargetValidationMetadatas: jest.fn(() => mockValidationMetadatas),
+}));
+jest.mock("class-validator", () => ({
+    getMetadataStorage: mockGetMetadataStorage,
+}));
+// Helper to set Reflect metadata for property types and openapi
+function setPropertyMetadata(target, property, type, openApi) {
+    Reflect.defineMetadata("design:type", type, target, property);
+    if (openApi) {
+        Reflect.defineMetadata("property:openapi", openApi, target, property);
+    }
+}
+// Test class
+class TestDto {
+}
+setPropertyMetadata(TestDto.prototype, "name", String);
+setPropertyMetadata(TestDto.prototype, "age", Number);
+setPropertyMetadata(TestDto.prototype, "email", String);
+setPropertyMetadata(TestDto.prototype, "tags", Array);
+setPropertyMetadata(TestDto.prototype, "desc", String, { description: "Description", example: "A desc" });
+setPropertyMetadata(TestDto.prototype, "ignored", String, { exclude: true });
+describe("generateSwaggerSchema", () => {
+    it("should generate correct schema for class properties and validation", () => {
+        const schema = (0, swagger_schema_1.generateSwaggerSchema)(TestDto);
+        expect(schema).toEqual({
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "integer" },
+                email: { type: "string", format: "email" },
+                tags: { type: "array", items: { type: "string" } },
+                desc: {
+                    type: "string",
+                    description: "Description",
+                    example: "A desc",
+                    minLength: 5,
+                    maxLength: 100,
+                },
+            },
+            required: ["name", "age", "email", "desc"],
+        });
+        expect(schema.properties.ignored).toBeUndefined();
+    });
+    it("should handle openapi metadata fields", () => {
+        setPropertyMetadata(TestDto.prototype, "desc", String, {
+            description: "desc field",
+            example: "example",
+            deprecated: true,
+            enum: ["a", "b"],
+            format: "custom-format",
+            default: "default",
+            minimum: 1,
+            maximum: 10,
+            minLength: 2,
+            maxLength: 20,
+            pattern: ".*",
+            oneOf: [{ type: "string" }],
+            allOf: [{ type: "string" }],
+            anyOf: [{ type: "string" }],
+        });
+        const schema = (0, swagger_schema_1.generateSwaggerSchema)(TestDto);
+        expect(schema.properties.desc).toMatchObject({
+            description: "desc field",
+            example: "example",
+            deprecated: true,
+            enum: ["a", "b"],
+            format: "custom-format",
+            default: "default",
+            minimum: 1,
+            maximum: 10,
+            minLength: 2,
+            maxLength: 20,
+            pattern: ".*",
+            oneOf: [{ type: "string" }],
+            allOf: [{ type: "string" }],
+            anyOf: [{ type: "string" }],
+            type: "string",
+        });
+    });
+    it("should not include excluded properties", () => {
+        setPropertyMetadata(TestDto.prototype, "ignored", String, { exclude: true });
+        const schema = (0, swagger_schema_1.generateSwaggerSchema)(TestDto);
+        expect(schema.properties.ignored).toBeUndefined();
+    });
+    it("should fallback to string type if type is unknown", () => {
+        setPropertyMetadata(TestDto.prototype, "unknown", undefined);
+        mockValidationMetadatas.push({ propertyName: "unknown", name: "isNotEmpty", constraints: [] });
+        const schema = (0, swagger_schema_1.generateSwaggerSchema)(TestDto);
+        expect(schema.properties.unknown.type).toBe("string");
+    });
+});

package/dist/validation.d.ts

@@ -28,5 +28,12 @@ export type ValidationProps = {
 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

@@ -6,6 +6,7 @@
  * @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 {
@@ -76,6 +77,7 @@ class Validator {
         return [erors, obj];
     }
 }
+exports.Validator = Validator;
 const isBool = (val) => {
     if (typeof val == "boolean")
         return true;

package/dist/validation.test.d.ts

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

package/dist/validation.test.js

@@ -0,0 +1,61 @@
+"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/websocket.test.d.ts

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

package/dist/websocket.test.js

@@ -0,0 +1,27 @@
+"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();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.39",
+  "version": "0.0.42-rc0.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "keywords": [
@@ -25,22 +25,24 @@
   "dependencies": {
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.2",
-    "fastify": "^5.6.0",
+    "fastify": "^5.1.0",
+    "mime": "^4.1.0",
     "pino": "^9.10.0",
+    "pino-pretty": "^13.1.1",
     "reflect-metadata": "^0.2.2",
     "typedi": "^0.10.0"
   },
   "peerDependencies": {
-    "@fastify/cors": "*",
-    "@fastify/multipart": "*",
-    "@fastify/static": "*",
-    "@fastify/swagger": "*",
-    "@fastify/swagger-ui": "*",
-    "@fastify/view": "*",
+    "@fastify/cors": "^11.0.0",
+    "@fastify/multipart": "^9.0.3",
+    "@fastify/static": "^8.1.1",
+    "@fastify/swagger": "^9.4.0",
+    "@fastify/swagger-ui": "^5.1.0",
+    "@fastify/view": "^11.0.0",
     "@scalar/fastify-api-reference": "*",
     "bcryptjs": "3.0.2",
     "dotenv": "*",
-    "fastify-socket.io": "*",
+    "fastify-socket.io": "^4.0.0",
     "highlight.js": "*",
     "ioredis": "*",
     "knex": "*",