Cache do Microsoft Graph Toolkit

O Microsoft Graph Toolkit dá suporte ao cache de chamadas selecionadas da API do Graph Microsoft. As chamadas são armazenadas em cache por entidade, como pessoas, contato, foto. Isso permite que um componente recupere os dados e outros componentes os reutilizem sem chamar o Microsoft Graph.

Os bancos de dados criados pelo Toolkit para armazenamento em cache são prefixados com mgt-. Os dados de cada entidade são armazenados em um repositório de objetos separado. Para inspecionar o cache, use a guia Aplicativo no painel do desenvolvedor (ferramentas F12). Na seção Armazenamento , escolha a guia IndexedDB .

Configuração de cache

Você pode ler e gravar as opções de cache por meio do objeto de classe CacheService.config estático. O exemplo a seguir mostra o formato.

let config = {
  defaultInvalidationPeriod: number,
  isEnabled: boolean,
  people: {
    invalidationPeriod: number,
    isEnabled: boolean
  },
  photos: {
    invalidationPeriod: number,
    isEnabled: boolean
  },
  users: {
    invalidationPeriod: number,
    isEnabled: boolean
  },
  presence: {
    invalidationPeriod: number,
    isEnabled: boolean
  },
  groups: {
    invalidationPeriod: number,
    isEnabled: boolean
  },
  response: {
    invalidationPeriod: number,
    isEnabled: boolean
  },
  files: {
    invalidationPeriod: number,
    isEnabled: boolean
  },
  fileLists: {
    invalidationPeriod: number,
    isEnabled: boolean
  }
};

Os períodos de invalidação de cache individuais são padronizados para null no objeto de configuração e o padrão para o valor geral defaultInvalidationPeriod de 3.600.000 ms (60 minutos). Qualquer valor passado substituirá defaultInvalidationPeriod.config.x.invalidationPeriod

O repositório de presença é a única exceção e tem um valor padrão de 300000 ms ou 5 minutos.

Exemplos

Para desabilitar individualmente um repositório, basta definir o valor de isEnabled nas propriedades de configuração desse repositório como false:

import { CacheService } from '@microsoft/mgt-element';

CacheService.config.users.isEnabled = false;

Desabilitar o cache não limpa o cache.

A alteração do período de invalidação é semelhante:

import { CacheService } from '@microsoft/mgt';

CacheService.config.users.invalidationPeriod = 1800000;

Limpando o cache

O cache é limpo automaticamente quando o usuário sai. Também pode ser limpo manualmente.

Para limpar todos os armazenamentos no cache do usuário conectado no momento, use o clearCacheById() método da CacheService classe, fornecendo a ID de cache do usuário. Para recuperar a ID de cache do usuário, chame o getCacheId método da Providers classe.

import { Providers } from '@microsoft/mgt';
import { CacheService } from '@microsoft/mgt-element';

const cacheId = await Providers.getCacheId();
await CacheService.clearCacheById(cacheId);

Criar seus próprios armazenamentos de cache

Se você quiser criar e preencher seus próprios armazenamentos de cache para seus componentes personalizados, use a CacheService classe estática.

CacheService.getCache(schema: CacheSchema, storeName: String);

Observação: A storeName referência que você faz na chamada para getCache() deve corresponder a uma das lojas listadas em seu CacheSchema objeto.

O CacheSchema objeto é um dicionário com os pares chave/valor.

import { CacheSchema } from '@microsoft/mgt-element';
const cacheSchema: CacheSchema = {
  name: string,
  stores: {
    store1: {},
    store2: {},
    ...
  },
  version: number
};

O exemplo a seguir mostra a implementação do cache.

import { CacheItem, CacheSchema, CacheService, CacheStore } from '@microsoft/mgt-element';

const cacheSchema: CacheSchema = {
  name: 'users',
  stores: {
    users: {},
    usersQuery: {}
  },
  version: 1
};

interface CacheUser extends CacheItem {
  user?: string;
}

// retrieves invalidation time from cache config
const getUserInvalidationTime = (): number =>
  CacheService.config.users.invalidationPeriod || CacheService.config.defaultInvalidationPeriod;

// checks for if cache is enabled
const usersCacheEnabled = (): boolean => CacheService.config.users.isEnabled && CacheService.config.isEnabled;

// declare the desired cache store
let cache: CacheStore<CacheUser>

// check if the cache is enabled
if (usersCacheEnabled()) {
  cache = CacheService.getCache<CacheUser>(cacheSchema, 'users');
  const user = await cache.getValue(query);

  // check if an item is retrieved, and if it's not expired
  if (user && getUserInvalidationTime() > Date.now() - user.timeCached) {
    return JSON.parse(user.user);
  }
}

// graph call
const graphRes = graph
  .api('me')
  .middlewareOptions(prepScopes('user.read'))
  .get();

// store graph result into the cache if cache is enabled
if (usersCacheEnabled()) {
  cache.putValue(userId, { user: JSON.stringify(graphRes) });
}