Validating a nested object with a property from the parent

[markjaniczak]

There doesn't seem to be a straight forward way of validating a nested object based on a property from its parent or further up the tree. I'm looking for guidance on the best way to achieve this.

For example, I have the following object from a form:

{
    "name": "My Video Stream",
    "hasRedundancy": true,
    "source": {
        "type": "hls",
        "primary": "https://some-domain.com/index.m3u8",
        "secondary": "https://some-domain.com/backup.m3u8"
    }
}

The secondary property in the source object is only required if has_redundancy is true. So I write my classes like so:

const SOURCE_TYPES = ['HLS', 'MP4'] as const

type SourceType = (typeof SOURCE_TYPES)[number]

class Source {
    type: SourceType
    primary: any
    secondary: any
}

class HLSSource extends Source {
    type: 'HLS'

    @IsUrl()
    primary: string

    @ValidateIf((obj) => obj.hasRedundancy)
    @IsUrl()
    secondary: string
}

class MP4Source extends Source {
  type: 'MP4'
  
  @IsUrl()
  primary: string

  @ValidateIf((obj) => obj.hasRedundancy)
  @IsUrl()
  secondary: any;
}

class CreateStreamRequest {
    @IsString()
    name: string

    @IsBoolean()
    hasRedundancy: boolean

    @ValidateNested({
      each: true
    })
    @Type(() => Source, {
      discriminator: {
        property: 'type',
        subTypes: [
          { name: 'MP4', value: MP4Source },
          { name: 'HLS', value: HLSSource}
        ]
      },
      keepDiscriminatorProperty: true
    })
    source: HLSSource | MP4Source
}

But hasRedundancy is not included in the plain object that the my Source is created from, only in the top level plain object that CreateStreamRequest is made from. I thought about using the groups feature to tackle this but that seems like double handling because I already have the data to pass to the condition in the original object. I see that the first parameter in the Type decorator provides some parameters but they are not documented anywhere.

[Iuriiiiiii]

Hi, i have this problem too... the parent information is a relevant data that can't be ignored within a complex custom contraint. What should we do?

[elovin]

I would recursively inject an object reference to the parent into all objects into a property with the @Allow & @IsOptional decorators.

E.g. using @Transform() on a custom property on the root Dto or some custom recursive function.

In case you are using NestJS you could do this with an interceptor and modify the request body directly, this interceptor could then also recursively remove the reference in case it ends up in the response for some reason.

[rinaldihtb]

Hi I'm also having this issue, just want to check if there's anyone that already have the solution ?

[usualdesigner]

The problem is @type()'s discriminator resolution happens before your nested class ever sees the parent object, so hasRedundancy genuinely isn't available there. I'd write a custom class-level @ValidatorConstraint on CreateStreamRequest itself that checks object.hasRedundancy && !object.source.secondary and fails there - validating the cross-field rule at the level where both properties actually exist, rather than reaching up from the nested class.

[halilertekin]

The root-level constraint suggested above is the right direction. One implementation detail: class-validator validates properties, so attach the cross-field constraint to CreateStreamRequest.source, where ValidationArguments.object is the root DTO. Attaching it to HLSSource.secondary makes that object the nested source instead.

There is no need to inject parent references into the input or introduce a circular object graph. Use two separate rules:

• On the root source property: require a non-empty secondary value when hasRedundancy === true.
• On the nested secondary property: validate its URL whenever a non-null value is supplied, even when redundancy is disabled.

Here is a complete DTO-only example retaining the discriminator:

import 'reflect-metadata';
import { Type } from 'class-transformer';
import {
  IsBoolean, IsDefined, IsIn, IsObject, IsOptional, IsString, IsUrl, Validate,
  ValidateNested, ValidatorConstraint,
  type ValidationArguments, type ValidatorConstraintInterface,
} from 'class-validator';

export class SourceDto {
  @IsIn(['HLS', 'MP4'])
  type!: 'HLS' | 'MP4';
  @IsUrl()
  primary!: string;
  @IsOptional()
  @IsUrl()
  secondary?: string;
}

export class HLSSource extends SourceDto { declare type: 'HLS'; }
export class MP4Source extends SourceDto { declare type: 'MP4'; }

@ValidatorConstraint({ name: 'secondaryRequired', async: false })
export class SecondaryRequired implements ValidatorConstraintInterface {
  validate(source: unknown, args: ValidationArguments): boolean {
    const parent = args.object as CreateStreamRequest;
    if (parent.hasRedundancy !== true) return true;
    if (typeof source !== 'object' || source === null) return false;
    const secondary = (source as { secondary?: unknown }).secondary;
    return typeof secondary === 'string' && secondary.trim().length > 0;
  }
  defaultMessage(): string {
    return 'source.secondary is required when hasRedundancy is true';
  }
}

export class CreateStreamRequest {
  @IsString()
  name!: string;
  @IsBoolean()
  hasRedundancy!: boolean;
  @IsDefined()
  @IsObject()
  @ValidateNested()
  @Type(() => SourceDto, {
    discriminator: { property: 'type', subTypes: [
      { name: 'HLS', value: HLSSource },
      { name: 'MP4', value: MP4Source },
    ] },
    keepDiscriminatorProperty: true,
  })
  @Validate(SecondaryRequired)
  source!: SourceDto;
}

Apply it through your normal Nest pipe:

import { ValidationPipe } from '@nestjs/common';

app.useGlobalPipes(new ValidationPipe({
  transform: true,
  whitelist: true,
  forbidNonWhitelisted: true,
}));

I checked this with the real Nest 11.1.28 ValidationPipe, class-validator 0.14.4 and class-transformer 0.5.1, including transformation into both HLSSource and MP4Source:

Input	Result
Redundancy true, valid secondary URL	Accepted
Redundancy true, missing/null/empty secondary	Rejected
Redundancy false, omitted secondary	Accepted
Either boolean value, supplied invalid secondary URL	Rejected
String "true" instead of boolean	Rejected
Missing source, invalid discriminator, unknown nested field	Rejected

The relevant suite had five passing tests covering those cases. I did not enable implicit boolean conversion, so "false" is not accidentally treated as true. @IsOptional() skips null/undefined on secondary, but the root constraint still rejects them when redundancy is required.

Also, your sample payload has "type": "hls" while the discriminator names are "HLS"/"MP4"; keep these consistent. For a single nested object, @ValidateNested() is sufficient (each: true is unnecessary).

References: custom constraints / ValidationArguments, conditional validation, and class-transformer discriminators.