Move read offer to RP (#326)

.eslintignore

@@ -288,8 +288,6 @@ src/Utils/DatabaseAccountUtils.ts
 src/Utils/JunoUtils.ts
 src/Utils/MessageValidation.ts
 src/Utils/NotebookConfigurationUtils.ts
-src/Utils/OfferUtils.test.ts
-src/Utils/OfferUtils.ts
 src/Utils/PricingUtils.test.ts
 src/Utils/QueryUtils.test.ts
 src/Utils/QueryUtils.ts

src/Common/DataAccessUtilityBase.ts

@@ -1,26 +1,13 @@
-import {
+import { ConflictDefinition, FeedOptions, ItemDefinition, QueryIterator, Resource } from "@azure/cosmos";
-  ConflictDefinition,
-  FeedOptions,
-  ItemDefinition,
-  OfferDefinition,
-  QueryIterator,
-  Resource
-} from "@azure/cosmos";
-import { RequestOptions } from "@azure/cosmos/dist-esm";
 import Q from "q";
-import { configContext, Platform } from "../ConfigContext";
 import * as DataModels from "../Contracts/DataModels";
-import { MessageTypes } from "../Contracts/ExplorerContracts";
 import * as ViewModels from "../Contracts/ViewModels";
 import ConflictId from "../Explorer/Tree/ConflictId";
 import DocumentId from "../Explorer/Tree/DocumentId";
 import StoredProcedure from "../Explorer/Tree/StoredProcedure";
 import { LocalStorageUtility, StorageKey } from "../Shared/StorageUtility";
-import { OfferUtils } from "../Utils/OfferUtils";
 import * as Constants from "./Constants";
 import { client } from "./CosmosClient";
-import * as HeadersUtility from "./HeadersUtility";
-import { sendCachedDataMessage } from "./MessageHandler";
 
 export function getCommonQueryOptions(options: FeedOptions): any {
   const storedItemPerPageSetting: number = LocalStorageUtility.getEntryNumber(StorageKey.ActualItemPerPage);

src/Common/OfferUtility.test.ts

@@ -0,0 +1,62 @@
+import * as OfferUtility from "./OfferUtility";
+import { SDKOfferDefinition, Offer } from "../Contracts/DataModels";
+import { OfferResponse } from "@azure/cosmos";
+
+describe("parseSDKOfferResponse", () => {
+  it("manual throughput", () => {
+    const mockOfferDefinition = {
+      content: {
+        offerThroughput: 500,
+        collectionThroughputInfo: {
+          minimumRUForCollection: 400,
+          numPhysicalPartitions: 1
+        }
+      },
+      id: "test"
+    } as SDKOfferDefinition;
+
+    const mockResponse = {
+      resource: mockOfferDefinition
+    } as OfferResponse;
+
+    const expectedResult: Offer = {
+      manualThroughput: 500,
+      autoscaleMaxThroughput: undefined,
+      minimumThroughput: 400,
+      id: "test",
+      offerDefinition: mockOfferDefinition
+    };
+
+    expect(OfferUtility.parseSDKOfferResponse(mockResponse)).toEqual(expectedResult);
+  });
+
+  it("autoscale throughput", () => {
+    const mockOfferDefinition = {
+      content: {
+        offerThroughput: 400,
+        collectionThroughputInfo: {
+          minimumRUForCollection: 400,
+          numPhysicalPartitions: 1
+        },
+        offerAutopilotSettings: {
+          maxThroughput: 5000
+        }
+      },
+      id: "test"
+    } as SDKOfferDefinition;
+
+    const mockResponse = {
+      resource: mockOfferDefinition
+    } as OfferResponse;
+
+    const expectedResult: Offer = {
+      manualThroughput: undefined,
+      autoscaleMaxThroughput: 5000,
+      minimumThroughput: 400,
+      id: "test",
+      offerDefinition: mockOfferDefinition
+    };
+
+    expect(OfferUtility.parseSDKOfferResponse(mockResponse)).toEqual(expectedResult);
+  });
+});

src/Common/OfferUtility.ts

@@ -0,0 +1,33 @@
+import { Offer, SDKOfferDefinition } from "../Contracts/DataModels";
+import { OfferResponse } from "@azure/cosmos";
+
+export const parseSDKOfferResponse = (offerResponse: OfferResponse): Offer => {
+  const offerDefinition: SDKOfferDefinition = offerResponse?.resource;
+  const offerContent = offerDefinition.content;
+  if (!offerContent) {
+    return undefined;
+  }
+
+  const minimumThroughput = offerContent.collectionThroughputInfo?.minimumRUForCollection;
+  const autopilotSettings = offerContent.offerAutopilotSettings;
+
+  if (autopilotSettings) {
+    return {
+      id: offerDefinition.id,
+      autoscaleMaxThroughput: autopilotSettings.maxThroughput,
+      manualThroughput: undefined,
+      minimumThroughput,
+      offerDefinition,
+      headers: offerResponse.headers
+    };
+  }
+
+  return {
+    id: offerDefinition.id,
+    autoscaleMaxThroughput: undefined,
+    manualThroughput: offerContent.offerThroughput,
+    minimumThroughput,
+    offerDefinition,
+    headers: offerResponse.headers
+  };
+};

src/Common/dataAccess/readCollectionOffer.ts

@@ -1,9 +1,6 @@
-import * as DataModels from "../../Contracts/DataModels";
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
-import { HttpHeaders } from "../Constants";
+import { Offer, ReadCollectionOfferParams } from "../../Contracts/DataModels";
-import { RequestOptions } from "@azure/cosmos/dist-esm";
-import { client } from "../CosmosClient";
 import { handleError } from "../ErrorHandlingUtils";
 import { getSqlContainerThroughput } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
 import { getMongoDBCollectionThroughput } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
@@ -11,50 +8,22 @@ import { getCassandraTableThroughput } from "../../Utils/arm/generatedClients/20
 import { getGremlinGraphThroughput } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
 import { getTableThroughput } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
 import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { readOffers } from "./readOffers";
+import { readOfferWithSDK } from "./readOfferWithSDK";
 import { userContext } from "../../UserContext";
 
-export const readCollectionOffer = async (
+export const readCollectionOffer = async (params: ReadCollectionOfferParams): Promise<Offer> => {
-  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()
+    if (
-      .offer(offerId)
+      window.authType === AuthType.AAD &&
-      .read(options);
+      !userContext.useSDKOperations &&
-    return (
+      userContext.defaultExperience !== DefaultAccountExperienceType.Table
-      response && {
+    ) {
-        ...response.resource,
+      return await readCollectionOfferWithARM(params.databaseId, params.collectionId);
-        headers: response.headers
+    }
-      }
+
-    );
+    return await readOfferWithSDK(params.offerId, params.collectionResourceId);
   } catch (error) {
     handleError(error, "ReadCollectionOffer", `Error while querying offer for collection ${params.collectionId}`);
     throw error;
@@ -63,61 +32,90 @@ export const readCollectionOffer = async (
   }
 };
 
-const getCollectionOfferIdWithARM = async (databaseId: string, collectionId: string): Promise<string> => {
+const readCollectionOfferWithARM = async (databaseId: string, collectionId: string): Promise<Offer> => {
-  let rpResponse;
   const subscriptionId = userContext.subscriptionId;
   const resourceGroup = userContext.resourceGroup;
   const accountName = userContext.databaseAccount.name;
   const defaultExperience = userContext.defaultExperience;
-  switch (defaultExperience) {
+
-    case DefaultAccountExperienceType.DocumentDB:
+  let rpResponse;
-      rpResponse = await getSqlContainerThroughput(
+  try {
-        subscriptionId,
+    switch (defaultExperience) {
-        resourceGroup,
+      case DefaultAccountExperienceType.DocumentDB:
-        accountName,
+        rpResponse = await getSqlContainerThroughput(
-        databaseId,
+          subscriptionId,
-        collectionId
+          resourceGroup,
-      );
+          accountName,
-      break;
+          databaseId,
-    case DefaultAccountExperienceType.MongoDB:
+          collectionId
-      rpResponse = await getMongoDBCollectionThroughput(
+        );
-        subscriptionId,
+        break;
-        resourceGroup,
+      case DefaultAccountExperienceType.MongoDB:
-        accountName,
+        rpResponse = await getMongoDBCollectionThroughput(
-        databaseId,
+          subscriptionId,
-        collectionId
+          resourceGroup,
-      );
+          accountName,
-      break;
+          databaseId,
-    case DefaultAccountExperienceType.Cassandra:
+          collectionId
-      rpResponse = await getCassandraTableThroughput(
+        );
-        subscriptionId,
+        break;
-        resourceGroup,
+      case DefaultAccountExperienceType.Cassandra:
-        accountName,
+        rpResponse = await getCassandraTableThroughput(
-        databaseId,
+          subscriptionId,
-        collectionId
+          resourceGroup,
-      );
+          accountName,
-      break;
+          databaseId,
-    case DefaultAccountExperienceType.Graph:
+          collectionId
-      rpResponse = await getGremlinGraphThroughput(
+        );
-        subscriptionId,
+        break;
-        resourceGroup,
+      case DefaultAccountExperienceType.Graph:
-        accountName,
+        rpResponse = await getGremlinGraphThroughput(
-        databaseId,
+          subscriptionId,
-        collectionId
+          resourceGroup,
-      );
+          accountName,
-      break;
+          databaseId,
-    case DefaultAccountExperienceType.Table:
+          collectionId
-      rpResponse = await getTableThroughput(subscriptionId, resourceGroup, accountName, collectionId);
+        );
-      break;
+        break;
-    default:
+      case DefaultAccountExperienceType.Table:
-      throw new Error(`Unsupported default experience type: ${defaultExperience}`);
+        rpResponse = await getTableThroughput(subscriptionId, resourceGroup, accountName, collectionId);
+        break;
+      default:
+        throw new Error(`Unsupported default experience type: ${defaultExperience}`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+
+    return undefined;
   }
 
-  return rpResponse?.name;
+  const resource = rpResponse?.properties?.resource;
-};
+  if (resource) {
+    const offerId: string = rpResponse.name;
+    const minimumThroughput: number =
+      typeof resource.minimumThroughput === "string"
+        ? parseInt(resource.minimumThroughput)
+        : resource.minimumThroughput;
+    const autoscaleSettings = resource.autoscaleSettings;
 
-const getCollectionOfferIdWithSDK = async (collectionResourceId: string): Promise<string> => {
+    if (autoscaleSettings) {
-  const offers = await readOffers();
+      return {
-  const offer = offers.find(offer => offer.resource === collectionResourceId);
+        id: offerId,
-  return offer?.id;
+        autoscaleMaxThroughput: autoscaleSettings.maxThroughput,
+        manualThroughput: undefined,
+        minimumThroughput
+      };
+    }
+
+    return {
+      id: offerId,
+      autoscaleMaxThroughput: undefined,
+      manualThroughput: resource.throughput,
+      minimumThroughput
+    };
+  }
+
+  return undefined;
 };

src/Common/dataAccess/readDatabaseOffer.ts

@@ -1,51 +1,28 @@
-import * as DataModels from "../../Contracts/DataModels";
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
-import { HttpHeaders } from "../Constants";
+import { Offer, ReadDatabaseOfferParams } from "../../Contracts/DataModels";
-import { RequestOptions } from "@azure/cosmos/dist-esm";
-import { client } from "../CosmosClient";
 import { getSqlDatabaseThroughput } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
 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 { handleError } from "../ErrorHandlingUtils";
 import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
-import { readOffers } from "./readOffers";
+import { readOfferWithSDK } from "./readOfferWithSDK";
 import { userContext } from "../../UserContext";
 
-export const readDatabaseOffer = async (
+export const readDatabaseOffer = async (params: ReadDatabaseOfferParams): Promise<Offer> => {
-  params: DataModels.ReadDatabaseOfferParams
-): Promise<DataModels.OfferWithHeaders> => {
   const clearMessage = logConsoleProgress(`Querying offer for database ${params.databaseId}`);
-  let offerId = params.offerId;
-  if (!offerId) {
-    offerId = await (window.authType === AuthType.AAD &&
-    !userContext.useSDKOperations &&
-    userContext.defaultExperience !== DefaultAccountExperienceType.Table
-      ? getDatabaseOfferIdWithARM(params.databaseId)
-      : getDatabaseOfferIdWithSDK(params.databaseResourceId));
-    if (!offerId) {
-      clearMessage();
-      return undefined;
-    }
-  }
-
-  const options: RequestOptions = {
-    initialHeaders: {
-      [HttpHeaders.populateCollectionThroughputInfo]: true
-    }
-  };
 
   try {
-    const response = await client()
+    if (
-      .offer(offerId)
+      window.authType === AuthType.AAD &&
-      .read(options);
+      !userContext.useSDKOperations &&
-    return (
+      userContext.defaultExperience !== DefaultAccountExperienceType.Table
-      response && {
+    ) {
-        ...response.resource,
+      return await readDatabaseOfferWithARM(params.databaseId);
-        headers: response.headers
+    }
-      }
+
-    );
+    return await readOfferWithSDK(params.offerId, params.databaseResourceId);
   } catch (error) {
     handleError(error, "ReadDatabaseOffer", `Error while querying offer for database ${params.databaseId}`);
     throw error;
@@ -54,13 +31,13 @@ export const readDatabaseOffer = async (
   }
 };
 
-const getDatabaseOfferIdWithARM = async (databaseId: string): Promise<string> => {
+const readDatabaseOfferWithARM = async (databaseId: string): Promise<Offer> => {
-  let rpResponse;
   const subscriptionId = userContext.subscriptionId;
   const resourceGroup = userContext.resourceGroup;
   const accountName = userContext.databaseAccount.name;
   const defaultExperience = userContext.defaultExperience;
 
+  let rpResponse;
   try {
     switch (defaultExperience) {
       case DefaultAccountExperienceType.DocumentDB:
@@ -78,18 +55,39 @@ const getDatabaseOfferIdWithARM = async (databaseId: string): Promise<string> =>
       default:
         throw new Error(`Unsupported default experience type: ${defaultExperience}`);
     }
-
-    return rpResponse?.name;
   } catch (error) {
     if (error.code !== "NotFound") {
       throw error;
     }
+
     return undefined;
   }
-};
 
-const getDatabaseOfferIdWithSDK = async (databaseResourceId: string): Promise<string> => {
+  const resource = rpResponse?.properties?.resource;
-  const offers = await readOffers();
+  if (resource) {
-  const offer = offers.find(offer => offer.resource === databaseResourceId);
+    const offerId: string = rpResponse.name;
-  return offer?.id;
+    const minimumThroughput: number =
+      typeof resource.minimumThroughput === "string"
+        ? parseInt(resource.minimumThroughput)
+        : resource.minimumThroughput;
+    const autoscaleSettings = resource.autoscaleSettings;
+
+    if (autoscaleSettings) {
+      return {
+        id: offerId,
+        autoscaleMaxThroughput: autoscaleSettings.maxThroughput,
+        manualThroughput: undefined,
+        minimumThroughput
+      };
+    }
+
+    return {
+      id: offerId,
+      autoscaleMaxThroughput: undefined,
+      manualThroughput: resource.throughput,
+      minimumThroughput
+    };
+  }
+
+  return undefined;
 };

src/Common/dataAccess/readOfferWithSDK.ts

@@ -0,0 +1,29 @@
+import { HttpHeaders } from "../Constants";
+import { Offer } from "../../Contracts/DataModels";
+import { RequestOptions } from "@azure/cosmos/dist-esm";
+import { client } from "../CosmosClient";
+import { parseSDKOfferResponse } from "../OfferUtility";
+import { readOffers } from "./readOffers";
+
+export const readOfferWithSDK = async (offerId: string, resourceId: string): Promise<Offer> => {
+  if (!offerId) {
+    const offers = await readOffers();
+    const offer = offers.find(offer => offer.resource === resourceId);
+
+    if (!offer) {
+      return undefined;
+    }
+    offerId = offer.id;
+  }
+
+  const options: RequestOptions = {
+    initialHeaders: {
+      [HttpHeaders.populateCollectionThroughputInfo]: true
+    }
+  };
+  const response = await client()
+    .offer(offerId)
+    .read(options);
+
+  return parseSDKOfferResponse(response);
+};

src/Common/dataAccess/readOffers.ts

@@ -1,9 +1,9 @@
-import { Offer } from "../../Contracts/DataModels";
+import { SDKOfferDefinition } from "../../Contracts/DataModels";
 import { logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { client } from "../CosmosClient";
 import { handleError, getErrorMessage } from "../ErrorHandlingUtils";
 
-export const readOffers = async (): Promise<Offer[]> => {
+export const readOffers = async (): Promise<SDKOfferDefinition[]> => {
   const clearMessage = logConsoleProgress(`Querying offers`);
 
   try {

src/Common/dataAccess/updateOffer.ts

@@ -1,13 +1,14 @@
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
 import { HttpHeaders } from "../Constants";
-import { Offer, UpdateOfferParams } from "../../Contracts/DataModels";
+import { Offer, SDKOfferDefinition, UpdateOfferParams } from "../../Contracts/DataModels";
 import { OfferDefinition } from "@azure/cosmos";
 import { RequestOptions } from "@azure/cosmos/dist-esm";
 import { ThroughputSettingsUpdateParameters } from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
 import { handleError } from "../ErrorHandlingUtils";
 import { logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import { parseSDKOfferResponse } from "../OfferUtility";
 import { readCollectionOffer } from "./readCollectionOffer";
 import { readDatabaseOffer } from "./readDatabaseOffer";
 import {
@@ -373,21 +374,21 @@ const createUpdateOfferBody = (params: UpdateOfferParams): ThroughputSettingsUpd
 };
 
 const updateOfferWithSDK = async (params: UpdateOfferParams): Promise<Offer> => {
-  const currentOffer = params.currentOffer;
+  const sdkOfferDefinition = params.currentOffer.offerDefinition;
-  const newOffer: Offer = {
+  const newOffer: SDKOfferDefinition = {
     content: {
       offerThroughput: undefined,
       offerIsRUPerMinuteThroughputEnabled: false
     },
     _etag: undefined,
     _ts: undefined,
-    _rid: currentOffer._rid,
+    _rid: sdkOfferDefinition._rid,
-    _self: currentOffer._self,
+    _self: sdkOfferDefinition._self,
-    id: currentOffer.id,
+    id: sdkOfferDefinition.id,
-    offerResourceId: currentOffer.offerResourceId,
+    offerResourceId: sdkOfferDefinition.offerResourceId,
-    offerVersion: currentOffer.offerVersion,
+    offerVersion: sdkOfferDefinition.offerVersion,
-    offerType: currentOffer.offerType,
+    offerType: sdkOfferDefinition.offerType,
-    resource: currentOffer.resource
+    resource: sdkOfferDefinition.resource
   };
 
   if (params.autopilotThroughput) {
@@ -415,5 +416,6 @@ const updateOfferWithSDK = async (params: UpdateOfferParams): Promise<Offer> =>
     .offer(params.currentOffer.id)
     // TODO Remove casting when SDK types are fixed (https://github.com/Azure/azure-sdk-for-js/issues/10660)
     .replace((newOffer as unknown) as OfferDefinition, options);
-  return sdkResponse?.resource;
+
+  return parseSDKOfferResponse(sdkResponse);
 };

src/Common/dataAccess/updateOfferThroughputBeyondLimit.test.ts

@@ -1,25 +0,0 @@
-import { updateOfferThroughputBeyondLimit } from "./updateOfferThroughputBeyondLimit";
-
-describe("updateOfferThroughputBeyondLimit", () => {
-  it("should call fetch", async () => {
-    window.fetch = jest.fn(() => {
-      return {
-        ok: true
-      };
-    });
-    window.dataExplorer = {
-      logConsoleData: jest.fn(),
-      deleteInProgressConsoleDataWithId: jest.fn()
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } as any;
-    await updateOfferThroughputBeyondLimit({
-      subscriptionId: "foo",
-      resourceGroup: "foo",
-      databaseAccountName: "foo",
-      databaseName: "foo",
-      throughput: 1000000000,
-      offerIsRUPerMinuteThroughputEnabled: false
-    });
-    expect(window.fetch).toHaveBeenCalled();
-  });
-});

src/Common/dataAccess/updateOfferThroughputBeyondLimit.ts

@@ -1,57 +0,0 @@
-import { Platform, configContext } from "../../ConfigContext";
-import { getAuthorizationHeader } from "../../Utils/AuthorizationUtils";
-import { AutoPilotOfferSettings } from "../../Contracts/DataModels";
-import { logConsoleProgress, logConsoleInfo } from "../../Utils/NotificationConsoleUtils";
-import { HttpHeaders } from "../Constants";
-import { handleError } from "../ErrorHandlingUtils";
-
-interface UpdateOfferThroughputRequest {
-  subscriptionId: string;
-  resourceGroup: string;
-  databaseAccountName: string;
-  databaseName: string;
-  collectionName?: string;
-  throughput: number;
-  offerIsRUPerMinuteThroughputEnabled: boolean;
-  offerAutopilotSettings?: AutoPilotOfferSettings;
-}
-
-export async function updateOfferThroughputBeyondLimit(request: UpdateOfferThroughputRequest): Promise<void> {
-  if (configContext.platform !== Platform.Portal) {
-    throw new Error("Updating throughput beyond specified limit is not supported on this platform");
-  }
-
-  const resourceDescriptionInfo = request.collectionName
-    ? `database ${request.databaseName} and container ${request.collectionName}`
-    : `database ${request.databaseName}`;
-
-  const clearMessage = logConsoleProgress(
-    `Requesting increase in throughput to ${request.throughput} for ${resourceDescriptionInfo}`
-  );
-
-  const url = `${configContext.BACKEND_ENDPOINT}/api/offerthroughputrequest/updatebeyondspecifiedlimit`;
-  const authorizationHeader = getAuthorizationHeader();
-
-  const response = await fetch(url, {
-    method: "POST",
-    body: JSON.stringify(request),
-    headers: { [authorizationHeader.header]: authorizationHeader.token, [HttpHeaders.contentType]: "application/json" }
-  });
-
-  if (response.ok) {
-    logConsoleInfo(
-      `Successfully requested an increase in throughput to ${request.throughput} for ${resourceDescriptionInfo}`
-    );
-    clearMessage();
-    return undefined;
-  }
-
-  const error = await response.json();
-  handleError(
-    error,
-    "updateOfferThroughputBeyondLimit",
-    `Failed to request an increase in throughput for ${request.throughput}`
-  );
-  clearMessage();
-  throw error;
-}

src/Contracts/DataModels.ts

@@ -208,12 +208,21 @@ export interface QueryMetrics {
   vmExecutionTime: any;
 }
 
-export interface Offer extends Resource {
+export interface Offer {
+  id: string;
+  autoscaleMaxThroughput: number;
+  manualThroughput: number;
+  minimumThroughput: number;
+  offerDefinition?: SDKOfferDefinition;
+  headers?: any;
+}
+
+export interface SDKOfferDefinition extends Resource {
   offerVersion?: string;
   offerType?: string;
   content?: {
     offerThroughput: number;
-    offerIsRUPerMinuteThroughputEnabled: boolean;
+    offerIsRUPerMinuteThroughputEnabled?: boolean;
     collectionThroughputInfo?: OfferThroughputInfo;
     offerAutopilotSettings?: AutoPilotOfferSettings;
   };
@@ -221,10 +230,6 @@ export interface Offer extends Resource {
   offerResourceId?: string;
 }
 
-export interface OfferWithHeaders extends Offer {
-  headers: any;
-}
-
 export interface CollectionQuotaInfo {
   storedProcedures: number;
   triggers: number;

src/Explorer/Controls/Settings/SettingsComponent.test.tsx

@@ -89,12 +89,11 @@ describe("SettingsComponent", () => {
   it("auto pilot helper functions pass on correct value", () => {
     const newCollection = { ...collection };
     newCollection.offer = ko.observable<DataModels.Offer>({
-      content: {
+      autoscaleMaxThroughput: 10000,
-        offerAutopilotSettings: {
+      manualThroughput: undefined,
-          maxThroughput: 10000
+      minimumThroughput: 400,
-        }
+      id: "test"
-      }
+    });
-    } as DataModels.Offer);
 
     const props = { ...baseProps };
     props.settingsTab.collection = newCollection;
@@ -187,21 +186,6 @@ describe("SettingsComponent", () => {
     expect(settingsComponentInstance.hasConflictResolution()).toEqual(true);
   });
 
-  it("isOfferReplacePending", () => {
-    let settingsComponentInstance = new SettingsComponent(baseProps);
-    expect(settingsComponentInstance.isOfferReplacePending()).toEqual(undefined);
-
-    const newCollection = { ...collection };
-    newCollection.offer = ko.observable({
-      headers: { "x-ms-offer-replace-pending": true }
-    } as DataModels.OfferWithHeaders);
-    const props = { ...baseProps };
-    props.settingsTab.collection = newCollection;
-
-    settingsComponentInstance = new SettingsComponent(props);
-    expect(settingsComponentInstance.isOfferReplacePending()).toEqual(true);
-  });
-
   it("save calls updateCollection, updateMongoDBCollectionThroughRP and updateOffer", async () => {
     const wrapper = shallow(<SettingsComponent {...baseProps} />);
     wrapper.setState({ isSubSettingsSaveable: true, isScaleSaveable: true, isMongoIndexingPolicySaveable: true });

src/Explorer/Controls/Settings/SettingsComponent.tsx

@@ -2,28 +2,23 @@ import * as React from "react";
 import * as AutoPilotUtils from "../../../Utils/AutoPilotUtils";
 import * as Constants from "../../../Common/Constants";
 import * as DataModels from "../../../Contracts/DataModels";
-import * as SharedConstants from "../../../Shared/Constants";
 import * as ViewModels from "../../../Contracts/ViewModels";
 import DiscardIcon from "../../../../images/discard.svg";
 import SaveIcon from "../../../../images/save-cosmos.svg";
 import { traceStart, traceFailure, traceSuccess, trace } from "../../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../../Shared/Telemetry/TelemetryConstants";
-import { RequestOptions } from "@azure/cosmos/dist-esm";
 import Explorer from "../../Explorer";
 import { updateOffer } from "../../../Common/dataAccess/updateOffer";
 import { updateCollection, updateMongoDBCollectionThroughRP } from "../../../Common/dataAccess/updateCollection";
 import { CommandButtonComponentProps } from "../../Controls/CommandButton/CommandButtonComponent";
-import { userContext } from "../../../UserContext";
-import { updateOfferThroughputBeyondLimit } from "../../../Common/dataAccess/updateOfferThroughputBeyondLimit";
 import SettingsTab from "../../Tabs/SettingsTabV2";
-import { mongoIndexingPolicyAADError, throughputUnit } from "./SettingsRenderUtils";
+import { mongoIndexingPolicyAADError } from "./SettingsRenderUtils";
 import { ScaleComponent, ScaleComponentProps } from "./SettingsSubComponents/ScaleComponent";
 import {
   MongoIndexingPolicyComponent,
   MongoIndexingPolicyComponentProps
 } from "./SettingsSubComponents/MongoIndexingPolicy/MongoIndexingPolicyComponent";
 import {
-  getMaxRUs,
   hasDatabaseSharedThroughput,
   GeospatialConfigType,
   TtlType,
@@ -275,19 +270,14 @@ export class SettingsComponent extends React.Component<SettingsComponentProps, S
   };
 
   private setAutoPilotStates = (): void => {
-    const offer = this.collection?.offer && this.collection.offer();
+    const autoscaleMaxThroughput = this.collection?.offer()?.autoscaleMaxThroughput;
-    const offerAutopilotSettings = offer?.content?.offerAutopilotSettings;
 
-    if (
+    if (autoscaleMaxThroughput && AutoPilotUtils.isValidAutoPilotThroughput(autoscaleMaxThroughput)) {
-      offerAutopilotSettings &&
-      offerAutopilotSettings.maxThroughput &&
-      AutoPilotUtils.isValidAutoPilotThroughput(offerAutopilotSettings.maxThroughput)
-    ) {
       this.setState({
         isAutoPilotSelected: true,
         wasAutopilotOriginallySet: true,
-        autoPilotThroughput: offerAutopilotSettings.maxThroughput,
+        autoPilotThroughput: autoscaleMaxThroughput,
-        autoPilotThroughputBaseline: offerAutopilotSettings.maxThroughput
+        autoPilotThroughputBaseline: autoscaleMaxThroughput
       });
     }
   };
@@ -305,12 +295,7 @@ export class SettingsComponent extends React.Component<SettingsComponentProps, S
     !!this.collection.conflictResolutionPolicy();
 
   public isOfferReplacePending = (): boolean => {
-    const offer = this.collection?.offer && this.collection.offer();
+    return !!this.collection?.offer()?.headers?.[Constants.HttpHeaders.offerReplacePending];
-    return (
-      offer &&
-      Object.keys(offer).find(value => value === "headers") &&
-      !!(offer as DataModels.OfferWithHeaders).headers[Constants.HttpHeaders.offerReplacePending]
-    );
   };
 
   public onSaveClick = async (): Promise<void> => {
@@ -448,103 +433,34 @@ export class SettingsComponent extends React.Component<SettingsComponentProps, S
       }
 
       if (this.state.isScaleSaveable) {
-        const newThroughput = this.state.throughput;
+        const updateOfferParams: DataModels.UpdateOfferParams = {
-        const newOffer: DataModels.Offer = { ...this.collection.offer() };
+          databaseId: this.collection.databaseId,
-        const originalThroughputValue: number = this.state.throughput;
+          collectionId: this.collection.id(),
-
+          currentOffer: this.collection.offer(),
-        if (newOffer.content) {
+          autopilotThroughput: this.state.isAutoPilotSelected ? this.state.autoPilotThroughput : undefined,
-          newOffer.content.offerThroughput = newThroughput;
+          manualThroughput: this.state.isAutoPilotSelected ? undefined : this.state.throughput
-        } else {
+        };
-          newOffer.content = {
+        if (this.hasProvisioningTypeChanged()) {
-            offerThroughput: newThroughput,
-            offerIsRUPerMinuteThroughputEnabled: false
-          };
-        }
-
-        const headerOptions: RequestOptions = { initialHeaders: {} };
-
-        if (this.state.isAutoPilotSelected) {
-          newOffer.content.offerAutopilotSettings = {
-            maxThroughput: this.state.autoPilotThroughput
-          };
-
-          // user has changed from provisioned --> autoscale
-          if (this.hasProvisioningTypeChanged()) {
-            headerOptions.initialHeaders[Constants.HttpHeaders.migrateOfferToAutopilot] = "true";
-            delete newOffer.content.offerAutopilotSettings;
-          } else {
-            delete newOffer.content.offerThroughput;
-          }
-        } else {
-          this.setState({
-            isAutoPilotSelected: false
-          });
-
-          // user has changed from autoscale --> provisioned
-          if (this.hasProvisioningTypeChanged()) {
-            headerOptions.initialHeaders[Constants.HttpHeaders.migrateOfferToManualThroughput] = "true";
-          } else {
-            delete newOffer.content.offerAutopilotSettings;
-          }
-        }
-
-        if (
-          getMaxRUs(this.collection, this.container) <=
-            SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
-          newThroughput > SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
-          this.container
-        ) {
-          const requestPayload = {
-            subscriptionId: userContext.subscriptionId,
-            databaseAccountName: userContext.databaseAccount.name,
-            resourceGroup: userContext.resourceGroup,
-            databaseName: this.collection.databaseId,
-            collectionName: this.collection.id(),
-            throughput: newThroughput,
-            offerIsRUPerMinuteThroughputEnabled: false
-          };
-
-          await updateOfferThroughputBeyondLimit(requestPayload);
-          this.collection.offer().content.offerThroughput = originalThroughputValue;
-          this.setState({
-            isScaleSaveable: false,
-            isScaleDiscardable: false,
-            throughput: originalThroughputValue,
-            throughputBaseline: originalThroughputValue,
-            initialNotification: {
-              description: `Throughput update for ${newThroughput} ${throughputUnit}`
-            } as DataModels.Notification
-          });
-        } else {
-          const updateOfferParams: DataModels.UpdateOfferParams = {
-            databaseId: this.collection.databaseId,
-            collectionId: this.collection.id(),
-            currentOffer: this.collection.offer(),
-            autopilotThroughput: this.state.isAutoPilotSelected ? this.state.autoPilotThroughput : undefined,
-            manualThroughput: this.state.isAutoPilotSelected ? undefined : newThroughput
-          };
-          if (this.hasProvisioningTypeChanged()) {
-            if (this.state.isAutoPilotSelected) {
-              updateOfferParams.migrateToAutoPilot = true;
-            } else {
-              updateOfferParams.migrateToManual = true;
-            }
-          }
-          const updatedOffer: DataModels.Offer = await updateOffer(updateOfferParams);
-          this.collection.offer(updatedOffer);
-          this.setState({ isScaleSaveable: false, isScaleDiscardable: false });
           if (this.state.isAutoPilotSelected) {
-            this.setState({
+            updateOfferParams.migrateToAutoPilot = true;
-              autoPilotThroughput: updatedOffer.content.offerAutopilotSettings.maxThroughput,
-              autoPilotThroughputBaseline: updatedOffer.content.offerAutopilotSettings.maxThroughput
-            });
           } else {
-            this.setState({
+            updateOfferParams.migrateToManual = true;
-              throughput: updatedOffer.content.offerThroughput,
-              throughputBaseline: updatedOffer.content.offerThroughput
-            });
           }
         }
+        const updatedOffer: DataModels.Offer = await updateOffer(updateOfferParams);
+        this.collection.offer(updatedOffer);
+        this.setState({ isScaleSaveable: false, isScaleDiscardable: false });
+        if (this.state.isAutoPilotSelected) {
+          this.setState({
+            autoPilotThroughput: updatedOffer.autoscaleMaxThroughput,
+            autoPilotThroughputBaseline: updatedOffer.autoscaleMaxThroughput
+          });
+        } else {
+          this.setState({
+            throughput: updatedOffer.manualThroughput,
+            throughputBaseline: updatedOffer.manualThroughput
+          });
+        }
       }
       this.container.isRefreshingExplorer(false);
       this.setBaseline();
@@ -809,7 +725,7 @@ export class SettingsComponent extends React.Component<SettingsComponentProps, S
       }
     }
 
-    const offerThroughput = this.collection?.offer && this.collection.offer()?.content?.offerThroughput;
+    const offerThroughput = this.collection.offer()?.manualThroughput;
     const changeFeedPolicy = this.collection.rawDataModel?.changeFeedPolicy
       ? ChangeFeedPolicyState.On
       : ChangeFeedPolicyState.Off;

src/Explorer/Controls/Settings/SettingsRenderUtils.test.tsx

@@ -42,7 +42,7 @@ class SettingsRenderUtilsTestComponent extends React.Component {
         {updateThroughputDelayedApplyWarningMessage}
 
         {getThroughputApplyDelayedMessage(false, 1000, "RU/s", "sampleDb", "sampleCollection", 2000)}
-        {getThroughputApplyShortDelayMessage(false, 1000, "RU/s", "sampleDb", "sampleCollection", 2000)}
+        {getThroughputApplyShortDelayMessage(false, 1000, "RU/s", "sampleDb", "sampleCollection")}
         {getThroughputApplyLongDelayMessage(false, 1000, "RU/s", "sampleDb", "sampleCollection", 2000)}
 
         {getToolTipContainer(<span>Sample Text</span>)}

src/Explorer/Controls/Settings/SettingsRenderUtils.tsx

@@ -319,14 +319,13 @@ export const getThroughputApplyShortDelayMessage = (
   throughput: number,
   throughputUnit: string,
   databaseName: string,
-  collectionName: string,
+  collectionName: string
-  targetThroughput: number
 ): JSX.Element => (
   <Text styles={infoAndToolTipTextStyle} id="throughputApplyShortDelayMessage">
     A request to increase the throughput is currently in progress. This operation will take some time to complete.
     <br />
     Database: {databaseName}, Container: {collectionName}{" "}
-    {getCurrentThroughput(isAutoscale, throughput, throughputUnit, targetThroughput)}
+    {getCurrentThroughput(isAutoscale, throughput, throughputUnit)}
   </Text>
 );
 

src/Explorer/Controls/Settings/SettingsSubComponents/ScaleComponent.test.tsx

@@ -44,7 +44,7 @@ describe("ScaleComponent", () => {
     } as DataModels.Notification
   };
 
-  it("renders with correct intiial notification", () => {
+  it("renders with correct initial notification", () => {
     let wrapper = shallow(<ScaleComponent {...baseProps} />);
     expect(wrapper).toMatchSnapshot();
     expect(wrapper.exists(ThroughputInputAutoPilotV3Component)).toEqual(true);
@@ -54,16 +54,13 @@ describe("ScaleComponent", () => {
 
     const newCollection = { ...collection };
     const maxThroughput = 5000;
-    const targetMaxThroughput = 50000;
     newCollection.offer = ko.observable({
-      content: {
+      manualThroughput: undefined,
-        offerAutopilotSettings: {
+      autoscaleMaxThroughput: maxThroughput,
-          maxThroughput: maxThroughput,
+      minimumThroughput: 400,
-          targetMaxThroughput: targetMaxThroughput
+      id: "offer",
-        }
-      },
       headers: { "x-ms-offer-replace-pending": true }
-    } as DataModels.OfferWithHeaders);
+    });
     const newProps = {
       ...baseProps,
       initialNotification: undefined as DataModels.Notification,
@@ -73,7 +70,6 @@ describe("ScaleComponent", () => {
     expect(wrapper.exists("#throughputApplyShortDelayMessage")).toEqual(true);
     expect(wrapper.exists("#throughputApplyLongDelayMessage")).toEqual(false);
     expect(wrapper.find("#throughputApplyShortDelayMessage").html()).toContain(maxThroughput);
-    expect(wrapper.find("#throughputApplyShortDelayMessage").html()).toContain(targetMaxThroughput);
   });
 
   it("autoScale disabled", () => {
@@ -109,11 +105,6 @@ describe("ScaleComponent", () => {
     expect(scaleComponent.isAutoScaleEnabled()).toEqual(true);
   });
 
-  it("getMaxRUThroughputInputLimit", () => {
-    const scaleComponent = new ScaleComponent(baseProps);
-    expect(scaleComponent.getMaxRUThroughputInputLimit()).toEqual(40000);
-  });
-
   it("getThroughputTitle", () => {
     let scaleComponent = new ScaleComponent(baseProps);
     expect(scaleComponent.getThroughputTitle()).toEqual("Throughput (6,000 - unlimited RU/s)");
@@ -138,14 +129,8 @@ describe("ScaleComponent", () => {
 
   it("getThroughputWarningMessage", () => {
     const throughputBeyondLimit = SharedConstants.CollectionCreation.DefaultCollectionRUs1Million + 1000;
-    const throughputBeyondMaxRus = SharedConstants.CollectionCreation.DefaultCollectionRUs1Million - 1000;
-
     const newProps = { ...baseProps, container: nonNationalCloudContainer, throughput: throughputBeyondLimit };
-    let scaleComponent = new ScaleComponent(newProps);
+    const scaleComponent = new ScaleComponent(newProps);
     expect(scaleComponent.getThroughputWarningMessage().props.id).toEqual("updateThroughputBeyondLimitWarningMessage");
-
-    newProps.throughput = throughputBeyondMaxRus;
-    scaleComponent = new ScaleComponent(newProps);
-    expect(scaleComponent.getThroughputWarningMessage().props.id).toEqual("updateThroughputDelayedApplyWarningMessage");
   });
 });

src/Explorer/Controls/Settings/SettingsSubComponents/ScaleComponent.tsx

@@ -12,10 +12,9 @@ import {
   throughputUnit,
   getThroughputApplyLongDelayMessage,
   getThroughputApplyShortDelayMessage,
-  updateThroughputBeyondLimitWarningMessage,
+  updateThroughputBeyondLimitWarningMessage
-  updateThroughputDelayedApplyWarningMessage
 } from "../SettingsRenderUtils";
-import { getMaxRUs, getMinRUs, hasDatabaseSharedThroughput } from "../SettingsUtils";
+import { hasDatabaseSharedThroughput } from "../SettingsUtils";
 import * as AutoPilotUtils from "../../../../Utils/AutoPilotUtils";
 import { Text, TextField, Stack, Label, MessageBar, MessageBarType } from "office-ui-fabric-react";
 import { configContext, Platform } from "../../../../ConfigContext";
@@ -62,11 +61,7 @@ export class ScaleComponent extends React.Component<ScaleComponentProps> {
   };
 
   private getStorageCapacityTitle = (): JSX.Element => {
-    // Mongo container with system partition key still treat as "Fixed"
+    const capacity: string = this.props.isFixedContainer ? "Fixed" : "Unlimited";
-    const isFixed =
-      !this.props.collection.partitionKey ||
-      (this.props.container.isPreferredApiMongoDB() && this.props.collection.partitionKey.systemKey);
-    const capacity: string = isFixed ? "Fixed" : "Unlimited";
     return (
       <Stack {...titleAndInputStackProps}>
         <Label>Storage capacity</Label>
@@ -75,12 +70,26 @@ export class ScaleComponent extends React.Component<ScaleComponentProps> {
     );
   };
 
-  public getMaxRUThroughputInputLimit = (): number => {
+  public getMaxRUs = (): number => {
-    if (configContext.platform === Platform.Hosted && this.props.collection.partitionKey) {
+    if (this.props.container?.isTryCosmosDBSubscription()) {
-      return SharedConstants.CollectionCreation.DefaultCollectionRUs1Million;
+      return Constants.TryCosmosExperience.maxRU;
     }
 
-    return getMaxRUs(this.props.collection, this.props.container);
+    if (this.props.isFixedContainer) {
+      return SharedConstants.CollectionCreation.MaxRUPerPartition;
+    }
+
+    return SharedConstants.CollectionCreation.DefaultCollectionRUs1Million;
+  };
+
+  public getMinRUs = (): number => {
+    if (this.props.container?.isTryCosmosDBSubscription()) {
+      return SharedConstants.CollectionCreation.DefaultCollectionRUs400;
+    }
+
+    return (
+      this.props.collection.offer()?.minimumThroughput || SharedConstants.CollectionCreation.DefaultCollectionRUs400
+    );
   };
 
   public getThroughputTitle = (): string => {
@@ -88,11 +97,8 @@ export class ScaleComponent extends React.Component<ScaleComponentProps> {
       return AutoPilotUtils.getAutoPilotHeaderText();
     }
 
-    const minThroughput: string = getMinRUs(this.props.collection, this.props.container).toLocaleString();
+    const minThroughput: string = this.getMinRUs().toLocaleString();
-    const maxThroughput: string =
+    const maxThroughput: string = !this.props.isFixedContainer ? "unlimited" : this.getMaxRUs().toLocaleString();
-      this.canThroughputExceedMaximumValue() && !this.props.isFixedContainer
-        ? "unlimited"
-        : getMaxRUs(this.props.collection, this.props.container).toLocaleString();
     return `Throughput (${minThroughput} - ${maxThroughput} RU/s)`;
   };
 
@@ -109,26 +115,15 @@ export class ScaleComponent extends React.Component<ScaleComponentProps> {
       return this.getLongDelayMessage();
     }
 
-    const offer = this.props.collection?.offer && this.props.collection.offer();
+    const offer = this.props.collection?.offer();
-    if (
+    if (offer?.headers?.[Constants.HttpHeaders.offerReplacePending]) {
-      offer &&
+      const throughput = offer.manualThroughput || offer.autoscaleMaxThroughput;
-      Object.keys(offer).find(value => {
-        return value === "headers";
-      }) &&
-      !!(offer as DataModels.OfferWithHeaders).headers[Constants.HttpHeaders.offerReplacePending]
-    ) {
-      const throughput = offer?.content?.offerAutopilotSettings?.maxThroughput;
-
-      const targetThroughput =
-        offer.content?.offerAutopilotSettings?.targetMaxThroughput || offer?.content?.offerThroughput;
-
       return getThroughputApplyShortDelayMessage(
         this.props.isAutoPilotSelected,
         throughput,
         throughputUnit,
         this.props.collection.databaseId,
-        this.props.collection.id(),
+        this.props.collection.id()
-        targetThroughput
       );
     }
 
@@ -138,21 +133,12 @@ export class ScaleComponent extends React.Component<ScaleComponentProps> {
   public getThroughputWarningMessage = (): JSX.Element => {
     const throughputExceedsBackendLimits: boolean =
       this.canThroughputExceedMaximumValue() &&
-      getMaxRUs(this.props.collection, this.props.container) <=
-        SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
       this.props.throughput > SharedConstants.CollectionCreation.DefaultCollectionRUs1Million;
 
     if (throughputExceedsBackendLimits && !!this.props.collection.partitionKey && !this.props.isFixedContainer) {
       return updateThroughputBeyondLimitWarningMessage;
     }
 
-    const throughputExceedsMaxValue: boolean =
-      !this.isEmulator && this.props.throughput > getMaxRUs(this.props.collection, this.props.container);
-
-    if (throughputExceedsMaxValue && !!this.props.collection.partitionKey && !this.props.isFixedContainer) {
-      return updateThroughputDelayedApplyWarningMessage;
-    }
-
     return undefined;
   };
 
@@ -183,8 +169,8 @@ export class ScaleComponent extends React.Component<ScaleComponentProps> {
       throughput={this.props.throughput}
       throughputBaseline={this.props.throughputBaseline}
       onThroughputChange={this.props.onThroughputChange}
-      minimum={getMinRUs(this.props.collection, this.props.container)}
+      minimum={this.getMinRUs()}
-      maximum={this.getMaxRUThroughputInputLimit()}
+      maximum={this.getMaxRUs()}
       isEnabled={!hasDatabaseSharedThroughput(this.props.collection)}
       canExceedMaximumValue={this.canThroughputExceedMaximumValue()}
       label={this.getThroughputTitle()}

src/Explorer/Controls/Settings/SettingsSubComponents/__snapshots__/ScaleComponent.test.tsx.snap

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`ScaleComponent renders with correct intiial notification 1`] = `
+exports[`ScaleComponent renders with correct initial notification 1`] = `
 <Stack
   tokens={
     Object {
@@ -48,7 +48,7 @@ exports[`ScaleComponent renders with correct intiial notification 1`] = `
       label="Throughput (6,000 - unlimited RU/s)"
       maxAutoPilotThroughput={4000}
       maxAutoPilotThroughputBaseline={4000}
-      maximum={40000}
+      maximum={1000000}
       minimum={6000}
       onAutoPilotSelected={[Function]}
       onMaxAutoPilotThroughputChange={[Function]}

src/Explorer/Controls/Settings/SettingsUtils.test.tsx

@@ -1,7 +1,5 @@
-import { collection, container } from "./TestUtils";
+import { collection } from "./TestUtils";
 import {
-  getMaxRUs,
-  getMinRUs,
   getMongoIndexType,
   getMongoNotification,
   getSanitizedInputValue,
@@ -23,16 +21,6 @@ import * as ViewModels from "../../../Contracts/ViewModels";
 import ko from "knockout";
 
 describe("SettingsUtils", () => {
-  it("getMaxRUs", () => {
-    expect(collection.offer().content.collectionThroughputInfo.numPhysicalPartitions).toEqual(4);
-    expect(getMaxRUs(collection, container)).toEqual(40000);
-  });
-
-  it("getMinRUs", () => {
-    expect(collection.offer().content.collectionThroughputInfo.numPhysicalPartitions).toEqual(4);
-    expect(getMinRUs(collection, container)).toEqual(6000);
-  });
-
   it("hasDatabaseSharedThroughput", () => {
     expect(hasDatabaseSharedThroughput(collection)).toEqual(undefined);
 

src/Explorer/Controls/Settings/SettingsUtils.tsx

@@ -1,10 +1,6 @@
 import * as ViewModels from "../../../Contracts/ViewModels";
 import * as DataModels from "../../../Contracts/DataModels";
 import * as Constants from "../../../Common/Constants";
-import * as SharedConstants from "../../../Shared/Constants";
-import * as PricingUtils from "../../../Utils/PricingUtils";
-
-import Explorer from "../../Explorer";
 import { MongoIndex } from "../../../Utils/arm/generatedClients/2020-04-01/types";
 
 const zeroValue = 0;
@@ -71,57 +67,6 @@ export const hasDatabaseSharedThroughput = (collection: ViewModels.Collection):
   return database?.isDatabaseShared() && !collection.offer();
 };
 
-export const getMaxRUs = (collection: ViewModels.Collection, container: Explorer): number => {
-  const isTryCosmosDBSubscription = container?.isTryCosmosDBSubscription() || false;
-  if (isTryCosmosDBSubscription) {
-    return Constants.TryCosmosExperience.maxRU;
-  }
-
-  const numPartitionsFromOffer: number =
-    collection?.offer && collection.offer()?.content?.collectionThroughputInfo?.numPhysicalPartitions;
-
-  const numPartitionsFromQuotaInfo: number = collection?.quotaInfo()?.numPartitions;
-
-  const numPartitions = numPartitionsFromOffer ?? numPartitionsFromQuotaInfo ?? 1;
-
-  return SharedConstants.CollectionCreation.MaxRUPerPartition * numPartitions;
-};
-
-export const getMinRUs = (collection: ViewModels.Collection, container: Explorer): number => {
-  const isTryCosmosDBSubscription = container?.isTryCosmosDBSubscription();
-  if (isTryCosmosDBSubscription) {
-    return SharedConstants.CollectionCreation.DefaultCollectionRUs400;
-  }
-
-  const offerContent = collection?.offer && collection.offer()?.content;
-
-  if (offerContent?.offerAutopilotSettings) {
-    return SharedConstants.CollectionCreation.DefaultCollectionRUs400;
-  }
-
-  const collectionThroughputInfo: DataModels.OfferThroughputInfo = offerContent?.collectionThroughputInfo;
-
-  if (collectionThroughputInfo?.minimumRUForCollection > 0) {
-    return collectionThroughputInfo.minimumRUForCollection;
-  }
-
-  const numPartitions = collectionThroughputInfo?.numPhysicalPartitions ?? collection.quotaInfo()?.numPartitions;
-
-  if (!numPartitions || numPartitions === 1) {
-    return SharedConstants.CollectionCreation.DefaultCollectionRUs400;
-  }
-
-  const baseRU = SharedConstants.CollectionCreation.DefaultCollectionRUs400;
-
-  const quotaInKb = collection.quotaInfo().collectionSize;
-  const quotaInGb = PricingUtils.usageInGB(quotaInKb);
-
-  const perPartitionGBQuota: number = Math.max(10, quotaInGb / numPartitions);
-  const baseRUbyPartitions: number = ((numPartitions * perPartitionGBQuota) / 10) * 100;
-
-  return Math.max(baseRU, baseRUbyPartitions);
-};
-
 export const parseConflictResolutionMode = (modeFromBackend: string): DataModels.ConflictResolutionMode => {
   // Backend can contain different casing as it does case-insensitive comparisson
   if (!modeFromBackend) {

src/Explorer/Controls/Settings/TestUtils.tsx

@@ -20,15 +20,11 @@ export const collection = ({
   uniqueKeyPolicy: {} as DataModels.UniqueKeyPolicy,
   quotaInfo: ko.observable<DataModels.CollectionQuotaInfo>({} as DataModels.CollectionQuotaInfo),
   offer: ko.observable<DataModels.Offer>({
-    content: {
+    autoscaleMaxThroughput: undefined,
-      offerThroughput: 10000,
+    manualThroughput: 10000,
-      offerIsRUPerMinuteThroughputEnabled: false,
+    minimumThroughput: 6000,
-      collectionThroughputInfo: {
+    id: "offer"
-        minimumRUForCollection: 6000,
+  }),
-        numPhysicalPartitions: 4
-      } as DataModels.OfferThroughputInfo
-    }
-  } as DataModels.Offer),
   conflictResolutionPolicy: ko.observable<DataModels.ConflictResolutionPolicy>(
     {} as DataModels.ConflictResolutionPolicy
   ),

src/Explorer/Controls/Settings/__snapshots__/SettingsRenderUtils.test.tsx.snap

@@ -227,7 +227,7 @@ exports[`SettingsUtils functions render 1`] = `
     , Container: 
     sampleCollection
      
-    , Current manual throughput: 1000 RU/s, Target manual throughput: 2000
+    , Current manual throughput: 1000 RU/s
   </Text>
   <Text
     id="throughputApplyLongDelayMessage"

src/Explorer/Tabs/DatabaseSettingsTab.ts

@@ -16,8 +16,6 @@ import { RequestOptions } from "@azure/cosmos/dist-esm";
 import Explorer from "../Explorer";
 import { updateOffer } from "../../Common/dataAccess/updateOffer";
 import { CommandButtonComponentProps } from "../Controls/CommandButton/CommandButtonComponent";
-import { userContext } from "../../UserContext";
-import { updateOfferThroughputBeyondLimit } from "../../Common/dataAccess/updateOfferThroughputBeyondLimit";
 import { configContext, Platform } from "../../ConfigContext";
 import { getErrorMessage, getErrorStack } from "../../Common/ErrorHandlingUtils";
 
@@ -35,11 +33,6 @@ const currentThroughput: (isAutoscale: boolean, throughput: number) => string =
     ? `Current autoscale throughput: ${Math.round(throughput / 10)} - ${throughput} RU/s`
     : `Current manual throughput: ${throughput} RU/s`;
 
-const throughputApplyDelayedMessage = (isAutoscale: boolean, throughput: number, databaseName: string) =>
-  `The request to increase the throughput has successfully been submitted. 
-  This operation will take 1-3 business days to complete. View the latest status in Notifications.<br />
-  Database: ${databaseName}, ${currentThroughput(isAutoscale, throughput)}`;
-
 const throughputApplyShortDelayMessage = (isAutoscale: boolean, throughput: number, databaseName: string) =>
   `A request to increase the throughput is currently in progress. 
   This operation will take some time to complete.<br />
@@ -66,8 +59,8 @@ export default class DatabaseSettingsTab extends TabsBase implements ViewModels.
   public displayedError: ko.Observable<string>;
   public isTemplateReady: ko.Observable<boolean>;
   public minRUAnotationVisible: ko.Computed<boolean>;
-  public minRUs: ko.Computed<number>;
+  public minRUs: ko.Observable<number>;
-  public maxRUs: ko.Computed<number>;
+  public maxRUs: ko.Observable<number>;
   public maxRUsText: ko.PureComputed<string>;
   public maxRUThroughputInputLimit: ko.Computed<number>;
   public notificationStatusInfo: ko.Observable<string>;
@@ -92,7 +85,7 @@ export default class DatabaseSettingsTab extends TabsBase implements ViewModels.
 
   private _hasProvisioningTypeChanged: ko.Computed<boolean>;
   private _wasAutopilotOriginallySet: ko.Observable<boolean>;
-  private _offerReplacePending: ko.Computed<boolean>;
+  private _offerReplacePending: ko.Observable<boolean>;
   private container: Explorer;
 
   constructor(options: ViewModels.TabOptions) {
@@ -111,15 +104,14 @@ export default class DatabaseSettingsTab extends TabsBase implements ViewModels.
     this._wasAutopilotOriginallySet = ko.observable(false);
     this.isAutoPilotSelected = editable.observable(false);
     this.autoPilotThroughput = editable.observable<number>();
-    const offer = this.database && this.database.offer && this.database.offer();
-    const offerAutopilotSettings = offer && offer.content && offer.content.offerAutopilotSettings;
     this.userCanChangeProvisioningTypes = ko.observable(true);
 
-    if (offerAutopilotSettings && offerAutopilotSettings.maxThroughput) {
+    const autoscaleMaxThroughput = this.database?.offer()?.autoscaleMaxThroughput;
-      if (AutoPilotUtils.isValidAutoPilotThroughput(offerAutopilotSettings.maxThroughput)) {
+    if (autoscaleMaxThroughput) {
+      if (AutoPilotUtils.isValidAutoPilotThroughput(autoscaleMaxThroughput)) {
         this._wasAutopilotOriginallySet(true);
         this.isAutoPilotSelected(true);
-        this.autoPilotThroughput(offerAutopilotSettings.maxThroughput);
+        this.autoPilotThroughput(autoscaleMaxThroughput);
       }
     }
 
@@ -205,45 +197,15 @@ export default class DatabaseSettingsTab extends TabsBase implements ViewModels.
       return this._hasProvisioningTypeChanged() && !this._wasAutopilotOriginallySet();
     });
 
-    this.minRUs = ko.computed<number>(() => {
+    this.minRUs = ko.observable<number>(
-      const offerContent =
+      this.database.offer()?.minimumThroughput || this.container.collectionCreationDefaults.throughput.unlimitedmin
-        this.database && this.database.offer && this.database.offer() && this.database.offer().content;
+    );
-
-      // TODO: backend is returning 1,000,000 as min throughput which seems wrong
-      // Setting to min throughput to not block and let the backend pass or fail
-      if (offerContent && offerContent.offerAutopilotSettings) {
-        return 400;
-      }
-
-      const collectionThroughputInfo: DataModels.OfferThroughputInfo =
-        offerContent && offerContent.collectionThroughputInfo;
-
-      if (collectionThroughputInfo && !!collectionThroughputInfo.minimumRUForCollection) {
-        return collectionThroughputInfo.minimumRUForCollection;
-      }
-      const throughputDefaults = this.container.collectionCreationDefaults.throughput;
-      return throughputDefaults.unlimitedmin;
-    });
 
     this.minRUAnotationVisible = ko.computed<boolean>(() => {
       return PricingUtils.isLargerThanDefaultMinRU(this.minRUs());
     });
 
-    this.maxRUs = ko.computed<number>(() => {
+    this.maxRUs = ko.observable<number>(this.container.collectionCreationDefaults.throughput.unlimitedmax);
-      const collectionThroughputInfo: DataModels.OfferThroughputInfo =
-        this.database &&
-        this.database.offer &&
-        this.database.offer() &&
-        this.database.offer().content &&
-        this.database.offer().content.collectionThroughputInfo;
-      const numPartitions = collectionThroughputInfo && collectionThroughputInfo.numPhysicalPartitions;
-      if (!!numPartitions) {
-        return SharedConstants.CollectionCreation.MaxRUPerPartition * numPartitions;
-      }
-
-      const throughputDefaults = this.container.collectionCreationDefaults.throughput;
-      return throughputDefaults.unlimitedmax;
-    });
 
     this.maxRUThroughputInputLimit = ko.pureComputed<number>(() => {
       if (configContext.platform === Platform.Hosted) {
@@ -269,37 +231,23 @@ export default class DatabaseSettingsTab extends TabsBase implements ViewModels.
       return this.throughputTitle() + this.requestUnitsUsageCost();
     });
     this.pendingNotification = ko.observable<DataModels.Notification>();
-    this._offerReplacePending = ko.pureComputed<boolean>(() => {
+    this._offerReplacePending = ko.observable<boolean>(
-      const offer = this.database && this.database.offer && this.database.offer();
+      !!this.database.offer()?.headers?.[Constants.HttpHeaders.offerReplacePending]
-      return (
+    );
-        offer &&
-        offer.hasOwnProperty("headers") &&
-        !!(offer as DataModels.OfferWithHeaders).headers[Constants.HttpHeaders.offerReplacePending]
-      );
-    });
     this.notificationStatusInfo = ko.observable<string>("");
     this.shouldShowNotificationStatusPrompt = ko.computed<boolean>(() => this.notificationStatusInfo().length > 0);
     this.warningMessage = ko.computed<string>(() => {
-      const offer = this.database && this.database.offer && this.database.offer();
-
       if (this.overrideWithProvisionedThroughputSettings()) {
         return AutoPilotUtils.manualToAutoscaleDisclaimer;
       }
 
-      if (
+      const offer = this.database.offer();
-        offer &&
+      if (offer?.headers?.[Constants.HttpHeaders.offerReplacePending]) {
-        offer.hasOwnProperty("headers") &&
+        const throughput = offer.manualThroughput || offer.autoscaleMaxThroughput;
-        !!(offer as DataModels.OfferWithHeaders).headers[Constants.HttpHeaders.offerReplacePending]
-      ) {
-        const throughput = offer.content.offerAutopilotSettings
-          ? offer.content.offerAutopilotSettings.maxThroughput
-          : offer.content.offerThroughput;
-
         return throughputApplyShortDelayMessage(this.isAutoPilotSelected(), throughput, this.database.id());
       }
 
       if (
-        this.maxRUs() <= SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
         this.throughput() > SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
         this.canThroughputExceedMaximumValue()
       ) {
@@ -432,60 +380,26 @@ export default class DatabaseSettingsTab extends TabsBase implements ViewModels.
     const headerOptions: RequestOptions = { initialHeaders: {} };
 
     try {
-      if (this.isAutoPilotSelected()) {
+      const updateOfferParams: DataModels.UpdateOfferParams = {
-        const updateOfferParams: DataModels.UpdateOfferParams = {
+        databaseId: this.database.id(),
-          databaseId: this.database.id(),
+        currentOffer: this.database.offer(),
-          currentOffer: this.database.offer(),
+        autopilotThroughput: this.isAutoPilotSelected() ? this.autoPilotThroughput() : undefined,
-          autopilotThroughput: this.autoPilotThroughput(),
+        manualThroughput: this.isAutoPilotSelected() ? undefined : this.throughput()
-          manualThroughput: undefined,
+      };
-          migrateToAutoPilot: this._hasProvisioningTypeChanged()
-        };
 
-        const updatedOffer: DataModels.Offer = await updateOffer(updateOfferParams);
+      if (this._hasProvisioningTypeChanged()) {
-        this.database.offer(updatedOffer);
+        if (this.isAutoPilotSelected()) {
-        this.database.offer.valueHasMutated();
+          updateOfferParams.migrateToAutoPilot = true;
-        this._wasAutopilotOriginallySet(this.isAutoPilotSelected());
+        } else {
-      } else {
+          updateOfferParams.migrateToManual = true;
-        if (this.throughput.editableIsDirty() || this.isAutoPilotSelected.editableIsDirty()) {
-          const originalThroughputValue = this.throughput.getEditableOriginalValue();
-          const newThroughput = this.throughput();
-
-          if (
-            this.canThroughputExceedMaximumValue() &&
-            this.maxRUs() <= SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
-            this.throughput() > SharedConstants.CollectionCreation.DefaultCollectionRUs1Million
-          ) {
-            const requestPayload = {
-              subscriptionId: userContext.subscriptionId,
-              databaseAccountName: userContext.databaseAccount.name,
-              resourceGroup: userContext.resourceGroup,
-              databaseName: this.database.id(),
-              throughput: newThroughput,
-              offerIsRUPerMinuteThroughputEnabled: false
-            };
-            await updateOfferThroughputBeyondLimit(requestPayload);
-            this.database.offer().content.offerThroughput = originalThroughputValue;
-            this.throughput(originalThroughputValue);
-            this.notificationStatusInfo(
-              throughputApplyDelayedMessage(this.isAutoPilotSelected(), newThroughput, this.database.id())
-            );
-            this.throughput.valueHasMutated(); // force component re-render
-          } else {
-            const updateOfferParams: DataModels.UpdateOfferParams = {
-              databaseId: this.database.id(),
-              currentOffer: this.database.offer(),
-              autopilotThroughput: undefined,
-              manualThroughput: newThroughput,
-              migrateToManual: this._hasProvisioningTypeChanged()
-            };
-
-            const updatedOffer = await updateOffer(updateOfferParams);
-            this._wasAutopilotOriginallySet(this.isAutoPilotSelected());
-            this.database.offer(updatedOffer);
-            this.database.offer.valueHasMutated();
-          }
         }
       }
+
+      const updatedOffer: DataModels.Offer = await updateOffer(updateOfferParams);
+      this.database.offer(updatedOffer);
+      this.database.offer.valueHasMutated();
+      this._setBaseline();
+      this._wasAutopilotOriginallySet(this.isAutoPilotSelected());
     } catch (error) {
       this.container.isRefreshingExplorer(false);
       this.isExecutionError(true);
@@ -527,15 +441,10 @@ export default class DatabaseSettingsTab extends TabsBase implements ViewModels.
 
   private _setBaseline() {
     const offer = this.database && this.database.offer && this.database.offer();
-    const offerThroughput = offer.content && offer.content.offerThroughput;
+    this.isAutoPilotSelected.setBaseline(AutoPilotUtils.isValidAutoPilotThroughput(offer.autoscaleMaxThroughput));
-    const offerAutopilotSettings = offer && offer.content && offer.content.offerAutopilotSettings;
+    this.autoPilotThroughput.setBaseline(offer.autoscaleMaxThroughput);
-
+    this.throughput.setBaseline(offer.manualThroughput);
-    this.throughput.setBaseline(offerThroughput);
     this.userCanChangeProvisioningTypes(true);
-
-    const maxThroughputForAutoPilot = offerAutopilotSettings && offerAutopilotSettings.maxThroughput;
-    this.isAutoPilotSelected.setBaseline(AutoPilotUtils.isValidAutoPilotThroughput(maxThroughputForAutoPilot));
-    this.autoPilotThroughput.setBaseline(maxThroughputForAutoPilot || AutoPilotUtils.minAutoPilotThroughput);
   }
 
   protected getTabsButtons(): CommandButtonComponentProps[] {

src/Explorer/Tree/Collection.ts

@@ -1295,8 +1295,7 @@ export default class Collection implements ViewModels.Collection {
             databaseAccountName: this.container.databaseAccount().name,
             databaseName: this.databaseId,
             collectionName: this.id(),
-            defaultExperience: this.container.defaultExperience(),
+            defaultExperience: this.container.defaultExperience()
-            offerVersion: this.offer()?.offerVersion
           },
           startKey
         );

src/Utils/AutoPilotUtils.ts

@@ -7,15 +7,6 @@ export const minAutoPilotThroughput = 4000;
 
 export const autoPilotIncrementStep = 1000;
 
-export function isValidV3AutoPilotOffer(offer: Offer): boolean {
-  const maxThroughput =
-    offer &&
-    offer.content &&
-    offer.content.offerAutopilotSettings &&
-    offer.content.offerAutopilotSettings.maxThroughput;
-  return isValidAutoPilotThroughput(maxThroughput);
-}
-
 export function isValidAutoPilotThroughput(maxThroughput: number): boolean {
   if (!maxThroughput) {
     return false;

src/Utils/OfferUtils.test.ts

@@ -1,51 +0,0 @@
-import * as Constants from "../../src/Common/Constants";
-import * as DataModels from "../../src/Contracts/DataModels";
-import { OfferUtils } from "../../src/Utils/OfferUtils";
-
-describe("OfferUtils tests", () => {
-  const offerV1: DataModels.Offer = {
-    _rid: "",
-    _self: "",
-    _ts: 0,
-    _etag: "",
-    id: "v1",
-    offerVersion: Constants.OfferVersions.V1,
-    offerType: "Standard",
-    offerResourceId: "",
-    content: null,
-    resource: ""
-  };
-
-  const offerV2: DataModels.Offer = {
-    _rid: "",
-    _self: "",
-    _ts: 0,
-    _etag: "",
-    id: "v1",
-    offerVersion: Constants.OfferVersions.V2,
-    offerType: "Standard",
-    offerResourceId: "",
-    content: null,
-    resource: ""
-  };
-
-  describe("isOfferV1()", () => {
-    it("should return true for V1", () => {
-      expect(OfferUtils.isOfferV1(offerV1)).toBeTruthy();
-    });
-
-    it("should return false for V2", () => {
-      expect(OfferUtils.isOfferV1(offerV2)).toBeFalsy();
-    });
-  });
-
-  describe("isNotOfferV1()", () => {
-    it("should return true for V2", () => {
-      expect(OfferUtils.isNotOfferV1(offerV2)).toBeTruthy();
-    });
-
-    it("should return false for V1", () => {
-      expect(OfferUtils.isNotOfferV1(offerV1)).toBeFalsy();
-    });
-  });
-});

src/Utils/OfferUtils.ts

@@ -1,12 +0,0 @@
-import * as Constants from "../Common/Constants";
-import * as DataModels from "../Contracts/DataModels";
-
-export class OfferUtils {
-  public static isOfferV1(offer: DataModels.Offer): boolean {
-    return !offer || offer.offerVersion !== Constants.OfferVersions.V2;
-  }
-
-  public static isNotOfferV1(offer: DataModels.Offer): boolean {
-    return !OfferUtils.isOfferV1(offer);
-  }
-}

tsconfig.strict.json

@@ -76,7 +76,6 @@
     "./src/Utils/BlobUtils.ts",
     "./src/Utils/GitHubUtils.ts",
     "./src/Utils/MessageValidation.ts",
-    "./src/Utils/OfferUtils.ts",
     "./src/Utils/StringUtils.ts",
     "./src/Utils/WindowUtils.ts",
     "./src/Utils/arm/generatedClients/2020-04-01/types.ts",