@hosterai/types 0.0.16 → 0.0.18

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.
@@ -70,6 +73,7 @@ DTOs define the shape of data that is exchanged between different parts of the s
 
 - `product/product-info.dto.ts`: Contains detailed information about a product.
 - `product/product-item-data.dto.ts`: Represents the data of a specific product item.
+- `product/requests/product-validate-attributes-request.dto.ts`: Defines the structure for validating product attributes.
 - `product/requests/*`: DTOs for product-related requests (create, delete, upgrade, etc.).
 - `product/responses/*`: DTOs for product-related responses.
 
@@ -79,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.
@@ -109,6 +113,7 @@ This package includes validation functions that leverage `class-validator` to en
 - `validateNotificationRequestDto`: Validates the main notification request.
 - `validateEmailReceiverDto`, `validateSmsReceiverDto`, `validatePushReceiverDto`: Validators for notification receivers.
 - `validateEmailSenderDto`, `validateSmsSenderDto`, `validatePushSenderDto`: Validators for notification senders.
+- `validateProductValidateAttributesRequestDto`: Validates requests for product attribute validation.
 
 ## Usage Example
 
@@ -122,7 +127,7 @@ import {
   ClientDataDto,
   ProductItemDataDto,
   DurationEnum,
-  validateProductCreateRequestDto, // Assuming a validator exists
+  validateProductCreateRequestDto,
 } from '@hosterai/types';
 
 // 1. Create a request object
@@ -142,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/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 {};

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;