class-validator#IsArray TypeScript Examples

@IsArray()
  @IsIn(['rsa', 'bbs', 'ecdsa'], { each: true })
  keyTypes: KeyAlgorithmType[]

/**
   * A list of Discord user IDs to ping when posting the message. The IDs must be strings wrapped in quotes.
   * How to get a user ID: https://support.discord.com/hc/en-us/articles/206346498-Where-can-I-find-my-User-Server-Message-ID-
   * @example ["914360712086843432", "914360712086843433"]
   * @env DISCORD_MENTIONED_USERS (comma separated)
   */
  @IsOptional()
  @IsArray()
  @IsString({ each: true })
  mentionedUsers: string[];

// advanced configuration, while we allow the user to set these it's generally
    // assumed that only those with technical knowledge or experience would be modifying
    // these

    // when parsing data from this data source, these are nodes which should be removed
    // and ignored when creating the shape_hash
    @IsOptional()
    @IsArray()
    stop_nodes?: string[];

@IsArray()
  @ArrayMaxSize(3000)
  @ValidateNested({ each: true })
  @Type(() => BaseFieldDto, {
    keepDiscriminatorProperty: true,
    discriminator: {
      property: 'type',
      subTypes: [
        { name: 'boolean', value: BooleanFieldDto },
        { name: 'float', value: FloatFieldDto },
        { name: 'integer', value: IntegerFieldDto },
        { name: 'string', value: StringFieldDto },
      ],
    },
  })
  readonly fields!: FieldDto[];

/**
   * Select one or multiple fields with each Alias field
   *
   * @param args Array of Array of field with alias, e.g: ['t1.id', 'id'], ...
   */
  public selectRaw(...args: Array<string | string[]>) {
    const expressionArgs = args.filter(
      arg => isString(arg) || (isArray(arg) && arg.length <= 2),
    );
    if (!expressionArgs.length) {
      throw new Error(`String expression is required for the selectRaw method`);
    }

    for (const arg of args) {
      if (args.indexOf(arg) === 0) {
        if (arg[1]) {
          this.qb.select(arg[0], arg[1]);
        } else {
          this.qb.select(arg[0]);
        }
      } else {
        if (arg[1]) {
          this.qb.addSelect(arg[0], arg[1]);
        } else {
          this.qb.addSelect(arg[0]);
        }
      }
    }

    return this;
  }

export function IsPluginConfig(validationOptions?: ValidationOptions) {
    return (object: any, propertyName: string) => {
        registerDecorator({
            name: 'isPluginConfig',
            target: object.constructor,
            propertyName: propertyName,
            options: validationOptions,
            validator: {
                validate(value: any, _args: ValidationArguments) {
                    if (isObjectLike(value)) {
                        return Object.entries(value).every(([_, v]) => {
                            if (isArray(v)) {
                                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                                // @ts-ignore
                                return Array.from(v).every(isString);
                            }

                            return isString(v) || isBoolean(v);
                        });
                    }

                    return false;
                },
                defaultMessage(args?: ValidationArguments) {
                    const expectedMsg = 'Expected "{ [key: string]: string | string[] | boolean }"';

                    if (!args) {
                        return expectedMsg;
                    }

                    const strValue = JSON.stringify(args.value);
                    return `${expectedMsg} on "${args.property}" but found "${strValue}" instead`;
                },
            },
        });
    };
}

@ApiProperty({
    description: 'list of origins that are allowed to invoke the client',
    example: ['localhost:5000', 'http://localhost:5000', 'https://localhost:5000/login'],
  })
  @IsArray()
  @IsNotEmpty()
  authorizedOrigin: Array<string>;

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

@IsArray()
  rootDomains: string[];

/**
   * A list of accounts to work with
   */
  @IsArray()
  @ValidateNested({ each: true })
  @ArrayNotEmpty()
  @Type(() => AccountConfig)
  accounts: AccountConfig[];

@Expose()
  @IsArray()
  @Length(1, columnSize.length32, { each: true })
  @ApiProperty({ isArray: true, type: String })
  @IsOptional()
  technologies?: string[];

/**
   * The Tag associated with the course
   * @example WEB_DEV
   */
  @IsNotEmpty()
  @IsArray()
  @IsEnum(TagType, { each: true })
  tags: TagType[];

export function IsFiles(validationOptions?: ValidationOptions): PropertyDecorator {
  return applyDecorators(
    IsArray(validationOptions),
    IsFile(Object.assign(validationOptions || {}, { each: true })),
  );
}

@IsArray()
    @ValidateNested()
    @Type(() => CollectedInput)
    collectedInputs?: CollectedInput[];

/** 照片列表 */
  @IsArray()
  @IsOptional()
  images: string[]

@IsArray()
  @ArrayMinSize(1)
  @ValidateNested({ each: true })
  @Type(() => TransactionDto)
  readonly transactions!: TransactionDto[];

@IsArray()
    symptoms: object;

@ApiProperty({ type: TempIDDto, isArray: true })
  @IsArray()
  @ValidateNested({ each: true })
  @Type(() => TempIDDto)
  tempIDs: TempIDDto[]

@ApiProperty()
  @IsArray()
  @ArrayNotEmpty()
  @IsEnum(ROLE, { each: true })
  roles: ROLE[];

@IsOptional()
    @IsString({each: true})
    @IsArray()
    public tags: string[] = [];

@IsArray()
  progress?: string[]

@IsArray()
  @IsNotEmpty()
  @ApiProperty({
    type: () => CreateMessageTemplateDto,
    isArray: true,
  })
  readonly templates: CreateMessageTemplateDto[];

@ApiProperty({ description: 'Additional user metadata or custom fields', type: CreateUserMetadataDto, isArray: true })
  @IsArray()
  @ValidateNested({ each: true })
  @Type(() => CreateUserMetadataDto)
  @IsOptional()
  metadata: CreateUserMetadataDto[];

// List of CRN's in the section group
  @IsArray()
  crns!: number[];