EntitySearchQuery

Rechercher des entités.

Usage

import { EntitySearchQuery } from 'nr1';

Exemples

Requête déclarative

function render() {
  const filters = [
    {
      type: EntitySearchQuery.FILTER_TYPE.TAG,
      value: { key: 'environment', value: 'production' },
    },
  ];

  return (
    <EntitySearchQuery filters={filters}>
      {({ loading, error, data, fetchMore }) => {
        if (loading) {
          return <Spinner />;
        }

        if (error) {
          return 'Error!';
        }

        return (
          <List
            items={data.entities}
            rowCount={data.count}
            rowHeight={20}
            onLoadMore={fetchMore}
          >
            {({ item }) => <ListItem key={item.guid}>{item.name}</ListItem>}
          </List>
        );
      }}
    </EntitySearchQuery>
  );
}

Récupérer avec des critères de tri

<EntitySearchQuery
  entityDomain="APM"
  sortType={[EntitySearchQuery.SORT_TYPE.ALERT_SEVERITY]}
>
  {({ data, error, fetchMore }) => {
    if (error) {
      return 'Error!';
    }

    return (
      <List
        items={data.entities}
        rowCount={data.count}
        rowHeight={20}
        onLoadMore={fetchMore}
      >
        {({ item }) => <ListItem key={item.guid}>{item.name}</ListItem>}
      </List>
    );
  }}
</EntitySearchQuery>;

Requête impérative

EntitySearchQuery.query({
  filters: [
    {
      type: EntitySearchQuery.FILTER_TYPE.TAG,
      value: { key: 'environment', value: 'production' },
    },
  ],
}).then(({ data }) => console.log(data));

Récupérer plus de résultats à l'aide d'une requête impérative

const filters = [
  {
    type: EntitySearchQuery.FILTER_TYPE.TAG,
    value: { key: 'environment', value: 'production' },
  },
];

const firstPage = await EntitySearchQuery.query({ filters });

console.log('First page data', firstPage.data);

const cursor = firstPage.data.nextCursor;
const secondPage = await EntitySearchQuery.query({ cursor, filters });

console.log('Second page data', secondPage.data);

// NOTE: To fetch multiple page results consecutively, use EntitySearchQuery
// component's fetchMore approach.

Accessoires

children

fonction

Rendre la fonction prop comme un enfant.

function (queryResult: QueryResult Results of the query.
) => React.ReactNode

entityDomain

chaîne

Domaine de l'entité que vous souhaitez interroger.

entityFragmentExtension

objet

Document fragment GraphQL analysé dans un AST par graphql-tag. Les composants de requête renvoient les champs les plus couramment utilisés disponibles sur une entité. Vous pouvez utiliser cet accessoire lorsque vous souhaitez demander des champs supplémentaires pour l'entité renvoyée par votre requête. Le fragment doit être nommé EntityFragmentExtension et s'appliquer au type EntityOutline.

const entityFragmentExtension = ngql`
  fragment EntityFragmentExtension on EntityOutline {
    indexedAt
    guid
  }
`;

entityGuids

string[]

GUID de l'entité à requêter.

entityType

chaîne

Type de l'entité que vous souhaitez interroger.

fetchPolicyType

énum.

Vous permet de spécifier comment vous souhaitez que votre requête interagisse avec les données mises en cache.

CACHE_AND_NETWORK: La requête renvoie vos données initiales du cache si elles sont disponibles. Cependant, que les données complètes soient ou non dans votre cache, la requête effectue toujours une demande à l'aide de votre interface réseau et renvoie les données mises à jour. Cette option n'est pas disponible lors de l'utilisation de la méthode statique query() du composant.
CACHE_FIRST: La requête effectue une demande à l'aide de votre interface réseau uniquement si les données de votre requête ne sont pas déjà dans le cache.
CACHE_ONLY: La requête n'effectue jamais de demande à l'aide de votre interface réseau. Au lieu de cela, il renvoie les données disponibles dans le cache. Si les données de votre requête n'existent pas dans le cache, une erreur est générée.
NETWORK_ONLY: La requête ne renvoie jamais vos données initiales à partir du cache. Au lieu de cela, il fait toujours une demande en utilisant votre interface réseau.
NO_CACHE: La requête ne renvoie jamais vos données initiales à partir du cache. Au lieu de cela, il fait toujours une demande en utilisant votre interface réseau. Contrairement à la politique NETWORK_ONLY, aucune donnée n'est écrite dans le cache une fois la requête terminée.
<One ofEntitySearchQuery.FETCH_POLICY_TYPE.CACHE_AND_NETWORK, EntitySearchQuery.FETCH_POLICY_TYPE.CACHE_FIRST, EntitySearchQuery.FETCH_POLICY_TYPE.CACHE_ONLY, EntitySearchQuery.FETCH_POLICY_TYPE.NETWORK_ONLY, EntitySearchQuery.FETCH_POLICY_TYPE.NO_CACHE, >

filters

chaîne|(forme|forme|forme)[]

Filtres utilisés pour affiner l'entité. Il s'agit d'un éventail de filtres, et il existe 3 filtres possibles :

SearchQueryFilter: : Object<type: string = "searchQuery", value: string>
EntityTypeFilter : Object<type: string = "entityType", Object<domain: string, type: string>>

TagFilter : Object<type: string = "tag", Object<key: string, value: string>>

const filters = [
  {
    type: 'searchQuery',
    value: 'foo',
  },
  {
    type: 'entityType',
    value: { domain: 'APM', type: 'APPLICATION' },
  },
  {
    type: 'tag',
    value: { key: 'environment', value: 'production' },
  },
  {
    type: 'tag',
    value: { key: 'team', value: 'bar' },
  },
];

includeCount

booléen

Si true, la réponse de la requête inclut le nombre total d'entités pour chaque domaine et type.

includeResults

booléen

Si true, la réponse à la requête inclut l'entité.

includeSummaryMetrics

booléen

includeTags

booléen

Si true, l'entité renvoyée inclut sa balise.

limit

nombre

Pagination, nombre d'entités à récupérer sur chaque page.

name

chaîne

Nom ou nom partiel des entités à interroger.

pollInterval

nombre

Intervalle en millisecondes pour interroger de nouvelles données. Réglez à zéro pour éviter tout type d'interrogation régulière.

skip

booléen

Lorsqu'il est défini sur true, la requête sera entièrement ignorée du rendu.

sortBy

OBSOLÈTE

Date limite de soumission : 1er novembre 2023

Le sortBy est obsolète, utilisez plutôt sortType

sortType

énumération[]

Éventail de critères utilisés pour trier les résultats de recherche d'entités.

<Array of<One ofEntitySearchQuery.SORT_TYPE.ALERT_SEVERITY, EntitySearchQuery.SORT_TYPE.DOMAIN, EntitySearchQuery.SORT_TYPE.MOST_RELEVANT, EntitySearchQuery.SORT_TYPE.NAME, EntitySearchQuery.SORT_TYPE.REPORTING, EntitySearchQuery.SORT_TYPE.TYPE,
>
>

Méthodes