Lazy load collection offer (#234)

src/Common/DataAccessUtilityBase.ts

@@ -184,86 +184,6 @@ export function deleteConflict(
   );
 }
 
-export function readCollectionQuotaInfo(
-  collection: ViewModels.Collection,
-  options: any
-): Q.Promise<DataModels.CollectionQuotaInfo> {
-  options = options || {};
-  options.populateQuotaInfo = true;
-  options.initialHeaders = options.initialHeaders || {};
-  options.initialHeaders[Constants.HttpHeaders.populatePartitionStatistics] = true;
-
-  return Q(
-    client()
-      .database(collection.databaseId)
-      .container(collection.id())
-      .read(options)
-      // TODO any needed because SDK does not properly type response.resource.statistics
-      .then((response: any) => {
-        let quota: DataModels.CollectionQuotaInfo = HeadersUtility.getQuota(response.headers);
-        quota["usageSizeInKB"] = response.resource.statistics.reduce(
-          (
-            previousValue: number,
-            currentValue: DataModels.Statistic,
-            currentIndex: number,
-            array: DataModels.Statistic[]
-          ) => {
-            return previousValue + currentValue.sizeInKB;
-          },
-          0
-        );
-        quota["numPartitions"] = response.resource.statistics.length;
-        quota["uniqueKeyPolicy"] = collection.uniqueKeyPolicy; // TODO: Remove after refactoring (#119617)
-        return quota;
-      })
-  );
-}
-
-export function readOffers(options: any): Q.Promise<DataModels.Offer[]> {
-  if (options.isServerless) {
-    return Q([]); // Reading offers is not supported for serverless accounts
-  }
-
-  try {
-    if (configContext.platform === Platform.Portal) {
-      return sendCachedDataMessage<DataModels.Offer[]>(MessageTypes.AllOffers, [
-        (<any>window).dataExplorer.databaseAccount().id,
-        Constants.ClientDefaults.portalCacheTimeoutMs
-      ]);
-    }
-  } catch (error) {
-    // If error getting cached Offers, continue on and read via SDK
-  }
-  return Q(
-    client()
-      .offers.readAll()
-      .fetchAll()
-      .then(response => response.resources)
-      .catch(error => {
-        // This should be removed when we can correctly identify if an account is serverless when connected using connection string too.
-        if (error.message.includes("Reading or replacing offers is not supported for serverless accounts")) {
-          return [];
-        }
-        throw error;
-      })
-  );
-}
-
-export function readOffer(requestedResource: DataModels.Offer, options: any): Q.Promise<DataModels.OfferWithHeaders> {
-  options = options || {};
-  options.initialHeaders = options.initialHeaders || {};
-  if (!OfferUtils.isOfferV1(requestedResource)) {
-    options.initialHeaders[Constants.HttpHeaders.populateCollectionThroughputInfo] = true;
-  }
-
-  return Q(
-    client()
-      .offer(requestedResource.id)
-      .read(options)
-      .then(response => ({ ...response.resource, headers: response.headers }))
-  );
-}
-
 export function refreshCachedOffers(): Q.Promise<void> {
   if (configContext.platform === Platform.Portal) {
     return sendCachedDataMessage(MessageTypes.RefreshOffers, []);

src/Common/DocumentClientUtilityBase.ts

@@ -277,78 +277,3 @@ export function refreshCachedResources(options: any = {}): Q.Promise<void> {
 export function refreshCachedOffers(): Q.Promise<void> {
   return DataAccessUtilityBase.refreshCachedOffers();
 }
-
-export function readCollectionQuotaInfo(
-  collection: ViewModels.Collection,
-  options?: any
-): Q.Promise<DataModels.CollectionQuotaInfo> {
-  var deferred = Q.defer<DataModels.CollectionQuotaInfo>();
-
-  const clearMessage = logConsoleProgress(`Querying quota info for container ${collection.id}`);
-  DataAccessUtilityBase.readCollectionQuotaInfo(collection, options)
-    .then(
-      (quota: DataModels.CollectionQuotaInfo) => {
-        deferred.resolve(quota);
-      },
-      (error: any) => {
-        logConsoleError(`Error while querying quota info for container ${collection.id}:\n ${JSON.stringify(error)}`);
-        Logger.logError(JSON.stringify(error), "ReadCollectionQuotaInfo", error.code);
-        sendNotificationForError(error);
-        deferred.reject(error);
-      }
-    )
-    .finally(() => {
-      clearMessage();
-    });
-
-  return deferred.promise;
-}
-
-export function readOffers(options: any = {}): Q.Promise<DataModels.Offer[]> {
-  var deferred = Q.defer<DataModels.Offer[]>();
-
-  const clearMessage = logConsoleProgress("Querying offers");
-  DataAccessUtilityBase.readOffers(options)
-    .then(
-      (offers: DataModels.Offer[]) => {
-        deferred.resolve(offers);
-      },
-      (error: any) => {
-        logConsoleError(`Error while querying offers:\n ${JSON.stringify(error)}`);
-        Logger.logError(JSON.stringify(error), "ReadOffers", error.code);
-        sendNotificationForError(error);
-        deferred.reject(error);
-      }
-    )
-    .finally(() => {
-      clearMessage();
-    });
-
-  return deferred.promise;
-}
-
-export function readOffer(
-  requestedResource: DataModels.Offer,
-  options: any = {}
-): Q.Promise<DataModels.OfferWithHeaders> {
-  var deferred = Q.defer<DataModels.OfferWithHeaders>();
-
-  const clearMessage = logConsoleProgress("Querying offer");
-  DataAccessUtilityBase.readOffer(requestedResource, options)
-    .then(
-      (offer: DataModels.OfferWithHeaders) => {
-        deferred.resolve(offer);
-      },
-      (error: any) => {
-        logConsoleError(`Error while querying offer:\n ${JSON.stringify(error)}`);
-        Logger.logError(JSON.stringify(error), "ReadOffer", error.code);
-        sendNotificationForError(error);
-        deferred.reject(error);
-      }
-    )
-    .finally(() => {
-      clearMessage();
-    });
-
-  return deferred.promise;
-}

src/Common/dataAccess/readCollectionOffer.ts

@@ -0,0 +1,126 @@
+import * as DataModels from "../../Contracts/DataModels";
+import { AuthType } from "../../AuthType";
+import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
+import { HttpHeaders } from "../Constants";
+import { RequestOptions } from "@azure/cosmos/dist-esm";
+import { client } from "../CosmosClient";
+import { getSqlContainerThroughput } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
+import { getMongoDBCollectionThroughput } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
+import { getCassandraTableThroughput } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
+import { getGremlinGraphThroughput } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
+import { getTableThroughput } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
+import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
+import { logError } from "../Logger";
+import { readOffers } from "./readOffers";
+import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
+
+export const readCollectionOffer = async (
+  params: DataModels.ReadCollectionOfferParams
+): Promise<DataModels.OfferWithHeaders> => {
+  const clearMessage = logConsoleProgress(`Querying offer for collection ${params.collectionId}`);
+  let offerId = params.offerId;
+  if (!offerId) {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      try {
+        offerId = await getCollectionOfferIdWithARM(params.databaseId, params.collectionId);
+      } catch (error) {
+        clearMessage();
+        if (error.code !== "NotFound") {
+          throw error;
+        }
+        return undefined;
+      }
+    } else {
+      offerId = await getCollectionOfferIdWithSDK(params.collectionResourceId);
+      if (!offerId) {
+        clearMessage();
+        return undefined;
+      }
+    }
+  }
+
+  const options: RequestOptions = {
+    initialHeaders: {
+      [HttpHeaders.populateCollectionThroughputInfo]: true
+    }
+  };
+
+  try {
+    const response = await client()
+      .offer(offerId)
+      .read(options);
+    return (
+      response && {
+        ...response.resource,
+        headers: response.headers
+      }
+    );
+  } catch (error) {
+    logConsoleError(`Error while querying offer for collection ${params.collectionId}:\n ${JSON.stringify(error)}`);
+    logError(JSON.stringify(error), "ReadCollectionOffer", error.code);
+    sendNotificationForError(error);
+    throw error;
+  } finally {
+    clearMessage();
+  }
+};
+
+const getCollectionOfferIdWithARM = async (databaseId: string, collectionId: string): Promise<string> => {
+  let rpResponse;
+  const subscriptionId = userContext.subscriptionId;
+  const resourceGroup = userContext.resourceGroup;
+  const accountName = userContext.databaseAccount.name;
+  const defaultExperience = userContext.defaultExperience;
+  switch (defaultExperience) {
+    case DefaultAccountExperienceType.DocumentDB:
+      rpResponse = await getSqlContainerThroughput(
+        subscriptionId,
+        resourceGroup,
+        accountName,
+        databaseId,
+        collectionId
+      );
+      break;
+    case DefaultAccountExperienceType.MongoDB:
+      rpResponse = await getMongoDBCollectionThroughput(
+        subscriptionId,
+        resourceGroup,
+        accountName,
+        databaseId,
+        collectionId
+      );
+      break;
+    case DefaultAccountExperienceType.Cassandra:
+      rpResponse = await getCassandraTableThroughput(
+        subscriptionId,
+        resourceGroup,
+        accountName,
+        databaseId,
+        collectionId
+      );
+      break;
+    case DefaultAccountExperienceType.Graph:
+      rpResponse = await getGremlinGraphThroughput(
+        subscriptionId,
+        resourceGroup,
+        accountName,
+        databaseId,
+        collectionId
+      );
+      break;
+    case DefaultAccountExperienceType.Table:
+      rpResponse = await getTableThroughput(subscriptionId, resourceGroup, accountName, collectionId);
+      break;
+    default:
+      throw new Error(`Unsupported default experience type: ${defaultExperience}`);
+  }
+
+  return rpResponse?.name;
+};
+
+const getCollectionOfferIdWithSDK = async (collectionResourceId: string): Promise<string> => {
+  const offers = await readOffers();
+  const offer = offers.find(offer => offer.resource === collectionResourceId);
+  return offer?.id;
+};

src/Common/dataAccess/readCollectionQuotaInfo.ts

@@ -0,0 +1,48 @@
+import * as DataModels from "../../Contracts/DataModels";
+import * as HeadersUtility from "../HeadersUtility";
+import * as ViewModels from "../../Contracts/ViewModels";
+import { ContainerDefinition, Resource } from "@azure/cosmos";
+import { HttpHeaders } from "../Constants";
+import { RequestOptions } from "@azure/cosmos/dist-esm";
+import { client } from "../CosmosClient";
+import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
+import { logError } from "../Logger";
+import { sendNotificationForError } from "./sendNotificationForError";
+
+interface ResourceWithStatistics {
+  statistics: DataModels.Statistic[];
+}
+
+export const readCollectionQuotaInfo = async (
+  collection: ViewModels.Collection
+): Promise<DataModels.CollectionQuotaInfo> => {
+  const clearMessage = logConsoleProgress(`Querying containers for database ${collection.id}`);
+  const options: RequestOptions = {};
+  options.populateQuotaInfo = true;
+  options.initialHeaders = options.initialHeaders || {};
+  options.initialHeaders[HttpHeaders.populatePartitionStatistics] = true;
+
+  try {
+    const response = await client()
+      .database(collection.databaseId)
+      .container(collection.id())
+      .read(options);
+    const quota: DataModels.CollectionQuotaInfo = HeadersUtility.getQuota(response.headers);
+    const resource = response.resource as ContainerDefinition & Resource & ResourceWithStatistics;
+    quota["usageSizeInKB"] = resource.statistics.reduce(
+      (previousValue: number, currentValue: DataModels.Statistic) => previousValue + currentValue.sizeInKB,
+      0
+    );
+    quota["numPartitions"] = resource.statistics.length;
+    quota["uniqueKeyPolicy"] = collection.uniqueKeyPolicy; // TODO: Remove after refactoring (#119617)
+
+    return quota;
+  } catch (error) {
+    logConsoleError(`Error while querying quota info for container ${collection.id}:\n ${JSON.stringify(error)}`);
+    logError(JSON.stringify(error), "ReadCollectionQuotaInfo", error.code);
+    sendNotificationForError(error);
+    throw error;
+  } finally {
+    clearMessage();
+  }
+};

src/Common/dataAccess/readDatabaseOffer.ts

@@ -8,12 +8,16 @@ import { getSqlDatabaseThroughput } from "../../Utils/arm/generatedClients/2020-
 import { getMongoDBDatabaseThroughput } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
 import { getCassandraKeyspaceThroughput } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
 import { getGremlinDatabaseThroughput } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
+import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
+import { logError } from "../Logger";
 import { readOffers } from "./readOffers";
+import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 
 export const readDatabaseOffer = async (
   params: DataModels.ReadDatabaseOfferParams
 ): Promise<DataModels.OfferWithHeaders> => {
+  const clearMessage = logConsoleProgress(`Querying offer for database ${params.databaseId}`);
   let offerId = params.offerId;
   if (!offerId) {
     if (
@@ -24,14 +28,16 @@ export const readDatabaseOffer = async (
       try {
         offerId = await getDatabaseOfferIdWithARM(params.databaseId);
       } catch (error) {
+        clearMessage();
         if (error.code !== "NotFound") {
-          throw new Error(error);
+          throw new error();
         }
         return undefined;
       }
     } else {
       offerId = await getDatabaseOfferIdWithSDK(params.databaseResourceId);
       if (!offerId) {
+        clearMessage();
         return undefined;
       }
     }
@@ -43,6 +49,7 @@ export const readDatabaseOffer = async (
     }
   };
 
+  try {
     const response = await client()
       .offer(offerId)
       .read(options);
@@ -52,6 +59,14 @@ export const readDatabaseOffer = async (
         headers: response.headers
       }
     );
+  } catch (error) {
+    logConsoleError(`Error while querying offer for database ${params.databaseId}:\n ${JSON.stringify(error)}`);
+    logError(JSON.stringify(error), "ReadDatabaseOffer", error.code);
+    sendNotificationForError(error);
+    throw error;
+  } finally {
+    clearMessage();
+  }
 };
 
 const getDatabaseOfferIdWithARM = async (databaseId: string): Promise<string> => {

src/Common/dataAccess/readOffers.ts

@@ -3,10 +3,14 @@ import { ClientDefaults } from "../Constants";
 import { MessageTypes } from "../../Contracts/ExplorerContracts";
 import { Platform, configContext } from "../../ConfigContext";
 import { client } from "../CosmosClient";
+import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
+import { logError } from "../Logger";
 import { sendCachedDataMessage } from "../MessageHandler";
+import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
 
 export const readOffers = async (): Promise<Offer[]> => {
+  const clearMessage = logConsoleProgress(`Querying offers`);
   try {
     if (configContext.platform === Platform.Portal) {
       return sendCachedDataMessage<Offer[]>(MessageTypes.AllOffers, [
@@ -18,15 +22,22 @@ export const readOffers = async (): Promise<Offer[]> => {
     // If error getting cached Offers, continue on and read via SDK
   }
 
-  return client()
+  try {
+    const response = await client()
       .offers.readAll()
-    .fetchAll()
-    .then(response => response.resources)
-    .catch(error => {
+      .fetchAll();
+    return response?.resources;
+  } catch (error) {
     // This should be removed when we can correctly identify if an account is serverless when connected using connection string too.
     if (error.message.includes("Reading or replacing offers is not supported for serverless accounts")) {
       return [];
     }
+
+    logConsoleError(`Error while querying offers:\n ${JSON.stringify(error)}`);
+    logError(JSON.stringify(error), "ReadOffers", error.code);
+    sendNotificationForError(error);
     throw error;
-    });
+  } finally {
+    clearMessage();
+  }
 };

src/Contracts/DataModels.ts

@@ -296,6 +296,13 @@ export interface ReadDatabaseOfferParams {
   offerId?: string;
 }
 
+export interface ReadCollectionOfferParams {
+  collectionId: string;
+  databaseId: string;
+  collectionResourceId?: string;
+  offerId?: string;
+}
+
 export interface Notification {
   id: string;
   kind: string;

src/Contracts/ViewModels.ts

@@ -133,8 +133,7 @@ export interface Collection extends CollectionBase {
   onMongoDBDocumentsClick(): void;
   openTab(): void;
 
-  onSettingsClick: () => void;
-  readSettings(): Q.Promise<void>;
+  onSettingsClick: () => Promise<void>;
   onDeleteCollectionContextMenuClick(source: Collection, event: MouseEvent): void;
 
   onNewGraphClick(): void;
@@ -162,6 +161,7 @@ export interface Collection extends CollectionBase {
   loadUserDefinedFunctions(): Promise<any>;
   loadStoredProcedures(): Promise<any>;
   loadTriggers(): Promise<any>;
+  loadOffer(): Promise<void>;
 
   createStoredProcedureNode(data: StoredProcedureDefinition & Resource): StoredProcedure;
   createUserDefinedFunctionNode(data: UserDefinedFunctionDefinition & Resource): UserDefinedFunction;

src/Explorer/Tabs/SettingsTab.ts

@@ -1181,7 +1181,6 @@ export default class SettingsTab extends TabsBase implements ViewModels.WaitsFor
 
       this.container.isRefreshingExplorer(false);
       this._setBaseline();
-      this.collection.readSettings();
       this._wasAutopilotOriginallySet(this.isAutoPilotSelected());
       TelemetryProcessor.traceSuccess(
         Action.UpdateSettings,

src/Explorer/Tree/Collection.ts

@@ -8,7 +8,9 @@ import * as Constants from "../../Common/Constants";
 import { readStoredProcedures } from "../../Common/dataAccess/readStoredProcedures";
 import { readTriggers } from "../../Common/dataAccess/readTriggers";
 import { readUserDefinedFunctions } from "../../Common/dataAccess/readUserDefinedFunctions";
-import { createDocument, readCollectionQuotaInfo, readOffer, readOffers } from "../../Common/DocumentClientUtilityBase";
+import { createDocument } from "../../Common/DocumentClientUtilityBase";
+import { readCollectionOffer } from "../../Common/dataAccess/readCollectionOffer";
+import { readCollectionQuotaInfo } from "../../Common/dataAccess/readCollectionQuotaInfo";
 import * as Logger from "../../Common/Logger";
 import { configContext } from "../../ConfigContext";
 import * as DataModels from "../../Contracts/DataModels";
@@ -541,7 +543,7 @@ export default class Collection implements ViewModels.Collection {
     }
   };
 
-  public onSettingsClick = () => {
+  public onSettingsClick = async (): Promise<void> => {
     this.container.selectedNode(this);
     this.selectedSubnodeKind(ViewModels.CollectionTabKind.Settings);
     TelemetryProcessor.trace(Action.SelectItem, ActionModifiers.Mark, {
@@ -553,6 +555,7 @@ export default class Collection implements ViewModels.Collection {
       dataExplorerArea: Constants.Areas.ResourceTree
     });
 
+    await this.loadOffer();
     const tabTitle = !this.offer() ? "Settings" : "Scale & Settings";
     const pendingNotificationsPromise: Q.Promise<DataModels.Notification> = this._getPendingThroughputSplitNotification();
     const matchingTabs = this.container.tabsManager.getTabs(ViewModels.CollectionTabKind.Settings, tab => {
@@ -570,12 +573,12 @@ export default class Collection implements ViewModels.Collection {
         tabTitle: tabTitle
       });
 
-      Q.all([pendingNotificationsPromise, this.readSettings()]).then(
+      pendingNotificationsPromise.then(
         (data: any) => {
           const pendingNotification: DataModels.Notification = data && data[0];
           settingsTab = new SettingsTab({
             tabKind: ViewModels.CollectionTabKind.Settings,
-            title: !this.offer() ? "Settings" : "Scale & Settings",
+            title: tabTitle,
             tabPath: "",
 
             collection: this,
@@ -624,103 +627,12 @@ export default class Collection implements ViewModels.Collection {
     }
   };
 
-  public readSettings(): Q.Promise<void> {
-    const deferred: Q.Deferred<void> = Q.defer<void>();
-    this.container.isRefreshingExplorer(true);
-    const collectionDataModel: DataModels.Collection = <DataModels.Collection>{
-      id: this.id(),
-      _rid: this.rid,
-      _self: this.self,
-      defaultTtl: this.defaultTtl(),
-      indexingPolicy: this.indexingPolicy(),
-      partitionKey: this.partitionKey
-    };
-    const startKey: number = TelemetryProcessor.traceStart(Action.LoadOffers, {
-      databaseAccountName: this.container.databaseAccount().name,
-      databaseName: this.databaseId,
-      collectionName: this.id(),
-      defaultExperience: this.container.defaultExperience()
-    });
+  private async loadCollectionQuotaInfo(): Promise<void> {
     // TODO: Use the collection entity cache to get quota info
-    const quotaInfoPromise: Q.Promise<DataModels.CollectionQuotaInfo> = readCollectionQuotaInfo(this);
-    const offerInfoPromise: Q.Promise<DataModels.Offer[]> = readOffers({
-      isServerless: this.container.isServerlessEnabled()
-    });
-    Q.all([quotaInfoPromise, offerInfoPromise]).then(
-      () => {
-        this.container.isRefreshingExplorer(false);
-        const quotaInfoWithUniqueKeyPolicy: DataModels.CollectionQuotaInfo = quotaInfoPromise.valueOf();
+    const quotaInfoWithUniqueKeyPolicy = await readCollectionQuotaInfo(this);
     this.uniqueKeyPolicy = quotaInfoWithUniqueKeyPolicy.uniqueKeyPolicy;
     const quotaInfo = _.omit(quotaInfoWithUniqueKeyPolicy, "uniqueKeyPolicy");
-
-        const collectionOffer = this._getOfferForCollection(offerInfoPromise.valueOf(), collectionDataModel);
-        if (!collectionOffer) {
     this.quotaInfo(quotaInfo);
-          TelemetryProcessor.traceSuccess(
-            Action.LoadOffers,
-            {
-              databaseAccountName: this.container.databaseAccount().name,
-              databaseName: this.databaseId,
-              collectionName: this.id(),
-              defaultExperience: this.container.defaultExperience()
-            },
-            startKey
-          );
-          deferred.resolve();
-          return;
-        }
-
-        readOffer(collectionOffer).then((offerDetail: DataModels.OfferWithHeaders) => {
-          if (OfferUtils.isNotOfferV1(collectionOffer)) {
-            const offerThroughputInfo: DataModels.OfferThroughputInfo = {
-              minimumRUForCollection:
-                offerDetail.content &&
-                offerDetail.content.collectionThroughputInfo &&
-                offerDetail.content.collectionThroughputInfo.minimumRUForCollection,
-              numPhysicalPartitions:
-                offerDetail.content &&
-                offerDetail.content.collectionThroughputInfo &&
-                offerDetail.content.collectionThroughputInfo.numPhysicalPartitions
-            };
-
-            collectionOffer.content.collectionThroughputInfo = offerThroughputInfo;
-          }
-
-          (collectionOffer as DataModels.OfferWithHeaders).headers = offerDetail.headers;
-          this.offer(collectionOffer);
-          this.offer.valueHasMutated();
-          this.quotaInfo(quotaInfo);
-          TelemetryProcessor.traceSuccess(
-            Action.LoadOffers,
-            {
-              databaseAccountName: this.container.databaseAccount().name,
-              databaseName: this.databaseId,
-              collectionName: this.id(),
-              defaultExperience: this.container.defaultExperience(),
-              offerVersion: collectionOffer && collectionOffer.offerVersion
-            },
-            startKey
-          );
-          deferred.resolve();
-        });
-      },
-      (error: any) => {
-        this.container.isRefreshingExplorer(false);
-        deferred.reject(error);
-        TelemetryProcessor.traceFailure(
-          Action.LoadOffers,
-          {
-            databaseAccountName: this.container.databaseAccount().name,
-            databaseName: this.databaseId,
-            collectionName: this.id(),
-            defaultExperience: this.container.defaultExperience()
-          },
-          startKey
-        );
-      }
-    );
-
-    return deferred.promise;
   }
 
   public onNewQueryClick(source: any, event: MouseEvent, queryText?: string) {
@@ -1399,4 +1311,53 @@ export default class Collection implements ViewModels.Collection {
   public getDatabase(): ViewModels.Database {
     return this.container.findDatabaseWithId(this.databaseId);
   }
+
+  public async loadOffer(): Promise<void> {
+    if (!this.container.isServerlessEnabled() && !this.offer()) {
+      this.container.isRefreshingExplorer(true);
+      const startKey: number = TelemetryProcessor.traceStart(Action.LoadOffers, {
+        databaseAccountName: this.container.databaseAccount().name,
+        databaseName: this.databaseId,
+        collectionName: this.id(),
+        defaultExperience: this.container.defaultExperience()
+      });
+
+      const params: DataModels.ReadCollectionOfferParams = {
+        collectionId: this.id(),
+        collectionResourceId: this.self,
+        databaseId: this.databaseId
+      };
+
+      try {
+        this.offer(await readCollectionOffer(params));
+        await this.loadCollectionQuotaInfo();
+
+        TelemetryProcessor.traceSuccess(
+          Action.LoadOffers,
+          {
+            databaseAccountName: this.container.databaseAccount().name,
+            databaseName: this.databaseId,
+            collectionName: this.id(),
+            defaultExperience: this.container.defaultExperience(),
+            offerVersion: this.offer()?.offerVersion
+          },
+          startKey
+        );
+      } catch (error) {
+        TelemetryProcessor.traceFailure(
+          Action.LoadOffers,
+          {
+            databaseAccountName: this.container.databaseAccount().name,
+            databaseName: this.databaseId,
+            collectionName: this.id(),
+            defaultExperience: this.container.defaultExperience()
+          },
+          startKey
+        );
+        throw error;
+      } finally {
+        this.container.isRefreshingExplorer(false);
+      }
+    }
+  }
 }