class-validator#IsDefined TypeScript Examples

private static getConnectionOptions(options: AMQPConnectionOptions): AMQPConnectionOptions {
    const { connectionOptions, connectionUri, throwExceptionOnConnectionError } = options;

    return {
      connectionUri,
      ...(isDefined(connectionOptions) ? { connectionOptions } : {}),
      ...(isDefined(throwExceptionOnConnectionError) ? { throwExceptionOnConnectionError } : {}),
    };
  }

@ApiPropertyOptional({
    description:
      'Block sequence. Will only return blocks on the main chain if provided',
  })
  @ValidateIf((o: BlockQueryDto) => o.hash === undefined)
  @IsDefined({
    message: '"hash" or "sequence" required to query for single block',
  })
  @Max(Number.MAX_SAFE_INTEGER)
  @Min(1)
  @IsInt()
  @Type(() => Number)
  readonly sequence?: number;

@IsDefined()
    value: any;

@IsDefined()
  user: admin.auth.UserRecord;

@IsDefined()
    sample_payload?: any;

@IsDefined()
    value?: any;

@IsDefined()
    original_value: any;

@IsDefined()
    data_type: 'json' | 'csv' = 'json';

@IsDefined()
    auth_method: 'none' | 'basic' | 'token' = 'none';

@IsDefined()
    data: any;

@IsOptional()
    @IsDefined()
    data?: any;

@ApiPropertyOptional({ description: 'Block hash' })
  @ValidateIf((o: BlockQueryDto) => o.sequence === undefined)
  @IsDefined({
    message: '"hash" or "sequence" required to query for single block',
  })
  @IsString()
  readonly hash?: string;

@ValidateIf((o: CreateUserDto) => o.telegram === undefined)
  @IsDefined({
    message: '"discord" or "telegram" required when registering',
  })
  readonly discord?: string;

@ValidateIf((o: CreateUserDto) => o.discord === undefined)
  @IsDefined({
    message: '"discord" or "telegram" required when registering',
  })
  readonly telegram?: string;

@IsDefined()
  @ManyToOne(() => User, user => user.orders)
  user: User;

@IsDefined()
  @ManyToOne(() => Product, product => product.placements)
  product: Product;

@IsDefined()
  @ManyToOne(() => Order, order => order.placements)
  order: Order;

@IsDefined()
  @Column({type: 'text', nullable: false})
  title: string;

@IsPositive()
  @IsDefined()
  @Column({type: 'float', nullable: false})
  price: number;

@IsDefined()
  @IsEmail()
  @Column({unique: true})
  email: string;

@IsDefined()
  @Column()
  hashedPassword: string;

@Expose()
  @IsDefined()
  public file: Buffer|NodeJS.ReadableStream;

@IsOptional()
  @IsDefined() // TODO: use ValidateNested instead, for some reason it's crunked
  courses!: KhouryCourse[] | KhouryProfCourse[];

static async process(schema: any, index: number) {
    const { type: Schema, isRequired, value: SchemaValue } = schema

    const allErrors: any = []

    const isUndefined = !isDefined(SchemaValue)

    if (isRequired && isUndefined) {
      allErrors.push({ value: SchemaValue, message: `Required parameter at index [${index}] is missing.` })
    }

    if (isUndefined) {
      return allErrors
    }

    if (isPrimitive(Schema)) {
      const { isValid, message } = ParametersValidator.validatePrimitive(Schema, SchemaValue)

      if (!isValid) {
        allErrors.push({ value: SchemaValue, message })
      }
    } else if (Object.keys(jsonSchemas).indexOf(Schema) !== -1) {
      try {
        const ajv = new Ajv()
        const isValid = ajv.validate(jsonSchemas[Schema as keyof typeof jsonSchemas].valueOf(), SchemaValue)

        if (!isValid) {
          allErrors.push({ value: SchemaValue, message: ajv.errorsText() })
        }
      } catch (error) {
        allErrors.push({ value: SchemaValue, message: error })
      }
    } else {
      const schema = new Schema()

      for (const [key, value] of Object.entries(SchemaValue)) {
        schema[key] = value
      }

      const errors = await validate(schema)
      const schemaErrors = []

      for (const error of errors) {
        const { property, value, constraints } = error

        schemaErrors.push({
          argument: property,
          value: value,
          message: constraints,
        })
      }

      if (schemaErrors.length > 0) {
        allErrors.push(schemaErrors)
      }
    }

    return allErrors
  }

@IsDefined()
  @IsArray()
  context: unknown[]

@IsDefined()
    @IsString()
    @Length(1, 128)
    name: string;

@IsDefined()
    @IsUrl()
    url: string;

@IsDefined()
    @IsUrl({ require_tld: false })
    url: string;

@IsDefined()
    @IsString()
    @Length(5, 2000)
    token: string;