@orioro/util 0.0.0 → 0.2.0

package/src/promise/resolveNestedPromises.spec.ts

@@ -0,0 +1,205 @@
+import { deepFreeze, wait } from '../debug'
+import { resolveNestedPromises } from './resolveNestedPromises'
+
+async function asyncDo(delay, fn) {
+  await wait(delay)
+
+  const result = fn()
+  // console.log('asyncDo', result)
+
+  return result
+}
+
+describe('resolveNestedPromises', () => {
+  test('basic', async () => {
+    const obj = {
+      a: asyncDo(100, () => 'A'),
+      b: asyncDo(300, () => 'B'),
+      c: asyncDo(200, () => ({
+        c: 'C',
+        d: asyncDo(200, () => 'D'),
+        e: {
+          f: {
+            g: asyncDo(200, () => 'G'),
+          },
+        },
+      })),
+    }
+
+    const startTime = performance.now()
+    const resolved = await resolveNestedPromises(obj)
+    const endTime = performance.now()
+
+    expect(resolved).toEqual({
+      a: 'A',
+      b: 'B',
+      c: {
+        c: 'C',
+        d: 'D',
+        e: {
+          f: {
+            g: 'G',
+          },
+        },
+      },
+    })
+    const executionTime = endTime - startTime
+
+    //
+    // Parallel promise resolution
+    //
+    expect(executionTime).toBeGreaterThan(400)
+    expect(executionTime).toBeLessThan(450)
+  })
+
+  test('deep nesting', async () => {
+    const obj = {
+      a: asyncDo(100, () => ({
+        a1: asyncDo(100, () => ({
+          a2: asyncDo(100, () => ({
+            a3: asyncDo(100, () => ({
+              a4: asyncDo(100, () => ({
+                a5: asyncDo(100, () => ({
+                  a6: asyncDo(100, () => ({
+                    a7: asyncDo(100, () => ({
+                      a8: 'a8',
+                    })),
+                  })),
+                })),
+              })),
+            })),
+          })),
+        })),
+      })),
+      b: asyncDo(200, () => ({
+        c: 'C',
+        d: asyncDo(200, () => 'D'),
+        e: {
+          f: {
+            g: asyncDo(200, () => 'G'),
+          },
+        },
+      })),
+    }
+
+    const startTime = performance.now()
+    const resolved = await resolveNestedPromises(obj)
+    const endTime = performance.now()
+
+    expect(resolved).toEqual({
+      a: { a1: { a2: { a3: { a4: { a5: { a6: { a7: { a8: 'a8' } } } } } } } },
+      b: { c: 'C', d: 'D', e: { f: { g: 'G' } } },
+    })
+    const executionTime = endTime - startTime
+
+    //
+    // Parallel promise resolution
+    //
+    expect(executionTime).toBeGreaterThan(800)
+    expect(executionTime).toBeLessThan(850)
+  })
+
+  test('immutability', async () => {
+    const obj = deepFreeze({
+      a: asyncDo(100, () => 'A'),
+      b: asyncDo(100, () => 'B'),
+      c: asyncDo(200, () => ({
+        c: 'C',
+        d: asyncDo(200, () => 'D'),
+        e: {
+          f: {
+            g: asyncDo(200, () => 'G'),
+          },
+        },
+      })),
+    })
+
+    expect(await resolveNestedPromises(obj)).toEqual({
+      a: 'A',
+      b: 'B',
+      c: {
+        c: 'C',
+        d: 'D',
+        e: {
+          f: {
+            g: 'G',
+          },
+        },
+      },
+    })
+  })
+
+  test('maxDepth', async () => {
+    const obj = {
+      a: asyncDo(100, () => 'A'),
+      b: asyncDo(300, () => 'B'),
+      c: asyncDo(200, () => ({
+        c: 'C',
+        d: asyncDo(200, () => 'D'),
+        e: {
+          f: {
+            g: asyncDo(200, () => 'G'),
+          },
+        },
+      })),
+    }
+
+    expect(
+      await resolveNestedPromises(obj, {
+        maxDepth: 4,
+      }),
+    ).toEqual({
+      a: 'A',
+      b: 'B',
+      c: {
+        c: 'C',
+        d: 'D',
+        e: {
+          f: {
+            g: 'G',
+          },
+        },
+      },
+    })
+
+    await expect(() =>
+      resolveNestedPromises(obj, {
+        maxDepth: 3,
+      }),
+    ).rejects.toThrow('Max depth exceeded: { depth: 4, maxDepth: 3 }')
+  })
+
+  test('lazy mode', async () => {
+    const obj = {
+      a: asyncDo(100, () => 'A'),
+      b: asyncDo(300, () => 'B'),
+      c: asyncDo(200, () => ({
+        c: 'C',
+        d: asyncDo(200, () => 'D'),
+        e: {
+          f: {
+            g: asyncDo(200, () => 'G'),
+          },
+        },
+      })),
+    }
+
+    expect(
+      await resolveNestedPromises(obj, {
+        mode: 'lazy',
+      }),
+    ).toEqual({
+      a: 'A',
+      b: 'B',
+      c: {
+        c: 'C',
+        d: expect.any(Promise),
+        e: {
+          f: {
+            g: expect.any(Promise),
+          },
+        },
+      },
+    })
+  })
+})

package/src/promise/resolveNestedPromises.ts

@@ -0,0 +1,83 @@
+import traverse from 'traverse'
+import copy from 'fast-copy'
+import { AnyArray, AnyObject } from './types'
+
+type ResolveCtx = {
+  root: AnyArray | AnyObject
+  depth: number
+}
+
+type ResolveOptions = {
+  mode: 'eager' | 'lazy'
+  maxDepth: number
+  clone: false | (<T = { [key: string]: any } | any[]>(obj: T) => T)
+}
+
+const DEFAULT_OPTIONS: ResolveOptions = {
+  mode: 'eager',
+  maxDepth: 30,
+  clone: copy,
+}
+
+function _echo<T = any>(input: T): T {
+  return input
+}
+
+export async function resolveNestedPromises(
+  node: AnyArray | AnyObject,
+  options: Partial<ResolveOptions> = {},
+  ctx: ResolveCtx = { root: node, depth: 0 },
+): Promise<AnyArray | AnyObject> {
+  const opts: ResolveOptions = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+  }
+  let promises: Promise<void>[] = []
+
+  //
+  // Allow consumers to provide a clone function.
+  // There are multiple nuances regarding cloning. Here are some
+  // we've faced:
+  // - clone-deep (https://www.npmjs.com/package/clone-deep) does
+  //   creates new versions of symbols
+  // - fast-copy (default export) does not clone array custom properties
+  //   (but allows for creating a copier function that does)
+  //
+  // It would be incorrect to use copyStrict (from fast-copy) by default, thus
+  // we allow consumers to provide their copy functions
+  //
+  // If opts.clone is set to false, use the _echo function
+  //
+  const _cloneFn = opts.clone || _echo
+  const clonedNode = _cloneFn(node)
+
+  const resolved = traverse(clonedNode).forEach(function (value) {
+    const depth = ctx.depth + this.path.length
+
+    if (depth > opts.maxDepth) {
+      throw new Error(
+        `Max depth exceeded: { depth: ${depth}, maxDepth: ${opts.maxDepth} }`,
+      )
+    }
+
+    if (value instanceof Promise) {
+      const updatePromise = value.then(async (resolvedValue) => {
+        // Arrow function;
+        // this refers to outside this ctx
+        this.update(
+          opts.mode === 'eager'
+            ? await resolveNestedPromises(resolvedValue, opts, {
+                ...ctx,
+                // pass the base depth of the current value
+                depth,
+              })
+            : resolvedValue,
+        )
+      })
+
+      promises = [...promises, updatePromise]
+    }
+  })
+
+  return Promise.all(promises).then(() => resolved)
+}

package/src/promise/types.ts

@@ -0,0 +1,2 @@
+export type AnyArray = unknown[]
+export type AnyObject = Record<string, unknown>

package/src/resolvePaths/index.spec.ts

@@ -0,0 +1,42 @@
+import { resolvePaths } from './'
+
+describe('resolvePaths', () => {
+  test('basic', () => {
+    const SOURCE = {
+      username: 'joaosilva',
+      email: 'joao@example.com',
+      profile: {
+        givenName: 'João Silva',
+        picture: {
+          url: 'https://example.com/image.png',
+          size: {
+            width: 100,
+            height: 200,
+          },
+        },
+      },
+    }
+
+    expect(
+      resolvePaths(SOURCE, [
+        'username',
+        ['primaryEmail', 'email'],
+        ['profilePicture.url', 'profile.picture.url'],
+        ['profilePicture.width', 'profile.picture.size.width'],
+        ['profilePicture.height', 'profile.picture.size.height'],
+        [
+          'profilePicture.fileType',
+          (obj) => obj.picture?.mimeType || 'application/octet-stream',
+        ],
+      ]),
+    ).toEqual({
+      username: SOURCE.username,
+      primaryEmail: SOURCE.email,
+      profilePicture: {
+        url: SOURCE.profile.picture.url,
+        ...SOURCE.profile.picture.size,
+        fileType: 'application/octet-stream',
+      },
+    })
+  })
+})

package/src/resolvePaths/index.ts

@@ -0,0 +1,21 @@
+import { getProperty, setProperty } from 'dot-prop'
+
+type Resolver = string | ((sourceObj: Record<string, any>) => any)
+
+type PathSpec = string | [string, Resolver]
+
+export function resolvePaths(
+  sourceObj: Record<string, any>,
+  paths: PathSpec[],
+): Record<string, any> {
+  return paths.reduce((acc, path) => {
+    const [targetPath, resolver] = Array.isArray(path) ? path : [path, path]
+
+    const value =
+      typeof resolver === 'string'
+        ? getProperty(sourceObj, resolver)
+        : resolver(sourceObj)
+
+    return setProperty(acc, targetPath, value)
+  }, {})
+}

package/src/switchValue.spec.ts

@@ -0,0 +1,30 @@
+import { switchValue } from './switchValue'
+
+describe('switchValue', () => {
+  test('basic', () => {
+    const cases = {
+      string: 'String value',
+      number: 'Number value',
+      regexp: 'RegExp value',
+    }
+
+    expect(switchValue(typeof 'string input', cases)).toEqual('String value')
+    expect(switchValue(typeof 8, cases)).toEqual('Number value')
+  })
+
+  test('function criteria', () => {
+    const cases = [
+      [
+        (input) => typeof input === 'string' || typeof input === 'number',
+        'Number or String',
+      ],
+      [(input) => Array.isArray(input), 'Array value'],
+      ['Default value']
+    ]
+
+    expect(switchValue('str', cases)).toEqual('Number or String')
+    expect(switchValue(8, cases)).toEqual('Number or String')
+    expect(switchValue([], cases)).toEqual('Array value')
+    expect(switchValue({}, cases)).toEqual('Default value')
+  })
+})

package/src/switchValue.ts

@@ -0,0 +1,59 @@
+type Criteria = string | symbol | RegExp | ((input: any) => boolean)
+
+type ObjectSwitchCases<ValueType = any> = {
+  [key: string | symbol]: ValueType
+}
+
+type TupleSwitchCases<ValueType = any> = ([Criteria, ValueType] | [ValueType])[]
+
+export type SwitchCases<ValueType = any> =
+  | ObjectSwitchCases<ValueType>
+  | TupleSwitchCases<ValueType>
+
+function testCriteria(criteria: Criteria, input: any) {
+  switch (typeof criteria) {
+    case 'function': {
+      return criteria(input)
+    }
+    case 'object': {
+      if (criteria instanceof RegExp) {
+        return criteria.test(input)
+      } else {
+        throw new Error('Unsupported criteria')
+      }
+    }
+    case 'string':
+    case 'symbol': {
+      return criteria === input
+    }
+  }
+}
+
+export function switchValue<ValueType = any>(
+  input: any,
+  cases: SwitchCases,
+): ValueType | undefined {
+  if (Array.isArray(cases)) {
+    const matching = cases.find((case_) => {
+      return case_.length === 1 || testCriteria(case_[0], input)
+    })
+
+    return matching
+      ? matching.length === 1
+        ? matching[0]
+        : matching[1]
+      : undefined
+  } else {
+    return cases[input] || cases.default
+  }
+}
+
+export function switchExec<ArgsType extends any[] = any[]>(
+  input: any,
+  cases: SwitchCases<(...args: any[]) => any>,
+  ...args: ArgsType
+) {
+  const fn = switchValue(input, cases)
+
+  return fn(...args)
+}

package/src/typeOf.spec.ts

@@ -0,0 +1,47 @@
+import { typeOf } from './typeOf'
+
+describe('test', () => {
+  test('basic', () => {
+    expect(typeOf({})).toEqual('object')
+    expect(typeOf(null)).toEqual('null')
+    expect(typeOf(undefined)).toEqual('undefined')
+    expect(typeOf(true)).toEqual('boolean')
+    expect(typeOf(1n)).toEqual('bigint')
+    expect(typeOf(Symbol())).toEqual('symbol')
+    expect(typeOf(() => {})).toEqual('function')
+    expect(typeOf('string')).toEqual('string')
+    expect(typeOf(6)).toEqual('number')
+    expect(typeOf(parseInt('('))).toEqual('nan')
+    expect(typeOf([6, 'str'])).toEqual('array')
+    expect(typeOf(new Error('Error message'))).toEqual('error')
+    expect(typeOf(new RegExp('^Hello'))).toEqual('regexp')
+    expect(typeOf(new Date())).toEqual('date')
+    expect(typeOf(new Map())).toEqual('map')
+    expect(typeOf(new WeakMap())).toEqual('weakmap')
+    expect(typeOf(new Set())).toEqual('set')
+    expect(typeOf(new WeakSet())).toEqual('weakset')
+    expect(typeOf(new Promise(() => {}))).toEqual('promise')
+  })
+
+  test('custom error', () => {
+    class ValidationError extends Error {
+      constructor(message) {
+        super(message) // (1)
+        this.name = 'ValidationError' // (2)
+      }
+    }
+
+    expect(typeOf(new ValidationError('Some error'))).toEqual('error')
+  })
+
+  test('unknown constructor', () => {
+    class Custom {
+      a: string
+      constructor(a) {
+        this.a = a
+      }
+    }
+
+    expect(typeOf(new Custom('a'))).toEqual(null)
+  })
+})

package/src/typeOf.ts

@@ -0,0 +1,81 @@
+import { isPlainObject } from 'is-plain-object'
+
+export type TypeTest = (value: any) => boolean
+
+type TypeMap = Record<string, TypeTest>
+
+//
+// The only role of this function is to let typescript
+// be aware of the available types
+//
+export function typeMap<T extends TypeMap>(typeMap: T) {
+  return typeMap
+}
+
+export function makeTypeOf<T extends TypeMap>(typeMap: T) {
+  return function typeOf(value: any): keyof T | null {
+    for (const typeName in typeMap) {
+      if (typeMap[typeName](value)) {
+        return typeName
+      }
+    }
+    return null
+  }
+}
+
+function basicType(typeName: string) {
+  return (value: any) => typeof value === typeName
+}
+
+const DEFAULT_TYPES = typeMap({
+  //
+  // Primitives
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#primitive_values
+  //
+  null: (value) => value === null,
+  undefined: basicType('undefined'),
+  boolean: basicType('boolean'),
+
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
+  number: (value) => typeof value === 'number' && !Number.isNaN(value),
+  bigint: basicType('bigint'),
+  string: basicType('string'),
+  symbol: basicType('symbol'),
+  function: basicType('function'),
+
+  object: isPlainObject,
+  array: (value) => Array.isArray(value),
+
+  regexp: (value) => value instanceof RegExp,
+  nan: (value) => Number.isNaN(value),
+  date: (value) => value instanceof Date,
+  map: (value) => value instanceof Map,
+  weakmap: (value) => value instanceof WeakMap,
+  set: (value) => value instanceof Set,
+  weakset: (value) => value instanceof WeakSet,
+  promise: (value) => value instanceof Promise,
+  error: (value) => value instanceof Error,
+})
+
+export type DEFAULT_TYPE_NAMES =
+  | 'null'
+  | 'undefined'
+  | 'boolean'
+  | 'number'
+  | 'bigint'
+  | 'string'
+  | 'symbol'
+  | 'function'
+  | 'object'
+  | 'array'
+  | 'regexp'
+  | 'nan'
+  | 'date'
+  | 'map'
+  | 'weakmap'
+  | 'set'
+  | 'weakset'
+  | 'promise'
+  | 'error'
+
+export const typeOf = makeTypeOf(DEFAULT_TYPES)

package/src/validate/__snapshots__/index.spec.ts.snap

@@ -0,0 +1,9 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`validateAPI 1`] = `
+[
+  "validate",
+  "validateAsync",
+  "ValidationError",
+]
+`;