atLeastOne validation

[angelhdzmultimedia]

Any plans to add an atLeastOne validation which accepts an union type of 'digit' | 'uppercase' | 'symbol' as parameter,
and depending on that parameter, it makes the corresponding validation with regex?

It would be nice to:

class RegisterDto {
  password: password([nonempty(), max(12), min(6), atLeast('digit'), atLeast('uppercase'), atLeast('symbol')])
}

I implemented it like this with zod:

z.password = function (): z.ZodPassword {
  let validation: z.ZodString = z.string()

  const obj: z.ZodPassword = {
    resolve() {
      return validation
    },

    nonempty() {
      validation = validation.nonempty()
      return obj
    },

    min(num: number) {
      validation = validation.min(num)
      return obj
    },

    atLeastOne(kind: 'digit' | 'symbol' | 'uppercase') {
      let data: { message: string; regex: RegExp } = {
        regex: null,
        message: `At least one ${kind} expected`,
      }

      if (kind === 'uppercase') {
        data.regex = /^(?=.*[A-Z]).+$/g
      }

      if (kind === 'digit') {
        data.regex = /^(?=.*[0-9]).+$/g
      }

      if (kind === 'symbol') {
        data.regex = /^(?=.*[^a-zA-Z0-9]).+$/g
      }

      validation = validation.regex(data.regex, data.message)

      return {
        ...obj,
      }
    },
  }

  return obj
}

[fabian-hiller]

I am not sure. Isn't it easier to use regex? I am happy about further feedback.