@avleon/core 0.0.40 → 0.0.43

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.40",
+  "version": "0.0.43",
   "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": "*",