class-validator#isString TypeScript Examples

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`;
                },
            },
        });
    };
}

/**
   * 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;
  }

/**
   * TZ name from this list: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List
   * @example America/Chicago
   * @default UTC
   * @env TZ
   */
  @IsOptional()
  @IsString()
  timezone = process.env.TZ || 'UTC';

@IsString()
  @IsIn([
    'title',
    'createdAt',
    'severity',
    'cvss',
    'state',
    'createdAt',
    'domain'
  ])
  @IsOptional()
  sort: string = 'createdAt';

@IsString()
  todoId!: string;

@ApiProperty({ example: 'La Niña heatwave 20/21' })
  @IsNotEmpty()
  @IsString()
  name: string;

@IsString()
  firstName: string;

static validatePrimitive(schema: string, value: any) {
    let message: string
    let isValid: boolean = true

    switch (schema) {
      case did:
        isValid = matches(value, DID)
        message = `Parameter "${value}" is not a valid. Valid format: (${DID}).`
        break

      case didMethod:
        isValid = matches(value, DID_METHOD)
        message = `Parameter "${value}" is not a valid. Valid format: (${DID_METHOD}).`
        break

      case jwt:
        isValid = matches(value, JWT)
        message = `Parameter "${value}" is not a valid JWT. Valid format: (${JWT}).`
        break

      case array:
        isValid = isArray(value)
        message = `Parameter "${value}" should be an array.`
        break

      case number:
        isValid = isNumber(value)
        message = `Parameter "${value}" should be a number.`
        break

      case object:
        isValid = isObject(value)
        message = `Parameter "${value}" should be an object.`
        break

      case string:
        isValid = isString(value)
        message = `Parameter "${value}" should be a string.`
        break

      case boolean:
        isValid = isBoolean(value)
        message = `Parameter "${value}" should be a boolean.`
        break

      case isoString:
        isValid = isISO8601(value)
        message = `Parameter "${value}" is not a valid ISO 8601 date string.`
        break

      case confirmationCode:
        isValid = matches(value, COGNITO_CONFIRMATION_CODE)
        message = `Parameter "${value}" is not a valid confirmation code. Valid format: (${COGNITO_CONFIRMATION_CODE}).`
        break

      case password:
        isValid = matches(value, PASSWORD)
        message = `Parameter "${value}" is not a password. Valid format: (${PASSWORD}).`
        break
    }

    return { isValid, message }
  }

/**
   * Creator of the announcement
   * @example 'John Doe'
   */
  @IsNotEmpty()
  @IsString()
  added_by: string;

/**
   * Epic Games login password
   * @example abc1234
   * @env PASSWORD
   */
  @IsString()
  @MinLength(7)
  password: string;

@IsString()
  @IsOptional()
  @IsIn(['title'])
  groupBy?: 'title';