@avleon/core 0.0.45 → 0.0.46

package/dist/swagger-schema.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenApiProperty = OpenApiProperty;
 exports.CreateSwaggerObjectSchema = CreateSwaggerObjectSchema;
+exports.generateClassSchema = generateClassSchema;
 exports.generateSwaggerSchema = generateSwaggerSchema;
 exports.OpenApiResponse = OpenApiResponse;
 /**
@@ -11,6 +12,7 @@ exports.OpenApiResponse = OpenApiResponse;
  * @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) {
@@ -39,6 +41,7 @@ function OpenApiProperty(options) {
 }
 function extractOpenApiFields(meta) {
     const result = {};
+    // ✅ Complete list — was missing required, title, readOnly, writeOnly, nullable
     const jsonSchemaFields = [
         "description",
         "deprecated",
@@ -54,46 +57,28 @@ function extractOpenApiFields(meta) {
         "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",
+        "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];
@@ -105,17 +90,13 @@ function extractOpenApiFields(meta) {
 function CreateSwaggerObjectSchema(classType) {
     const metadataStorage = (0, class_validator_1.getMetadataStorage)();
     const validationMetadata = metadataStorage.getTargetValidationMetadatas(classType, "", true, false);
-    const schema = {
-        type: "object",
-        properties: {},
-        required: [],
-    };
+    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));
+    // ✅ Discover instance-level properties (class fields with !)
     try {
         const instance = new classType();
         Reflect.ownKeys(instance).forEach((k) => {
@@ -128,11 +109,9 @@ function CreateSwaggerObjectSchema(classType) {
         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) {
@@ -151,7 +130,7 @@ function CreateSwaggerObjectSchema(classType) {
                 break;
             case Array:
                 swaggerProperty.type = "array";
-                swaggerProperty.items = { type: "string" }; // fallback
+                swaggerProperty.items = { type: "string" };
                 break;
             case Object:
                 swaggerProperty = CreateSwaggerObjectSchema(propertyType);
@@ -170,7 +149,6 @@ function CreateSwaggerObjectSchema(classType) {
                 ...openApiMeta,
                 ...extractOpenApiFields(openApiMeta),
             };
-            // 🪄 Auto-handle file uploads
             if (openApiMeta.format === "binary") {
                 if (openApiMeta.isArray || propertyType === Array) {
                     swaggerProperty = {
@@ -190,7 +168,6 @@ function CreateSwaggerObjectSchema(classType) {
         }
         schema.properties[propertyName] = swaggerProperty;
     });
-    // Handle validation decorators
     validationMetadata.forEach((meta) => {
         const propertyName = meta.propertyName;
         const property = schema.properties[propertyName];
@@ -199,9 +176,8 @@ function CreateSwaggerObjectSchema(classType) {
         switch (meta.name) {
             case "isNotEmpty":
             case "isDefined":
-                if (!schema.required.includes(propertyName)) {
+                if (!schema.required.includes(propertyName))
                     schema.required.push(propertyName);
-                }
                 break;
             case "isOptional":
                 schema.required = schema.required.filter((item) => item !== propertyName);
@@ -241,24 +217,32 @@ function CreateSwaggerObjectSchema(classType) {
                 break;
         }
     });
-    if (schema.required.length === 0) {
+    if (schema.required.length === 0)
         delete schema.required;
-    }
     return schema;
 }
-function generateSwaggerSchema(classType) {
+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 schema = {
-        type: "object",
-        properties: {},
-        required: [],
-    };
     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")
@@ -284,36 +268,40 @@ function generateSwaggerSchema(classType) {
                 break;
             case Array:
                 swaggerProperty.type = "array";
-                swaggerProperty.items = { type: "string" }; // fallback
+                swaggerProperty.items = { type: "string" };
                 break;
             case Object:
-                swaggerProperty = generateSwaggerSchema(propertyType);
+                swaggerProperty = generateClassSchema(propertyType);
                 break;
             default:
-                swaggerProperty.type = ((_a = propertyType === null || propertyType === void 0 ? void 0 : propertyType.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "string";
+                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 if present
+        // ✅ Apply OpenApi metadata — extractOpenApiFields now includes all fields
         if (openApiMeta) {
+            const { required: _required, exclude: _exclude, isArray: _isArray, ...safeOpenApiMeta } = openApiMeta;
             swaggerProperty = {
                 ...swaggerProperty,
-                ...extractOpenApiFields(openApiMeta),
+                ...extractOpenApiFields(safeOpenApiMeta),
             };
         }
         schema.properties[propertyName] = swaggerProperty;
     });
-    // Handle validation rules
     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":
-                if (!schema.required.includes(propertyName)) {
-                    schema.required.push(propertyName);
-                }
-                break;
             case "isDefined":
-                if (!schema.required.includes(propertyName)) {
+                if (!schema.required.includes(propertyName))
                     schema.required.push(propertyName);
-                }
                 break;
             case "isOptional":
                 schema.required = schema.required.filter((item) => item !== propertyName);
@@ -353,20 +341,46 @@ function generateSwaggerSchema(classType) {
                 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") {
-        // Class or constructor
-        dataSchema = generateSwaggerSchema(model);
+        dataSchema = generateClassSchema(model);
     }
     else if (model && typeof model === "object") {
-        // Example object
         dataSchema = inferSchemaFromExample(model);
     }
     else {
-        // Fallback
         dataSchema = { type: "string" };
     }
     let message = "OK";
@@ -408,16 +422,10 @@ function OpenApiResponse(code = 200, model, description = "Successful response")
         },
     };
 }
-/**
- * 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 : {}),
-        };
+        return { type: "array", items: inferSchemaFromExample((_a = obj[0]) !== null && _a !== void 0 ? _a : {}) };
     }
     if (obj && typeof obj === "object") {
         const properties = {};
@@ -428,18 +436,12 @@ function inferSchemaFromExample(obj) {
     }
     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 "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);

package/dist/swagger-schema.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const swagger_schema_1 = require("./swagger-schema");
+const swagger_schema_1 = require("./swagger-schema"); // ✅ single-class function
 // Mocks for class-validator metadata
 const mockValidationMetadatas = [
     { propertyName: "name", name: "isNotEmpty", constraints: [] },
@@ -11,12 +11,21 @@ const mockValidationMetadatas = [
     { 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,
-}));
+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);
@@ -33,9 +42,9 @@ 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", () => {
+describe("generateClassSchema", () => {
     it("should generate correct schema for class properties and validation", () => {
-        const schema = (0, swagger_schema_1.generateSwaggerSchema)(TestDto);
+        const schema = (0, swagger_schema_1.generateClassSchema)(TestDto); // ✅
         expect(schema).toEqual({
             type: "object",
             properties: {
@@ -72,7 +81,7 @@ describe("generateSwaggerSchema", () => {
             allOf: [{ type: "string" }],
             anyOf: [{ type: "string" }],
         });
-        const schema = (0, swagger_schema_1.generateSwaggerSchema)(TestDto);
+        const schema = (0, swagger_schema_1.generateClassSchema)(TestDto); // ✅
         expect(schema.properties.desc).toMatchObject({
             description: "desc field",
             example: "example",
@@ -93,13 +102,24 @@ describe("generateSwaggerSchema", () => {
     });
     it("should not include excluded properties", () => {
         setPropertyMetadata(TestDto.prototype, "ignored", String, { exclude: true });
-        const schema = (0, swagger_schema_1.generateSwaggerSchema)(TestDto);
+        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.generateSwaggerSchema)(TestDto);
+        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/utils/common-utils.d.ts

@@ -0,0 +1,17 @@
+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>;

package/dist/utils/common-utils.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLineNumber = exports.uuid = void 0;
+exports.isConstructor = isConstructor;
+exports.formatUrl = formatUrl;
+exports.parsedPath = parsedPath;
+exports.normalizePath = normalizePath;
+exports.extrctParamFromUrl = extrctParamFromUrl;
+exports.findDuplicates = findDuplicates;
+exports.sleep = sleep;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+exports.uuid = crypto_1.default.randomUUID();
+function isConstructor(func) {
+    if (typeof func !== "function") {
+        return false;
+    }
+    if (func === Function.prototype.bind || func instanceof RegExp) {
+        return false;
+    }
+    if (func.prototype && typeof func.prototype === "object") {
+        return true;
+    }
+    try {
+        const instance = new func();
+        return typeof instance === "object";
+    }
+    catch (e) {
+        return false;
+    }
+}
+function formatUrl(path) {
+    if (typeof path !== "string") {
+        throw new Error("The path must be a string");
+    }
+    path = path.trim();
+    if (!path.startsWith("/")) {
+        path = "/" + path;
+    }
+    path = path.replace(/\/\/+/g, "/");
+    if (path.endsWith("/")) {
+        path = path.slice(0, -1);
+    }
+    return path;
+}
+function parsedPath(ipath) {
+    return !ipath.startsWith("/") ? "/" + ipath : ipath;
+}
+const getLineNumber = (filePath, rpath) => {
+    var _a;
+    let numbers = [];
+    try {
+        const fileContent = fs_1.default.readFileSync(filePath, "utf8");
+        const lines = fileContent.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(rpath);
+            if (match) {
+                console.log(match);
+                numbers.push({
+                    line: i + 1,
+                    column: (_a = match.index) !== null && _a !== void 0 ? _a : 0,
+                });
+            }
+        }
+        return numbers;
+    }
+    catch (error) {
+        return numbers;
+    }
+};
+exports.getLineNumber = getLineNumber;
+function normalizePath(base = "/", subPath = "/") {
+    return `/${base}/${subPath}`.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function extrctParamFromUrl(url) {
+    const splitPart = url
+        .split("/")
+        .filter((x) => x.startsWith(":") || x.startsWith("?:"));
+    return splitPart.map((f) => ({
+        key: f.replace(/(\?|:)/g, ""),
+        required: !f.startsWith("?:"),
+    }));
+}
+function findDuplicates(arr) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const str of arr) {
+        if (seen.has(str)) {
+            duplicates.add(str);
+        }
+        else {
+            seen.add(str);
+        }
+    }
+    return Array.from(duplicates);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1 @@
+export declare function inject<T>(cls: new (...args: any[]) => T): T;

package/dist/utils/di-utils.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inject = inject;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+const container_1 = __importDefault(require("../container"));
+const system_exception_1 = require("../exceptions/system-exception");
+function inject(cls) {
+    try {
+        return container_1.default.get(cls);
+    }
+    catch (error) {
+        throw new system_exception_1.SystemUseError("Not a project class. Maybe you wanna register it first.");
+    }
+}

package/dist/utils/hash.d.ts

@@ -1,4 +1,2 @@
-export declare const hashPasswordSync: (password: string) => string;
-export declare const matchPasswordSync: (password: string, hash: string) => boolean;
 export declare const hashPassword: (password: string) => Promise<string>;
 export declare const matchPassword: (password: string, hash: string) => Promise<boolean>;

package/dist/utils/hash.js

@@ -3,12 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchPassword = exports.hashPassword = exports.matchPasswordSync = exports.hashPasswordSync = void 0;
+exports.matchPassword = exports.hashPassword = void 0;
 const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const hashPasswordSync = (password) => bcryptjs_1.default.hashSync(password, 12);
-exports.hashPasswordSync = hashPasswordSync;
-const matchPasswordSync = (password, hash) => bcryptjs_1.default.compareSync(password, hash);
-exports.matchPasswordSync = matchPasswordSync;
 const hashPassword = (password) => bcryptjs_1.default.hash(password, 12);
 exports.hashPassword = hashPassword;
 const matchPassword = (password, hash) => bcryptjs_1.default.compare(password, hash);

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

@@ -0,0 +1,11 @@
+import { Constructor } from "./common-utils";
+export declare function pick<T extends object>(obj: T, paths: string[]): Partial<T>;
+export declare function exclude<T extends object>(obj: T | T[], paths: string[]): Partial<T> | Partial<T>[];
+export declare function autoCast(value: any, typeHint?: any, schema?: any): any;
+/**
+ * Deeply normalizes query strings into nested JS objects.
+ */
+export declare function normalizeQueryDeep(query: Record<string, any>): Record<string, any>;
+export declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
+export declare function jsonToJs(value: string): any;
+export declare function jsonToInstance(value: string, instance: Constructor): any;