@avleon/core 0.0.46 → 0.0.48

package/dist/swagger-schema.js

@@ -1,454 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenApiProperty = OpenApiProperty;
-exports.CreateSwaggerObjectSchema = CreateSwaggerObjectSchema;
-exports.generateClassSchema = generateClassSchema;
-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");
-const container_1 = require("./container");
-// 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 = {};
-    // ✅ Complete list — was missing required, title, readOnly, writeOnly, nullable
-    const jsonSchemaFields = [
-        "description",
-        "deprecated",
-        "example",
-        "enum",
-        "format",
-        "default",
-        "minimum",
-        "maximum",
-        "minLength",
-        "maxLength",
-        "pattern",
-        "oneOf",
-        "allOf",
-        "anyOf",
-        "title",
-        "readOnly",
-        "writeOnly",
-        "nullable"
-    ];
-    // 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) {
-            if (field === "format") {
-                const formatValue = meta[field];
-                if (validFormats.includes(formatValue)) {
-                    result[field] = formatValue;
-                }
-            }
-            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();
-    Object.getOwnPropertyNames(prototype).forEach((k) => propertyKeys.add(k));
-    Object.keys(prototype).forEach((k) => propertyKeys.add(k));
-    validationMetadata.forEach((m) => propertyKeys.add(m.propertyName));
-    // ✅ Discover instance-level properties (class fields with !)
-    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;
-        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" };
-                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),
-            };
-            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;
-    });
-    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 generateClassSchema(classType) {
-    const schema = { type: "object", properties: {}, required: [] };
-    // ✅ Guard against null/undefined
-    if (!classType || !classType.prototype)
-        return schema;
-    const metadataStorage = (0, class_validator_1.getMetadataStorage)();
-    const validationMetadata = metadataStorage.getTargetValidationMetadatas(classType, "", true, false);
-    const prototype = classType.prototype;
-    const propertyKeys = new Set([
-        ...Object.getOwnPropertyNames(prototype),
-        ...validationMetadata.map((m) => m.propertyName),
-    ]);
-    // ✅ Discover instance-level class fields (e.g. `search!: string`)
-    // These don't appear on prototype — only on instantiated objects
-    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;
-        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" };
-                break;
-            case Object:
-                swaggerProperty = generateClassSchema(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";
-                }
-        }
-        // ✅ Apply OpenApi metadata — extractOpenApiFields now includes all fields
-        if (openApiMeta) {
-            const { required: _required, exclude: _exclude, isArray: _isArray, ...safeOpenApiMeta } = openApiMeta;
-            swaggerProperty = {
-                ...swaggerProperty,
-                ...extractOpenApiFields(safeOpenApiMeta),
-            };
-        }
-        schema.properties[propertyName] = swaggerProperty;
-    });
-    validationMetadata.forEach((meta) => {
-        const propertyName = meta.propertyName;
-        // Guard: property might not be in schema if it had no type info
-        if (!schema.properties[propertyName]) {
-            schema.properties[propertyName] = { type: "string" }; // ✅ safe fallback
-        }
-        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":
-                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;
-        }
-    });
-    if (schema.required.length === 0)
-        delete schema.required;
-    return schema;
-}
-// Build OpenAPI components.schemas from an array of controller/DTO classes
-function generateSwaggerSchema(controllers) {
-    if (!Array.isArray(controllers)) {
-        return generateClassSchema(controllers);
-    }
-    const components = {};
-    for (const controller of controllers) {
-        if (!controller || typeof controller !== "function")
-            continue;
-        if (!controller.prototype)
-            continue;
-        // Skip @ApiController classes
-        const isController = Reflect.getMetadata(container_1.CONTROLLER_META_KEY, controller);
-        if (isController)
-            continue;
-        // Only include classes explicitly marked with @ApiSchema
-        const isSchema = Reflect.getMetadata("openapi:schema", controller);
-        if (!isSchema)
-            continue;
-        components[controller.name] = generateClassSchema(controller);
-    }
-    return {
-        components: Object.keys(components).length > 0
-            ? { schemas: components }
-            : undefined,
-    };
-}
-function OpenApiResponse(code = 200, model, description = "Successful response") {
-    let dataSchema;
-    if (typeof model === "function") {
-        dataSchema = generateClassSchema(model);
-    }
-    else if (model && typeof model === "object") {
-        dataSchema = inferSchemaFromExample(model);
-    }
-    else {
-        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,
-                    },
-                },
-            },
-        },
-    };
-}
-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);
-}
-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,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const swagger_schema_1 = require("./swagger-schema"); // ✅ single-class function
-// 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] },
-];
-jest.mock("class-validator", () => {
-    const mockGetMetadataStorage = jest.fn(() => ({
-        getTargetValidationMetadatas: jest.fn(() => [
-            { 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] },
-        ]),
-    }));
-    return {
-        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("generateClassSchema", () => {
-    it("should generate correct schema for class properties and validation", () => {
-        const schema = (0, swagger_schema_1.generateClassSchema)(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.generateClassSchema)(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.generateClassSchema)(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.generateClassSchema)(TestDto); // ✅
-        expect(schema.properties.unknown.type).toBe("string");
-    });
-    it("should return empty schema for null or undefined input", () => {
-        const schema = (0, swagger_schema_1.generateClassSchema)(null);
-        expect(schema).toEqual({ type: "object", properties: {}, required: [] });
-    });
-    it("should handle array controllers input gracefully", () => {
-        // generateSwaggerSchema (array version) should skip non-DTO classes
-        // generateClassSchema should never receive an array
-        const schema = (0, swagger_schema_1.generateClassSchema)(TestDto);
-        expect(schema.type).toBe("object");
-        expect(schema.properties).toBeDefined();
-    });
-});

package/dist/types/app-builder.interface.d.ts

@@ -1,15 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import { IApplication } from "./application.interface";
-export interface IAppBuilder {
-    createBuilder(): IAppBuilder;
-    /**
-     * @description will create a application instace
-     * @returns IApplication
-     */
-    builder: () => IApplication;
-}

package/dist/types/app-builder.interface.js

@@ -1,8 +0,0 @@
-"use strict";
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/application.interface.d.ts

@@ -1,8 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface IApplication {
-}

package/dist/types/application.interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/common-utils.d.ts

@@ -1,17 +0,0 @@
-export declare const uuid: `${string}-${string}-${string}-${string}-${string}`;
-export type Constructor<T = any> = new (...args: any[]) => T;
-export declare function isConstructor(func: any): boolean;
-export declare function formatUrl(path: string): string;
-export declare function parsedPath(ipath: string): string;
-export interface MatchLocation {
-    line: number;
-    column: number;
-}
-export declare const getLineNumber: (filePath: string, rpath: string | RegExp) => MatchLocation[] | null;
-export declare function normalizePath(base?: string, subPath?: string): string;
-export declare function extrctParamFromUrl(url: string): {
-    key: string;
-    required: boolean;
-}[];
-export declare function findDuplicates(arr: string[]): string[];
-export declare function sleep(ms: number): Promise<unknown>;