utils.ts

import { EffectResult } from './types'

export const doNotProxy = Symbol('doNotProxy')

function isObject(value) {
  return typeof value === 'object' && !Array.isArray(value) && value !== null
}

let hasWarnedConstructor = false

function createProxyGetHandler(
  path: string,
  cb: (effect: EffectResult) => void
): ProxyHandler<any>['get'] {
  return (target, prop) => {
    if (typeof target[prop] === 'function') {
      const func = function(...args) {
        const result = target[prop].apply(this, args)
        if (result instanceof Promise) {
          result.then((promisedResult) => {
            // eslint-disable-next-line standard/no-callback-literal
            cb({
              name: path,
              method: prop,
              args,
              result: promisedResult,
            })
          })
        } else {
          // eslint-disable-next-line standard/no-callback-literal
          cb({
            name: path,
            method: prop,
            args,
            result,
          })
        }
        return result
      }

      return new Proxy(func, {
        construct(_, args) {
          // eslint-disable-next-line
          cb({
            name: path,
            method: prop,
            args,
            result: `[${prop.toString()}]`,
          })

          if (!hasWarnedConstructor) {
            console.warn(
              `EFFECTS - It is highly recommended to create a custom effect, exposing a method that deals with the instantiation of "${path}.${prop.toString()}". It improves readability and debugability of your app`
            )
            hasWarnedConstructor = true
          }

          return new target[prop](...args)
        },
      })
    }
    if (isObject(target[prop])) {
      return new Proxy(target[prop], {
        get: createProxyGetHandler(path + '.' + prop.toString(), cb),
      })
    }
    return target[prop]
  }
}

export function proxifyEffects<Effects>(
  effects: Effects,
  skipKeys: string[] = [],
  cb: (effect: EffectResult) => void
): Effects {
  return Object.keys(effects).reduce(
    (currentEffects, key) => {
      const effect = effects[key]
      if (skipKeys.indexOf(key) === -1 && isObject(effect)) {
        currentEffects[key] = new Proxy(effect, {
          get: createProxyGetHandler(key, cb),
        })
      } else {
        currentEffects[key] = effect
      }
      return currentEffects
    },
    {} as Effects
  )
}