Caching Added for Presence and Groups (#593)

* Caching experimentation

* moved cache files

* working cache

* first stab at completing the P0 entities

* cleaned up some caching code, started logout-clear work

* cache organizational changes, inital cache clearing system implemented

* added cache options for enabling/disabling and changing invalidation time for cache stores

* got rid of unused class, build should now pass

* added MS header

* default invalidation was accidentally 6 minutes, reverted to expected 60 minutes

* refactor in response to Nikola's PR comments

* Fixed mispelling of 'invalidation'

* made edits in response to Beth's comments

* added group and presence caching

* refactor before PR

* got rid of agenda from cache config since it's not part of this PR

* fixed presence one-by-one fallback, accounted for top & groupTypes params in group caching

* Fixed up presence and groups in response to Nikola's comments

* fix db name

Co-authored-by: Nikola Metulev <[email protected]>
Co-authored-by: Nikola Metulev <[email protected]>

Author: adrien-chaussabel

packages/mgt/src/graph/graph.groups.ts

@@ -7,6 +7,7 @@
 
 import { IGraph } from '@microsoft/mgt-element';
 import { Group } from '@microsoft/microsoft-graph-types';
+import { CacheItem, CacheSchema, CacheService, CacheStore } from '../utils/Cache';
 import { prepScopes } from '../utils/GraphHelpers';
 
 /**
@@ -46,6 +47,42 @@ export enum GroupType {
   distribution = 1 << 3
 }
 
+/**
+ * Definition of cache structure
+ */
+const cacheSchema: CacheSchema = {
+  name: 'groups',
+  stores: {
+    groupsQuery: {}
+  },
+  version: 1
+};
+
+/**
+ * Object to be stored in cache representing individual people
+ */
+interface CacheGroupQuery extends CacheItem {
+  /**
+   * json representing a person stored as string
+   */
+  groups?: string[];
+  /**
+   * top number of results
+   */
+  top?: number;
+}
+
+/**
+ * Defines the expiration time
+ */
+const getGroupsInvalidationTime = (): number =>
+  CacheService.config.groups.invalidationPeriod || CacheService.config.defaultInvalidationPeriod;
+
+/**
+ * Whether the groups store is enabled
+ */
+const groupsCacheEnabled = (): boolean => CacheService.config.groups.isEnabled && CacheService.config.isEnabled;
+
 /**
  * Searches the Graph for Groups
  *
@@ -64,6 +101,21 @@ export async function findGroups(
 ): Promise<Group[]> {
   const scopes = 'Group.Read.All';
 
+  let cache: CacheStore<CacheGroupQuery>;
+  const key = query || '*' + groupTypes;
+
+  if (groupsCacheEnabled()) {
+    cache = CacheService.getCache(cacheSchema, 'groupsQuery');
+    const cacheGroupQuery = await cache.getValue(key);
+    if (cacheGroupQuery && getGroupsInvalidationTime() > Date.now() - cacheGroupQuery.timeCached) {
+      if (cacheGroupQuery.top >= top) {
+        // if request is less than the cache's requests, return a slice of the results
+        return cacheGroupQuery.groups.map(x => JSON.parse(x)).slice(0, top + 1);
+      }
+      // if the new request needs more results than what's presently in the cache, graph must be called again
+    }
+  }
+
   let filterQuery = '';
   if (query !== '') {
     filterQuery = `(startswith(displayName,'${query}') or startswith(mailNickname,'${query}') or startswith(mail,'${query}'))`;
@@ -101,5 +153,10 @@ export async function findGroups(
     .top(top)
     .middlewareOptions(prepScopes(scopes))
     .get();
+
+  if (groupsCacheEnabled() && result) {
+    cache.putValue(key, { groups: result.value.map(x => JSON.stringify(x)), top: top });
+  }
+
   return result ? result.value : null;
 }

packages/mgt/src/graph/graph.presence.ts

@@ -8,9 +8,42 @@
 import { IGraph } from '@microsoft/mgt-element';
 import { Presence } from '@microsoft/microsoft-graph-types-beta';
 import { BetaGraph } from '../BetaGraph';
+import { CacheItem, CacheSchema, CacheService, CacheStore } from '../utils/Cache';
 import { prepScopes } from '../utils/GraphHelpers';
 import { IDynamicPerson } from './types';
 
+/**
+ * Definition of cache structure
+ */
+const cacheSchema: CacheSchema = {
+  name: 'presence',
+  stores: {
+    presence: {}
+  },
+  version: 1
+};
+
+/**
+ * Object to be stored in cache representing individual people
+ */
+interface CachePresence extends CacheItem {
+  /**
+   * json representing a person stored as string
+   */
+  presence?: string;
+}
+
+/**
+ * Defines the expiration time
+ */
+const getPresenceInvalidationTime = (): number =>
+  CacheService.config.presence.invalidationPeriod || CacheService.config.defaultInvalidationPeriod;
+
+/**
+ * Whether the groups store is enabled
+ */
+const presenceCacheEnabled = (): boolean => CacheService.config.presence.isEnabled && CacheService.config.isEnabled;
+
 /**
  * async promise, allows developer to get my presense
  *
@@ -20,11 +53,25 @@ import { IDynamicPerson } from './types';
 export async function getMyPresence(graph: IGraph): Promise<Presence> {
   const betaGraph = BetaGraph.fromGraph(graph);
   const scopes = 'presence.read';
+  let cache: CacheStore<CachePresence>;
+
+  if (presenceCacheEnabled()) {
+    cache = CacheService.getCache(cacheSchema, 'presence');
+    const presence = await cache.getValue('me');
+    if (presence && getPresenceInvalidationTime() > Date.now() - presence.timeCached) {
+      return JSON.parse(presence.presence);
+    }
+  }
+
   const result = await betaGraph
     .api('/me/presence')
     .middlewareOptions(prepScopes(scopes))
     .get();
 
+  if (presenceCacheEnabled()) {
+    cache.putValue('me', { presence: result });
+  }
+
   return result;
 }
 
@@ -37,10 +84,23 @@ export async function getMyPresence(graph: IGraph): Promise<Presence> {
 export async function getUserPresence(graph: IGraph, userId: string): Promise<Presence> {
   const betaGraph = BetaGraph.fromGraph(graph);
   const scopes = ['presence.read', 'presence.read.all'];
+  let cache: CacheStore<CachePresence>;
+
+  if (presenceCacheEnabled()) {
+    cache = CacheService.getCache(cacheSchema, 'presence');
+    const presence = await cache.getValue(userId);
+    if (presence && getPresenceInvalidationTime() > Date.now() - presence.timeCached) {
+      return JSON.parse(presence.presence);
+    }
+  }
+
   const result = await betaGraph
     .api(`/users/${userId}/presence`)
     .middlewareOptions(prepScopes(...scopes))
     .get();
+  if (presenceCacheEnabled()) {
+    cache.putValue(userId, { presence: JSON.stringify(result) });
+  }
 
   return result;
 }
@@ -55,30 +115,65 @@ export async function getUsersPresenceByPeople(graph: IGraph, people?: IDynamicP
   if (!people || people.length === 0) {
     return {};
   }
+
   const betaGraph = BetaGraph.fromGraph(graph);
   const batch = betaGraph.createBatch();
+  const peoplePresence = {};
+  let cache: CacheStore<CachePresence>;
+
+  if (presenceCacheEnabled()) {
+    cache = CacheService.getCache(cacheSchema, 'presence');
+  }
 
   for (const person of people) {
     if (person !== '' && person.id) {
       const id = person.id;
-      batch.get(id, `/users/${id}/presence`, ['presence.read', 'presence.read.all']);
+      peoplePresence[id] = null;
+      let presence: CachePresence;
+      if (presenceCacheEnabled()) {
+        presence = await cache.getValue(id);
+      }
+      if (
+        presenceCacheEnabled() &&
+        presence &&
+        getPresenceInvalidationTime() > Date.now() - (await presence).timeCached
+      ) {
+        peoplePresence[id] = JSON.parse(presence.presence);
+      } else {
+        batch.get(id, `/users/${id}/presence`, ['presence.read', 'presence.read.all']);
+      }
     }
   }
 
   try {
-    const peoplePresence = {};
     const response = await batch.executeAll();
 
     for (const r of response.values()) {
       peoplePresence[r.id] = r.content;
+      if (presenceCacheEnabled()) {
+        cache.putValue(r.id, { presence: JSON.stringify(r.content) });
+      }
     }
 
     return peoplePresence;
   } catch (_) {
     try {
-      const peoplePresence = {};
+      /**
+       * individual calls to getUserPresence as fallback
+       * must filter out the contacts, which will either 404 or have PresenceUnknown response
+       * caching will be handled by getUserPresence
+       */
       const response = await Promise.all(
-        people.filter(person => person && person.id).map(person => getUserPresence(betaGraph, person.id))
+        people
+          .filter(
+            person =>
+              person &&
+              person.id &&
+              !peoplePresence[person.id] &&
+              'personType' in person &&
+              (person as any).personType.subclass === 'OrganizationUser'
+          )
+          .map(person => getUserPresence(betaGraph, person.id))
       );
 
       for (const r of response) {

packages/mgt/src/graph/graph.user.ts

@@ -241,7 +241,6 @@ export async function getUsersForUserIds(graph: IGraph, userIds: string[]): Prom
       notInCache.push(id);
     }
   }
-
   try {
     const responses = await batch.executeAll();
     // iterate over userIds to ensure the order of ids

packages/mgt/src/utils/Cache.ts

@@ -45,19 +45,27 @@ export interface CacheConfig {
    */
   people: CacheOptions;
   /**
-   * Cache options for users store
+   * Cache options for photos store
    *
    * @type {CacheOptions}
    * @memberof CacheConfig
    */
-  users: CacheOptions;
+  photos: CacheOptions;
   /**
-   * Cache options for photos store
+   * Cache options for presence store
    *
    * @type {CacheOptions}
    * @memberof CacheConfig
    */
-  photos: CacheOptions;
+
+  presence: CacheOptions;
+  /**
+   * Cache options for users store
+   *
+   * @type {CacheOptions}
+   * @memberof CacheConfig
+   */
+  users: CacheOptions;
 }
 
 /**
@@ -139,6 +147,10 @@ export class CacheService {
       invalidationPeriod: null,
       isEnabled: true
     },
+    presence: {
+      invalidationPeriod: 300000,
+      isEnabled: true
+    },
     users: {
       invalidationPeriod: null,
       isEnabled: true

samples/examples/cache.html

@@ -2,7 +2,7 @@
 <html lang="en">
   <head>
     <script type="module" src="../../packages/mgt/dist/es6/mock/mgt-mock-provider.js"></script>
-
+    <title>MGT Cache Sample</title>
     <script type="module">
       import { CacheService } from '../../packages/mgt/dist/es6/index.js';
 
@@ -41,18 +41,18 @@
     <mgt-mock-provider></mgt-mock-provider>
 
     <button id="CacheButton" type="button"></button>
-    <!-- <button id="DisableCacheButton" type="button">Disable Cache</button> -->
     <button id="ClearCacheButton" type="button">Clear Cache</button>
 
     <mgt-login></mgt-login>
     <mgt-person person-query="me" view="twoLines" person-card="hover" show-presence></mgt-person>
     <mgt-person user-id="4782e723-f4f4-4af3-a76e-25e3bab0d896" view="twoLines"></mgt-person>
     <mgt-people-picker></mgt-people-picker>
+    <mgt-people-picker type="group"></mgt-people-picker>
     <mgt-people-picker group-id="02bd9fd6-8f93-4758-87c3-1fb73740a315"></mgt-people-picker>
     <mgt-teams-channel-picker></mgt-teams-channel-picker>
     <mgt-tasks data-source="todo"></mgt-tasks>
     <mgt-agenda group-by-day></mgt-agenda>
-    <mgt-people show-presence></mgt-people>
+    <mgt-people show-presence show-max="10"></mgt-people>
     <mgt-people group-id="02bd9fd6-8f93-4758-87c3-1fb73740a315"></mgt-people>
     <mgt-people user-ids="4782e723-f4f4-4af3-a76e-25e3bab0d896, f5289423-7233-4d60-831a-fe107a8551cc"></mgt-people>
   </body>