@orioro/util 0.0.0 → 0.1.0

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

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

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

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

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

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

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

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

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

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

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

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

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