First draft ready for testing in example app

Author: larsvankleef

.gitignore

@@ -0,0 +1 @@
+/node_modules

REAMD.md

@@ -0,0 +1,21 @@
+```js
+
+const rules = {
+  fields: {
+    email: {
+      validator: () => {},
+    },
+    password: {
+      validator: () => {},
+    }
+  }
+}
+
+const callback = (messages) => {
+
+}
+
+validate({
+  rules,
+}, callback)
+```

jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testEnvironment: "jest-environment-node"
+}

package.json

@@ -0,0 +1,16 @@
+{
+  "name": "validate",
+  "version": "0.0.1",
+  "main": "index.js",
+  "repository": "[email protected]:stackkit/validate.git",
+  "author": "larsvankleef <[email protected]>",
+  "license": "MIT",
+  "scripts": {
+    "test": "jest --coverage",
+    "test:watch": "jest --watch",
+    "test:open": "open coverage/lcov-report/index.html"
+  },
+  "devDependencies": {
+    "jest": "^26.2.2"
+  }
+}

src/__tests__/validate.test.js

@@ -0,0 +1,69 @@
+const { validate } = require('../validate')
+
+it('initializes', () => {
+  const callback = jest.fn()
+
+  const fields = {}
+  const rules = {}
+
+  validate(fields, {
+    rules,
+  }, callback)
+})
+
+it('calls the correct validation checks and calls them with the current value', () => {
+  const email = '[email protected]'
+  const password = 'password'
+
+  const fields = {
+    email,
+    password
+  }
+
+  const emailValidator = jest.fn(() => true)
+  const passwordValidator = jest.fn(() => true)
+
+  const rules = {
+    fields: {
+      email: {
+        validator: emailValidator
+      },
+      password: {
+        validator: passwordValidator
+      }
+    }
+  }
+
+  const { valid } = validate(fields, {
+    rules,
+  })
+
+  expect(valid).toEqual(true)
+  expect(emailValidator).toBeCalledTimes(1)
+  expect(emailValidator).toBeCalledWith(email)
+  expect(passwordValidator).toBeCalledTimes(1)
+  expect(passwordValidator).toBeCalledWith(password)
+})
+
+it('shows a message when a field is entered but there are no rules for it', () => {
+  const fields = {
+    email: '[email protected]',
+  }
+
+  const { valid, results } = validate(fields, {
+    rules: {
+      fields: {},
+    }
+  })
+
+  const expected = [
+    {
+      field: 'email',
+      valid: false,
+      message: 'No validation rules for field email',
+    }
+  ]
+
+  expect(valid).toEqual(false)
+  expect(results).toEqual(expected)
+})

src/validate.js

@@ -0,0 +1,35 @@
+function validate (fields, { rules }) {
+  if (isEmpty(fields)) {
+    return false
+  }
+
+  const checked = []
+
+  Object.keys(fields).forEach((field) => {
+    const rule = rules.fields[field]
+
+    if (!rule) {
+      checked.push({ field, valid: false, message: `No validation rules for field ${field}`})
+      return
+    }
+
+    if (rule.validator(fields[field])) {
+      checked.push({ field, valid: true, message: '' })
+    } else {
+      checked.push({ field, valid: false, message: rules.fields[field].message || 'Validation failed for field' })
+    }
+  })
+
+  return {
+    valid: checked.every((current) => current.valid === true),
+    results: checked
+  }
+}
+
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+
+module.exports = {
+  validate
+}

src/validation/__tests__/email.test.js

@@ -0,0 +1,14 @@
+const { email } = require('../index')
+
+it('returns true when a valid email is given', () => {
+  const result = email('[email protected]')
+
+  expect(result).toEqual(true)
+})
+
+it('returns false when a invalid email is given', () => {
+  expect(email('info.example.com')).toEqual(false)
+  expect(email('info@@example.com')).toEqual(false)
+  expect(email('info...example.com')).toEqual(false)
+  expect(email('[email protected]@asdf')).toEqual(false)
+})

src/validation/__tests__/length.test.js

@@ -0,0 +1,44 @@
+const { length } = require('../index')
+
+const string = 'string'
+
+it('checks for the length of a min value', () => {
+  const result = length(string, {
+    min: 4
+  })
+
+  expect(result).toEqual(true)
+})
+
+it('checks for the length of a max value', () => {
+  const result = length(string, {
+    max: 7
+  })
+
+  expect(result).toEqual(true)
+})
+
+it('returns false when the min length is not reached', () => {
+  const result = length(string, {
+    min: 100,
+  })
+
+  expect(result).toEqual(false)
+})
+
+it('returns false when the max length is not reached', () => {
+  const result = length(string, {
+    max: 1,
+  })
+
+  expect(result).toEqual(false)
+})
+
+it('works with a min and a max value', () => {
+  const result = length('strings', {
+    min: 4,
+    max: 5
+  })
+
+  expect(result).toEqual(false)
+})

src/validation/__tests__/number.test.js

@@ -0,0 +1,20 @@
+const { number } = require('../index')
+
+it('validates that a given value is a number', () => {
+  expect(number(10)).toEqual(true)
+  expect(number('10')).toEqual(false)
+})
+
+it('validates that a given number is a lower then the max value', () => {
+  const value = 10
+
+  expect(number(value, { max: 11 })).toEqual(true)
+  expect(number(value, { max: 9 })).toEqual(false)
+})
+
+it('validates that a given number is higher then the min value', () => {
+  const value = 10
+
+  expect(number(value, { min: 9 })).toEqual(true)
+  expect(number(value, { min: 11 })).toEqual(false)
+})

src/validation/index.js

@@ -0,0 +1,36 @@
+function number (x, { max, min } = {}) {
+  if (min || max) {
+    if (Number(x) === x) {
+      if (x >= min && x <= max) return true
+      if (x >= min && max === undefined) return true
+      if (x <= max && min === undefined) return true
+    }
+  }
+
+  if (Number(x) === x && (min === undefined && max === undefined)) {
+    return true
+  }
+
+  return false
+}
+
+function email (x) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+  return emailRegex.test(x)
+}
+
+function length (x, { min, max }) {
+  const length = x.length
+
+  if (length >= min && length <= max) return true
+  if (length >= min && max === undefined) return true
+  if (length <= max && min === undefined) return true
+
+  return false
+}
+
+module.exports = {
+  email,
+  length,
+  number,
+}