@strictly/define 0.0.7 → 0.0.9

package/validation/validators/optional_validator_proxy.ts

@@ -0,0 +1,52 @@
+import { type AnnotatedValidator } from 'validation/validator'
+
+export class OptionalValidatorProxy<
+  V,
+  V1 extends V,
+  E,
+  ValuePath extends string,
+  Context,
+> implements AnnotatedValidator<
+  V,
+  E,
+  ValuePath,
+  Context
+> {
+  static createNullable<
+    V,
+    E,
+    ValuePath extends string,
+    Context,
+  >(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>) {
+    return new OptionalValidatorProxy(proxied, (v: V) => v != null)
+  }
+
+  static createNullableOrEmptyString<
+    V extends string | null | undefined,
+    E,
+    ValuePath extends string,
+    Context,
+  >(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>) {
+    return new OptionalValidatorProxy(proxied, (v: V): v is NonNullable<V> => v != null && v !== '')
+  }
+
+  constructor(
+    private readonly proxied: AnnotatedValidator<V1, E, ValuePath, Context>,
+    private readonly isRequired: (v: V) => v is V1,
+  ) {
+  }
+
+  validate(v: V, valuePath: ValuePath, context: Context): E | null {
+    if (this.isRequired(v)) {
+      return this.proxied.validate(v, valuePath, context)
+    }
+    return null
+  }
+
+  annotations(valuePath: ValuePath, context: Context) {
+    return {
+      ...this.proxied.annotations(valuePath, context),
+      required: false,
+    }
+  }
+}

package/validation/validators/regexp_validator.ts

@@ -0,0 +1,61 @@
+import {
+  type AnnotatedValidator,
+} from 'validation/validator'
+
+export const RegexpValidationErrorType = 'regexp'
+
+export type RegexpValidationError<Intent extends string> = {
+  type: typeof RegexpValidationErrorType,
+  intent: Intent,
+}
+
+export class RegexpValidator<Intent extends string>
+  implements AnnotatedValidator<string, RegexpValidationError<Intent>, never, never>
+{
+  /**
+   * Extremely permissive email validator
+   */
+  static readonly email = new RegexpValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, 'email')
+
+  /**
+   * Extremely permissive phone number validator
+   */
+  static readonly phone = new RegexpValidator(/^(\+\d{1,4}[\s]*)?(((\([\d\s-]{1,6}\))|\d)[\s-]*){3,14}(\d|(\(\d+\)))$/,
+    'phone')
+
+  private readonly negate: boolean
+  private readonly required: boolean
+
+  constructor(
+    private readonly regexp: RegExp,
+    private readonly intent: Intent,
+    {
+      negate = false,
+      required = false,
+    }: {
+      negate?: boolean,
+      required?: boolean,
+    } = {},
+  ) {
+    this.negate = negate
+    this.required = required
+  }
+
+  validate(value: string): RegexpValidationError<Intent> | null {
+    const passes = this.regexp.test(value)
+    if (!passes && !this.negate || passes && this.negate) {
+      return {
+        type: RegexpValidationErrorType,
+        intent: this.intent,
+      }
+    }
+    return null
+  }
+
+  annotations() {
+    return {
+      required: this.required,
+      readonly: false,
+    }
+  }
+}

package/validation/validators/specs/minimum_string_length_validator.tests.ts

@@ -0,0 +1,76 @@
+import {
+  MinimumStringLengthValidationErrorType,
+  MinimumStringLengthValidator,
+} from 'validation/validators/minimum_string_length_validator'
+
+describe('MinimumStringLengthValidator', () => {
+  describe('required', () => {
+    it.each([
+      1,
+      2,
+      100,
+    ])('is required when the string length is %s', (minimumLength) => {
+      const validator = new MinimumStringLengthValidator(minimumLength)
+      expect(validator.annotations().required).toBeTruthy()
+    })
+
+    it('is not required when the string length is zero', () => {
+      const validator = new MinimumStringLengthValidator(0)
+      expect(validator.annotations().required).toBeFalsy()
+    })
+  })
+
+  describe('validation', () => {
+    it.each([
+      [
+        1,
+        'a',
+      ],
+      [
+        2,
+        'asdf',
+      ],
+      [
+        0,
+        '',
+      ],
+      [
+        20,
+        '12345678901234567890',
+      ],
+    ])('passes validation with minimum length %s and value "%s"', (minimumLength, value) => {
+      const validator = new MinimumStringLengthValidator(minimumLength)
+      expect(validator.validate(value)).toBeNull()
+    })
+
+    it.each([
+      [
+        1,
+        '',
+        0,
+      ],
+      [
+        2,
+        'a',
+        1,
+      ],
+      [
+        20,
+        '1234567890123456789',
+        19,
+      ],
+      [
+        100,
+        '',
+        0,
+      ],
+    ])('fails validation with minimum length %s and value "%s', (minimumLength, value, receivedLength) => {
+      const validator = new MinimumStringLengthValidator(minimumLength)
+      expect(validator.validate(value)).toEqual({
+        type: MinimumStringLengthValidationErrorType,
+        minimumLength,
+        receivedLength,
+      })
+    })
+  })
+})

package/validation/validators/specs/regexp_validator.tests.ts

@@ -0,0 +1,108 @@
+import {
+  RegexpValidationErrorType,
+  RegexpValidator,
+} from 'validation/validators/regexp_validator'
+
+describe('RegexpValidator', () => {
+  describe('phone', () => {
+    it.each([
+      '0403545000',
+      '+12 (1800) 000 000',
+      '1-2-3-4-5-6',
+      '+1 394 3234 000 (2)',
+      '1234',
+    ])('accepts "%s"', (phoneNumber) => {
+      expect(RegexpValidator.phone.validate(phoneNumber)).toBeNull()
+    })
+
+    it.each([
+      '',
+      'ABC',
+      '1',
+      ' 0412345678',
+      '----1245456',
+      '1      2',
+      '234234+234',
+    ])('rejects "%s"', (phoneNumber) => {
+      expect(RegexpValidator.phone.validate(phoneNumber)).toEqual({
+        type: RegexpValidationErrorType,
+        intent: 'phone',
+      })
+    })
+  })
+
+  describe('email', () => {
+    it.each([
+      'x@y.z',
+      'support@company.com',
+      '...@......',
+      '1234@3454.23',
+    ])('accepts "%s"', (email) => {
+      expect(RegexpValidator.email.validate(email)).toBeNull()
+    })
+
+    it.each([
+      '',
+      '@@@@',
+      'email',
+      '@bee.com',
+      'aaa@bbb',
+      'a a@b b.c c',
+    ])('rejects "%s"', (email) => {
+      expect(RegexpValidator.email.validate(email)).toEqual({
+        type: RegexpValidationErrorType,
+        intent: 'email',
+      })
+    })
+  })
+
+  describe('required', () => {
+    it.each([
+      true,
+      false,
+    ])('exposes required %s', (required) => {
+      const validator = new RegexpValidator(/a/, 'test', {
+        required,
+      })
+      expect(validator.annotations().required).toBe(required)
+    })
+  })
+
+  describe('general', () => {
+    // not here to test if regexp works
+    it.each([
+      [
+        '^a$',
+        'a',
+      ],
+      [
+        '^\\w+$',
+        'asdf',
+      ],
+    ])('passes validation with regexp "%s" and value "%s"', (regexpString, value) => {
+      const regexp = new RegExp(regexpString)
+      const validator = new RegexpValidator(regexp, 'test')
+      expect(validator.validate(value)).toBeNull()
+    })
+
+    it.each([
+      [
+        '^$',
+        'something',
+        'empty',
+      ],
+      [
+        '^\\w+$',
+        '',
+        'non-empty',
+      ],
+    ])('fails validation with regexp "%s" and value "%s', (regexpString, value, intent) => {
+      const regexp = new RegExp(regexpString)
+      const validator = new RegexpValidator(regexp, intent)
+      expect(validator.validate(value)).toEqual({
+        type: RegexpValidationErrorType,
+        intent,
+      })
+    })
+  })
+})