@hosterai/types 0.0.17 → 0.0.19

package/dist/decorators/is-one-of-validator.spec.js

@@ -0,0 +1,51 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const is_one_of_validator_1 = require("../decorators/is-one-of.validator");
+class A {
+}
+class B {
+}
+class C {
+}
+class TestDto {
+}
+__decorate([
+    (0, is_one_of_validator_1.IsOneOf)([A, B], { message: 'value must be instance of A or B' }),
+    __metadata("design:type", Object)
+], TestDto.prototype, "prop", void 0);
+describe('IsOneOf decorator', () => {
+    const cases = [
+        [new A(), true],
+        [new B(), true],
+        [new C(), false],
+        ['string', false],
+        [123, false],
+    ];
+    it.each(cases)('validates %p as %p', async (value, valid) => {
+        const dto = (0, class_transformer_1.plainToInstance)(TestDto, { prop: value });
+        const errors = await (0, class_validator_1.validate)(dto);
+        if (valid)
+            expect(errors.length).toBe(0);
+        else {
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].constraints).toHaveProperty('isOneOf');
+        }
+    });
+    it('returns custom message', async () => {
+        var _a;
+        const dto = (0, class_transformer_1.plainToInstance)(TestDto, { prop: 123 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect((_a = errors[0].constraints) === null || _a === void 0 ? void 0 : _a.isOneOf).toBe('value must be instance of A or B');
+    });
+});

package/dist/decorators/is-one-of.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from "class-validator";
+export declare function IsOneOf(validClasses: Function[], validationOptions?: ValidationOptions): (object: Object, propertyName: string) => void;

package/dist/decorators/is-one-of.validator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsOneOf = IsOneOf;
+const class_validator_1 = require("class-validator");
+function IsOneOf(validClasses, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'isOneOf',
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, _args) {
+                    return validClasses.some(cls => value instanceof cls);
+                },
+            },
+        });
+    };
+}

package/dist/decorators/is-plain-object-validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/decorators/is-plain-object-validator.spec.js

@@ -0,0 +1,46 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const class_validator_1 = require("class-validator");
+const is_plain_object_validator_1 = require("./is-plain-object.validator");
+class TestDto {
+}
+__decorate([
+    (0, is_plain_object_validator_1.IsPlainObject)(),
+    __metadata("design:type", Object)
+], TestDto.prototype, "plainObjectField", void 0);
+describe('IsPlainObject', () => {
+    it('should validate plain objects', () => {
+        const dto = new TestDto();
+        dto.plainObjectField = { key: 'value' };
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('should invalidate objects with functions', () => {
+        const dto = new TestDto();
+        dto.plainObjectField = { key: () => { } };
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should invalidate non-object values', () => {
+        const dto = new TestDto();
+        // @ts-ignore
+        dto.plainObjectField = 'not an object';
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should invalidate null values', () => {
+        const dto = new TestDto();
+        dto.plainObjectField = null;
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

package/dist/decorators/is-plain-object.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsPlainObject(validationOptions?: ValidationOptions): (object: Object, propertyName: string) => void;

package/dist/decorators/is-plain-object.validator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsPlainObject = IsPlainObject;
+const class_validator_1 = require("class-validator");
+function IsPlainObject(validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'isPlainObject',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value, _args) {
+                    if (value === null || typeof value !== 'object' || value.constructor !== Object) {
+                        return false;
+                    }
+                    for (const key in value) {
+                        if (typeof key !== 'string' || typeof value[key] === 'function') {
+                            return false;
+                        }
+                    }
+                    return true;
+                },
+                defaultMessage(_args) {
+                    return '$property must be a plain object with key-value pairs';
+                },
+            },
+        });
+    };
+}

package/dist/decorators/is-property-forbidden-validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/decorators/is-property-forbidden-validator.spec.js

@@ -0,0 +1,62 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const is_property_forbidden_validator_1 = require("../decorators/is-property-forbidden.validator");
+class TestDto {
+}
+__decorate([
+    (0, is_property_forbidden_validator_1.IsPropertyForbidden)('forbiddenProp', { message: 'forbiddenProp must not be present' }),
+    __metadata("design:type", Object)
+], TestDto.prototype, "someProp", void 0);
+class TestDto2 {
+}
+__decorate([
+    (0, is_property_forbidden_validator_1.IsPropertyForbidden)('forbiddenProp'),
+    __metadata("design:type", Object)
+], TestDto2.prototype, "someProp", void 0);
+describe('IsPropertyForbidden decorator', () => {
+    it('passes validation when forbidden property is absent', async () => {
+        const dto = (0, class_transformer_1.plainToInstance)(TestDto, { someProp: 'allowed' });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails validation when forbidden property is present', async () => {
+        const dto = (0, class_transformer_1.plainToInstance)(TestDto, { someProp: 'allowed', forbiddenProp: 'not allowed' });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+        // Validate error message
+        expect(errors[0].constraints).toBeDefined();
+        expect(errors[0].constraints).toHaveProperty('isPropertyForbidden');
+        expect(errors[0].constraints.isPropertyForbidden).toBe('forbiddenProp must not be present');
+    });
+    it('uses custom error message if provided', async () => {
+        class CustomMessageDto {
+        }
+        __decorate([
+            (0, is_property_forbidden_validator_1.IsPropertyForbidden)('badProp', { message: 'Custom forbidden message' }),
+            __metadata("design:type", Object)
+        ], CustomMessageDto.prototype, "prop", void 0);
+        const dto = (0, class_transformer_1.plainToInstance)(CustomMessageDto, { prop: 'ok', badProp: 123 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].constraints).toBeDefined();
+        expect(errors[0].constraints.isPropertyForbidden).toBe('Custom forbidden message');
+    });
+    it('uses default error message if no message is provided', async () => {
+        const dto = (0, class_transformer_1.plainToInstance)(TestDto2, { someProp: 'allowed', forbiddenProp: 'not allowed' });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].constraints).toBeDefined();
+        expect(errors[0].constraints.isPropertyForbidden).toBe('Property \'forbiddenProp\' is not allowed');
+    });
+});

package/dist/decorators/is-property-forbidden.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsPropertyForbidden(property: string, validationOptions?: ValidationOptions): (object: Object, propertyName: string) => void;

package/dist/decorators/is-property-forbidden.validator.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsPropertyForbidden = IsPropertyForbidden;
+const class_validator_1 = require("class-validator");
+function IsPropertyForbidden(property, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'isPropertyForbidden',
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            validator: {
+                validate(_value, args) {
+                    return !(property in args.object);
+                },
+                defaultMessage(_args) {
+                    return `Property '${property}' is not allowed`;
+                },
+            },
+        });
+    };
+}

package/dist/decorators/is-regex-validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/decorators/is-regex-validator.spec.js

@@ -0,0 +1,46 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const class_validator_1 = require("class-validator");
+const is_regex_validator_1 = require("./is-regex.validator");
+class TestDto {
+}
+__decorate([
+    (0, is_regex_validator_1.IsRegex)(),
+    __metadata("design:type", String)
+], TestDto.prototype, "regexField", void 0);
+describe('IsRegex', () => {
+    it('should validate valid regex strings', () => {
+        const dto = new TestDto();
+        dto.regexField = '^abc$';
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('should invalidate invalid regex strings', () => {
+        const dto = new TestDto();
+        dto.regexField = '[';
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should invalidate non-string values', () => {
+        const dto = new TestDto();
+        // @ts-ignore
+        dto.regexField = 123;
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should invalidate empty strings', () => {
+        const dto = new TestDto();
+        dto.regexField = '';
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+});

package/dist/decorators/is-regex.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsRegex(validationOptions?: ValidationOptions): (object: Object, propertyName: string) => void;

package/dist/decorators/is-regex.validator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsRegex = IsRegex;
+const class_validator_1 = require("class-validator");
+function IsRegex(validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'isRegex',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value) {
+                    if (typeof value !== 'string')
+                        return false;
+                    if (value.trim().length === 0)
+                        return false;
+                    try {
+                        new RegExp(value);
+                        return true;
+                    }
+                    catch (_a) {
+                        return false;
+                    }
+                },
+                defaultMessage() {
+                    return '$property must be a valid regular expression';
+                },
+            },
+        });
+    };
+}

package/dist/decorators/min-less-or-equal-validator.spec.d.ts

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

package/dist/decorators/min-less-or-equal-validator.spec.js

@@ -0,0 +1,60 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const class_validator_1 = require("class-validator");
+const min_less_or_equal_validator_1 = require("./min-less-or-equal.validator");
+let MinMaxDto = class MinMaxDto {
+    constructor(data) { Object.assign(this, data); }
+};
+MinMaxDto = __decorate([
+    (0, min_less_or_equal_validator_1.MinLessOrEqualMaxProperty)(['min', 'max']),
+    __metadata("design:paramtypes", [Object])
+], MinMaxDto);
+let MultiMinMaxDto = class MultiMinMaxDto {
+    constructor(data) { Object.assign(this, data); }
+};
+MultiMinMaxDto = __decorate([
+    (0, min_less_or_equal_validator_1.MinLessOrEqualMaxProperty)([
+        ['min1', 'max1'],
+        ['min2', 'max2'],
+    ]),
+    __metadata("design:paramtypes", [Object])
+], MultiMinMaxDto);
+describe('MinLessOrEqualMaxProperty', () => {
+    it('passes when one or both are absent', async () => {
+        const dto1 = new MinMaxDto({});
+        const dto2 = new MinMaxDto({ min: 1 });
+        const dto3 = new MinMaxDto({ max: 2 });
+        expect((await (0, class_validator_1.validate)(dto1)).length).toBe(0);
+        expect((await (0, class_validator_1.validate)(dto2)).length).toBe(0);
+        expect((await (0, class_validator_1.validate)(dto3)).length).toBe(0);
+    });
+    it('passes when min <= max', async () => {
+        const dto = new MinMaxDto({ min: 1, max: 1 });
+        const dto2 = new MinMaxDto({ min: 1, max: 2 });
+        expect((await (0, class_validator_1.validate)(dto)).length).toBe(0);
+        expect((await (0, class_validator_1.validate)(dto2)).length).toBe(0);
+    });
+    it('fails when min > max', async () => {
+        const dto = new MinMaxDto({ min: 3, max: 2 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('handles multiple pairs correctly', async () => {
+        const ok = new MultiMinMaxDto({ min1: 1, max1: 2, min2: 3, max2: 3 });
+        const errorsOk = await (0, class_validator_1.validate)(ok);
+        expect(errorsOk.length).toBe(0);
+        const bad = new MultiMinMaxDto({ min1: 1, max1: 0, min2: 3, max2: 3 });
+        const errorsBad = await (0, class_validator_1.validate)(bad);
+        expect(errorsBad.length).toBeGreaterThan(0);
+    });
+});

package/dist/decorators/min-less-or-equal.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from 'class-validator';
+export declare function MinLessOrEqualMaxProperty(keysOrPairs: [string, string] | [string, string][], validationOptions?: ValidationOptions): (constructor: Function) => void;

package/dist/decorators/min-less-or-equal.validator.js

@@ -0,0 +1,58 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinLessOrEqualMaxProperty = MinLessOrEqualMaxProperty;
+const class_validator_1 = require("class-validator");
+let MinLessOrEqualMaxConstraint = class MinLessOrEqualMaxConstraint {
+    validate(_, args) {
+        const object = args.object;
+        const input = args.constraints[0];
+        const pairs = Array.isArray(input) && typeof input[0] === 'string'
+            ? [input]
+            : input;
+        return pairs.every(([minKey, maxKey]) => {
+            const minVal = object[minKey];
+            const maxVal = object[maxKey];
+            // If one or both are missing, do not fail here; let AllOrNone or other validators handle presence
+            if (minVal === undefined || minVal === null)
+                return true;
+            if (maxVal === undefined || maxVal === null)
+                return true;
+            if (typeof minVal !== 'number' || typeof maxVal !== 'number')
+                return true; // Type guards handled elsewhere
+            return minVal <= maxVal;
+        });
+    }
+    defaultMessage(args) {
+        const input = args.constraints[0];
+        const pairs = Array.isArray(input) && typeof input[0] === 'string'
+            ? [input]
+            : input;
+        if (pairs.length === 1) {
+            const [minKey, maxKey] = pairs[0];
+            return `${minKey} must be less than or equal to ${maxKey}`;
+        }
+        const list = pairs.map(([a, b]) => `${a}<=${b}`).join(', ');
+        return `The following constraints must hold: ${list}`;
+    }
+};
+MinLessOrEqualMaxConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'MinLessOrEqualMax', async: false })
+], MinLessOrEqualMaxConstraint);
+function MinLessOrEqualMaxProperty(keysOrPairs, validationOptions) {
+    return function (constructor) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'MinLessOrEqualMax',
+            target: constructor,
+            propertyName: '',
+            options: validationOptions,
+            constraints: [keysOrPairs],
+            validator: MinLessOrEqualMaxConstraint,
+        });
+    };
+}

package/dist/decorators/unique-field-in-array-validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/decorators/unique-field-in-array-validator.spec.js

@@ -0,0 +1,39 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const class_validator_1 = require("class-validator");
+const unique_field_in_array_validator_1 = require("./unique-field-in-array.validator");
+class TestDto {
+}
+__decorate([
+    (0, unique_field_in_array_validator_1.UniqueFieldInArray)('id'),
+    __metadata("design:type", Array)
+], TestDto.prototype, "items", void 0);
+describe('UniqueFieldInArray', () => {
+    it('should validate array with unique field values', () => {
+        const dto = new TestDto();
+        dto.items = [{ id: 1 }, { id: 2 }];
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('should invalidate array with duplicate field values', () => {
+        const dto = new TestDto();
+        dto.items = [{ id: 1 }, { id: 1 }];
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should validate empty array', () => {
+        const dto = new TestDto();
+        dto.items = [];
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBe(0);
+    });
+});

package/dist/decorators/unique-field-in-array.validator.d.ts

@@ -0,0 +1,6 @@
+import { ValidationArguments, ValidationOptions, ValidatorConstraintInterface } from 'class-validator';
+export declare class UniqueFieldInArrayConstraint implements ValidatorConstraintInterface {
+    validate(value: any[], args: ValidationArguments): boolean;
+    defaultMessage(args: ValidationArguments): string;
+}
+export declare function UniqueFieldInArray(field: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

package/dist/decorators/unique-field-in-array.validator.js

@@ -0,0 +1,47 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueFieldInArrayConstraint = void 0;
+exports.UniqueFieldInArray = UniqueFieldInArray;
+const class_validator_1 = require("class-validator");
+let UniqueFieldInArrayConstraint = class UniqueFieldInArrayConstraint {
+    validate(value, args) {
+        if (!Array.isArray(value))
+            return true; // Let @IsArray handle wrong type
+        const field = args.constraints[0];
+        const seen = new Set();
+        for (const obj of value) {
+            if (obj && typeof obj === 'object' && obj[field] !== undefined) {
+                if (seen.has(obj[field])) {
+                    return false;
+                }
+                seen.add(obj[field]);
+            }
+        }
+        return true;
+    }
+    defaultMessage(args) {
+        const field = args.constraints[0];
+        return `All objects in ${args.property} must have a unique "${field}" value`;
+    }
+};
+exports.UniqueFieldInArrayConstraint = UniqueFieldInArrayConstraint;
+exports.UniqueFieldInArrayConstraint = UniqueFieldInArrayConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ async: false })
+], UniqueFieldInArrayConstraint);
+function UniqueFieldInArray(field, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints: [field],
+            validator: UniqueFieldInArrayConstraint,
+        });
+    };
+}

package/dist/dtos/action.dto.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionDto = void 0;
 const class_validator_1 = require("class-validator");
 const open_method_enum_1 = require("../enums/open-method.enum");
+const class_validator_jsonschema_1 = require("class-validator-jsonschema");
 /**
  * Defines the structure for a UI action.
  * @example
@@ -27,18 +28,41 @@ class ActionDto {
 exports.ActionDto = ActionDto;
 __decorate([
     (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_jsonschema_1.JSONSchema)({
+        title: 'Icon',
+        description: 'Name of the icon to display for the action.',
+        type: 'string'
+    }),
     __metadata("design:type", String)
 ], ActionDto.prototype, "icon", void 0);
 __decorate([
     (0, class_validator_1.IsString)(),
     (0, class_validator_1.IsOptional)(),
+    (0, class_validator_jsonschema_1.JSONSchema)({
+        title: 'Label',
+        description: 'Text label for the action.',
+        type: 'string'
+    }),
     __metadata("design:type", String)
 ], ActionDto.prototype, "label", void 0);
 __decorate([
     (0, class_validator_1.IsEnum)(open_method_enum_1.OpenMethodEnum),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_jsonschema_1.JSONSchema)({
+        title: 'Open Method',
+        description: 'Method by which the action\'s URL should be opened.',
+        enum: Object.values(open_method_enum_1.OpenMethodEnum)
+    }),
     __metadata("design:type", String)
 ], ActionDto.prototype, "openMethod", void 0);
 __decorate([
-    (0, class_validator_1.IsUrl)(),
+    (0, class_validator_1.IsUrl)({ protocols: ['https'], require_protocol: true }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_jsonschema_1.JSONSchema)({
+        title: 'URL',
+        description: 'URL to navigate to when the action is triggered.',
+        type: 'string'
+    }),
     __metadata("design:type", String)
 ], ActionDto.prototype, "url", void 0);