@orioro/util 0.0.0 → 0.2.0

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

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

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

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

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

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

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

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

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

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

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

package/src/validate/types/sync.ts

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

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

package/array/index.js

@@ -1,11 +0,0 @@
-const arrayReduceAsync = (arr, fn, initial) => {
-  return arr.reduce((previousPromise, item, index) => {
-    return previousPromise.then(acc => {
-      return Promise.resolve(fn(acc, item, index, arr))
-    })
-  }, Promise.resolve(initial))
-}
-
-module.exports = {
-  arrayReduceAsync
-}

package/coverage/lcov-report/array/index.html

@@ -1,93 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-    <title>Code coverage report for array</title>
-    <meta charset="utf-8" />
-    <link rel="stylesheet" href="../prettify.css" />
-    <link rel="stylesheet" href="../base.css" />
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <style type='text/css'>
-        .coverage-summary .sorter {
-            background-image: url(../sort-arrow-sprite.png);
-        }
-    </style>
-</head>
-<body>
-<div class='wrapper'>
-  <div class='pad1'>
-    <h1>
-      <a href="../index.html">All files</a> array
-    </h1>
-    <div class='clearfix'>
-      <div class='fl pad1y space-right2'>
-        <span class="strong">100% </span>
-        <span class="quiet">Statements</span>
-        <span class='fraction'>5/5</span>
-      </div>
-      <div class='fl pad1y space-right2'>
-        <span class="strong">100% </span>
-        <span class="quiet">Branches</span>
-        <span class='fraction'>0/0</span>
-      </div>
-      <div class='fl pad1y space-right2'>
-        <span class="strong">100% </span>
-        <span class="quiet">Functions</span>
-        <span class='fraction'>3/3</span>
-      </div>
-      <div class='fl pad1y space-right2'>
-        <span class="strong">100% </span>
-        <span class="quiet">Lines</span>
-        <span class='fraction'>5/5</span>
-      </div>
-    </div>
-  </div>
-  <div class='status-line high'></div>
-<div class="pad1">
-<table class="coverage-summary">
-<thead>
-<tr>
-   <th data-col="file" data-fmt="html" data-html="true" class="file">File</th>
-   <th data-col="pic" data-type="number" data-fmt="html" data-html="true" class="pic"></th>
-   <th data-col="statements" data-type="number" data-fmt="pct" class="pct">Statements</th>
-   <th data-col="statements_raw" data-type="number" data-fmt="html" class="abs"></th>
-   <th data-col="branches" data-type="number" data-fmt="pct" class="pct">Branches</th>
-   <th data-col="branches_raw" data-type="number" data-fmt="html" class="abs"></th>
-   <th data-col="functions" data-type="number" data-fmt="pct" class="pct">Functions</th>
-   <th data-col="functions_raw" data-type="number" data-fmt="html" class="abs"></th>
-   <th data-col="lines" data-type="number" data-fmt="pct" class="pct">Lines</th>
-   <th data-col="lines_raw" data-type="number" data-fmt="html" class="abs"></th>
-</tr>
-</thead>
-<tbody><tr>
-	<td class="file high" data-value="index.js"><a href="index.js.html">index.js</a></td>
-	<td data-value="100" class="pic high"><div class="chart"><div class="cover-fill cover-full" style="width: 100%;"></div><div class="cover-empty" style="width:0%;"></div></div></td>
-	<td data-value="100" class="pct high">100%</td>
-	<td data-value="5" class="abs high">5/5</td>
-	<td data-value="100" class="pct high">100%</td>
-	<td data-value="0" class="abs high">0/0</td>
-	<td data-value="100" class="pct high">100%</td>
-	<td data-value="3" class="abs high">3/3</td>
-	<td data-value="100" class="pct high">100%</td>
-	<td data-value="5" class="abs high">5/5</td>
-	</tr>
-
-</tbody>
-</table>
-</div><div class='push'></div><!-- for sticky footer -->
-</div><!-- /wrapper -->
-<div class='footer quiet pad2 space-top1 center small'>
-  Code coverage
-  generated by <a href="https://istanbul.js.org/" target="_blank">istanbul</a> at Thu Jun 13 2019 20:54:46 GMT-0300 (-03)
-</div>
-</div>
-<script src="../prettify.js"></script>
-<script>
-window.onload = function () {
-        if (typeof prettyPrint === 'function') {
-            prettyPrint();
-        }
-};
-</script>
-<script src="../sorter.js"></script>
-</body>
-</html>