@orioro/util 0.2.0 → 0.3.0

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

@@ -1,81 +0,0 @@
-import { validate } from './'
-
-import { commonTests } from '../specUtil/commonTests'
-
-commonTests(
-  {
-    describe,
-    test,
-    expect,
-  },
-  {
-    validate: validate,
-  },
-)
-
-describe('error upon attempting async', () => {
-  test('basic', () => {
-    const asyncValidator = async (input) =>
-      typeof input === 'string' && input.length > 5
-
-    expect(() => {
-      validate(asyncValidator, 'Some text')
-    }).toThrow('Promises not supported in sync validation method')
-
-    expect(() => {
-      validate(asyncValidator, 'Some')
-    }).toThrow('Promises not supported in sync validation method')
-  })
-})
-
-describe('assertValid', () => {
-  test('basic', () => {
-    expect(validate.assertValid('string!', 'test')).toEqual('test')
-    expect(() => validate.assertValid('string!', null)).toThrow(
-      "Invalid input: 'null'. Expected type(s) `string!`, but got type `null`",
-    )
-  })
-
-  test('shorthand', () => {
-    const validator = {
-      param1: 'string!',
-      param2: {
-        param21: 'number! | string!',
-        param22: 'function',
-      },
-    }
-
-    const input1 = {
-      param1: 'Some string',
-      param2: {
-        param21: 2,
-        param22: () => {},
-      },
-    }
-
-    expect(validate.assertValid(validator, input1)).toEqual(input1)
-
-    const input2 = {
-      param1: 'Some string',
-      param2: {
-        param21: 2,
-        param22: 3,
-      },
-    }
-
-    expect(() => validate.assertValid(validator, input2)).toThrow(
-      "param22: Invalid input: '3'. Expected type(s) `function`, but got type `number`",
-    )
-
-    const input3 = {
-      param1: 'Some string',
-      param2: {
-        param21: null,
-      },
-    }
-
-    expect(() => validate.assertValid(validator, input3)).toThrow(
-      "param21: Invalid input: 'null'. Expected type(s) `number! | string!`, but got type `null`",
-    )
-  })
-})

package/src/validate/sync/index.ts

@@ -1,53 +0,0 @@
-import * as common from '../common/validators'
-import * as sync from './validators'
-
-import { validateSyncFn } from './validateSyncFn'
-import { DetailedInvalid, SyncValidatorSystem, Valid } from '../types'
-import { ValidationError } from '../common/ValidationError'
-
-function assertValidSync<InputT = any>(
-  validator: SyncValidatorSystem['ValidatorInput'],
-  input: InputT,
-): InputT {
-  const validationResult = validate(validator, input)
-
-  if (validationResult === true) {
-    return input
-  } else {
-    throw new ValidationError(validationResult)
-  }
-}
-
-interface Validate {
-  (
-    validatorInput: SyncValidatorSystem['ValidatorInput'],
-    input: any,
-  ): Valid | DetailedInvalid
-  type: typeof common.typeValidator
-
-  obj: typeof sync.obj
-  objOf: typeof sync.objOf
-  tuple: typeof sync.tuple
-  arrayOf: typeof sync.arrayOf
-
-  and: typeof sync.and
-  or: typeof sync.or
-  not: typeof sync.not
-
-  assertValid: typeof assertValidSync
-}
-
-export const validate: Validate = validateSyncFn as Validate
-
-validate.type = common.typeValidator
-
-validate.obj = sync.obj
-validate.objOf = sync.objOf
-validate.tuple = sync.tuple
-validate.arrayOf = sync.arrayOf
-
-validate.and = sync.and
-validate.or = sync.or
-validate.not = sync.not
-
-validate.assertValid = assertValidSync

package/src/validate/sync/validateSyncFn.ts

@@ -1,46 +0,0 @@
-import {
-  DetailedInvalid,
-  Valid,
-  SyncValidatorSystem,
-  ValidatorResult,
-} from '../types'
-
-import { obj as syncObjValidator } from './validators/shape'
-
-import { parseValidatorInput, resolveValidationResult } from '../common/util'
-
-export function validateSyncFn(
-  validatorInput: SyncValidatorSystem['ValidatorInput'],
-  input: any,
-): Valid | DetailedInvalid {
-  let result: ValidatorResult
-
-  const [validatorFn, errorMessage] = parseValidatorInput<
-    SyncValidatorSystem['ValidatorInput'],
-    SyncValidatorSystem['ValidatorFn'],
-    SyncValidatorSystem['Validator']
-  >(
-    {
-      objValidator: syncObjValidator,
-    },
-    validatorInput,
-  )
-
-  try {
-    result = validatorFn(input, {
-      validateSync: validateSyncFn,
-    })
-  } catch (err) {
-    result = err as Error
-  }
-
-  if (result instanceof Promise) {
-    throw new Error('Promises not supported in sync validation method')
-  }
-
-  return resolveValidationResult({
-    errorMessage,
-    input,
-    result,
-  })
-}

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

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

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

@@ -1,47 +0,0 @@
-import { DetailedInvalid, Valid, SyncValidatorSystem } from '../../types'
-
-//
-// And operator (serial)
-//
-export function and(
-  validators: SyncValidatorSystem['ValidatorInput'][],
-): SyncValidatorSystem['ValidatorFn'] {
-  return function validateAnd(input, { validateSync }) {
-    const result = validators.reduce(
-      (acc, validator) => (acc !== true ? acc : validateSync(validator, input)),
-      true as Valid | DetailedInvalid,
-    )
-
-    if (result === true) {
-      return true
-    } else {
-      return result
-    }
-  }
-}
-
-//
-// Or operator (serial)
-//
-export function or(
-  validators: SyncValidatorSystem['ValidatorInput'][],
-): SyncValidatorSystem['ValidatorFn'] {
-  return function validateOr(input, { validateSync }) {
-    const someIsValid = validators.some(
-      (validator) => validateSync(validator, input) === true,
-    )
-
-    return someIsValid
-  }
-}
-
-//
-// Not
-//
-export function not(
-  validator: SyncValidatorSystem['ValidatorInput'],
-): SyncValidatorSystem['ValidatorFn'] {
-  return function validateNot(input, { validateSync }) {
-    return validateSync(validator, input) !== true
-  }
-}

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

@@ -1,146 +0,0 @@
-import {
-  DetailedInvalid,
-  SyncValidatorSystem,
-  SyncValidateFn,
-} from '../../types'
-import { typeValidator } from '../../common/validators/type'
-import { getProperty } from 'dot-prop'
-
-function _shapeGeneralValidator({
-  input,
-  baseType,
-  collectNestedErrors,
-  validateSync,
-}: {
-  input: any
-  baseType: 'object' | 'array'
-  collectNestedErrors: () => DetailedInvalid[]
-  validateSync: SyncValidateFn
-}) {
-  const baseTypeValidation = validateSync(
-    typeValidator({
-      type: baseType,
-      required: true,
-    }),
-    input,
-  )
-
-  if (baseTypeValidation !== true) {
-    return baseTypeValidation
-  }
-
-  const nestedErrors = collectNestedErrors()
-
-  return nestedErrors.length === 0
-    ? true
-    : {
-        input,
-        nestedErrors,
-      }
-}
-
-export function obj(objShape: {
-  [key: string]: SyncValidatorSystem['ValidatorInput']
-}): SyncValidatorSystem['ValidatorFn'] {
-  return function validateObject(input, { validateSync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'object',
-      validateSync,
-      collectNestedErrors: () =>
-        Object.entries(objShape).reduce((acc, [path, pathValidator]) => {
-          const pathInput = getProperty(input, path)
-          const pathResult = validateSync(pathValidator, pathInput)
-
-          return pathResult === true
-            ? acc
-            : [
-                ...acc,
-                {
-                  ...pathResult,
-                  path,
-                },
-              ]
-        }, [] as DetailedInvalid[]),
-    })
-  }
-}
-
-export function objOf(
-  ofType: SyncValidatorSystem['ValidatorInput'],
-): SyncValidatorSystem['ValidatorFn'] {
-  return function validateObjOf(input, { validateSync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'object',
-      validateSync,
-      collectNestedErrors: () =>
-        Object.entries(input).reduce((acc, [key, keyInput]) => {
-          const indexResult = validateSync(ofType, keyInput)
-
-          return indexResult === true
-            ? acc
-            : [
-                ...acc,
-                {
-                  ...indexResult,
-                  path: key,
-                },
-              ]
-        }, [] as DetailedInvalid[]),
-    })
-  }
-}
-
-export function tuple(
-  tupleShape: SyncValidatorSystem['ValidatorInput'][],
-): SyncValidatorSystem['ValidatorFn'] {
-  return function validateTuple(input, { validateSync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'array',
-      validateSync,
-      collectNestedErrors: () =>
-        tupleShape.reduce((acc, indexValidator, index) => {
-          const indexInput = input[index]
-          const indexResult = validateSync(indexValidator, indexInput)
-
-          return indexResult === true
-            ? acc
-            : [
-                ...acc,
-                {
-                  ...indexResult,
-                  path: index + '',
-                },
-              ]
-        }, [] as DetailedInvalid[]),
-    })
-  }
-}
-
-export function arrayOf(
-  ofType: SyncValidatorSystem['ValidatorInput'],
-): SyncValidatorSystem['ValidatorFn'] {
-  return function validateArrayOf(input, { validateSync }) {
-    return _shapeGeneralValidator({
-      input,
-      baseType: 'array',
-      validateSync,
-      collectNestedErrors: () =>
-        (input as any[]).reduce((acc, indexInput, index) => {
-          const indexResult = validateSync(ofType, indexInput)
-
-          return indexResult === true
-            ? acc
-            : [
-                ...acc,
-                {
-                  ...indexResult,
-                  path: index + '',
-                },
-              ]
-        }, [] as DetailedInvalid[]),
-    })
-  }
-}

package/src/validate/types/async.ts

@@ -1,20 +0,0 @@
-import {
-  DetailedInvalid,
-  Valid,
-  ValidatorResult,
-  ValidatorSystem,
-} from './common'
-
-export type AsyncValidatorSystem = ValidatorSystem<
-  (
-    input: any,
-    context: {
-      validateAsync: AsyncValidateFn
-    },
-  ) => ValidatorResult | Promise<ValidatorResult>
->
-
-export type AsyncValidateFn = (
-  validatorInput: AsyncValidatorSystem['ValidatorInput'],
-  input: any,
-) => Promise<Valid | DetailedInvalid>

package/src/validate/types/common.ts

@@ -1,70 +0,0 @@
-export type Valid = true
-export type SimpleInvalid = false | undefined | null
-export type ErrorMessageInvalid = string
-export type ErrorInvalid = Error
-export type DetailedInvalid = {
-  input: any
-  message?: string
-  code?: string
-  error?: Error
-  path?: string
-  nestedErrors?: DetailedInvalid[]
-  expectedTypes?: string
-}
-
-export type ValidatorResult =
-  | Valid
-  | SimpleInvalid
-  | ErrorMessageInvalid
-  | ErrorInvalid
-  | DetailedInvalid
-
-//
-// Fucntion that generates an error message
-//
-export type ValidatorErrorMessageFn = (props: DetailedInvalid) => string
-
-export type ValidatorErrorMessageInput = string | ValidatorErrorMessageFn
-
-//
-// Validator Fn that can be used both in Sync and Async
-// versions
-//
-export type CommonValidatorFn = (input: any) => ValidatorResult
-
-type _ValidatorFnInput<ValidatorFn> =
-  | string
-  | {
-      [key: string]:
-        | _ValidatorFnInput<ValidatorFn>
-        | [_ValidatorFnInput<ValidatorFn>, ValidatorErrorMessageInput]
-    }
-  | ValidatorFn
-
-//
-// Generates all required types for validator system
-//
-export type ValidatorSystem<ValidatorFn> = {
-  ValidatorFn: ValidatorFn
-  //
-  // The input for the validator fn
-  //
-  ValidatorFnInput: _ValidatorFnInput<ValidatorFn>
-  //
-  // The final computed validator with:
-  // - function
-  // - error message
-  //
-  Validator: [ValidatorFn, ValidatorErrorMessageFn]
-  //
-  // The validator input, which may be provided in 3 formats:
-  // - string - indicating a shorthand for type validation
-  // - function - indicating a full fledged ValidatorFn without custom error message
-  // - [string, ValidatorErrorMessageInput] - indicating a shorthand validator function for type validation + custom error message
-  // - [function, ValidatorErrorMessageInput] - indicating a full fledged Validator
-  //
-  // prettier-ignore
-  ValidatorInput: 
-    | _ValidatorFnInput<ValidatorFn>
-    | [_ValidatorFnInput<ValidatorFn>, ValidatorErrorMessageInput]
-}

package/src/validate/types/index.ts

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

package/src/validate/types/sync.ts

@@ -1,20 +0,0 @@
-import {
-  DetailedInvalid,
-  Valid,
-  ValidatorResult,
-  ValidatorSystem,
-} from './common'
-
-export type SyncValidatorSystem = ValidatorSystem<
-  (
-    input: any,
-    context: {
-      validateSync: SyncValidateFn
-    },
-  ) => ValidatorResult
->
-
-export type SyncValidateFn = (
-  validatorInput: SyncValidatorSystem['ValidatorInput'],
-  input: any,
-) => Valid | DetailedInvalid

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es5",
-    "lib": ["dom", "esnext"],
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["**/*.spec.ts", "node_modules"]
-}