@orioro/util 0.0.0 → 0.1.0

package/src/validate/common/util/parseValidatorInput.ts

@@ -0,0 +1,77 @@
+import { defaultErrorMessage } from './defaultErrorMessage'
+import { typeValidator } from '../validators'
+import { DEFAULT_TYPE_NAMES, typeOf } from '../../../typeOf'
+import {
+  DetailedInvalid,
+  ValidatorErrorMessageFn,
+  ValidatorErrorMessageInput,
+} from '../../types'
+import { interpolate } from '../../../interpolate'
+
+export function parseValidatorInput<ValidatorInputT, ValidatorFnT, ValidatorT>(
+  {
+    objValidator,
+  }: {
+    objValidator: (objShape: { [key: string]: ValidatorInputT }) => ValidatorFnT
+  },
+  validatorInput: ValidatorInputT,
+) {
+  //
+  // Parses the validator fn.
+  // If provided with a string, will return a type validator
+  // If provided with a function, will return the function itself
+  //
+  function _parseValidatorFn(
+    fnInput:
+      | DEFAULT_TYPE_NAMES
+      | { [key: string]: ValidatorInputT }
+      | ((input: any) => any),
+  ): ValidatorFnT {
+    switch (typeOf(fnInput)) {
+      case 'string': {
+        return typeValidator(fnInput as DEFAULT_TYPE_NAMES) as ValidatorFnT
+      }
+      case 'object': {
+        return objValidator(fnInput as { [key: string]: ValidatorInputT })
+      }
+      case 'function': {
+        return fnInput as ValidatorFnT
+      }
+      default: {
+        throw new TypeError(`Unsupported fnInput ${fnInput}`)
+      }
+    }
+  }
+
+  function _parseValidatorErrorMessageFn(
+    fnInput: ValidatorErrorMessageInput,
+  ): ValidatorErrorMessageFn {
+    switch (typeof fnInput) {
+      case 'string': {
+        return (details: DetailedInvalid) => interpolate(fnInput, details)
+      }
+      case 'function': {
+        return fnInput
+      }
+      default: {
+        throw new TypeError(`Unsupported error message input ${fnInput}`)
+      }
+    }
+  }
+
+  //
+  // Parses the validator input. For more details, see:
+  // types/common.ts -> ValidatorSystem
+  //
+  // Ensures the return result is always of the following format:
+  // [ValidatorFn, ValidatorErrorMessageInput]
+  //
+  const [fnInput, errorMessageInput] = Array.isArray(validatorInput)
+    ? validatorInput
+    : [validatorInput, defaultErrorMessage]
+
+  return [
+    _parseValidatorFn(fnInput),
+    _parseValidatorErrorMessageFn(errorMessageInput),
+  ] as ValidatorT
+}

package/src/validate/common/util/resolveValidationResult.ts

@@ -0,0 +1,64 @@
+import { typeOf } from '../../../typeOf'
+import { switchExec } from '../../../switchValue'
+import {
+  DetailedInvalid,
+  Valid,
+  ValidatorErrorMessageFn,
+  ValidatorResult,
+} from '../../types'
+
+export function resolveValidationResult({
+  input,
+  result,
+  errorMessage,
+}: {
+  input: any
+  result: ValidatorResult
+  errorMessage: ValidatorErrorMessageFn
+}): Valid | DetailedInvalid {
+  if (result === true) {
+    return true
+  } else {
+    const _falseLikeResult = () => ({
+      message: errorMessage({ input }),
+    })
+
+    return {
+      input,
+      ...switchExec(typeOf(result), {
+        string: () =>
+          ({
+            message: result,
+          }) as DetailedInvalid,
+        error: () => ({
+          message: (result as Error).message,
+          error: result,
+        }),
+        object: () => {
+          const result_ = result as DetailedInvalid
+
+          return {
+            ...result_,
+            message: errorMessage(result_),
+          }
+        },
+
+        //
+        // Boolean result here MUST be false, as true was tested earlier
+        //
+        boolean: _falseLikeResult,
+        null: _falseLikeResult,
+        undefined: _falseLikeResult,
+
+        //
+        // Unsupported validation result
+        //
+        default: () => {
+          throw new Error(
+            `Invalid validation result: ${result} (${typeOf(result)})`,
+          )
+        },
+      }),
+    }
+  }
+}

package/src/validate/common/validators/index.ts

@@ -0,0 +1 @@
+export * from './type'

package/src/validate/common/validators/type.ts

@@ -0,0 +1,101 @@
+import { switchExec } from '../../../switchValue'
+import { DEFAULT_TYPE_NAMES, typeOf } from '../../../typeOf'
+import { DetailedInvalid, Valid, CommonValidatorFn } from '../../types'
+
+type ParsedExpectedType = {
+  type: DEFAULT_TYPE_NAMES
+  required: boolean
+}
+
+type ExpectedTypesInput =
+  | (string | ParsedExpectedType)[]
+  | string
+  | ParsedExpectedType
+
+const TYPE_RE = /([a-z0-9]+)(\!)?$/i
+const TYPE_SEPARATOR_RE = /\s*\|\s*/g
+
+function parseSingleType(typeInput: string): ParsedExpectedType {
+  const match = typeInput.match(TYPE_RE)
+
+  if (!match) {
+    throw new Error(`Invalid type ${typeInput}`)
+  } else {
+    const [, typeName, requiredSignal] = match
+
+    return {
+      type: typeName as DEFAULT_TYPE_NAMES,
+      required: requiredSignal === '!',
+    }
+  }
+}
+
+function serializeExpectedTypes(expectedTypes: ParsedExpectedType[]) {
+  return expectedTypes
+    .map(
+      (expectedType) =>
+        `${expectedType.type}${expectedType.required ? '!' : ''}`,
+    )
+    .join(' | ')
+}
+
+function parseExpectedTypes(
+  expectedTypesInput: ExpectedTypesInput,
+): ParsedExpectedType[] {
+  switch (typeOf(expectedTypesInput)) {
+    case 'string': {
+      return (expectedTypesInput as string)
+        .split(TYPE_SEPARATOR_RE)
+        .map((typeInput) => parseSingleType(typeInput))
+    }
+    case 'array': {
+      return (expectedTypesInput as (string | ParsedExpectedType)[]).map(
+        (expectedType) =>
+          typeof expectedType === 'string'
+            ? parseSingleType(expectedType)
+            : expectedType,
+      )
+    }
+    case 'object': {
+      return [expectedTypesInput as ParsedExpectedType]
+    }
+    default: {
+      throw new Error(`Invalid expectedType ${expectedTypesInput}`)
+    }
+  }
+}
+
+export function typeValidator(
+  expectedTypesInput: ExpectedTypesInput,
+): CommonValidatorFn {
+  const expectedTypes: ParsedExpectedType[] =
+    parseExpectedTypes(expectedTypesInput)
+
+  return function validateType(input) {
+    const inputType = typeOf(input)
+
+    const nullOrUndefined = () =>
+      expectedTypes.some(
+        (expectedType) =>
+          expectedType.type === 'undefined' ||
+          expectedType.type === 'null' ||
+          expectedType.required === false,
+      )
+
+    const isValid = switchExec(inputType, {
+      null: nullOrUndefined,
+      undefined: nullOrUndefined,
+      default: () =>
+        expectedTypes.some((expectedType) => expectedType.type === inputType),
+    })
+
+    if (isValid) {
+      return true
+    } else {
+      return {
+        expectedTypes: serializeExpectedTypes(expectedTypes),
+        input,
+      }
+    }
+  }
+}

package/src/validate/index.spec.ts

@@ -0,0 +1,5 @@
+import * as validateAPI from './index'
+
+test('validateAPI', () => {
+  expect(Object.keys(validateAPI)).toMatchSnapshot()
+})

package/src/validate/index.ts

@@ -0,0 +1,3 @@
+export * from './sync'
+export * from './async'
+export * from './common/ValidationError'

package/src/validate/specUtil/commonTests.js

@@ -0,0 +1,413 @@
+export function commonTests({ describe, test, expect }, { validate }) {
+  describe('basic', () => {
+    test('non-required', () => {
+      const isString = validate.type('string')
+
+      expect(validate(isString, 'Some text')).toEqual(true)
+      expect(validate(isString, null)).toEqual(true)
+      expect(validate(isString, undefined)).toEqual(true)
+      expect(validate(isString)).toEqual(true)
+      expect(validate(isString, false)).toMatchObject({
+        message:
+          "Invalid input: 'false'. Expected type(s) `string`, but got type `boolean`",
+      })
+      expect(validate(isString, 8)).toEqual({
+        input: 8,
+        expectedTypes: 'string',
+        message:
+          "Invalid input: '8'. Expected type(s) `string`, but got type `number`",
+      })
+    })
+
+    test('required', () => {
+      const isString = validate.type('string!')
+
+      expect(validate(isString, 'Some text')).toEqual(true)
+      expect(validate(isString, null)).toMatchObject({
+        message:
+          "Invalid input: 'null'. Expected type(s) `string!`, but got type `null`",
+      })
+      expect(validate(isString, undefined)).toMatchObject({
+        message:
+          "Invalid input: 'undefined'. Expected type(s) `string!`, but got type `undefined`",
+      })
+
+      expect(validate(isString, 8)).toEqual({
+        input: 8,
+        expectedTypes: 'string!',
+        message:
+          "Invalid input: '8'. Expected type(s) `string!`, but got type `number`",
+      })
+    })
+
+    test('basic fn', () => {
+      const fnValidator = (input) =>
+        typeof input === 'string' && input.length > 5
+
+      expect(validate(fnValidator, 'Some text')).toEqual(true)
+      expect(validate(fnValidator, 'Some')).toEqual({
+        input: 'Some',
+        message: "Invalid input: 'Some'.",
+      })
+    })
+  })
+
+  describe('shorthand type declaration', () => {
+    test('string validator', () => {
+      expect(validate('string', 'Some string')).toEqual(true)
+      expect(validate('string', null)).toEqual(true)
+      expect(validate('string!', null)).not.toEqual(true)
+
+      expect(validate('string', 9)).toEqual({
+        input: 9,
+        expectedTypes: 'string',
+        message:
+          "Invalid input: '9'. Expected type(s) `string`, but got type `number`",
+      })
+    })
+
+    test('multitype', () => {
+      const validator = 'string! | number! | function!'
+      expect(validate(validator, 'str')).toEqual(true)
+      expect(validate(validator, 10)).toEqual(true)
+      expect(validate(validator, () => {})).toEqual(true)
+      expect(validate(validator, undefined)).not.toEqual(true)
+    })
+
+    test('object shorthand', () => {
+      const validator = {
+        givenName: 'string',
+        age: 'number',
+        someFn: 'function!',
+      }
+      expect(
+        validate(validator, {
+          givenName: 'Boo',
+          age: 9,
+          someFn: () => {},
+        }),
+      ).toEqual(true)
+
+      expect(
+        validate(validator, {
+          givenName: 'Boo',
+          age: 9,
+          // someFn: () => {},
+        }),
+      ).toMatchObject({
+        nestedErrors: [
+          {
+            message:
+              "Invalid input: 'undefined'. Expected type(s) `function!`, but got type `undefined`",
+            path: 'someFn',
+          },
+        ],
+        message:
+          'Invalid input: `{"givenName":"Boo","age":9}`.\n' +
+          "  - someFn: Invalid input: 'undefined'. Expected type(s) `function!`, but got type `undefined`",
+      })
+    })
+  })
+
+  describe('obj', () => {
+    test('basic', () => {
+      const validator = validate.obj({
+        paramA: validate.type('number'),
+        paramB: validate.type('string'),
+      })
+
+      expect(
+        validate(validator, {
+          paramA: 10,
+          paramB: 'Hello',
+        }),
+      ).toEqual(true)
+
+      expect(
+        validate(validator, {
+          paramA: '10',
+          paramB: 'Hello',
+        }),
+      ).toEqual({
+        input: { paramA: '10', paramB: 'Hello' },
+        message:
+          'Invalid input: `{"paramA":"10","paramB":"Hello"}`.\n' +
+          "  - paramA: Invalid input: '10'. Expected type(s) `number`, but got type `string`",
+        nestedErrors: [
+          {
+            input: '10',
+            message:
+              "Invalid input: '10'. Expected type(s) `number`, but got type `string`",
+            path: 'paramA',
+            expectedTypes: 'number',
+          },
+        ],
+      })
+    })
+  })
+
+  describe('logical', () => {
+    test('and', () => {
+      const validator = validate.and([
+        validate.type('string'),
+        [(input) => input.length >= 8, 'Must have at least 8 characters'],
+        [(input) => input.length <= 20, 'Must have at most 20 characters'],
+      ])
+
+      expect(validate(validator, '12345678')).toEqual(true)
+      expect(validate(validator, '1234567')).toEqual({
+        input: '1234567',
+        message: 'Must have at least 8 characters',
+      })
+      expect(validate(validator, '12345678901234567890_1')).toEqual({
+        input: '12345678901234567890_1',
+        message: 'Must have at most 20 characters',
+      })
+    })
+
+    test('or', () => {
+      const validator = validate.or([
+        validate.type('string!'),
+        validate.type('number!'),
+      ])
+
+      expect(validate(validator, 'Hello')).toEqual(true)
+      expect(validate(validator, 90)).toEqual(true)
+      expect(validate(validator, undefined)).toEqual({
+        input: undefined,
+        message: "Invalid input: 'undefined'.",
+      })
+    })
+
+    test('nested', () => {
+      const validator = validate.and([
+        validate.type('string'),
+        [
+          validate.or([
+            (input) => input.length <= 8,
+            (input) => input.length >= 16,
+          ]),
+          'Must have either 8 chars or less or 16 or more',
+        ],
+      ])
+
+      expect(validate(validator, '1234567')).toEqual(true)
+      expect(validate(validator, '123456712345671234567')).toEqual(true)
+      expect(validate(validator, '12345671234567')).toEqual({
+        input: '12345671234567',
+        message: 'Must have either 8 chars or less or 16 or more',
+      })
+    })
+
+    test('with object shape', () => {
+      const validator = validate.obj({
+        username: [
+          validate.and([
+            validate.type('string'),
+            (str) => str.length >= 5,
+            (str) => str.length <= 10,
+            (str) => /^[a-zA-Z0-9]+$/.test(str),
+          ]),
+          'Username must be have at least 5 chars, at most 10 chars and contain only alphanumeric characters (0-9,a-Z)',
+        ],
+        password: [
+          validate.and([
+            validate.type('string'),
+            (str) => str.length >= 8,
+            (str) => str.length <= 15,
+          ]),
+          'Password must have at leadt 8 chars and at most 15',
+        ],
+      })
+
+      expect(
+        validate(validator, {
+          username: 'username',
+          password: 'testpassword',
+        }),
+      ).toEqual(true)
+
+      expect(
+        validate(validator, {
+          username: 'username_',
+          password: 'testpassword',
+        }),
+      ).not.toEqual(true)
+
+      expect(
+        validate(validator, {
+          username: null,
+          password: 'testpassword',
+        }),
+      ).not.toEqual(true)
+
+      expect(
+        validate(validator, {
+          username: 'username123123',
+          password: 'testpassword',
+        }),
+      ).toEqual({
+        input: { username: 'username123123', password: 'testpassword' },
+        nestedErrors: [
+          {
+            input: 'username123123',
+            message:
+              'Username must be have at least 5 chars, at most 10 chars and contain only alphanumeric characters (0-9,a-Z)',
+            path: 'username',
+          },
+        ],
+        message:
+          'Invalid input: `{"username":"username123123","password":"testpassword"}`.\n' +
+          '  - username: Username must be have at least 5 chars, at most 10 chars and contain only alphanumeric characters (0-9,a-Z)',
+      })
+    })
+  })
+
+  describe('objOf', () => {
+    test('basic', () => {
+      const validator = validate.objOf(validate.type('string'))
+
+      expect(
+        validate(validator, {
+          key1: 'v1',
+          key2: 'v2',
+        }),
+      ).toEqual(true)
+      expect(
+        validate(validator, {
+          key1: 'v1',
+          key2: 6,
+        }),
+      ).toMatchObject({
+        nestedErrors: [
+          {
+            path: 'key2',
+            message:
+              "Invalid input: '6'. Expected type(s) `string`, but got type `number`",
+          },
+        ],
+      })
+    })
+  })
+
+  describe('tuple', () => {
+    test('basic', () => {
+      const validator = validate.tuple([
+        validate.type('function!'),
+        validate.tuple([validate.type('string!'), validate.type('number!')]),
+      ])
+
+      expect(validate(validator, [() => {}, ['string', 10]])).toEqual(true)
+
+      expect(validate(validator, [['string', 10]])).toMatchObject({
+        input: [['string', 10]],
+        nestedErrors: [
+          {
+            message:
+              "Invalid input: 'string,10'. Expected type(s) `function!`, but got type `array`",
+            path: '0',
+          },
+          {
+            message:
+              "Invalid input: 'undefined'. Expected type(s) `array!`, but got type `undefined`",
+            path: '1',
+          },
+        ],
+        message:
+          'Invalid input: `[["string",10]]`.\n' +
+          "  - 0: Invalid input: 'string,10'. Expected type(s) `function!`, but got type `array`\n" +
+          "  - 1: Invalid input: 'undefined'. Expected type(s) `array!`, but got type `undefined`",
+      })
+    })
+  })
+
+  describe('arrayOf', () => {
+    test('basic', () => {
+      const validator = validate.arrayOf(
+        validate.or([
+          validate.type('string'),
+          validate.obj({
+            givenName: validate.type('string'),
+            age: validate.type('number'),
+          }),
+        ]),
+      )
+
+      expect(
+        validate(validator, [
+          'Lee',
+          {
+            givenName: 'Andressa',
+            age: 40,
+          },
+          'Amanda',
+        ]),
+      ).toEqual(true)
+
+      expect(
+        validate(validator, [
+          50,
+          {
+            givenName: 'Andressa',
+            age: 40,
+          },
+          'Amanda',
+        ]),
+      ).toMatchObject({
+        nestedErrors: [
+          { input: 50, message: "Invalid input: '50'.", path: '0' },
+        ],
+        message:
+          'Invalid input: `[50,{"givenName":"Andressa","age":40},"Amanda"]`.\n' +
+          "  - 0: Invalid input: '50'.",
+      })
+    })
+
+    test('minLength / maxLength', () => {
+      const validator = validate.and([
+        validate.arrayOf('string'),
+        (arr) => arr.length >= 5,
+      ])
+
+      expect(validate(validator, ['1', '2', '3', '4', '5'])).toEqual(true)
+      expect(validate(validator, ['1', '2', '3', '4'])).toEqual({
+        input: ['1', '2', '3', '4'],
+        message: "Invalid input: '1,2,3,4'.",
+      })
+    })
+  })
+
+  describe('not', () => {
+    test('basic', () => {
+      const notUndefinedOrNull = validate.not('undefined | null')
+      expect(validate(notUndefinedOrNull, 10)).toEqual(true)
+      expect(validate(notUndefinedOrNull, '10')).toEqual(true)
+      expect(validate(notUndefinedOrNull, false)).toEqual(true)
+      expect(validate(notUndefinedOrNull, null)).toEqual({
+        input: null,
+        message: "Invalid input: 'null'.",
+      })
+      expect(validate(notUndefinedOrNull)).toEqual({
+        input: undefined,
+        message: "Invalid input: 'undefined'.",
+      })
+    })
+    test('custom error message', () => {
+      const notUndefinedOrNull = [
+        validate.not('undefined | null'),
+        'Must not be undefined or null',
+      ]
+      expect(validate(notUndefinedOrNull, 10)).toEqual(true)
+      expect(validate(notUndefinedOrNull, '10')).toEqual(true)
+      expect(validate(notUndefinedOrNull, false)).toEqual(true)
+      expect(validate(notUndefinedOrNull, null)).toEqual({
+        input: null,
+        message: 'Must not be undefined or null',
+      })
+      expect(validate(notUndefinedOrNull)).toEqual({
+        input: undefined,
+        message: 'Must not be undefined or null',
+      })
+    })
+  })
+}