_fetchDataValues ({ data, specOptions }) {
    return Promise.all(data.map(async dataItem => {
      const { name, property = null, key, path, ...keyOptions } = dataItem

      let response = {}
      let plainOrObjValue

      // Supporting fetching by key or by path
      // If 'path' is not defined, we can assume 'key' will exist due to CRD validation
      let singleParameterKey = true
      if (path) { singleParameterKey = false }

      if (singleParameterKey) {
        // Single secret
        plainOrObjValue = await this._get({ key, keyOptions, specOptions })
      } else {
        // All secrets inside the specified path
        plainOrObjValue = await this._getByPath({ path, keyOptions, specOptions })
      }

      const shouldParseValue = 'property' in dataItem
      const isBinary = 'isBinary' in dataItem && dataItem.isBinary === true

      let value = plainOrObjValue
      if (shouldParseValue) {
        let parsedValue
        try {
          parsedValue = JSON.parse(value)
        } catch (err) {
          this._logger.warn(`Failed to JSON.parse value for '${key}',` +
            ' please verify that your secret value is correctly formatted as JSON.' +
            ` To use plain text secret remove the 'property: ${property}'`)
          return
        }

        if (!(hasIn(parsedValue, property))) {
          throw new Error(`Could not find property ${property} in ${key}`)
        }

        value = get(parsedValue, property)
      }

      if (isBinary) {
        // value in the backend is binary data which is already encoded in base64.
        if (typeof value === 'string') {
          // Skip this step if the value from the backend is not a string (e.g., AWS
          // SecretsManager will already return a `Buffer` with base64 encoding if the
          // secret contains `SecretBinary` instead of `SecretString`).
          value = Buffer.from(value, 'base64')
        }
      }

      if (singleParameterKey) {
        // Not path, return as is
        response = { [name]: value }
      } else {
        // Returning dict with path keys and values
        for (const records in value) {
          response[records] = value[records]
        }
      }

      return response
    }))
  }
Fetch Kubernetes secret property values.
@param {Object[]} data - Kubernetes secret properties.
@param {string} data[].key - Secret key in the backend.
@param {string} data[].name - Kubernetes Secret property name.
@param {string} data[].path - Kubernetes Secret path to fetch keys from.
@param {string} data[].property - If the backend secret is an
  object, this is the property name of the value to use.
@param {string} data[].isBinary - If the backend secret shall be treated
  as binary data represented by a base64-encoded string. Defaults to false.
@param {Object} specOptions - Options set on spec level.
@returns {Promise} Promise object representing secret property values.