Top 10 Examples of "class-validator in functional component" in JavaScript

public static async createUser(ctx: BaseContext) {

        // get a user repository to perform operations with user
        const userRepository: Repository = getManager().getRepository(User);

        // build up entity user to be saved
        const userToBeSaved: User = new User();
        userToBeSaved.name = ctx.request.body.name;
        userToBeSaved.email = ctx.request.body.email;

        // validate user entity
        const errors: ValidationError[] = await validate(userToBeSaved); // errors is an array of validation errors

        if (errors.length > 0) {
            // return BAD REQUEST status code and errors array
            ctx.status = 400;
            ctx.body = errors;
        } else if (await userRepository.findOne({ email: userToBeSaved.email })) {
            // return BAD REQUEST status code and email already exists error
            ctx.status = 400;
            ctx.body = 'The specified e-mail address already exists';
        } else {
            // save the user contained in the POST body
            const user = await userRepository.save(userToBeSaved);
            // return CREATED status code and updated user
            ctx.status = 201;
            ctx.body = user;
        }

import { IsMobilePhone, MinLength, MaxLength, IsNotEmpty } from 'class-validator';
import { ApiModelProperty } from '@nestjs/swagger';

export class LoginDto {
	@ApiModelProperty()
	// @IsMobilePhone('zh-CN', {
	// 	message: '手机号无效'
	// })
	@IsNotEmpty({
		message: '帐号不能为空'
	})
	readonly account: string;

	@ApiModelProperty()
	@MinLength(8, {
		message: '密码不能少于8位'
	})
	@MaxLength(12, {
		message: '密码不能大于12位'
	})
	@IsNotEmpty({
		message: '密码不能为空'
	})
	readonly password: string;
}

// namespace level hard limits
export class ResourceQuota implements IResourceQuota {
  @IsNotEmpty()
  @ValidateNested()
  @Type(() => Requests)
  requests: Requests;

  @IsNotEmpty()
  @ValidateNested()
  @Type(() => Limits)
  limits: Limits;

  @IsOptional()
  @IsNumber()
  @Min(0)
  @Max(10156)
  cpu ? = 1;

  @IsOptional()
  @IsNumber()
  @Min(0)
  @Max(10720)
  memory ? = 1;
}

import { Environment } from '../environment/environment.model';
import { FeatureFlagSegment } from '../feature-flag-segment/feature-flag-segment.model';
import { FeatureFlagUser } from '../feature-flag-user/feature-flag-user.model';
import { FeatureFlag } from '../feature-flag/feature-flag.model';
import { Segment } from '../segment/segment.model';
import { UserSegment } from '../user-segment/user-segment.model';

import { Matches } from 'class-validator';

@Model()
export class Project extends BaseModel {
  @StringField({ maxLength: 50, minLength: 3, nullable: false })
  name!: string;

  @Matches(/^[a-z0-9]+(-[a-z0-9]+)*$/) // Lowercase sluggified string
  @StringField({ maxLength: 20, minLength: 3, nullable: false, unique: true })
  key!: string;

  @OneToMany(() => Environment, (environment: Environment) => environment.project)
  environments?: Environment[];

  @OneToMany(() => Segment, (segment: Segment) => segment.project)
  segments?: Segment[];

  @OneToMany(() => FeatureFlag, (featureFlag: FeatureFlag) => featureFlag.project)
  featureFlags?: FeatureFlag[];

  @OneToMany(() => FeatureFlagUser, (featureFlagUser: FeatureFlagUser) => featureFlagUser.project)
  featureFlagUsers?: FeatureFlagUser[];

  @OneToMany(

@ApiModelProperty()
  @IsNotEmpty()
  // alphanumeric characters and - are valid
  // you can change this as you like
  @Matches(RegExp('^[a-zA-Z0-9\\-]+$'))
  @MaxLength(20)
  username: string;

  @ApiModelProperty()
  @IsNotEmpty()
  @MinLength(8)
  password: string;

  @ApiModelProperty()
  @IsNotEmpty()
  @Matches(RegExp('^[A-Za-zıöüçğşİÖÜÇĞŞñÑáéíóúÁÉÍÓÚ ]+$'))
  @MaxLength(20)
  firstName: string;

  @ApiModelProperty()
  @IsNotEmpty()
  @Matches(RegExp('^[A-Za-zıöüçğşİÖÜÇĞŞñÑáéíóúÁÉÍÓÚ ]+$'))
  @MaxLength(20)
  lastName: string;

  @ApiModelProperty()
  @IsOptional()
  @IsNotEmpty()
  @Matches(RegExp('^[A-Za-zıöüçğşİÖÜÇĞŞñÑáéíóúÁÉÍÓÚ ]+$'))
  @MaxLength(20)
  middleName?: string;
}

export function starkArraySizeRange(array: any[], minSize?: number, maxSize?: number): boolean {
	// by default, if the requested validator class is not already registered in the container from the 'class-validator' container
	// then it will registered automatically so it will indeed be a singleton
	// IMPORTANT: the StarkValidatorImpl should be used in the same way wherever needed to avoid instantiating it multiple times!
	const validator = getFromContainer(Validator);
	let isValid = true;

	if (typeof minSize !== "undefined") {
		isValid = isValid && validator.arrayMinSize(array, minSize);
	}
	if (typeof maxSize !== "undefined") {
		isValid = isValid && validator.arrayMaxSize(array, maxSize);
	}
	return isValid;
}

import {
  createExpressServer,
  getMetadataArgsStorage
} from 'routing-controllers'
import { routingControllersToSpec } from 'routing-controllers-openapi'

import { UsersController } from './UsersController'

const routingControllersOptions = {
  controllers: [UsersController],
  routePrefix: '/api'
}
const app: Express = createExpressServer(routingControllersOptions)

// Parse class-validator classes into JSON Schema:
const metadatas = (getFromContainer(MetadataStorage) as any).validationMetadatas
const schemas = validationMetadatasToSchemas(metadatas, {
  refPointerPrefix: '#/components/schemas/'
})

// Parse routing-controllers classes into OpenAPI spec:
const storage = getMetadataArgsStorage()
const spec = routingControllersToSpec(storage, routingControllersOptions, {
  components: {
    schemas,
    securitySchemes: {
      basicAuth: {
        scheme: 'basic',
        type: 'http'
      }
    }
  },

@ValidateNested()
    @IsArray()
    @Type(() => MailAddress)
    bccRecipients!: MailAddress[];

    @ValidateNested()
    @IsArray()
    @Type(() => File)
    attachments!: File[];

    @IsNotEmpty()
    @IsBoolean()
    unread!: Model.Mail["unread"];

    @IsIn(Model.MAIL_STATE._.values)
    state!: Model.Mail["state"];

    // TODO consider making Mail.confidential field optional, not used by protonmail?
    @IsNotEmpty()
    @IsBoolean()
    confidential!: Model.Mail["confidential"];

    @IsIn(Model.REPLY_TYPE._.values)
    replyType!: Model.Mail["replyType"];

    @ValidateNested()
    @Type(() => MailFailedDownload)
    failedDownload?: MailFailedDownload;
}

@Field(type => String, {
    nullable: true,
    description: 'Paginate before opaque cursor',
  })
  @ValidateIf(o => o.before !== undefined)
  @Validate(CannotUseWithout, ['last'])
  @Validate(CannotUseWith, ['after', 'first'])
  before?: Relay.ConnectionCursor;

  @Field(type => String, {
    nullable: true,
    description: 'Paginate after opaque cursor',
  })
  @ValidateIf(o => o.after !== undefined)
  @Validate(CannotUseWithout, ['first'])
  @Validate(CannotUseWith, ['before', 'last'])
  after?: Relay.ConnectionCursor;

  @Field(type => Int, { nullable: true, description: 'Paginate first' })
  @ValidateIf(o => o.first !== undefined)
  @Min(1)
  @Validate(CannotUseWith, ['before', 'last'])
  first?: number;

  @Field(type => Int, { nullable: true, description: 'Paginate last' })
  @ValidateIf(o => o.last !== undefined)
  // Required `before`. This is a weird corner case.
  // We'd have to invert the ordering of query to get the last few items then re-invert it when emitting the results.
  // We'll just ignore it for now.
  @Validate(CannotUseWithout, ['before'])
  @Validate(CannotUseWith, ['after', 'first'])
  @Min(1)

static async find(_query: WorldCountryStateQueryInterface): Promise {
        const query: WorldCountryStateQuery = plainToClass(WorldCountryStateQuery, _query);

        // clear undefined/empty values
        for (const key of Object.keys(query)) {
            if (!query[key]) {
                delete query[key];
            }
        }

        try {
            await validateOrReject(query, {
                whitelist: true,
                forbidNonWhitelisted: true,
                validationError: { target: false, value: false },
            });
        } catch (err) {
            return;
        }

        const stateData: WorldCountryStateInterface | undefined = (countryStates as WorldCountryStateInterface[]).find(
            (plainState: WorldCountryStateInterface) => {
                const state: WorldCountryState = plainToClass(WorldCountryState, plainState);

                return WorldCountryStateUtil.match(state, query);
            },
        );