@hosterai/types 0.0.17 → 0.0.19

package/README.md

@@ -46,6 +46,9 @@ DTOs define the shape of data that is exchanged between different parts of the s
 - `info.dto.ts`: Contains all necessary information for a service integration.
 - `jwt.dto.ts`: DTOs related to JSON Web Tokens.
 - `menu.dto.ts`: Defines the structure for menu items.
+- `settings.dto.ts`: Settings base DTO and variants (`SettingsWithUrlDto`, `SettingsWithTabsDto`).
+- `admin-panel.dto.ts`: Admin panel UI configuration (tabs, moreActions, menu, settings).
+- `client-panel.dto.ts`: Client panel UI configuration (tabs, moreActions, menu).
 - `multilang-text.dto.ts`: A DTO for handling text in multiple languages.
 - `response-data.dto.ts`: A generic wrapper for response data.
 - `setup-status-response.dto.ts`: DTO for returning the setup status.
@@ -80,7 +83,7 @@ Enums provide a set of named constants for common types, preventing errors with
 
 **Key Enums:**
 
-- `ProductActionsEnum`: Defines possible actions.
+- `ActionsEnum`: Defines possible actions.
 - `CountryEnum`: A list of all countries.
 - `DurationEnum`: Defines billing durations (e.g., `MONTHLY`, `YEARLY`).
 - `EventsEnum`: Defines triggerable events.
@@ -124,7 +127,7 @@ import {
   ClientDataDto,
   ProductItemDataDto,
   DurationEnum,
-  validateProductCreateRequestDto, // Assuming a validator exists
+  validateProductCreateRequestDto,
 } from '@hosterai/types';
 
 // 1. Create a request object
@@ -144,15 +147,15 @@ const request: ProductCreateRequestDto = {
   },
 };
 
-// 2. Validate the object
-// const errors = validateProductCreateRequestDto(request);
+// 2. Validate the object (async)
+const errors = await validateProductCreateRequestDto(request);
 
 // 3. Check for errors
-// if (errors.length > 0) {
-//   console.error('Validation failed:', errors);
-// } else {
-//   console.log('Validation successful!');
-// }
+if (errors.length > 0) {
+  console.error('Validation failed:', errors);
+} else {
+  console.log('Validation successful!');
+}
 ```
 
 ## Building from Source

package/dist/decorators/all-or-none-validator.spec.d.ts

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

package/dist/decorators/all-or-none-validator.spec.js

@@ -0,0 +1,91 @@
+"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 all_or_none_validator_1 = require("./all-or-none.validator");
+// Pairs
+let PairDto = class PairDto {
+    constructor(data) { Object.assign(this, data); }
+};
+PairDto = __decorate([
+    (0, all_or_none_validator_1.AllOrNoneProperty)(['a', 'b']),
+    __metadata("design:paramtypes", [Object])
+], PairDto);
+// Multiple pairs
+let MultiPairDto = class MultiPairDto {
+    constructor(data) { Object.assign(this, data); }
+};
+MultiPairDto = __decorate([
+    (0, all_or_none_validator_1.AllOrNoneProperty)([
+        ['a', 'b'],
+        ['c', 'd'],
+    ]),
+    __metadata("design:paramtypes", [Object])
+], MultiPairDto);
+// Group of 3+
+let GroupDto = class GroupDto {
+    constructor(data) { Object.assign(this, data); }
+};
+GroupDto = __decorate([
+    (0, all_or_none_validator_1.AllOrNoneProperty)(['x', 'y', 'z']),
+    __metadata("design:paramtypes", [Object])
+], GroupDto);
+describe('AllOrNoneProperty', () => {
+    // Single pair
+    it('passes when both pair fields are absent', async () => {
+        const dto = new PairDto({});
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when one of pair fields is present and the other is absent', async () => {
+        const dto = new PairDto({ a: 1 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('passes when both pair fields are present', async () => {
+        const dto = new PairDto({ a: 1, b: 2 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    // Multiple pairs
+    it('passes when all pairs are absent', async () => {
+        const dto = new MultiPairDto({});
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('passes when all pairs are present', async () => {
+        const dto = new MultiPairDto({ a: 1, b: 2, c: 3, d: 4 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when one pair violates the rule', async () => {
+        const dto = new MultiPairDto({ a: 1, b: 2, c: 3 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    // 3+ group
+    it('passes when all group fields are absent', async () => {
+        const dto = new GroupDto({});
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when only a subset of group fields are present', async () => {
+        const dto = new GroupDto({ x: 1 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('passes when all group fields are present', async () => {
+        const dto = new GroupDto({ x: 1, y: 2, z: 3 });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+});

package/dist/decorators/all-or-none.validator.d.ts

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

package/dist/decorators/all-or-none.validator.js

@@ -0,0 +1,71 @@
+"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.AllOrNoneProperty = AllOrNoneProperty;
+const class_validator_1 = require("class-validator");
+let AllOrNoneConstraint = class AllOrNoneConstraint {
+    validate(_, args) {
+        const object = args.object;
+        const input = args.constraints[0];
+        // Normalize to an array of groups, each group being string[] (length >= 2 preferred)
+        let groups = [];
+        if (Array.isArray(input)) {
+            if (input.length > 0 && typeof input[0] === 'string') {
+                // Single group given as string[] (could be pair or more than 2)
+                groups = [input];
+            }
+            else {
+                // Array of groups (pairs or larger)
+                groups = input.map((g) => g);
+            }
+        }
+        const has = (k) => object[k] !== undefined && object[k] !== null;
+        return groups.every((group) => {
+            if (!Array.isArray(group) || group.length < 2)
+                return true; // Ignore invalid/misconfigured groups
+            const statuses = group.map((k) => has(k));
+            const allPresent = statuses.every(Boolean);
+            const allAbsent = statuses.every((v) => !v);
+            return allPresent || allAbsent;
+        });
+    }
+    defaultMessage(args) {
+        const input = args.constraints[0];
+        let groups = [];
+        if (Array.isArray(input)) {
+            if (input.length > 0 && typeof input[0] === 'string') {
+                groups = [input];
+            }
+            else {
+                groups = input.map((g) => g);
+            }
+        }
+        if (groups.length === 1) {
+            const g = groups[0];
+            const list = g.join(', ');
+            return `All of (${list}) must be provided together or omitted together`;
+        }
+        const list = groups.map((g) => `(${g.join('/')})`).join(', ');
+        return `Each group must be provided together or omitted together: ${list}`;
+    }
+};
+AllOrNoneConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'AllOrNone', async: false })
+], AllOrNoneConstraint);
+function AllOrNoneProperty(keysOrGroups, validationOptions) {
+    return function (constructor) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'AllOrNone',
+            target: constructor,
+            propertyName: '',
+            options: validationOptions,
+            constraints: [keysOrGroups],
+            validator: AllOrNoneConstraint,
+        });
+    };
+}

package/dist/decorators/at-least-one-non-empty-validator.spec.d.ts

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

package/dist/decorators/at-least-one-non-empty-validator.spec.js

@@ -0,0 +1,79 @@
+"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 at_least_one_non_empty_validator_1 = require("../decorators/at-least-one-non-empty.validator");
+let TestDto = class TestDto {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+};
+TestDto = __decorate([
+    (0, at_least_one_non_empty_validator_1.AtLeastOneNonEmptyProperty)(['a', 'b', 'c'], {
+        message: 'At least one of a, b, or c must be non-empty.',
+    }),
+    __metadata("design:paramtypes", [Object])
+], TestDto);
+let TestDto2 = class TestDto2 {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+};
+TestDto2 = __decorate([
+    (0, at_least_one_non_empty_validator_1.AtLeastOneNonEmptyProperty)(['a', 'b', 'c']),
+    __metadata("design:paramtypes", [Object])
+], TestDto2);
+describe('AtLeastOneNonEmptyClass', () => {
+    it('fails when all keys are undefined', async () => {
+        const dto = new TestDto({});
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('fails when all keys are empty arrays/objects', async () => {
+        const dto = new TestDto({ a: [], b: {}, c: [] });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('passes when one key is a non-empty array', async () => {
+        const dto = new TestDto({ a: [1], b: [], c: {} });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('passes when one key is a non-empty object', async () => {
+        const dto = new TestDto({ a: {}, b: { x: 1 }, c: [] });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when non-object types are present', async () => {
+        const dto = new TestDto({ a: 'string', b: 123, c: false });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('passes when multiple keys are non-empty', async () => {
+        const dto = new TestDto({ a: [1], b: { test: true }, c: [] });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails when keys are missing', async () => {
+        const dto = new TestDto({ d: 'not part of the check' });
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('returns the default error message when validation fails', async () => {
+        const dto = new TestDto2({});
+        const errors = await (0, class_validator_1.validate)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+        const constraints = errors[0].constraints;
+        expect(constraints).toBeDefined();
+        const messages = Object.values(constraints);
+        expect(messages.some(msg => msg.includes('At least one of the following must be non-empty: a, b, c'))).toBe(true);
+    });
+});

package/dist/decorators/at-least-one-non-empty.validator.d.ts

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

package/dist/decorators/at-least-one-non-empty.validator.js

@@ -0,0 +1,43 @@
+"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.AtLeastOneNonEmptyProperty = AtLeastOneNonEmptyProperty;
+const class_validator_1 = require("class-validator");
+function isNonEmptyObjectOrArray(value) {
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value && typeof value === 'object')
+        return Object.keys(value).length > 0;
+    return false;
+}
+let AtLeastOneNonEmptyConstraint = class AtLeastOneNonEmptyConstraint {
+    validate(_, args) {
+        const object = args.object;
+        const keys = args.constraints[0];
+        return keys.some(key => isNonEmptyObjectOrArray(object[key]));
+    }
+    defaultMessage(args) {
+        const keys = args.constraints[0];
+        return `At least one of the following must be non-empty: ${keys.join(', ')}`;
+    }
+};
+AtLeastOneNonEmptyConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'AtLeastOneNonEmpty', async: false })
+], AtLeastOneNonEmptyConstraint);
+function AtLeastOneNonEmptyProperty(keys, validationOptions) {
+    return function (constructor) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'AtLeastOneNonEmpty',
+            target: constructor,
+            propertyName: "",
+            options: validationOptions,
+            constraints: [keys],
+            validator: AtLeastOneNonEmptyConstraint,
+        });
+    };
+}

package/dist/decorators/is-of-allowed-types-validator.spec.d.ts

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

package/dist/decorators/is-of-allowed-types-validator.spec.js

@@ -0,0 +1,188 @@
+"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 is_of_allowed_types_validator_1 = require("./is-of-allowed-types.validator");
+class DummyObject {
+}
+class DummyArrayElement {
+}
+class TestDto {
+}
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['string']),
+    __metadata("design:type", Object)
+], TestDto.prototype, "strProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['number']),
+    __metadata("design:type", Object)
+], TestDto.prototype, "numProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['boolean']),
+    __metadata("design:type", Object)
+], TestDto.prototype, "boolProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['object']),
+    __metadata("design:type", Object)
+], TestDto.prototype, "objProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['object'], { objectClass: DummyObject }),
+    __metadata("design:type", Object)
+], TestDto.prototype, "typedObjProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['array']),
+    __metadata("design:type", Object)
+], TestDto.prototype, "arrProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['array'], { arrayElementClass: DummyArrayElement }),
+    __metadata("design:type", Object)
+], TestDto.prototype, "typedArrProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['string', 'number']),
+    __metadata("design:type", Object)
+], TestDto.prototype, "multiTypeProp", void 0);
+class OptionsTestDto {
+}
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['string'], { stringPattern: /^[a-z]+$/, require: true }),
+    __metadata("design:type", Object)
+], OptionsTestDto.prototype, "strPatternProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['array'], { arrayNotEmpty: true }),
+    __metadata("design:type", Object)
+], OptionsTestDto.prototype, "arrayNotEmptyProp", void 0);
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['object'], { objectNotEmpty: true }),
+    __metadata("design:type", Object)
+], OptionsTestDto.prototype, "objectNotEmptyProp", void 0);
+class ArrayNotEmptyDto {
+}
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['array'], { arrayNotEmpty: true }),
+    __metadata("design:type", Object)
+], ArrayNotEmptyDto.prototype, "value", void 0);
+class ObjectNotEmptyDto {
+}
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['object'], { objectNotEmpty: true }),
+    __metadata("design:type", Object)
+], ObjectNotEmptyDto.prototype, "value", void 0);
+class ValidationOptionsDto {
+}
+__decorate([
+    (0, is_of_allowed_types_validator_1.IsOfAllowedTypes)(['string'], { message: 'Custom error message' }),
+    __metadata("design:type", Object)
+], ValidationOptionsDto.prototype, "prop", void 0);
+describe('IsOfAllowedTypes validator - compact', () => {
+    it('accepts valid types', () => {
+        const dto = new TestDto();
+        dto.strProp = 'hello';
+        dto.numProp = 42;
+        dto.boolProp = true;
+        dto.objProp = {};
+        dto.typedObjProp = new DummyObject();
+        dto.arrProp = [1, 2];
+        dto.typedArrProp = [new DummyArrayElement()];
+        dto.multiTypeProp = 'string or number';
+        expect((0, class_validator_1.validateSync)(dto)).toHaveLength(0);
+    });
+    it('rejects invalid types', () => {
+        const dto = new TestDto();
+        dto.strProp = 123;
+        dto.numProp = 'string';
+        dto.boolProp = 'true';
+        dto.objProp = 'string';
+        dto.typedObjProp = {};
+        dto.arrProp = 'not array';
+        dto.typedArrProp = [{}];
+        dto.multiTypeProp = true;
+        const errors = (0, class_validator_1.validateSync)(dto).map(e => e.property);
+        expect(new Set(errors)).toEqual(new Set([
+            'arrProp',
+            'boolProp',
+            'multiTypeProp',
+            'numProp',
+            'objProp',
+            'strProp',
+            'typedArrProp',
+            'typedObjProp',
+        ]));
+    });
+    it('allows null or undefined when not required', () => {
+        const dto = new TestDto();
+        dto.strProp = null;
+        dto.numProp = undefined;
+        expect((0, class_validator_1.validateSync)(dto)).toHaveLength(0);
+    });
+    it('fails when objectClass is provided but instance check fails', () => {
+        const dto = new TestDto();
+        dto.typedObjProp = {};
+        expect((0, class_validator_1.validateSync)(dto).some(e => e.property === 'typedObjProp')).toBe(true);
+    });
+    it('fails when arrayElementClass is provided but element check fails', () => {
+        const dto = new TestDto();
+        dto.typedArrProp = [{}];
+        expect((0, class_validator_1.validateSync)(dto).some(e => e.property === 'typedArrProp')).toBe(true);
+    });
+    // Added coverage tests
+    it('fails if string is empty but required', () => {
+        const dto = new OptionsTestDto();
+        dto.strPatternProp = '   ';
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.some(e => e.property === 'strPatternProp')).toBe(true);
+    });
+    it('fails if string does not match pattern', () => {
+        const dto = new OptionsTestDto();
+        dto.strPatternProp = '123';
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.some(e => e.property === 'strPatternProp')).toBe(true);
+    });
+    it('passes if string matches pattern', () => {
+        const dto = new OptionsTestDto();
+        dto.strPatternProp = 'abc';
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails if array is empty but arrayNotEmpty true', () => {
+        const dto = new OptionsTestDto();
+        dto.arrayNotEmptyProp = [];
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.some(e => e.property === 'arrayNotEmptyProp')).toBe(true);
+    });
+    it('passes if array is non-empty and arrayNotEmpty true', () => {
+        const dto = new ArrayNotEmptyDto();
+        dto.value = [1];
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('fails if object is empty but objectNotEmpty true', () => {
+        const dto = new OptionsTestDto();
+        dto.objectNotEmptyProp = {};
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.some(e => e.property === 'objectNotEmptyProp')).toBe(true);
+    });
+    it('passes if object is non-empty and objectNotEmpty true', () => {
+        const dto = new ObjectNotEmptyDto();
+        dto.value = { key: 'value' };
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBe(0);
+    });
+    it('accepts ValidationOptions as second argument', () => {
+        const dto = new ValidationOptionsDto();
+        dto.prop = 123;
+        const errors = (0, class_validator_1.validateSync)(dto);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].constraints).toBeDefined();
+        expect(errors[0].constraints).toHaveProperty('isOfAllowedTypes');
+        expect(errors[0].constraints['isOfAllowedTypes']).toContain('Custom error message');
+    });
+});

package/dist/decorators/is-of-allowed-types.validator.d.ts

@@ -0,0 +1,16 @@
+import { ValidationOptions } from 'class-validator';
+type AllowedPrimitive = 'string' | 'number' | 'boolean';
+type AllowedType = AllowedPrimitive | 'object' | 'array';
+interface IsOfAllowedTypesOptions {
+    objectClass?: new (...args: any[]) => any;
+    arrayElementClass?: new (...args: any[]) => any;
+    require?: boolean;
+    objectNotEmpty?: boolean;
+    arrayNotEmpty?: boolean;
+    stringPattern?: RegExp;
+}
+export declare function IsOfAllowedTypes(types: AllowedType[]): PropertyDecorator;
+export declare function IsOfAllowedTypes(types: AllowedType[], options: IsOfAllowedTypesOptions): PropertyDecorator;
+export declare function IsOfAllowedTypes(types: AllowedType[], validationOptions: ValidationOptions): PropertyDecorator;
+export declare function IsOfAllowedTypes(types: AllowedType[], options: IsOfAllowedTypesOptions, validationOptions: ValidationOptions): PropertyDecorator;
+export {};

package/dist/decorators/is-of-allowed-types.validator.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsOfAllowedTypes = IsOfAllowedTypes;
+const class_validator_1 = require("class-validator");
+// Implementation
+function IsOfAllowedTypes(types, optionsOrValidationOptions, validationOptions) {
+    return function (target, propertyKey) {
+        let options = {};
+        let finalValidationOptions;
+        if (optionsOrValidationOptions) {
+            if ('objectClass' in optionsOrValidationOptions ||
+                'arrayElementClass' in optionsOrValidationOptions ||
+                'require' in optionsOrValidationOptions ||
+                'objectNotEmpty' in optionsOrValidationOptions ||
+                'arrayNotEmpty' in optionsOrValidationOptions ||
+                'stringPattern' in optionsOrValidationOptions) {
+                options = optionsOrValidationOptions;
+                finalValidationOptions = validationOptions;
+            }
+            else {
+                finalValidationOptions = optionsOrValidationOptions;
+            }
+        }
+        (0, class_validator_1.registerDecorator)({
+            name: 'isOfAllowedTypes',
+            target: target.constructor,
+            propertyName: propertyKey.toString(),
+            constraints: [types, options],
+            options: finalValidationOptions,
+            validator: {
+                validate(value, args) {
+                    const [allowedTypes, opts] = args.constraints;
+                    if (value === null || value === undefined) {
+                        return !opts.require;
+                    }
+                    for (const type of allowedTypes) {
+                        switch (type) {
+                            case 'string':
+                                if (typeof value === 'string') {
+                                    if (opts.require && value.trim().length === 0)
+                                        return false;
+                                    if (opts.stringPattern && !opts.stringPattern.test(value))
+                                        return false;
+                                    return true;
+                                }
+                                break;
+                            case 'number':
+                                if (typeof value === 'number')
+                                    return true;
+                                break;
+                            case 'boolean':
+                                if (typeof value === 'boolean')
+                                    return true;
+                                break;
+                            case 'object':
+                                if (typeof value === 'object' &&
+                                    !Array.isArray(value) &&
+                                    (!opts.objectClass || value instanceof opts.objectClass)) {
+                                    if (opts.objectNotEmpty && Object.keys(value).length === 0) {
+                                        return false;
+                                    }
+                                    return true;
+                                }
+                                break;
+                            case 'array':
+                                if (Array.isArray(value) &&
+                                    (!opts.arrayElementClass ||
+                                        value.every((item) => item instanceof opts.arrayElementClass))) {
+                                    if (opts.arrayNotEmpty && value.length === 0) {
+                                        return false;
+                                    }
+                                    return true;
+                                }
+                                break;
+                        }
+                    }
+                    return false;
+                },
+                defaultMessage(args) {
+                    const [allowedTypes, opts] = args.constraints;
+                    const messages = [];
+                    if (opts.require) {
+                        messages.push('is required');
+                    }
+                    if (allowedTypes.includes('string')) {
+                        if (opts.require)
+                            messages.push('must be a non-empty string');
+                        if (opts.stringPattern)
+                            messages.push(`must match pattern ${opts.stringPattern}`);
+                    }
+                    if (allowedTypes.includes('array') && opts.arrayNotEmpty) {
+                        messages.push('must be a non-empty array');
+                    }
+                    if (allowedTypes.includes('object') && opts.objectNotEmpty) {
+                        messages.push('must be a non-empty object');
+                    }
+                    if (messages.length === 0) {
+                        messages.push(`must be one of: ${allowedTypes.join(', ')}`);
+                    }
+                    return `${args.property} ${messages.join(' and ')}`;
+                },
+            },
+        });
+    };
+}

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

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