@orioro/util 0.2.0 → 0.4.0

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

@@ -1,77 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

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

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

@@ -1,101 +0,0 @@
-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

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

package/src/validate/index.ts

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

package/src/validate/specUtil/commonTests.js

@@ -1,413 +0,0 @@
-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',
-      })
-    })
-  })
-}