graphql-data-hook.js

import { useMemo } from 'react'
import pipe from 'lodash/fp/pipe'
import omit from 'lodash/fp/omit'
import concat from 'lodash/concat'
import getOr from 'lodash/fp/getOr'
import isEqual from 'lodash/isEqual'
import filter from 'lodash/fp/filter'
import isObject from 'lodash/fp/isObject'
import { gql, useQuery } from '@apollo/client'
import { flattenSecurities, flattenSecurity } from '../../lib/data'
import { fullSecurityFields } from '../../lib/graphql/templates/fragments'

/**
 * ====================
 * Constants
 * ====================
 */
export const INCLUDE_TYPES = {
  INDUSTRY: 'IEXIndustry',
  PEERS: 'peers',
  SECTOR: 'IEXSector',
}

const template = gql`
  query Security(
    $input: SecurityInput!
    $includeIEXIndustry: Boolean!
    $includeIEXSector: Boolean!
    $includePeers: Boolean!
  ) {
    security(input: $input) {
      ...fullSecurityFields
      IEXIndustry @include(if: $includeIEXIndustry) {
        id
        label
        name
        securities {
          ...fullSecurityFields
        }
      }
      IEXSector @include(if: $includeIEXSector) {
        id
        label
        name
        securities {
          ...fullSecurityFields
        }
      }
      peers @include(if: $includePeers) {
        ...fullSecurityFields
      }
    }
  }

  ${fullSecurityFields}
`

/**
 * ====================
 * Utils
 * ====================
 */
const onlyObjects = filter(isObject)

const extractIEXTag = (include) =>
  pipe(getOr({}, `security.${include}`), ({ securities = [], ...rest }) => ({
    ...rest,
    securities: flattenSecurities(onlyObjects(securities)),
  }))

const extractSecurity = pipe(
  getOr({}, 'security'),
  omit(['IEXIndustry', 'IEXSector', 'peers']),
  flattenSecurity
)

const extractPeers = pipe(
  getOr({}, 'security'),
  getOr([], 'peers'),
  flattenSecurities
)

const useCompareSecurities = ({ include, skip, symbol }) => {
  /**
   * Makes request
   */
  const { data, error, loading, refetch } = useQuery(template, {
    fetchPolicy: 'cache-first',
    pollInterval: 60000,
    skip: skip || !symbol,
    variables: {
      input: { symbol },
      includeIEXIndustry: isEqual(include, INCLUDE_TYPES.INDUSTRY),
      includeIEXSector: isEqual(include, INCLUDE_TYPES.SECTOR),
      includePeers: isEqual(include, INCLUDE_TYPES.PEERS),
    },
  })

  const security = useMemo(() => extractSecurity(data), [data])
  const IEXTag = useMemo(() => extractIEXTag(include)(data), [data])
  const peers = useMemo(() => concat(security, extractPeers(data)), [
    data,
    security,
  ])

  return {
    error,
    IEXTag,
    loading,
    peers,
    refetch,
    security,
  }
}

export default useCompareSecurities