@avleon/core 0.0.45 → 0.0.48

package/dist/swagger-schema.js

@@ -1,452 +0,0 @@
-"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
- * @email xtrinsic96@gmail.com
- * @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);
-    const schema = {
-        type: "object",
-        properties: {},
-        required: [],
-    };
-    const prototype = classType.prototype;
-    const propertyKeys = new Set([
-        ...Object.getOwnPropertyNames(prototype),
-        ...validationMetadata.map((m) => m.propertyName),
-    ]);
-    propertyKeys.forEach((propertyName) => {
-        var _a;
-        if (!propertyName || propertyName === "constructor")
-            return;
-        const openApiMeta = Reflect.getMetadata("property:openapi", prototype, propertyName);
-        if (openApiMeta === null || openApiMeta === void 0 ? void 0 : openApiMeta.exclude)
-            return;
-        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 = generateSwaggerSchema(propertyType);
-                break;
-            default:
-                swaggerProperty.type = ((_a = propertyType === null || propertyType === void 0 ? void 0 : propertyType.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "string";
-        }
-        // Apply OpenApi metadata if present
-        if (openApiMeta) {
-            swaggerProperty = {
-                ...swaggerProperty,
-                ...extractOpenApiFields(openApiMeta),
-            };
-        }
-        schema.properties[propertyName] = swaggerProperty;
-    });
-    // Handle validation rules
-    validationMetadata.forEach((meta) => {
-        const propertyName = meta.propertyName;
-        switch (meta.name) {
-            case "isNotEmpty":
-                if (!schema.required.includes(propertyName)) {
-                    schema.required.push(propertyName);
-                }
-                break;
-            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":
-                schema.properties[propertyName].minLength = meta.constraints[0];
-                break;
-            case "maxLength":
-                schema.properties[propertyName].maxLength = meta.constraints[0];
-                break;
-            case "min":
-                schema.properties[propertyName].minimum = meta.constraints[0];
-                break;
-            case "max":
-                schema.properties[propertyName].maximum = meta.constraints[0];
-                break;
-            case "isEmail":
-                schema.properties[propertyName].format = "email";
-                break;
-            case "isDate":
-                schema.properties[propertyName].format = "date-time";
-                break;
-            case "isIn":
-                schema.properties[propertyName].enum = meta.constraints[0];
-                break;
-            case "isNumber":
-                schema.properties[propertyName].type = "number";
-                break;
-            case "isInt":
-                schema.properties[propertyName].type = "integer";
-                break;
-            case "isBoolean":
-                schema.properties[propertyName].type = "boolean";
-                break;
-            case "isString":
-                schema.properties[propertyName].type = "string";
-                break;
-        }
-    });
-    return schema;
-}
-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 { 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" };
-    }
-}

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

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

package/dist/swagger-schema.test.js

@@ -1,105 +0,0 @@
-"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/testing.d.ts

@@ -1,55 +0,0 @@
-import "reflect-metadata";
-import { DataSourceOptions } from "typeorm";
-export declare class AvleonTestUtility {
-    private static testDataSource;
-    private static testContainer;
-    /**
-     * Initialize test environment
-     */
-    static init(options?: {
-        dataSourceOptions?: DataSourceOptions;
-        resetContainer?: boolean;
-    }): Promise<typeof AvleonTestUtility>;
-    /**
-     * Mock a dependency for testing
-     * @param token Dependency token
-     * @param mockImplementation Mock implementation
-     */
-    static mockDependency<T>(token: any, mockImplementation: T): T;
-    /**
-     * Create an isolated test instance of a class
-     * @param ClassType Class to instantiate
-     * @param overrides Optional property overrides
-     */
-    static createTestInstance<T>(ClassType: new (...args: any[]) => T, overrides?: Partial<T>): T;
-    /**
-     * Cleanup test environment
-     */
-    static cleanup(): Promise<void>;
-}
-export declare class AvleonTestBuilder {
-    private controllers;
-    private testOptions;
-    private mocks;
-    /**
-     * Add controllers for testing
-     * @param controllers Controllers to add
-     */
-    addControllers(...controllers: any[]): this;
-    /**
-     * Mock a dependency
-     * @param token Dependency token
-     * @param mockImplementation Mock implementation
-     */
-    mockDependency(token: any, mockImplementation: any): this;
-    /**
-     * Set test options
-     * @param options Test configuration options
-     */
-    setOptions(options: any): this;
-    /**
-     * Build test application
-     */
-    build(): Promise<import("./icore").TestApplication>;
-}
-export declare function UnitTest(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;