@dhis2/ui-forms 10.16.2 → 10.16.3-alpha.1

package/src/validators/dhis2Password.js

@@ -0,0 +1,81 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString } from './helpers/index.js'
+
+const LOWER_CASE_PATTERN = /^(?=.*[a-z]).+$/
+const UPPER_CASE_PATTERN = /^(?=.*[A-Z]).+$/
+const DIGIT_PATTERN = /^(?=.*[0-9]).+$/
+// Using this regex to match all non-alphanumeric characters to match server-side implementation
+// https://github.com/dhis2/dhis2-core/blob/master/dhis-2/dhis-services/dhis-service-core/src/main/java/org/hisp/dhis/user/SpecialCharacterValidationRule.java#L39
+const SPECIAL_CHARACTER_PATTERN = /[^a-zA-Z0-9]/
+
+const notString = i18n.t('Password should be a string')
+const tooShort = i18n.t('Password should be at least 8 characters long')
+const tooLong = i18n.t('Password should be no longer than 34 characters')
+const noLowerCase = i18n.t(
+    'Password should contain at least one lowercase letter'
+)
+const noUpperCase = i18n.t(
+    'Password should contain at least one UPPERCASE letter'
+)
+const noNumber = i18n.t('Password should contain at least one number')
+const noSpecialCharacter = i18n.t(
+    'Password should have at least one special character'
+)
+
+/**
+ * Tests if a given password is compliant with the password restrictions.
+ * This function checks all restrictions below, but returns when the first violation was found:
+ * - At least 8 characters
+ * - No more than 34 characters
+ * - Contains at least 1 lowercase character
+ * - Contains at least 1 UPPERCASE character
+ * - Contains at least 1 number
+ * - Contains at least 1 special character
+ */
+const dhis2Password = (value) => {
+    if (isEmpty(value)) {
+        return undefined
+    }
+
+    if (!isString(value)) {
+        return notString
+    }
+
+    if (value.length < 8) {
+        return tooShort
+    }
+
+    if (value.length > 35) {
+        return tooLong
+    }
+
+    if (!LOWER_CASE_PATTERN.test(value)) {
+        return noLowerCase
+    }
+
+    if (!UPPER_CASE_PATTERN.test(value)) {
+        return noUpperCase
+    }
+
+    if (!DIGIT_PATTERN.test(value)) {
+        return noNumber
+    }
+
+    if (!SPECIAL_CHARACTER_PATTERN.test(value)) {
+        return noSpecialCharacter
+    }
+
+    return undefined
+}
+
+const errorMessages = {
+    notString,
+    tooShort,
+    tooLong,
+    noLowerCase,
+    noUpperCase,
+    noNumber,
+    noSpecialCharacter,
+}
+
+export { dhis2Password, errorMessages }

package/src/validators/dhis2Username.js

@@ -0,0 +1,16 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString } from './helpers/index.js'
+
+const USERNAME_PATTERN =
+    /^(?=.{4,255}$)(?![_\-.@])(?!.*[_\-.@]{2})[a-zA-Z0-9._\-@]+(?<![_\-.@])$/
+
+const invalidUsernameMessage = i18n.t(
+    'Please provide a username between 4 and 255 characters long and possibly separated by . _ - or @'
+)
+
+const dhis2Username = (value) =>
+    isEmpty(value) || (isString(value) && USERNAME_PATTERN.test(value))
+        ? undefined
+        : invalidUsernameMessage
+
+export { dhis2Username, invalidUsernameMessage }

package/src/validators/email.js

@@ -0,0 +1,38 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString } from './helpers/index.js'
+
+/*
+ * Email validation is complicated business. There is no perfect regex,
+ * instead we have to make a trade-off between complexity, correctness,
+ * and the risk of producing false negatives. This article
+ * https://www.regular-expressions.info/email.html offers a good overview.
+ * It recommends to use a very simple regex when having to validate many
+ * records, but for validating an individual email address a more complex
+ * regex may be used.
+ *
+ * The pattern below is taken from the "The Official Standard: RFC 5322"
+ * section of the article and is described as:
+ * "[..] a more practical implementation of RFC 5322 [..] that will still
+ * match 99.99% of all email addresses in actual use today"
+ *
+ * const EMAIL_ADDRESS_PATTERN = /[a-z0-9!#$%&'*+/=?^_‘{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_‘{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/i
+ *
+ * However, this regex produces a few false negatives and quite a lot
+ * of false positives.
+ *
+ * Another regex, found in this stackoverflow answer below resulted in a better
+ * overall picture in terms of false negatives and positives, so I settled on that one:
+ * https://stackoverflow.com/questions/46155/how-to-validate-an-email-address-in-javascript/46181#46181
+ */
+
+const EMAIL_ADDRESS_PATTERN =
+    /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/i
+
+const invalidEmailMessage = i18n.t('Please provide a valid email address')
+
+const email = (value) =>
+    isEmpty(value) || (isString(value) && EMAIL_ADDRESS_PATTERN.test(value))
+        ? undefined
+        : invalidEmailMessage
+
+export { email, invalidEmailMessage }

package/src/validators/hasValue.js

@@ -0,0 +1,8 @@
+import i18n from '../locales/index.js'
+import { isEmpty } from './helpers/index.js'
+
+const hasValueMessage = i18n.t('Please provide a value')
+
+const hasValue = (value) => (isEmpty(value) ? hasValueMessage : undefined)
+
+export { hasValue, hasValueMessage }

package/src/validators/helpers/index.js

@@ -0,0 +1,23 @@
+export const isEmpty = (value) =>
+    typeof value === 'undefined' || value === null || value === ''
+
+export const isString = (value) => typeof value === 'string'
+
+export const isNumber = (value) => typeof value === 'number'
+
+export const isNumeric = (value) =>
+    (isString(value) || isNumber(value)) && !isNaN(value)
+
+export const isInRange = (lowerBound, upperBound, value) =>
+    value >= lowerBound && value <= upperBound
+
+export const toNumber = (value) => Number(value)
+
+export const requiredArgumentErrorMessage =
+    'Incorrect arguments provided when creating validator'
+
+export const requireArgument = (value, type) => {
+    if (isEmpty(value) || typeof value !== type) {
+        throw new Error(requiredArgumentErrorMessage)
+    }
+}

package/src/validators/index.js

@@ -0,0 +1,20 @@
+export { alphaNumeric } from './alphaNumeric.js'
+export { boolean } from './boolean.js'
+export { composeValidators } from './composeValidators.js'
+export { createCharacterLengthRange } from './createCharacterLengthRange.js'
+export { createEqualTo } from './createEqualTo.js'
+export { createMaxCharacterLength } from './createMaxCharacterLength.js'
+export { createMaxNumber } from './createMaxNumber.js'
+export { createMinCharacterLength } from './createMinCharacterLength.js'
+export { createMinNumber } from './createMinNumber.js'
+export { createNumberRange } from './createNumberRange.js'
+export { createPattern } from './createPattern.js'
+export { dhis2Password } from './dhis2Password.js'
+export { dhis2Username } from './dhis2Username.js'
+export { email } from './email.js'
+export { hasValue } from './hasValue.js'
+export { integer } from './integer.js'
+export { internationalPhoneNumber } from './internationalPhoneNumber.js'
+export { number } from './number.js'
+export { string } from './string.js'
+export { url } from './url.js'

package/src/validators/integer.js

@@ -0,0 +1,20 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isNumeric, toNumber } from './helpers/index.js'
+
+const invalidIntegerMessage = i18n.t(
+    'Please provide a round number without decimals'
+)
+
+// Regex accepts only digits (no decimals even if it is trailing like 4.0)
+// it also rejects a leading 0 (i.e 04) as this is rejected by backend
+const INTEGER_PATTERN = /^(-?[1-9]\d*|0)$/
+
+const integer = (value) =>
+    isEmpty(value) ||
+    (INTEGER_PATTERN.test(value) &&
+        isNumeric(value) &&
+        Number.isSafeInteger(toNumber(value)))
+        ? undefined
+        : invalidIntegerMessage
+
+export { integer, invalidIntegerMessage }

package/src/validators/internationalPhoneNumber.js

@@ -0,0 +1,56 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString, isNumeric } from './helpers/index.js'
+
+/*
+ * There were some problems with the server side implementation
+ * of how international phone numbers are validated, and the
+ * server side implementation will likely be removed, see:
+ * https://jira.dhis2.org/browse/DHIS2-8040
+ *
+ * So, rather than aligning with the server-side implementation
+ * this validator implements the E.164 numbering plan, see:
+ * https://www.cm.com/blog/how-to-format-international-telephone-numbers/
+ *
+ * SPECS
+ * Here's how the E.164 numbering plan works:
+ * - A telephone number can have a maximum of 15 digits
+ * - The first part of the telephone number is the country code (one to three digits)
+ * - The second part is the national destination code (NDC)
+ * - The last part is the subscriber number (SN)
+ * - The NDC and SN together are collectively called the national (significant) number
+ *
+ * IMPLEMENTATION ADVICE
+ * Two important things to note: First of all, in the international E.164 notation a
+ * leading ‘0’ is removed. The UK mobile phone number ‘07911 123456’ in international
+ * format is ‘+44 7911 123456’, so without the first zero. Secondly in the E.164 notation
+ * all spaces, dashes [‘-‘] and parentheses [ ‘(‘ and ‘)’] are removed, besides the
+ * leading ‘+’ all characters should be numeric.
+ */
+
+const invalidInternationalPhoneNumberMessage = i18n.t(
+    'Please provide a valid international phone number.'
+)
+
+const internationalPhoneNumber = (value) => {
+    // allow empty values
+    if (isEmpty(value)) {
+        return undefined
+    }
+
+    // value must be a string
+    if (!isString(value)) {
+        return invalidInternationalPhoneNumberMessage
+    }
+
+    const cleanedValue = value
+        // strip all hyphens, dots, spaces
+        .replace(/[-. )(]/g, '')
+        // trim leading zeroes and plus signs
+        .replace(/^[0+]+/, '')
+
+    return isNumeric(cleanedValue) && cleanedValue.length <= 15
+        ? undefined
+        : invalidInternationalPhoneNumberMessage
+}
+
+export { internationalPhoneNumber, invalidInternationalPhoneNumberMessage }

package/src/validators/number.js

@@ -0,0 +1,9 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isNumeric } from './helpers/index.js'
+
+const invalidNumberMessage = i18n.t('Please provide a number')
+
+const number = (value) =>
+    isEmpty(value) || isNumeric(value) ? undefined : invalidNumberMessage
+
+export { number, invalidNumberMessage }

package/src/validators/string.js

@@ -0,0 +1,9 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString } from './helpers/index.js'
+
+const invalidStringMessage = i18n.t('Please provide a string')
+
+const string = (value) =>
+    isEmpty(value) || isString(value) ? undefined : invalidStringMessage
+
+export { string, invalidStringMessage }

package/src/validators/test-helpers/index.js

@@ -0,0 +1,21 @@
+const testValidatorValues = (validator, returnValue, values) => {
+    const returnValueStr =
+        returnValue === undefined ? 'undefined' : 'an error string'
+
+    for (const value of values) {
+        const type = typeof value
+        const valueStr = type === 'object' ? JSON.stringify(value) : value
+
+        it(`should return ${returnValueStr} for value \`${valueStr}\` of type ${type}`, () => {
+            expect(validator(value)).toBe(returnValue)
+        })
+    }
+}
+
+const allowsEmptyValues = (validator) => {
+    describe('allows empty values', () => {
+        testValidatorValues(validator, undefined, ['', null, undefined])
+    })
+}
+
+export { testValidatorValues, allowsEmptyValues }

package/src/validators/url.js

@@ -0,0 +1,15 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString } from './helpers/index.js'
+
+// Source: https://gist.github.com/dperini/729294
+const URL_PATTERN =
+    /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:[/?#]\S*)?$/i
+
+const invalidUrlMessage = i18n.t('Please provide a valid url')
+
+const url = (value) =>
+    isEmpty(value) || (isString(value) && URL_PATTERN.test(value))
+        ? undefined
+        : invalidUrlMessage
+
+export { url, invalidUrlMessage }