Colocação em cache do Microsoft Graph Toolkit

O Microsoft Graph Toolkit suporta a colocação em cache de chamadas selecionadas do Microsoft API do Graph. As chamadas são colocadas em cache por entidade, como pessoas, contactos, fotografias. Isto permite que um componente obtenha os dados e outros componentes para os reutilizar sem chamar o Microsoft Graph.

As bases de dados criadas pelo Toolkit para colocação em cache têm o prefixo mgt-. Os dados de cada entidade são armazenados num arquivo de objetos separado. Para inspecionar a cache, utilize o separador Aplicação no painel de programador (ferramentas F12). Na secção Armazenamento , selecione o separador IndexedDB .

Configuração da cache

Pode ler e escrever as opções de cache através do objeto de classe CacheService.config estática. O exemplo seguinte 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 da cache individual estão predefinidos no objeto de configuração e são predefinidos null para o valor geral defaultInvalidationPeriod de 3600 000 ms (60 minutos). Qualquer valor transmitido irá config.x.invalidationPeriod substituir defaultInvalidationPeriod.

O arquivo de presença é a única exceção e tem um valor predefinido de 30 0000 ms ou 5 minutos.

Exemplos

Para desativar individualmente um arquivo, basta definir o valor de isEnabled nas propriedades de configuração desse arquivo como falso:

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

CacheService.config.users.isEnabled = false;

Desativar a cache não limpa a cache.

Alterar o período de invalidação é semelhante:

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

CacheService.config.users.invalidationPeriod = 1800000;

Limpar a cache

A cache é automaticamente limpa quando o utilizador termina sessão. Também pode ser limpo manualmente.

Para limpar todos os arquivos na cache para o utilizador com sessão iniciada atualmente, utilize o clearCacheById() método da CacheService classe, fornecendo o ID de cache do utilizador. Para obter o ID de cache do utilizador, 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 os seus próprios arquivos de cache

Se quiser criar e preencher os seus próprios arquivos de cache para os componentes personalizados, utilize a CacheService classe estática.

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

Nota: A storeName referência que fizer na chamada para tem de corresponder a getCache() uma das lojas listadas no 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 seguinte mostra a implementação da 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) });
}