@avleon/core 0.0.44 → 0.0.46

package/dist/queue.js

@@ -1,116 +1,84 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueManager = exports.AvleonQueue = exports.FileQueueAdapter = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const crypto_1 = require("crypto");
-const events_1 = require("events");
-const decorators_1 = require("./decorators");
-class FileQueueAdapter {
-    constructor(queueName) {
-        this.queueFile = (0, path_1.join)(__dirname, `${queueName}.json`);
-    }
-    async loadJobs() {
-        try {
-            const data = await fs_1.promises.readFile(this.queueFile, "utf-8");
-            return JSON.parse(data);
+exports.AvleonQueue = void 0;
+exports.Queue = Queue;
+const bull_1 = __importDefault(require("bull"));
+const typedi_1 = require("typedi");
+class AvleonQueue {
+    constructor(name, adapter, handler) {
+        this.name = name;
+        this.adapter = adapter;
+        // Initialize queue with adapter or default Redis connection
+        this.queue = new bull_1.default(name || 'default', adapter);
+        this.handlerFn = handler;
+        // Check if the instance has a handler method defined
+        // This allows subclasses to define handler as a method
+        if (typeof this.handler === 'function' && !this.handlerFn) {
+            this.handlerFn = (job) => this.handler(job);
         }
-        catch (_a) {
-            return [];
+        // If handler is provided (from decorator or class method), set up processing
+        if (this.handlerFn) {
+            this.queue.process(this.handlerFn);
         }
     }
-    async saveJobs(jobs) {
-        await fs_1.promises.writeFile(this.queueFile, JSON.stringify(jobs, null, 2), "utf-8");
+    // Add job to queue
+    add(data, options) {
+        return this.queue.add(data, options);
     }
-}
-exports.FileQueueAdapter = FileQueueAdapter;
-class AvleonQueue extends events_1.EventEmitter {
-    constructor(name, adapter, jobHandler) {
-        super();
-        this.processing = false;
-        this.stopped = false;
-        this.name = name;
-        this.adapter = adapter ? adapter : new FileQueueAdapter(name);
-        this.jobHandler = jobHandler || this.defaultHandler.bind(this);
-        this.setMaxListeners(10);
+    // Add job with delay
+    delay(data, delayMs, options) {
+        return this.queue.add(data, { ...options, delay: delayMs });
     }
-    async defaultHandler(job) {
-        if (typeof job.data === "function") {
-            await job.data();
-        }
+    // Process jobs (can be called manually if not using handler)
+    process(handler) {
+        this.handlerFn = handler;
+        this.queue.process(handler);
     }
-    async addJob(data, options) {
-        const job = {
-            id: (0, crypto_1.randomUUID)(),
-            data,
-            runAt: Date.now() + ((options === null || options === void 0 ? void 0 : options.delay) || 0),
-            status: "pending",
-        };
-        const jobs = await this.adapter.loadJobs();
-        jobs.push(job);
-        await this.adapter.saveJobs(jobs);
-        if (!this.processing)
-            this.processNext();
+    // Process with concurrency
+    processConcurrent(concurrency, handler) {
+        this.handlerFn = handler;
+        this.queue.process(concurrency, handler);
     }
-    async processNext() {
-        if (this.processing || this.stopped)
-            return;
-        this.processing = true;
-        while (!this.stopped) {
-            const jobs = await this.adapter.loadJobs();
-            const nextJob = jobs.find((j) => j.status === "pending");
-            if (!nextJob) {
-                this.processing = false;
-                return;
-            }
-            const now = Date.now();
-            if (nextJob.runAt && nextJob.runAt > now) {
-                const delay = nextJob.runAt - now;
-                await new Promise((res) => setTimeout(res, delay));
-            }
-            nextJob.status = "running";
-            await this.adapter.saveJobs(jobs);
-            this.emit("start", nextJob);
-            try {
-                await this.jobHandler(nextJob);
-                nextJob.status = "completed";
-                this.emit("done", nextJob);
-            }
-            catch (err) {
-                nextJob.status = "failed";
-                this.emit("failed", err, nextJob);
-            }
-            await this.adapter.saveJobs(jobs.filter((j) => j.id !== nextJob.id));
-        }
-        this.processing = false;
+    // Get the underlying Bull queue
+    getQueue() {
+        return this.queue;
+    }
+    async clean(grace, status) {
+        return this.queue.clean(grace, status);
     }
-    async onDone(cb) {
-        this.on("done", cb);
+    async close() {
+        await this.queue.close();
     }
-    async onFailed(cb) {
-        this.on("failed", cb);
+    async pause() {
+        await this.queue.pause();
     }
-    async getJobs() {
-        return this.adapter.loadJobs();
+    async resume() {
+        await this.queue.resume();
     }
-    async stop() {
-        this.stopped = true;
+    async getJob(jobId) {
+        return this.queue.getJob(jobId);
+    }
+    async getJobs(types, start, end) {
+        return this.queue.getJobs(types, start, end);
     }
 }
 exports.AvleonQueue = AvleonQueue;
-let QueueManager = class QueueManager {
-    async from(name, jobHandler) {
-        const q = new AvleonQueue(name, new FileQueueAdapter(name), jobHandler);
-        return q;
-    }
-};
-exports.QueueManager = QueueManager;
-exports.QueueManager = QueueManager = __decorate([
-    decorators_1.AppService
-], QueueManager);
+function Queue(config) {
+    return function (target) {
+        // Create a new class that extends the target
+        const DecoratedClass = class extends target {
+            constructor(...args) {
+                super(config.name, config.adapter, config.handler);
+            }
+        };
+        Object.defineProperty(DecoratedClass, 'name', {
+            value: target.name,
+            writable: false
+        });
+        (0, typedi_1.Service)()(DecoratedClass);
+        return DecoratedClass;
+    };
+}

package/dist/route-methods.js

@@ -17,17 +17,28 @@ function Route(method, pathOrOptions, maybeOptions) {
         let path = "/";
         let options = {};
         if (typeof pathOrOptions === "string") {
-            path = pathOrOptions;
+            path = pathOrOptions || "/";
             options = maybeOptions || {};
         }
-        else if (typeof pathOrOptions === "object") {
+        else if (typeof pathOrOptions === "object" && pathOrOptions !== null) {
             options = pathOrOptions;
-            path = options.name || "/";
+            path = options.path || options.name || "/";
         }
-        // Define metadata
+        else {
+            // @Get() called with no args
+            options = maybeOptions || {};
+            path = "/";
+        }
+        //Ensure path is always a string
+        path = typeof path === "string" ? path : "/";
         Reflect.defineMetadata("route:path", path, target, propertyKey);
         Reflect.defineMetadata("route:method", method, target, propertyKey);
-        Reflect.defineMetadata(container_1.ROUTE_META_KEY, { ...options, method, path, controller: target.constructor.name }, target, propertyKey);
+        Reflect.defineMetadata(container_1.ROUTE_META_KEY, {
+            ...options,
+            method,
+            path,
+            controller: target.constructor.name,
+        }, target, propertyKey);
         if (options) {
             Reflect.defineMetadata("route:options", options, target, propertyKey);
         }

package/dist/swagger-schema.d.ts

@@ -1,25 +1,19 @@
-export declare function OpenApiProperty(options?: {
-    type?: any;
-    description?: string;
-    deprecated?: boolean;
-    example?: any;
-    enum?: any[];
-    format?: string;
-    default?: any;
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    oneOf?: any[];
-    allOf?: any[];
-    anyOf?: any[];
+import { ParamSchema } from "./openapi";
+export declare function OpenApiProperty(options?: ParamSchema & {
     exclude?: boolean;
     isArray?: boolean;
     items?: Record<string, any>;
+    oneOf?: any[];
+    allOf?: any[];
+    anyOf?: any[];
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    nullable?: boolean;
+    title?: string;
 }): (target: any, propertyKey: string) => void;
 export declare function CreateSwaggerObjectSchema(classType: any): any;
-export declare function generateSwaggerSchema(classType: any): any;
+export declare function generateClassSchema(classType: any): any;
+export declare function generateSwaggerSchema(controllers: any[]): any;
 export declare function OpenApiResponse(code: number | undefined, model: any, description?: string): {
     description: string;
     content: {

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();
+    });
 });