@orioro/util 0.1.0 → 0.3.0

package/src/validate/async/index.spec.ts

@@ -1,236 +0,0 @@
-import { validateAsync } from './'
-import { wait } from '../../debug'
-import { commonTests } from '../specUtil/commonTests'
-import { typeValidator } from '../common/validators'
-import { validate } from '../sync'
-import { AsyncValidatorSystem } from '../types'
-
-//
-// Async api should match the sync api
-// in most methods
-//
-commonTests(
-  {
-    describe,
-    test,
-    //
-    // Wrap the expects declartion into the async resolution mode
-    //
-    expect: (value) => expect(value).resolves,
-  },
-  {
-    validate: validateAsync,
-  },
-)
-
-describe('basic', () => {
-  test('basic', async () => {
-    const asyncValidator = async (input) => {
-      await wait(100)
-      return typeof input === 'string' && input.length > 5
-    }
-
-    expect(validateAsync(asyncValidator, 'Some text')).resolves.toEqual(true)
-
-    expect(validateAsync(asyncValidator, 'Some')).resolves.toEqual({
-      input: 'Some',
-      message: "Invalid input: 'Some'.",
-    })
-  })
-})
-
-test('simulate http request', async () => {
-  const DB = [
-    { username: 'user1' },
-    { username: 'user2' },
-    { username: 'user3' },
-    { username: 'user4' },
-  ]
-
-  async function usernameIsAvailable(input) {
-    await wait(500)
-    return DB.every((user) => user.username !== input)
-  }
-
-  const validator = validateAsync.obj({
-    username: validateAsync.and([
-      [validateAsync.type('string'), 'Is required'],
-      [(str) => str.length >= 4, 'Must have at least 4 chars'],
-      [(str) => str.length <= 10, 'Must have at most 10 chars'],
-      [(str) => usernameIsAvailable(str), 'Username is taken'],
-    ]),
-  })
-
-  await expect(
-    validateAsync(validator, {
-      username: 'user5',
-    }),
-  ).resolves.toEqual(true)
-
-  await expect(
-    validateAsync(validator, {
-      username: 'u',
-    }),
-  ).resolves.toMatchObject({
-    nestedErrors: [
-      {
-        path: 'username',
-        message: 'Must have at least 4 chars',
-      },
-    ],
-  })
-
-  await expect(
-    validateAsync(validator, {
-      username: 'user4',
-    }),
-  ).resolves.toMatchObject({
-    nestedErrors: [
-      {
-        path: 'username',
-        message: 'Username is taken',
-      },
-    ],
-  })
-})
-
-describe('obj', () => {
-  describe('series execution', () => {
-    const validator = validateAsync.obj({
-      param1: (input) => wait(300, typeof input === 'string'),
-      param2: (input) => wait(600, typeof input === 'number'),
-    })
-
-    test('success', async () => {
-      const start = Date.now()
-
-      await expect(
-        validateAsync(validator, {
-          param1: 'String value',
-          param2: 88,
-        }),
-      ).resolves.toEqual(true)
-
-      //
-      // Validation calls are executed in series
-      //
-      expect(Date.now() - start).toBeGreaterThan(900)
-      expect(Date.now() - start).toBeLessThan(1000)
-    })
-
-    test('failure', async () => {
-      const start = Date.now()
-
-      await expect(
-        validateAsync(validator, {
-          param1: 'String value',
-          param2: 'string value',
-        }),
-      ).resolves.toEqual({
-        input: { param1: 'String value', param2: 'string value' },
-        nestedErrors: [
-          {
-            input: 'string value',
-            message: "Invalid input: 'string value'.",
-            path: 'param2',
-          },
-        ],
-        message:
-          'Invalid input: `{"param1":"String value","param2":"string value"}`.\n' +
-          "  - param2: Invalid input: 'string value'.",
-      })
-
-      //
-      // Validation calls are executed in series
-      //
-      expect(Date.now() - start).toBeGreaterThan(900)
-      expect(Date.now() - start).toBeLessThan(1000)
-    })
-  })
-})
-
-describe('validateAsync.assertValid', () => {
-  test('basic', async () => {
-    await expect(validateAsync.assertValid('string!', 'test')).resolves.toEqual(
-      'test',
-    )
-    await expect(validateAsync.assertValid('string!', null)).rejects.toThrow(
-      "Invalid input: 'null'. Expected type(s) `string!`, but got type `null`",
-    )
-  })
-
-  test('shorthand', async () => {
-    const validator = {
-      param1: 'string!',
-      param2: {
-        param21: async (value) => {
-          const allowedTypes = await wait(400, 'number! | string!')
-
-          return validate(allowedTypes, value)
-        },
-        param22: 'function',
-      },
-    }
-
-    const input1 = {
-      param1: 'Some string',
-      param2: {
-        param21: 2,
-        param22: () => {},
-      },
-    }
-
-    await expect(validateAsync.assertValid(validator, input1)).resolves.toEqual(
-      input1,
-    )
-
-    const input2 = {
-      param1: 'Some string',
-      param2: {
-        param21: 2,
-        param22: 3,
-      },
-    }
-
-    await expect(validateAsync.assertValid(validator, input2)).rejects.toThrow(
-      "param22: Invalid input: '3'. Expected type(s) `function`, but got type `number`",
-    )
-
-    const input3 = {
-      param1: 'Some string',
-      param2: {
-        param21: null,
-      },
-    }
-
-    await expect(validateAsync.assertValid(validator, input3)).rejects.toThrow(
-      "param21: Invalid input: 'null'. Expected type(s) `number! | string!`, but got type `null`",
-    )
-  })
-
-  test('shorthand 2', async () => {
-    const validator: AsyncValidatorSystem['ValidatorInput'] = {
-      givenName: [
-        async (givenName) => {
-          await wait(500)
-          return typeof givenName === 'string' && givenName.length > 3
-        },
-        'Nome precisa ter ao menos 3 caracteres',
-      ],
-      familyName: [
-        async (familyName) => {
-          await wait(500)
-          return typeof familyName === 'string' && familyName.length > 3
-        },
-        'Sobrenome precisa ter ao menos 3 caracteres',
-      ],
-    }
-
-    await expect(
-      validateAsync(validator, {
-        givenName: 'Test',
-        familyName: 'Test',
-      }),
-    ).resolves.toEqual(true)
-  })
-})

package/src/validate/async/index.ts

@@ -1,52 +0,0 @@
-import * as common from '../common/validators'
-import * as asyncValidators from './validators'
-import { validateAsyncFn } from './validateAsyncFn'
-import { DetailedInvalid, AsyncValidatorSystem, Valid } from '../types'
-import { ValidationError } from '../common/ValidationError'
-
-async function assertValidAsync<InputT = any>(
-  validator: AsyncValidatorSystem['ValidatorInput'],
-  input: InputT,
-): Promise<InputT> {
-  const validationResult = await validateAsync(validator, input)
-
-  if (validationResult === true) {
-    return input
-  } else {
-    throw new ValidationError(validationResult)
-  }
-}
-
-interface ValidateAsync {
-  (
-    validatorInput: AsyncValidatorSystem['ValidatorInput'],
-    input: any,
-  ): Promise<Valid | DetailedInvalid>
-  type: typeof common.typeValidator
-
-  obj: typeof asyncValidators.obj
-  objOf: typeof asyncValidators.objOf
-  tuple: typeof asyncValidators.tuple
-  arrayOf: typeof asyncValidators.arrayOf
-
-  and: typeof asyncValidators.and
-  or: typeof asyncValidators.or
-  not: typeof asyncValidators.not
-
-  assertValid: typeof assertValidAsync
-}
-
-export const validateAsync: ValidateAsync = validateAsyncFn as ValidateAsync
-
-validateAsync.type = common.typeValidator
-
-validateAsync.obj = asyncValidators.obj
-validateAsync.objOf = asyncValidators.objOf
-validateAsync.tuple = asyncValidators.tuple
-validateAsync.arrayOf = asyncValidators.arrayOf
-
-validateAsync.and = asyncValidators.and
-validateAsync.or = asyncValidators.or
-validateAsync.not = asyncValidators.not
-
-validateAsync.assertValid = assertValidAsync

package/src/validate/async/validateAsyncFn.ts

@@ -1,41 +0,0 @@
-import {
-  DetailedInvalid,
-  Valid,
-  AsyncValidatorSystem,
-  ValidatorResult,
-} from '../types'
-import { obj as asyncObjValidator } from './validators/shape'
-
-import { parseValidatorInput, resolveValidationResult } from '../common/util'
-
-export async function validateAsyncFn(
-  validatorInput: AsyncValidatorSystem['ValidatorInput'],
-  input: any,
-): Promise<Valid | DetailedInvalid> {
-  let result: ValidatorResult
-
-  const [validatorFn, errorMessage] = parseValidatorInput<
-    AsyncValidatorSystem['ValidatorInput'],
-    AsyncValidatorSystem['ValidatorFn'],
-    AsyncValidatorSystem['Validator']
-  >(
-    {
-      objValidator: asyncObjValidator,
-    },
-    validatorInput,
-  )
-
-  try {
-    result = await validatorFn(input, {
-      validateAsync: validateAsyncFn,
-    })
-  } catch (err) {
-    result = err as Error
-  }
-
-  return resolveValidationResult({
-    errorMessage,
-    input,
-    result,
-  })
-}

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

@@ -1,2 +0,0 @@
-export * from './shape'
-export * from './logical'

package/src/validate/async/validators/logical.ts

@@ -1,56 +0,0 @@
-import { promiseReduce } from '../../../promise'
-import { DetailedInvalid, Valid, AsyncValidatorSystem } from '../../types'
-
-//
-// And operator (serial)
-//
-export function and(
-  validators: AsyncValidatorSystem['ValidatorInput'][],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function validateAnd(input, { validateAsync }) {
-    const result = await promiseReduce(
-      validators,
-      (acc, validator) =>
-        acc !== true ? acc : validateAsync(validator, input),
-      true as Valid | DetailedInvalid,
-    )
-
-    if (result === true) {
-      return true
-    } else {
-      return result
-    }
-  }
-}
-
-//
-// Or operator (serial)
-//
-export function or(
-  validators: AsyncValidatorSystem['ValidatorInput'][],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function validateOr(input, { validateAsync }) {
-    const someIsValid = await promiseReduce(
-      validators,
-      async (acc, validator) => {
-        return acc === true || (await validateAsync(validator, input)) === true
-      },
-      false as boolean,
-    )
-
-    return someIsValid
-  }
-}
-
-//
-// Not
-//
-export function not(
-  validator: AsyncValidatorSystem['ValidatorInput'],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function validateNot(input, { validateAsync }) {
-    const result = await validateAsync(validator, input)
-
-    return result !== true
-  }
-}

package/src/validate/async/validators/shape.ts

@@ -1,160 +0,0 @@
-import {
-  DetailedInvalid,
-  AsyncValidatorSystem,
-  AsyncValidateFn,
-} from '../../types'
-import { typeValidator } from '../../common/validators/type'
-import { getProperty } from 'dot-prop'
-import { promiseReduce } from '../../../promise'
-
-async function _shapeGeneralValidator({
-  input,
-  baseType,
-  validateAsync,
-  collectNestedErrors,
-}: {
-  input: any
-  baseType: 'object' | 'array'
-  validateAsync: AsyncValidateFn
-  collectNestedErrors: () => Promise<DetailedInvalid[]>
-}) {
-  const objectValidation = await validateAsync(
-    typeValidator({ type: baseType, required: true }),
-    input,
-  )
-
-  if (objectValidation !== true) {
-    return objectValidation
-  }
-
-  const nestedErrors = await collectNestedErrors()
-
-  return nestedErrors.length === 0
-    ? true
-    : {
-        input,
-        nestedErrors,
-      }
-}
-
-export function obj(objShape: {
-  [key: string]: AsyncValidatorSystem['ValidatorInput']
-}): AsyncValidatorSystem['ValidatorFn'] {
-  return async function asyncValidateObj(input, { validateAsync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'object',
-      validateAsync,
-      collectNestedErrors: () =>
-        promiseReduce(
-          Object.entries(objShape),
-          async (acc, [path, pathValidator]) => {
-            const pathInput = getProperty(input, path)
-            const pathResult = await validateAsync(pathValidator, pathInput)
-
-            return pathResult === true
-              ? acc
-              : [
-                  ...acc,
-                  {
-                    ...pathResult,
-                    path,
-                  },
-                ]
-          },
-          [] as DetailedInvalid[],
-        ),
-    })
-  }
-}
-
-export function objOf(
-  ofType: AsyncValidatorSystem['ValidatorInput'],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function asyncValidateObjOf(input, { validateAsync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'object',
-      validateAsync,
-      collectNestedErrors: () =>
-        promiseReduce(
-          Object.entries(input),
-          async (acc, [key, keyInput]) => {
-            const indexResult = await validateAsync(ofType, keyInput)
-
-            return indexResult === true
-              ? acc
-              : [
-                  ...acc,
-                  {
-                    ...indexResult,
-                    path: key,
-                  },
-                ]
-          },
-          [] as DetailedInvalid[],
-        ),
-    })
-  }
-}
-
-export function tuple(
-  tupleShape: AsyncValidatorSystem['ValidatorInput'][],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function asyncValidateTuple(input, { validateAsync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'array',
-      validateAsync,
-      collectNestedErrors: () =>
-        promiseReduce(
-          tupleShape,
-          async (acc, indexValidator, index) => {
-            const indexInput = input[index]
-            const indexResult = await validateAsync(indexValidator, indexInput)
-
-            return indexResult === true
-              ? acc
-              : [
-                  ...acc,
-                  {
-                    ...indexResult,
-                    path: index + '',
-                  },
-                ]
-          },
-          [] as DetailedInvalid[],
-        ),
-    })
-  }
-}
-
-export function arrayOf(
-  ofType: AsyncValidatorSystem['ValidatorInput'],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function asyncValidateArrayOf(input, { validateAsync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'array',
-      validateAsync,
-      collectNestedErrors: () =>
-        promiseReduce(
-          input as any[],
-          async (acc, indexInput, index) => {
-            const indexResult = await validateAsync(ofType, indexInput)
-
-            return indexResult === true
-              ? acc
-              : [
-                  ...acc,
-                  {
-                    ...indexResult,
-                    path: index + '',
-                  },
-                ]
-          },
-          [] as DetailedInvalid[],
-        ),
-    })
-  }
-}

package/src/validate/async/validators/tmpand.ts

@@ -1,24 +0,0 @@
-import { promiseReduce } from '../../../promise'
-import { DetailedInvalid, Valid, AsyncValidatorSystem } from '../../types'
-
-//
-// And operator (serial)
-//
-export function and(
-  validators: AsyncValidatorSystem['ValidatorInput'][],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function validateAnd(input, { validateAsync }) {
-    const result = await promiseReduce(
-      validators,
-      (acc, validator) =>
-        acc !== true ? acc : validateAsync(validator, input),
-      true as Valid | DetailedInvalid,
-    )
-
-    if (result === true) {
-      return true
-    } else {
-      return result
-    }
-  }
-}

package/src/validate/async/validators/tmpor.ts

@@ -1,21 +0,0 @@
-import { promiseReduce } from '../../../promise'
-import { AsyncValidatorSystem } from '../../types'
-
-//
-// Or operator (serial)
-//
-export function or(
-  validators: AsyncValidatorSystem['ValidatorInput'][],
-): AsyncValidatorSystem['ValidatorFn'] {
-  return async function validateOr(input, { validateAsync }) {
-    const someIsValid = await promiseReduce(
-      validators,
-      async (acc, validator) => {
-        return acc === true || (await validateAsync(validator, input)) === true
-      },
-      false as boolean,
-    )
-
-    return someIsValid
-  }
-}

package/src/validate/common/ValidationError.ts

@@ -1,33 +0,0 @@
-import { DetailedInvalid } from '../types'
-
-export class ValidationError extends Error {
-  input: any
-  code?: string
-  error?: Error
-  path?: string
-  nestedErrors?: DetailedInvalid[]
-
-  name: string = 'ValidationError'
-
-  constructor({ message, ...details }: DetailedInvalid) {
-    super(message || `Invalid input ${details.input}`)
-
-    // Capture correct stack trace in V8 environments (Node.js, Google Chrome)
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, ValidationError)
-    }
-
-    Object.assign(this, details)
-  }
-
-  toJSON(): DetailedInvalid {
-    return {
-      message: this.message,
-      input: this.input,
-      code: this.code,
-      error: this.error,
-      path: this.path,
-      nestedErrors: this.nestedErrors,
-    }
-  }
-}

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

@@ -1,26 +0,0 @@
-import { typeOf } from '../../../typeOf'
-import { DetailedInvalid } from '../../types'
-
-export function defaultErrorMessage({
-  input,
-  message,
-  nestedErrors,
-  expectedTypes,
-}: DetailedInvalid): string {
-  if (message) {
-    return message
-  }
-
-  if (nestedErrors) {
-    return `Invalid input: \`${JSON.stringify(input)}\`.\n${nestedErrors
-      .map((error: DetailedInvalid) => `  - ${error.path}: ${error.message}`)
-      .join('\n')}`
-  } else if (expectedTypes) {
-    const inputType = typeOf(input)
-    return `Invalid input: '${input}'. Expected type(s) \`${expectedTypes}\`, but got type \`${
-      inputType === null ? 'unknown' : inputType
-    }\``
-  } else {
-    return `Invalid input: '${input}'.`
-  }
-}

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

@@ -1,3 +0,0 @@
-export * from './defaultErrorMessage'
-export * from './resolveValidationResult'
-export * from './parseValidatorInput'