Fix strict mode

Co-authored-by: Daniel Si Pham <v-danpha@microsoft.com>

.eslintignore

@@ -266,10 +266,6 @@ src/ResourceProvider/ResourceProviderClientFactory.ts
 src/RouteHandlers/RouteHandler.ts
 src/RouteHandlers/TabRouteHandler.test.ts
 src/RouteHandlers/TabRouteHandler.ts
-src/Shared/AddCollectionUtility.test.ts
-src/Shared/AddCollectionUtility.ts
-src/Shared/AddDatabaseUtility.test.ts
-src/Shared/AddDatabaseUtility.ts
 src/Shared/Constants.ts
 src/Shared/DefaultExperienceUtility.test.ts
 src/Shared/DefaultExperienceUtility.ts
@@ -279,8 +275,6 @@ src/Shared/StorageUtility.test.ts
 src/Shared/StorageUtility.ts
 src/Shared/StringUtility.test.ts
 src/Shared/StringUtility.ts
-src/Shared/Telemetry/TelemetryConstants.ts
-src/Shared/Telemetry/TelemetryProcessor.ts
 src/Shared/appInsights.ts
 src/SparkClusterManager/ArcadiaResourceManager.ts
 src/SparkClusterManager/SparkClusterManager.ts
@@ -418,6 +412,5 @@ cypress/integration/dataexplorer/SQL/addCollection.spec.ts
 cypress/integration/dataexplorer/TABLE/addCollection.spec.ts
 cypress/integration/notebook/newNotebook.spec.ts
 cypress/integration/notebook/resourceTree.spec.ts
-__mocks__/AddDatabaseUtility.ts
 __mocks__/monaco-editor.ts
 src/Explorer/Tree/ResourceTreeAdapterForResourceToken.test.tsx

.eslintrc.js

@@ -41,6 +41,7 @@ module.exports = {
     "@typescript-eslint/no-extraneous-class": "error",
     "no-null/no-null": "error",
     "@typescript-eslint/no-explicit-any": "error",
-    "prefer-arrow/prefer-arrow-functions": ["error", { allowStandaloneDeclarations: true }]
+    "prefer-arrow/prefer-arrow-functions": ["error", { allowStandaloneDeclarations: true }],
+    eqeqeq: "error"
   }
 };

__mocks__/AddDatabaseUtility.ts

@@ -1,5 +0,0 @@
-export class AddDbUtilities {
-    createGremlinDatabase(params: any) {
-        return Promise.resolve(1)
-    }
-}

cypress/package.json

@@ -7,7 +7,7 @@
     "test": "cypress run",
     "wait-for-server": "wait-on -t 240000 -i 5000 -v https-get://0.0.0.0:1234/",
     "test:sql": "cypress run --browser chrome --spec \"./integration/dataexplorer/SQL/*\"",
-    "test:ci": "wait-on -t 240000 -i 5000 -v https-get://0.0.0.0:1234/ https-get://0.0.0.0:8081/_explorer/index.html && cypress run --browser chrome --headless",
+    "test:ci": "wait-on -t 240000 -i 5000 -v https-get://0.0.0.0:1234/ https-get://0.0.0.0:8081/_explorer/index.html && cypress run --browser edge --headless",
     "test:debug": "cypress open"
   },
   "devDependencies": {

less/documentDB.less

@@ -3017,4 +3017,8 @@ settings-pane {
 
 .italic {
     font-style: italic;
+}
+
+.warningErrorContent a {
+    color: @AccentMediumHigh
 }

package.json

@@ -4,11 +4,11 @@
   "description": "Cosmos Explorer",
   "main": "index.js",
   "dependencies": {
-    "@azure/cosmos": "3.7.4",
+    "@azure/cosmos": "3.9.0",
     "@azure/cosmos-language-service": "0.0.4",
     "@jupyterlab/services": "4.2.0",
     "@jupyterlab/terminal": "1.2.1",
-    "@microsoft/applicationinsights-web": "2.5.4",
+    "@microsoft/applicationinsights-web": "2.5.8",
     "@nteract/commutable": "7.1.4",
     "@nteract/connected-components": "6.7.8",
     "@nteract/core": "13.0.0",
@@ -66,13 +66,13 @@
     "mkdirp": "1.0.4",
     "monaco-editor": "0.15.6",
     "object.entries": "1.1.0",
-    "office-ui-fabric-react": "7.121.10",
+    "office-ui-fabric-react": "7.134.1",
     "p-retry": "4.2.0",
     "plotly.js-cartesian-dist-min": "1.52.3",
     "promise-polyfill": "8.1.0",
     "promise.prototype.finally": "3.1.0",
     "q": "1.5.1",
-    "react": "16.9.0",
+    "react": "16.13.1",
     "react-animate-height": "2.0.8",
     "react-dnd": "9.4.0",
     "react-dnd-html5-backend": "9.4.0",
@@ -118,8 +118,8 @@
     "@types/text-encoding": "0.0.33",
     "@types/underscore": "1.7.36",
     "@types/webfontloader": "1.6.29",
-    "@typescript-eslint/eslint-plugin": "3.2.0",
-    "@typescript-eslint/parser": "3.2.0",
+    "@typescript-eslint/eslint-plugin": "4.0.1",
+    "@typescript-eslint/parser": "4.0.1",
     "adal-angular": "1.0.15",
     "axe-puppeteer": "1.1.0",
     "babel-jest": "24.9.0",
@@ -132,7 +132,7 @@
     "enzyme": "3.10.0",
     "enzyme-adapter-react-16": "1.15.1",
     "enzyme-to-json": "3.4.3",
-    "eslint": "7.3.1",
+    "eslint": "7.8.1",
     "eslint-cli": "1.1.1",
     "eslint-plugin-no-null": "1.0.2",
     "eslint-plugin-prefer-arrow": "1.2.2",
@@ -160,11 +160,12 @@
     "rimraf": "3.0.0",
     "sinon": "3.2.1",
     "style-loader": "0.23.0",
+    "swr": "0.3.2",
     "terser-webpack-plugin": "3.0.5",
     "ts-loader": "6.2.2",
     "tslint": "5.11.0",
     "tslint-microsoft-contrib": "6.0.0",
-    "typescript": "3.9.6",
+    "typescript": "4.0.2",
     "url-loader": "1.1.1",
     "webpack": "4.43.0",
     "webpack-bundle-analyzer": "3.6.1",

sampleData/sqlSampleData.json

@@ -3,8 +3,8 @@
   "offerThroughput": 400,
   "databaseLevelThroughput": false,
   "collectionId": "Persons",
-  "rupmEnabled": false,
-  "partitionKey": { "kind": "Hash", "paths": ["/firstname"] },
+  "createNewDatabase": true,
+  "partitionKey": { "kind": "Hash", "paths": ["/firstname"], "version": 1 },
   "data": [
     {
       "firstname": "Eva",
@@ -23,4 +23,4 @@
       "age": 23
     }
   ]
-}
+}

src/Common/Constants.ts

@@ -134,6 +134,7 @@ export class Features {
   public static readonly enableAutoPilotV2 = "enableautopilotv2";
   public static readonly ttl90Days = "ttl90days";
   public static readonly enableRightPanelV2 = "enablerightpanelv2";
+  public static readonly enableSDKoperations = "enablesdkoperations";
 }
 
 export class AfecFeatures {

src/Common/DataAccessUtilityBase.ts

@@ -6,19 +6,14 @@ import * as ViewModels from "../Contracts/ViewModels";
 import Q from "q";
 import {
   ConflictDefinition,
-  ContainerDefinition,
-  ContainerResponse,
-  DatabaseResponse,
   FeedOptions,
   ItemDefinition,
-  PartitionKeyDefinition,
   QueryIterator,
   Resource,
-  TriggerDefinition
+  TriggerDefinition,
+  OfferDefinition
 } from "@azure/cosmos";
-import { ContainerRequest } from "@azure/cosmos/dist-esm/client/Container/ContainerRequest";
 import { client } from "./CosmosClient";
-import { DatabaseRequest } from "@azure/cosmos/dist-esm/client/Database/DatabaseRequest";
 import { LocalStorageUtility, StorageKey } from "../Shared/StorageUtility";
 import { sendCachedDataMessage } from "./MessageHandler";
 import { MessageTypes } from "../Contracts/ExplorerContracts";
@@ -202,23 +197,6 @@ export function getPartitionKeyHeader(partitionKeyDefinition: DataModels.Partiti
   return [partitionKeyValue];
 }
 
-export function updateCollection(
-  databaseId: string,
-  collectionId: string,
-  newCollection: DataModels.Collection,
-  options: any = {}
-): Q.Promise<DataModels.Collection> {
-  return Q(
-    client()
-      .database(databaseId)
-      .container(collectionId)
-      .replace(newCollection as ContainerDefinition, options)
-      .then(async (response: ContainerResponse) => {
-        return refreshCachedResources().then(() => response.resource as DataModels.Collection);
-      })
-  );
-}
-
 export function updateDocument(
   collection: ViewModels.CollectionBase,
   documentId: DocumentId,
@@ -244,7 +222,8 @@ export function updateOffer(
   return Q(
     client()
       .offer(offer.id)
-      .replace(newOffer, options)
+      // 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)
       .then(response => {
         return Promise.all([refreshCachedOffers(), refreshCachedResources()]).then(() => response.resource);
       })
@@ -454,6 +433,10 @@ export function readCollectionQuotaInfo(
 }
 
 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, [
@@ -469,6 +452,13 @@ export function readOffers(options: any): Q.Promise<DataModels.Offer[]> {
       .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;
+      })
   );
 }
 
@@ -487,89 +477,6 @@ export function readOffer(requestedResource: DataModels.Offer, options: any): Q.
   );
 }
 
-export function getOrCreateDatabaseAndCollection(
-  request: DataModels.CreateDatabaseAndCollectionRequest,
-  options: any
-): Q.Promise<DataModels.Collection> {
-  const databaseOptions: any = options && _.omit(options, "sharedOfferThroughput");
-  const {
-    databaseId,
-    databaseLevelThroughput,
-    collectionId,
-    partitionKey,
-    indexingPolicy,
-    uniqueKeyPolicy,
-    offerThroughput,
-    analyticalStorageTtl,
-    hasAutoPilotV2FeatureFlag
-  } = request;
-
-  const createBody: DatabaseRequest = {
-    id: databaseId
-  };
-
-  // TODO: replace when SDK support autopilot
-  const initialHeaders = request.autoPilot
-    ? !hasAutoPilotV2FeatureFlag
-      ? {
-          [Constants.HttpHeaders.autoPilotThroughputSDK]: JSON.stringify({
-            maxThroughput: request.autoPilot.maxThroughput
-          })
-        }
-      : {
-          [Constants.HttpHeaders.autoPilotTier]: request.autoPilot.autopilotTier
-        }
-    : undefined;
-  if (databaseLevelThroughput) {
-    if (request.autoPilot) {
-      databaseOptions.initialHeaders = initialHeaders;
-    }
-    createBody.throughput = offerThroughput;
-  }
-
-  return Q(
-    client()
-      .databases.createIfNotExists(createBody, databaseOptions)
-      .then(response => {
-        return response.database.containers.create(
-          {
-            id: collectionId,
-            partitionKey: (partitionKey || undefined) as PartitionKeyDefinition,
-            indexingPolicy: indexingPolicy ? indexingPolicy : undefined,
-            uniqueKeyPolicy: uniqueKeyPolicy ? uniqueKeyPolicy : undefined,
-            analyticalStorageTtl: analyticalStorageTtl,
-            throughput: databaseLevelThroughput || request.autoPilot ? undefined : offerThroughput
-          } as ContainerRequest, // TODO: remove cast when https://github.com/Azure/azure-cosmos-js/issues/423 is fixed
-          {
-            initialHeaders: databaseLevelThroughput ? undefined : initialHeaders
-          }
-        );
-      })
-      .then(containerResponse => containerResponse.resource as DataModels.Collection)
-      .finally(() => refreshCachedResources(options))
-  );
-}
-
-export function createDatabase(
-  request: DataModels.CreateDatabaseRequest,
-  options: any
-): Q.Promise<DataModels.Database> {
-  var deferred = Q.defer<DataModels.Database>();
-
-  _createDatabase(request, options).then(
-    (createdDatabase: DataModels.Database) => {
-      refreshCachedOffers().then(() => {
-        deferred.resolve(createdDatabase);
-      });
-    },
-    _createDatabaseError => {
-      deferred.reject(_createDatabaseError);
-    }
-  );
-
-  return deferred.promise;
-}
-
 export function refreshCachedOffers(): Q.Promise<void> {
   if (configContext.platform === Platform.Portal) {
     return sendCachedDataMessage(MessageTypes.RefreshOffers, []);
@@ -598,33 +505,3 @@ export function queryConflicts(
     .conflicts.query(query, options);
   return Q(documentsIterator);
 }
-
-function _createDatabase(request: DataModels.CreateDatabaseRequest, options: any = {}): Q.Promise<DataModels.Database> {
-  const { databaseId, databaseLevelThroughput, offerThroughput, autoPilot, hasAutoPilotV2FeatureFlag } = request;
-  const createBody: DatabaseRequest = { id: databaseId };
-  const databaseOptions: any = options && _.omit(options, "sharedOfferThroughput");
-  // TODO: replace when SDK support autopilot
-  const initialHeaders = autoPilot
-    ? !hasAutoPilotV2FeatureFlag
-      ? {
-          [Constants.HttpHeaders.autoPilotThroughputSDK]: JSON.stringify({ maxThroughput: autoPilot.maxThroughput })
-        }
-      : {
-          [Constants.HttpHeaders.autoPilotTier]: autoPilot.autopilotTier
-        }
-    : undefined;
-  if (!!databaseLevelThroughput) {
-    if (autoPilot) {
-      databaseOptions.initialHeaders = initialHeaders;
-    }
-    createBody.throughput = offerThroughput;
-  }
-
-  return Q(
-    client()
-      .databases.create(createBody, databaseOptions)
-      .then((response: DatabaseResponse) => {
-        return refreshCachedResources(databaseOptions).then(() => response.resource);
-      })
-  );
-}

src/Common/DocumentClientUtilityBase.ts

@@ -1,6 +1,5 @@
 import * as Constants from "./Constants";
 import * as DataModels from "../Contracts/DataModels";
-import * as ErrorParserUtility from "./ErrorParserUtility";
 import * as ViewModels from "../Contracts/ViewModels";
 import Q from "q";
 import { ConflictDefinition, ItemDefinition, QueryIterator, Resource } from "@azure/cosmos";
@@ -266,42 +265,6 @@ export function readDocument(collection: ViewModels.CollectionBase, documentId:
   return deferred.promise;
 }
 
-export function updateCollection(
-  databaseId: string,
-  collection: ViewModels.Collection,
-  newCollection: DataModels.Collection
-): Q.Promise<DataModels.Collection> {
-  var deferred = Q.defer<any>();
-  const id = NotificationConsoleUtils.logConsoleMessage(
-    ConsoleDataType.InProgress,
-    `Updating container ${collection.id()}`
-  );
-  DataAccessUtilityBase.updateCollection(databaseId, collection.id(), newCollection)
-    .then(
-      (replacedCollection: DataModels.Collection) => {
-        NotificationConsoleUtils.logConsoleMessage(
-          ConsoleDataType.Info,
-          `Successfully updated container ${collection.id()}`
-        );
-        deferred.resolve(replacedCollection);
-      },
-      (error: any) => {
-        NotificationConsoleUtils.logConsoleMessage(
-          ConsoleDataType.Error,
-          `Failed to update container ${collection.id()}: ${JSON.stringify(error)}`
-        );
-        Logger.logError(JSON.stringify(error), "UpdateCollection", error.code);
-        sendNotificationForError(error);
-        deferred.reject(error);
-      }
-    )
-    .finally(() => {
-      NotificationConsoleUtils.clearInProgressMessageWithId(id);
-    });
-
-  return deferred.promise;
-}
-
 export function updateDocument(
   collection: ViewModels.CollectionBase,
   documentId: DocumentId,
@@ -892,70 +855,3 @@ export function readOffer(
 
   return deferred.promise;
 }
-
-export function getOrCreateDatabaseAndCollection(
-  request: DataModels.CreateDatabaseAndCollectionRequest,
-  options: any = {}
-): Q.Promise<DataModels.Collection> {
-  const deferred: Q.Deferred<DataModels.Collection> = Q.defer<DataModels.Collection>();
-  const id = NotificationConsoleUtils.logConsoleMessage(
-    ConsoleDataType.InProgress,
-    `Creating a new container ${request.collectionId} for database ${request.databaseId}`
-  );
-
-  DataAccessUtilityBase.getOrCreateDatabaseAndCollection(request, options)
-    .then(
-      (collection: DataModels.Collection) => {
-        NotificationConsoleUtils.logConsoleMessage(
-          ConsoleDataType.Info,
-          `Successfully created container ${request.collectionId}`
-        );
-        deferred.resolve(collection);
-      },
-      (error: any) => {
-        const sanitizedError = ErrorParserUtility.replaceKnownError(JSON.stringify(error));
-        NotificationConsoleUtils.logConsoleMessage(
-          ConsoleDataType.Error,
-          `Error while creating container ${request.collectionId}:\n ${sanitizedError}`
-        );
-        sendNotificationForError(error);
-        deferred.reject(error);
-      }
-    )
-    .finally(() => NotificationConsoleUtils.clearInProgressMessageWithId(id));
-
-  return deferred.promise;
-}
-
-export function createDatabase(
-  request: DataModels.CreateDatabaseRequest,
-  options: any = {}
-): Q.Promise<DataModels.Database> {
-  const deferred: Q.Deferred<DataModels.Database> = Q.defer<DataModels.Database>();
-  const id = NotificationConsoleUtils.logConsoleMessage(
-    ConsoleDataType.InProgress,
-    `Creating a new database ${request.databaseId}`
-  );
-
-  DataAccessUtilityBase.createDatabase(request, options)
-    .then(
-      (database: DataModels.Database) => {
-        NotificationConsoleUtils.logConsoleMessage(
-          ConsoleDataType.Info,
-          `Successfully created database ${request.databaseId}`
-        );
-        deferred.resolve(database);
-      },
-      (error: any) => {
-        NotificationConsoleUtils.logConsoleMessage(
-          ConsoleDataType.Error,
-          `Error while creating database ${request.databaseId}:\n ${JSON.stringify(error)}`
-        );
-        sendNotificationForError(error);
-        deferred.reject(error);
-      }
-    )
-    .finally(() => NotificationConsoleUtils.clearInProgressMessageWithId(id));
-
-  return deferred.promise;
-}

src/Common/MongoProxyClient.test.ts

@@ -5,14 +5,7 @@ import { Collection } from "../Contracts/ViewModels";
 import DocumentId from "../Explorer/Tree/DocumentId";
 import { ResourceProviderClient } from "../ResourceProvider/ResourceProviderClient";
 import { updateUserContext } from "../UserContext";
-import {
-  deleteDocument,
-  getEndpoint,
-  queryDocuments,
-  readDocument,
-  updateDocument,
-  _createMongoCollectionWithARM
-} from "./MongoProxyClient";
+import { deleteDocument, getEndpoint, queryDocuments, readDocument, updateDocument } from "./MongoProxyClient";
 jest.mock("../ResourceProvider/ResourceProviderClient.ts");
 
 const databaseId = "testDB";
@@ -260,58 +253,4 @@ describe("MongoProxyClient", () => {
       expect(endpoint).toEqual("https://main.documentdb.ext.azure.com/api/guest/mongo/explorer");
     });
   });
-
-  describe("createMongoCollectionWithARM", () => {
-    it("should create a collection with autopilot when autopilot is selected + shared throughput is false", () => {
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      const properties = {
-        pk: "state",
-        coll: "abc-collection",
-        cd: true,
-        db: "a1-db",
-        st: false,
-        sid: "a2",
-        rg: "c1",
-        dba: "main",
-        is: false
-      };
-      _createMongoCollectionWithARM("management.azure.com", properties, { "x-ms-cosmos-offer-autopilot-tier": "1" });
-      expect(resourceProviderClientPutAsyncSpy).toHaveBeenCalledWith(
-        "subscriptions/a2/resourceGroups/c1/providers/Microsoft.DocumentDB/databaseAccounts/foo/mongodbDatabases/a1-db/collections/abc-collection",
-        "2020-04-01",
-        {
-          properties: {
-            options: { "x-ms-cosmos-offer-autopilot-tier": "1" },
-            resource: { id: "abc-collection" }
-          }
-        }
-      );
-    });
-    it("should create a collection with provisioned throughput when provisioned throughput is selected + shared throughput is false", () => {
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      const properties = {
-        pk: "state",
-        coll: "abc-collection",
-        cd: true,
-        db: "a1-db",
-        st: false,
-        sid: "a2",
-        rg: "c1",
-        dba: "main",
-        is: false,
-        offerThroughput: 400
-      };
-      _createMongoCollectionWithARM("management.azure.com", properties, undefined);
-      expect(resourceProviderClientPutAsyncSpy).toHaveBeenCalledWith(
-        "subscriptions/a2/resourceGroups/c1/providers/Microsoft.DocumentDB/databaseAccounts/foo/mongodbDatabases/a1-db/collections/abc-collection",
-        "2020-04-01",
-        {
-          properties: {
-            options: { throughput: "400" },
-            resource: { id: "abc-collection" }
-          }
-        }
-      );
-    });
-  });
 });

src/Common/MongoProxyClient.ts

@@ -1,16 +1,12 @@
 import { Constants as CosmosSDKConstants } from "@azure/cosmos";
 import queryString from "querystring";
 import { AuthType } from "../AuthType";
-import * as Constants from "../Common/Constants";
-import * as DataExplorerConstants from "../Common/Constants";
 import { configContext } from "../ConfigContext";
 import * as DataModels from "../Contracts/DataModels";
 import { MessageTypes } from "../Contracts/ExplorerContracts";
 import { Collection } from "../Contracts/ViewModels";
 import { ConsoleDataType } from "../Explorer/Menus/NotificationConsole/NotificationConsoleComponent";
 import DocumentId from "../Explorer/Tree/DocumentId";
-import { ResourceProviderClient } from "../ResourceProvider/ResourceProviderClient";
-import { AddDbUtilities } from "../Shared/AddDatabaseUtility";
 import * as NotificationConsoleUtils from "../Utils/NotificationConsoleUtils";
 import { ApiType, HttpHeaders, HttpStatusCodes } from "./Constants";
 import { userContext } from "../UserContext";
@@ -285,43 +281,35 @@ export function deleteDocument(databaseId: string, collection: Collection, docum
 }
 
 export function createMongoCollectionWithProxy(
-  databaseId: string,
-  collectionId: string,
-  offerThroughput: number,
-  shardKey: string,
-  createDatabase: boolean,
-  sharedThroughput: boolean,
-  isSharded: boolean,
-  autopilotOptions?: DataModels.RpOptions
+  params: DataModels.CreateCollectionParams
 ): Promise<DataModels.Collection> {
   const databaseAccount = userContext.databaseAccount;
-  const params: DataModels.MongoParameters = {
+  const shardKey: string = params.partitionKey?.paths[0];
+  const mongoParams: DataModels.MongoParameters = {
     resourceUrl: databaseAccount.properties.mongoEndpoint || databaseAccount.properties.documentEndpoint,
-    db: databaseId,
-    coll: collectionId,
+    db: params.databaseId,
+    coll: params.collectionId,
     pk: shardKey,
-    offerThroughput,
-    cd: createDatabase,
-    st: sharedThroughput,
-    is: isSharded,
+    offerThroughput: params.offerThroughput,
+    cd: params.createNewDatabase,
+    st: params.databaseLevelThroughput,
+    is: !!shardKey,
     rid: "",
     rtype: "colls",
     sid: userContext.subscriptionId,
     rg: userContext.resourceGroup,
     dba: databaseAccount.name,
-    isAutoPilot: false
+    isAutoPilot: !!params.autoPilotMaxThroughput,
+    autoPilotThroughput: params.autoPilotMaxThroughput?.toString()
   };
 
-  if (autopilotOptions) {
-    params.isAutoPilot = true;
-    params.autoPilotTier = autopilotOptions[Constants.HttpHeaders.autoPilotTier] as string;
-  }
-
   const endpoint = getEndpoint(databaseAccount);
 
   return window
     .fetch(
-      `${endpoint}/createCollection?${queryString.stringify((params as unknown) as queryString.ParsedUrlQueryInput)}`,
+      `${endpoint}/createCollection?${queryString.stringify(
+        (mongoParams as unknown) as queryString.ParsedUrlQueryInput
+      )}`,
       {
         method: "POST",
         headers: {
@@ -335,52 +323,10 @@ export function createMongoCollectionWithProxy(
       if (response.ok) {
         return response.json();
       }
-      return errorHandling(response, "creating collection", params);
+      return errorHandling(response, "creating collection", mongoParams);
     });
 }
 
-export function createMongoCollectionWithARM(
-  armEndpoint: string,
-  databaseId: string,
-  analyticalStorageTtl: number,
-  collectionId: string,
-  offerThroughput: number,
-  shardKey: string,
-  createDatabase: boolean,
-  sharedThroughput: boolean,
-  isSharded: boolean,
-  additionalOptions?: DataModels.RpOptions
-): Promise<DataModels.CreateCollectionWithRpResponse> {
-  const databaseAccount = userContext.databaseAccount;
-  const params: DataModels.MongoParameters = {
-    resourceUrl: databaseAccount.properties.mongoEndpoint || databaseAccount.properties.documentEndpoint,
-    db: databaseId,
-    coll: collectionId,
-    pk: shardKey,
-    offerThroughput,
-    cd: createDatabase,
-    st: sharedThroughput,
-    is: isSharded,
-    rid: "",
-    rtype: "colls",
-    sid: userContext.subscriptionId,
-    rg: userContext.resourceGroup,
-    dba: databaseAccount.name,
-    analyticalStorageTtl
-  };
-
-  if (createDatabase) {
-    return AddDbUtilities.createMongoDatabaseWithARM(
-      armEndpoint,
-      params,
-      sharedThroughput ? additionalOptions : {}
-    ).then(() => {
-      return _createMongoCollectionWithARM(armEndpoint, params, sharedThroughput ? {} : additionalOptions);
-    });
-  }
-  return _createMongoCollectionWithARM(armEndpoint, params, additionalOptions);
-}
-
 export function getEndpoint(databaseAccount: DataModels.DatabaseAccount): string {
   const serverId = window.dataExplorer.serverId();
   const extensionEndpoint = window.dataExplorer.extensionEndpoint();
@@ -413,46 +359,3 @@ async function errorHandling(response: Response, action: string, params: unknown
 export function getARMCreateCollectionEndpoint(params: DataModels.MongoParameters): string {
   return `subscriptions/${params.sid}/resourceGroups/${params.rg}/providers/Microsoft.DocumentDB/databaseAccounts/${userContext.databaseAccount.name}/mongodbDatabases/${params.db}/collections/${params.coll}`;
 }
-
-export async function _createMongoCollectionWithARM(
-  armEndpoint: string,
-  params: DataModels.MongoParameters,
-  rpOptions: DataModels.RpOptions
-): Promise<DataModels.CreateCollectionWithRpResponse> {
-  const rpPayloadToCreateCollection: DataModels.MongoCreationRequest = {
-    properties: {
-      resource: {
-        id: params.coll
-      },
-      options: {}
-    }
-  };
-
-  if (params.is) {
-    rpPayloadToCreateCollection.properties.resource["shardKey"] = { [params.pk]: "Hash" };
-  }
-
-  if (!params.st) {
-    if (rpOptions) {
-      rpPayloadToCreateCollection.properties.options = rpOptions;
-    } else {
-      rpPayloadToCreateCollection.properties.options["throughput"] =
-        params.offerThroughput && params.offerThroughput.toString();
-    }
-  }
-
-  if (params.analyticalStorageTtl) {
-    rpPayloadToCreateCollection.properties.resource.analyticalStorageTtl = params.analyticalStorageTtl;
-  }
-
-  try {
-    return new ResourceProviderClient<DataModels.CreateCollectionWithRpResponse>(armEndpoint).putAsync(
-      getARMCreateCollectionEndpoint(params),
-      DataExplorerConstants.ArmApiVersions.publicVersion,
-      rpPayloadToCreateCollection
-    );
-  } catch (response) {
-    errorHandling(response, "creating collection", undefined);
-    return undefined;
-  }
-}

src/Common/QueriesClient.ts

@@ -10,13 +10,8 @@ import * as NotificationConsoleUtils from "../Utils/NotificationConsoleUtils";
 import { QueryUtils } from "../Utils/QueryUtils";
 import { BackendDefaults, HttpStatusCodes, SavedQueries } from "./Constants";
 import { userContext } from "../UserContext";
-import {
-  createDocument,
-  deleteDocument,
-  getOrCreateDatabaseAndCollection,
-  queryDocuments,
-  queryDocumentsPage
-} from "./DocumentClientUtilityBase";
+import { createDocument, deleteDocument, queryDocuments, queryDocumentsPage } from "./DocumentClientUtilityBase";
+import { createCollection } from "./dataAccess/createCollection";
 import * as ErrorParserUtility from "./ErrorParserUtility";
 import * as Logger from "./Logger";
 
@@ -41,12 +36,13 @@ export class QueriesClient {
       ConsoleDataType.InProgress,
       "Setting up account for saving queries"
     );
-    return getOrCreateDatabaseAndCollection({
+    return createCollection({
       collectionId: SavedQueries.CollectionName,
+      createNewDatabase: true,
       databaseId: SavedQueries.DatabaseName,
       partitionKey: QueriesClient.PartitionKey,
       offerThroughput: SavedQueries.OfferThroughput,
-      databaseLevelThroughput: undefined
+      databaseLevelThroughput: false
     })
       .then(
         (collection: DataModels.Collection) => {

src/Common/dataAccess/createCollection.test.ts

@@ -0,0 +1,81 @@
+jest.mock("../../Utils/arm/request");
+jest.mock("../CosmosClient");
+jest.mock("../DataAccessUtilityBase");
+import { AuthType } from "../../AuthType";
+import { CreateCollectionParams, DatabaseAccount } from "../../Contracts/DataModels";
+import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
+import { armRequest } from "../../Utils/arm/request";
+import { client } from "../CosmosClient";
+import { createCollection, constructRpOptions } from "./createCollection";
+import { updateUserContext } from "../../UserContext";
+
+describe("createCollection", () => {
+  const createCollectionParams: CreateCollectionParams = {
+    createNewDatabase: false,
+    collectionId: "testContainer",
+    databaseId: "testDatabase",
+    databaseLevelThroughput: true,
+    offerThroughput: 400
+  };
+
+  beforeAll(() => {
+    updateUserContext({
+      databaseAccount: {
+        name: "test"
+      } as DatabaseAccount,
+      defaultExperience: DefaultAccountExperienceType.DocumentDB
+    });
+  });
+
+  it("should call ARM if logged in with AAD", async () => {
+    window.authType = AuthType.AAD;
+    await createCollection(createCollectionParams);
+    expect(armRequest).toHaveBeenCalled();
+  });
+
+  it("should call SDK if not logged in with non-AAD method", async () => {
+    window.authType = AuthType.MasterKey;
+    (client as jest.Mock).mockReturnValue({
+      databases: {
+        createIfNotExists: () => {
+          return {
+            database: {
+              containers: {
+                create: () => ({})
+              }
+            }
+          };
+        }
+      }
+    });
+    await createCollection(createCollectionParams);
+    expect(client).toHaveBeenCalled();
+  });
+
+  it("constructRpOptions should return the correct options", () => {
+    expect(constructRpOptions(createCollectionParams)).toEqual({});
+
+    const manualThroughputParams: CreateCollectionParams = {
+      createNewDatabase: false,
+      collectionId: "testContainer",
+      databaseId: "testDatabase",
+      databaseLevelThroughput: false,
+      offerThroughput: 400
+    };
+    expect(constructRpOptions(manualThroughputParams)).toEqual({ throughput: 400 });
+
+    const autoPilotThroughputParams: CreateCollectionParams = {
+      createNewDatabase: false,
+      collectionId: "testContainer",
+      databaseId: "testDatabase",
+      databaseLevelThroughput: false,
+      offerThroughput: 400,
+      autoPilotMaxThroughput: 4000
+    };
+    expect(constructRpOptions(autoPilotThroughputParams)).toEqual({
+      autoscaleSettings: {
+        maxThroughput: 4000
+      }
+    });
+  });
+});

src/Common/dataAccess/createCollection.ts

@@ -0,0 +1,374 @@
+import * as DataModels from "../../Contracts/DataModels";
+import * as ErrorParserUtility from "../ErrorParserUtility";
+import { AuthType } from "../../AuthType";
+import { ContainerResponse, DatabaseResponse } from "@azure/cosmos";
+import { ContainerRequest } from "@azure/cosmos/dist-esm/client/Container/ContainerRequest";
+import { DatabaseRequest } from "@azure/cosmos/dist-esm/client/Database/DatabaseRequest";
+import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
+import { RequestOptions } from "@azure/cosmos/dist-esm";
+import * as ARMTypes from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/types";
+import { client } from "../CosmosClient";
+import { createMongoCollectionWithProxy } from "../MongoProxyClient";
+import {
+  createUpdateSqlContainer,
+  getSqlContainer
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/sqlResources";
+import {
+  createUpdateCassandraTable,
+  getCassandraTable
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources";
+import {
+  createUpdateMongoDBCollection,
+  getMongoDBCollection
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/mongoDBResources";
+import {
+  createUpdateGremlinGraph,
+  getGremlinGraph
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/gremlinResources";
+import { createUpdateTable, getTable } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/tableResources";
+import { logConsoleProgress, logConsoleError, logConsoleInfo } from "../../Utils/NotificationConsoleUtils";
+import { logError } from "../Logger";
+import { refreshCachedResources } from "../DataAccessUtilityBase";
+import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
+import { createDatabase } from "./createDatabase";
+
+export const createCollection = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  let collection: DataModels.Collection;
+  const clearMessage = logConsoleProgress(
+    `Creating a new container ${params.collectionId} for database ${params.databaseId}`
+  );
+  try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      if (params.createNewDatabase) {
+        const createDatabaseParams: DataModels.CreateDatabaseParams = {
+          autoPilotMaxThroughput: params.autoPilotMaxThroughput,
+          databaseId: params.databaseId,
+          databaseLevelThroughput: params.databaseLevelThroughput,
+          offerThroughput: params.offerThroughput
+        };
+        await createDatabase(createDatabaseParams);
+      }
+      collection = await createCollectionWithARM(params);
+    } else if (userContext.defaultExperience === DefaultAccountExperienceType.MongoDB) {
+      collection = await createMongoCollectionWithProxy(params);
+    } else {
+      collection = await createCollectionWithSDK(params);
+    }
+  } catch (error) {
+    const sanitizedError = ErrorParserUtility.replaceKnownError(JSON.stringify(error));
+    logConsoleError(`Error while creating container ${params.collectionId}:\n ${sanitizedError}`);
+    logError(JSON.stringify(error), "CreateCollection", error.code);
+    sendNotificationForError(error);
+    clearMessage();
+    throw error;
+  }
+  logConsoleInfo(`Successfully created container ${params.collectionId}`);
+  await refreshCachedResources();
+  clearMessage();
+  return collection;
+};
+
+const createCollectionWithARM = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  const defaultExperience = userContext.defaultExperience;
+  switch (defaultExperience) {
+    case DefaultAccountExperienceType.DocumentDB:
+      return createSqlContainer(params);
+    case DefaultAccountExperienceType.MongoDB:
+      return createMongoCollection(params);
+    case DefaultAccountExperienceType.Cassandra:
+      return createCassandraTable(params);
+    case DefaultAccountExperienceType.Graph:
+      return createGraph(params);
+    case DefaultAccountExperienceType.Table:
+      return createTable(params);
+    default:
+      throw new Error(`Unsupported default experience type: ${defaultExperience}`);
+  }
+};
+
+const createSqlContainer = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  try {
+    const getResponse = await getSqlContainer(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId,
+      params.collectionId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create container failed: container with id ${params.collectionId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: ARMTypes.CreateUpdateOptions = constructRpOptions(params);
+  const resource: ARMTypes.SqlContainerResource = {
+    id: params.collectionId
+  };
+  if (params.analyticalStorageTtl) {
+    resource.analyticalStorageTtl = params.analyticalStorageTtl;
+  }
+  if (params.indexingPolicy) {
+    resource.indexingPolicy = params.indexingPolicy;
+  }
+  if (params.partitionKey) {
+    resource.partitionKey = params.partitionKey;
+  }
+  if (params.uniqueKeyPolicy) {
+    resource.uniqueKeyPolicy = params.uniqueKeyPolicy;
+  }
+
+  const rpPayload: ARMTypes.SqlDatabaseCreateUpdateParameters = {
+    properties: {
+      resource,
+      options
+    }
+  };
+
+  const createResponse = await createUpdateSqlContainer(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    params.collectionId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Collection);
+};
+
+const createMongoCollection = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  try {
+    const getResponse = await getMongoDBCollection(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId,
+      params.collectionId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create collection failed: collection with id ${params.collectionId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: ARMTypes.CreateUpdateOptions = constructRpOptions(params);
+  const resource: ARMTypes.MongoDBCollectionResource = {
+    id: params.collectionId
+  };
+  if (params.analyticalStorageTtl) {
+    resource.analyticalStorageTtl = params.analyticalStorageTtl;
+  }
+  if (params.partitionKey) {
+    const partitionKeyPath: string = params.partitionKey.paths[0];
+    resource.shardKey = { [partitionKeyPath]: "Hash" };
+  }
+
+  const rpPayload: ARMTypes.MongoDBCollectionCreateUpdateParameters = {
+    properties: {
+      resource,
+      options
+    }
+  };
+
+  const createResponse = await createUpdateMongoDBCollection(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    params.collectionId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Collection);
+};
+
+const createCassandraTable = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  try {
+    const getResponse = await getCassandraTable(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId,
+      params.collectionId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create table failed: table with id ${params.collectionId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: ARMTypes.CreateUpdateOptions = constructRpOptions(params);
+  const resource: ARMTypes.CassandraTableResource = {
+    id: params.collectionId
+  };
+  if (params.analyticalStorageTtl) {
+    resource.analyticalStorageTtl = params.analyticalStorageTtl;
+  }
+
+  const rpPayload: ARMTypes.CassandraTableCreateUpdateParameters = {
+    properties: {
+      resource,
+      options
+    }
+  };
+
+  const createResponse = await createUpdateCassandraTable(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    params.collectionId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Collection);
+};
+
+const createGraph = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  try {
+    const getResponse = await getGremlinGraph(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId,
+      params.collectionId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create graph failed: graph with id ${params.collectionId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: ARMTypes.CreateUpdateOptions = constructRpOptions(params);
+  const resource: ARMTypes.GremlinGraphResource = {
+    id: params.collectionId
+  };
+
+  if (params.indexingPolicy) {
+    resource.indexingPolicy = params.indexingPolicy;
+  }
+  if (params.partitionKey) {
+    resource.partitionKey = params.partitionKey;
+  }
+  if (params.uniqueKeyPolicy) {
+    resource.uniqueKeyPolicy = params.uniqueKeyPolicy;
+  }
+
+  const rpPayload: ARMTypes.GremlinGraphCreateUpdateParameters = {
+    properties: {
+      resource,
+      options
+    }
+  };
+
+  const createResponse = await createUpdateGremlinGraph(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    params.collectionId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Collection);
+};
+
+const createTable = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  try {
+    const getResponse = await getTable(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.collectionId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create table failed: table with id ${params.collectionId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: ARMTypes.CreateUpdateOptions = constructRpOptions(params);
+  const resource: ARMTypes.TableResource = {
+    id: params.collectionId
+  };
+
+  const rpPayload: ARMTypes.TableCreateUpdateParameters = {
+    properties: {
+      resource,
+      options
+    }
+  };
+
+  const createResponse = await createUpdateTable(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.collectionId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Collection);
+};
+
+export const constructRpOptions = (params: DataModels.CreateDatabaseParams): ARMTypes.CreateUpdateOptions => {
+  if (params.databaseLevelThroughput) {
+    return {};
+  }
+
+  if (params.autoPilotMaxThroughput) {
+    return {
+      autoscaleSettings: {
+        maxThroughput: params.autoPilotMaxThroughput
+      }
+    };
+  }
+
+  return {
+    throughput: params.offerThroughput
+  };
+};
+
+const createCollectionWithSDK = async (params: DataModels.CreateCollectionParams): Promise<DataModels.Collection> => {
+  const createCollectionBody: ContainerRequest = {
+    id: params.collectionId,
+    partitionKey: params.partitionKey || undefined,
+    indexingPolicy: params.indexingPolicy || undefined,
+    uniqueKeyPolicy: params.uniqueKeyPolicy || undefined,
+    analyticalStorageTtl: params.analyticalStorageTtl
+  } as ContainerRequest; // TODO: remove cast when https://github.com/Azure/azure-cosmos-js/issues/423 is fixed
+  const collectionOptions: RequestOptions = {};
+  const createDatabaseBody: DatabaseRequest = { id: params.databaseId };
+
+  if (params.databaseLevelThroughput) {
+    if (params.autoPilotMaxThroughput) {
+      createDatabaseBody.maxThroughput = params.autoPilotMaxThroughput;
+    } else {
+      createDatabaseBody.throughput = params.offerThroughput;
+    }
+  } else {
+    if (params.autoPilotMaxThroughput) {
+      createCollectionBody.maxThroughput = params.autoPilotMaxThroughput;
+    } else {
+      createCollectionBody.throughput = params.offerThroughput;
+    }
+  }
+
+  const databaseResponse: DatabaseResponse = await client().databases.createIfNotExists(createDatabaseBody);
+  const collectionResponse: ContainerResponse = await databaseResponse?.database.containers.create(
+    createCollectionBody,
+    collectionOptions
+  );
+  return collectionResponse?.resource as DataModels.Collection;
+};

src/Common/dataAccess/createDatabase.ts

@@ -0,0 +1,254 @@
+import * as DataModels from "../../Contracts/DataModels";
+import { AuthType } from "../../AuthType";
+import { DatabaseResponse } from "@azure/cosmos";
+import { DatabaseRequest } from "@azure/cosmos/dist-esm/client/Database/DatabaseRequest";
+import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
+import {
+  CassandraKeyspaceCreateUpdateParameters,
+  GremlinDatabaseCreateUpdateParameters,
+  MongoDBDatabaseCreateUpdateParameters,
+  SqlDatabaseCreateUpdateParameters,
+  CreateUpdateOptions
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/types";
+import { client } from "../CosmosClient";
+import {
+  createUpdateSqlDatabase,
+  getSqlDatabase
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/sqlResources";
+import {
+  createUpdateCassandraKeyspace,
+  getCassandraKeyspace
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources";
+import {
+  createUpdateMongoDBDatabase,
+  getMongoDBDatabase
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/mongoDBResources";
+import {
+  createUpdateGremlinDatabase,
+  getGremlinDatabase
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/gremlinResources";
+import { logConsoleProgress, logConsoleError, logConsoleInfo } from "../../Utils/NotificationConsoleUtils";
+import { logError } from "../Logger";
+import { refreshCachedOffers, refreshCachedResources } from "../DataAccessUtilityBase";
+import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
+
+export async function createDatabase(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
+  let database: DataModels.Database;
+  const clearMessage = logConsoleProgress(`Creating a new database ${params.databaseId}`);
+  try {
+    if (
+      window.authType === AuthType.AAD &&
+      !userContext.useSDKOperations &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.Table
+    ) {
+      database = await createDatabaseWithARM(params);
+    } else {
+      database = await createDatabaseWithSDK(params);
+    }
+  } catch (error) {
+    logConsoleError(`Error while creating database ${params.databaseId}:\n ${error.message}`);
+    logError(JSON.stringify(error), "CreateDatabase", error.code);
+    sendNotificationForError(error);
+    clearMessage();
+    throw error;
+  }
+  logConsoleInfo(`Successfully created database ${params.databaseId}`);
+  await refreshCachedResources();
+  await refreshCachedOffers();
+  clearMessage();
+  return database;
+}
+
+async function createDatabaseWithARM(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
+  const defaultExperience = userContext.defaultExperience;
+  switch (defaultExperience) {
+    case DefaultAccountExperienceType.DocumentDB:
+      return createSqlDatabase(params);
+    case DefaultAccountExperienceType.MongoDB:
+      return createMongoDatabase(params);
+    case DefaultAccountExperienceType.Cassandra:
+      return createCassandraKeyspace(params);
+    case DefaultAccountExperienceType.Graph:
+      return createGremlineDatabase(params);
+    default:
+      throw new Error(`Unsupported default experience type: ${defaultExperience}`);
+  }
+}
+
+async function createSqlDatabase(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
+  try {
+    const getResponse = await getSqlDatabase(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create database failed: database with id ${params.databaseId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: CreateUpdateOptions = constructRpOptions(params);
+  const rpPayload: SqlDatabaseCreateUpdateParameters = {
+    properties: {
+      resource: {
+        id: params.databaseId
+      },
+      options
+    }
+  };
+  const createResponse = await createUpdateSqlDatabase(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Database);
+}
+
+async function createMongoDatabase(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
+  try {
+    const getResponse = await getMongoDBDatabase(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create database failed: database with id ${params.databaseId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: CreateUpdateOptions = constructRpOptions(params);
+  const rpPayload: MongoDBDatabaseCreateUpdateParameters = {
+    properties: {
+      resource: {
+        id: params.databaseId
+      },
+      options
+    }
+  };
+  const createResponse = await createUpdateMongoDBDatabase(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Database);
+}
+
+async function createCassandraKeyspace(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
+  try {
+    const getResponse = await getCassandraKeyspace(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create database failed: database with id ${params.databaseId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: CreateUpdateOptions = constructRpOptions(params);
+  const rpPayload: CassandraKeyspaceCreateUpdateParameters = {
+    properties: {
+      resource: {
+        id: params.databaseId
+      },
+      options
+    }
+  };
+  const createResponse = await createUpdateCassandraKeyspace(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Database);
+}
+
+async function createGremlineDatabase(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
+  try {
+    const getResponse = await getGremlinDatabase(
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      params.databaseId
+    );
+    if (getResponse?.properties?.resource) {
+      throw new Error(`Create database failed: database with id ${params.databaseId} already exists`);
+    }
+  } catch (error) {
+    if (error.code !== "NotFound") {
+      throw error;
+    }
+  }
+
+  const options: CreateUpdateOptions = constructRpOptions(params);
+  const rpPayload: GremlinDatabaseCreateUpdateParameters = {
+    properties: {
+      resource: {
+        id: params.databaseId
+      },
+      options
+    }
+  };
+  const createResponse = await createUpdateGremlinDatabase(
+    userContext.subscriptionId,
+    userContext.resourceGroup,
+    userContext.databaseAccount.name,
+    params.databaseId,
+    rpPayload
+  );
+  return createResponse && (createResponse.properties.resource as DataModels.Database);
+}
+
+async function createDatabaseWithSDK(params: DataModels.CreateDatabaseParams): Promise<DataModels.Database> {
+  const createBody: DatabaseRequest = { id: params.databaseId };
+
+  if (params.databaseLevelThroughput) {
+    if (params.autoPilotMaxThroughput) {
+      createBody.maxThroughput = params.autoPilotMaxThroughput;
+    } else {
+      createBody.throughput = params.offerThroughput;
+    }
+  }
+
+  const response: DatabaseResponse = await client().databases.create(createBody);
+  return response.resource;
+}
+
+function constructRpOptions(params: DataModels.CreateDatabaseParams): CreateUpdateOptions {
+  if (!params.databaseLevelThroughput) {
+    return {};
+  }
+
+  if (params.autoPilotMaxThroughput) {
+    return {
+      autoscaleSettings: {
+        maxThroughput: params.autoPilotMaxThroughput
+      }
+    };
+  }
+
+  return {
+    throughput: params.offerThroughput
+  };
+}

src/Common/dataAccess/deleteCollection.ts

@@ -1,10 +1,10 @@
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
-import { deleteSqlContainer } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { deleteCassandraTable } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
-import { deleteMongoDBCollection } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
-import { deleteGremlinGraph } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
-import { deleteTable } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
+import { deleteSqlContainer } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/sqlResources";
+import { deleteCassandraTable } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources";
+import { deleteMongoDBCollection } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/mongoDBResources";
+import { deleteGremlinGraph } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/gremlinResources";
+import { deleteTable } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/tableResources";
 import { logConsoleError, logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
@@ -15,7 +15,7 @@ import { refreshCachedResources } from "../DataAccessUtilityBase";
 export async function deleteCollection(databaseId: string, collectionId: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting container ${collectionId}`);
   try {
-    if (window.authType === AuthType.AAD) {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
       await deleteCollectionWithARM(databaseId, collectionId);
     } else {
       await client()

src/Common/dataAccess/deleteDatabase.ts

@@ -1,9 +1,9 @@
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
-import { deleteSqlDatabase } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { deleteCassandraKeyspace } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
-import { deleteMongoDBDatabase } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
-import { deleteGremlinDatabase } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
+import { deleteSqlDatabase } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/sqlResources";
+import { deleteCassandraKeyspace } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources";
+import { deleteMongoDBDatabase } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/mongoDBResources";
+import { deleteGremlinDatabase } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/gremlinResources";
 import { logConsoleError, logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { userContext } from "../../UserContext";
 import { client } from "../CosmosClient";
@@ -15,7 +15,11 @@ export async function deleteDatabase(databaseId: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting database ${databaseId}`);
 
   try {
-    if (window.authType === AuthType.AAD) {
+    if (
+      window.authType === AuthType.AAD &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.Table &&
+      !userContext.useSDKOperations
+    ) {
       await deleteDatabaseWithARM(databaseId);
     } else {
       await client()

src/Common/dataAccess/readCollections.ts

@@ -2,11 +2,11 @@ import * as DataModels from "../../Contracts/DataModels";
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
 import { client } from "../CosmosClient";
-import { listSqlContainers } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { listCassandraTables } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
-import { listMongoDBCollections } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
-import { listGremlinGraphs } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
-import { listTables } from "../../Utils/arm/generatedClients/2020-04-01/tableResources";
+import { listSqlContainers } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/sqlResources";
+import { listCassandraTables } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources";
+import { listMongoDBCollections } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/mongoDBResources";
+import { listGremlinGraphs } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/gremlinResources";
+import { listTables } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/tableResources";
 import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
@@ -16,7 +16,12 @@ export async function readCollections(databaseId: string): Promise<DataModels.Co
   let collections: DataModels.Collection[];
   const clearMessage = logConsoleProgress(`Querying containers for database ${databaseId}`);
   try {
-    if (window.authType === AuthType.AAD) {
+    if (
+      window.authType === AuthType.AAD &&
+      !userContext.useSDKOperations &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.MongoDB &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.Table
+    ) {
       collections = await readCollectionsWithARM(databaseId);
     } else {
       const sdkResponse = await client()

src/Common/dataAccess/readDatabases.ts

@@ -2,10 +2,10 @@ import * as DataModels from "../../Contracts/DataModels";
 import { AuthType } from "../../AuthType";
 import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
 import { client } from "../CosmosClient";
-import { listSqlDatabases } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
-import { listCassandraKeyspaces } from "../../Utils/arm/generatedClients/2020-04-01/cassandraResources";
-import { listMongoDBDatabases } from "../../Utils/arm/generatedClients/2020-04-01/mongoDBResources";
-import { listGremlinDatabases } from "../../Utils/arm/generatedClients/2020-04-01/gremlinResources";
+import { listSqlDatabases } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/sqlResources";
+import { listCassandraKeyspaces } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources";
+import { listMongoDBDatabases } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/mongoDBResources";
+import { listGremlinDatabases } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/gremlinResources";
 import { logConsoleProgress, logConsoleError } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
@@ -15,7 +15,13 @@ export async function readDatabases(): Promise<DataModels.Database[]> {
   let databases: DataModels.Database[];
   const clearMessage = logConsoleProgress(`Querying databases`);
   try {
-    if (window.authType === AuthType.AAD) {
+    if (
+      window.authType === AuthType.AAD &&
+      !userContext.useSDKOperations &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.MongoDB &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.Table &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.Cassandra
+    ) {
       databases = await readDatabasesWithARM();
     } else {
       const sdkResponse = await client()

src/Common/dataAccess/updateCollection.ts

@@ -0,0 +1,228 @@
+import { AuthType } from "../../AuthType";
+import { Collection } from "../../Contracts/DataModels";
+import { ContainerDefinition } from "@azure/cosmos";
+import { DefaultAccountExperienceType } from "../../DefaultAccountExperienceType";
+import {
+  ExtendedResourceProperties,
+  SqlContainerCreateUpdateParameters,
+  SqlContainerResource
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/types";
+import { RequestOptions } from "@azure/cosmos/dist-esm";
+import { client } from "../CosmosClient";
+import {
+  createUpdateSqlContainer,
+  getSqlContainer
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/sqlResources";
+import {
+  createUpdateCassandraTable,
+  getCassandraTable
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources";
+import {
+  createUpdateMongoDBCollection,
+  getMongoDBCollection
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/mongoDBResources";
+import {
+  createUpdateGremlinGraph,
+  getGremlinGraph
+} from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/gremlinResources";
+import { createUpdateTable, getTable } from "../../Utils/arm/generatedClients/2020-04-01-cosmos-db/tableResources";
+import { logConsoleError, logConsoleInfo, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import { logError } from "../Logger";
+import { refreshCachedResources } from "../DataAccessUtilityBase";
+import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
+
+export async function updateCollection(
+  databaseId: string,
+  collectionId: string,
+  newCollection: Collection,
+  options: RequestOptions = {}
+): Promise<Collection> {
+  let collection: Collection;
+  const clearMessage = logConsoleProgress(`Updating container ${collectionId}`);
+
+  try {
+    if (
+      window.authType === AuthType.AAD &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.MongoDB &&
+      userContext.defaultExperience !== DefaultAccountExperienceType.Table
+    ) {
+      collection = await updateCollectionWithARM(databaseId, collectionId, newCollection);
+    } else {
+      const sdkResponse = await client()
+        .database(databaseId)
+        .container(collectionId)
+        .replace(newCollection as ContainerDefinition, options);
+      collection = sdkResponse.resource as Collection;
+    }
+  } catch (error) {
+    logConsoleError(`Failed to update container ${collectionId}: ${JSON.stringify(error)}`);
+    logError(JSON.stringify(error), "UpdateCollection", error.code);
+    sendNotificationForError(error);
+    throw error;
+  }
+  logConsoleInfo(`Successfully updated container ${collectionId}`);
+  clearMessage();
+  await refreshCachedResources();
+  return collection;
+}
+
+async function updateCollectionWithARM(
+  databaseId: string,
+  collectionId: string,
+  newCollection: Collection
+): Promise<Collection> {
+  const subscriptionId = userContext.subscriptionId;
+  const resourceGroup = userContext.resourceGroup;
+  const accountName = userContext.databaseAccount.name;
+  const defaultExperience = userContext.defaultExperience;
+
+  switch (defaultExperience) {
+    case DefaultAccountExperienceType.DocumentDB:
+      return updateSqlContainer(databaseId, collectionId, subscriptionId, resourceGroup, accountName, newCollection);
+    case DefaultAccountExperienceType.MongoDB:
+      return updateMongoDBCollection(
+        databaseId,
+        collectionId,
+        subscriptionId,
+        resourceGroup,
+        accountName,
+        newCollection
+      );
+    case DefaultAccountExperienceType.Cassandra:
+      return updateCassandraTable(databaseId, collectionId, subscriptionId, resourceGroup, accountName, newCollection);
+    case DefaultAccountExperienceType.Graph:
+      return updateGremlinGraph(databaseId, collectionId, subscriptionId, resourceGroup, accountName, newCollection);
+    case DefaultAccountExperienceType.Table:
+      return updateTable(collectionId, subscriptionId, resourceGroup, accountName, newCollection);
+    default:
+      throw new Error(`Unsupported default experience type: ${defaultExperience}`);
+  }
+}
+
+async function updateSqlContainer(
+  databaseId: string,
+  collectionId: string,
+  subscriptionId: string,
+  resourceGroup: string,
+  accountName: string,
+  newCollection: Collection
+): Promise<Collection> {
+  const getResponse = await getSqlContainer(subscriptionId, resourceGroup, accountName, databaseId, collectionId);
+  if (getResponse && getResponse.properties && getResponse.properties.resource) {
+    getResponse.properties.resource = newCollection as SqlContainerResource & ExtendedResourceProperties;
+    const updateResponse = await createUpdateSqlContainer(
+      subscriptionId,
+      resourceGroup,
+      accountName,
+      databaseId,
+      collectionId,
+      getResponse as SqlContainerCreateUpdateParameters
+    );
+    return updateResponse && (updateResponse.properties.resource as Collection);
+  }
+
+  throw new Error(`Sql container to update does not exist. Database id: ${databaseId} Collection id: ${collectionId}`);
+}
+
+async function updateMongoDBCollection(
+  databaseId: string,
+  collectionId: string,
+  subscriptionId: string,
+  resourceGroup: string,
+  accountName: string,
+  newCollection: Collection
+): Promise<Collection> {
+  const getResponse = await getMongoDBCollection(subscriptionId, resourceGroup, accountName, databaseId, collectionId);
+  if (getResponse && getResponse.properties && getResponse.properties.resource) {
+    getResponse.properties.resource = newCollection as SqlContainerResource & ExtendedResourceProperties;
+    const updateResponse = await createUpdateMongoDBCollection(
+      subscriptionId,
+      resourceGroup,
+      accountName,
+      databaseId,
+      collectionId,
+      getResponse as SqlContainerCreateUpdateParameters
+    );
+    return updateResponse && (updateResponse.properties.resource as Collection);
+  }
+
+  throw new Error(
+    `MongoDB collection to update does not exist. Database id: ${databaseId} Collection id: ${collectionId}`
+  );
+}
+
+async function updateCassandraTable(
+  databaseId: string,
+  collectionId: string,
+  subscriptionId: string,
+  resourceGroup: string,
+  accountName: string,
+  newCollection: Collection
+): Promise<Collection> {
+  const getResponse = await getCassandraTable(subscriptionId, resourceGroup, accountName, databaseId, collectionId);
+  if (getResponse && getResponse.properties && getResponse.properties.resource) {
+    getResponse.properties.resource = newCollection as SqlContainerResource & ExtendedResourceProperties;
+    const updateResponse = await createUpdateCassandraTable(
+      subscriptionId,
+      resourceGroup,
+      accountName,
+      databaseId,
+      collectionId,
+      getResponse as SqlContainerCreateUpdateParameters
+    );
+    return updateResponse && (updateResponse.properties.resource as Collection);
+  }
+
+  throw new Error(
+    `Cassandra table to update does not exist. Database id: ${databaseId} Collection id: ${collectionId}`
+  );
+}
+
+async function updateGremlinGraph(
+  databaseId: string,
+  collectionId: string,
+  subscriptionId: string,
+  resourceGroup: string,
+  accountName: string,
+  newCollection: Collection
+): Promise<Collection> {
+  const getResponse = await getGremlinGraph(subscriptionId, resourceGroup, accountName, databaseId, collectionId);
+  if (getResponse && getResponse.properties && getResponse.properties.resource) {
+    getResponse.properties.resource = newCollection as SqlContainerResource & ExtendedResourceProperties;
+    const updateResponse = await createUpdateGremlinGraph(
+      subscriptionId,
+      resourceGroup,
+      accountName,
+      databaseId,
+      collectionId,
+      getResponse as SqlContainerCreateUpdateParameters
+    );
+    return updateResponse && (updateResponse.properties.resource as Collection);
+  }
+
+  throw new Error(`Gremlin graph to update does not exist. Database id: ${databaseId} Collection id: ${collectionId}`);
+}
+
+async function updateTable(
+  collectionId: string,
+  subscriptionId: string,
+  resourceGroup: string,
+  accountName: string,
+  newCollection: Collection
+): Promise<Collection> {
+  const getResponse = await getTable(subscriptionId, resourceGroup, accountName, collectionId);
+  if (getResponse && getResponse.properties && getResponse.properties.resource) {
+    getResponse.properties.resource = newCollection as SqlContainerResource & ExtendedResourceProperties;
+    const updateResponse = await createUpdateTable(
+      subscriptionId,
+      resourceGroup,
+      accountName,
+      collectionId,
+      getResponse as SqlContainerCreateUpdateParameters
+    );
+    return updateResponse && (updateResponse.properties.resource as Collection);
+  }
+
+  throw new Error(`Table to update does not exist. Table id: ${collectionId}`);
+}

src/ConfigContext.ts

@@ -80,12 +80,20 @@ export async function initializeConfiguration(): Promise<ConfigContext> {
         console.error(error);
       }
     }
-    // Allow override of any config value with URL query parameters
+    // Allow override of platform value with URL query parameter
     const params = new URLSearchParams(window.location.search);
-    params.forEach((value, key) => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (configContext as any)[key] = value;
-    });
+    if (params.has("platform")) {
+      const platform = params.get("platform");
+      switch (platform) {
+        default:
+          console.log("Invalid platform query parameter given, ignoring");
+          break;
+        case Platform.Portal:
+        case Platform.Hosted:
+        case Platform.Emulator:
+          updateConfigContext({ platform });
+      }
+    }
   } catch (error) {
     console.log("No configuration file found using defaults");
   }

src/Contracts/DataModels.ts

@@ -153,7 +153,14 @@ export interface KeyResource {
   Token: string;
 }
 
-export interface IndexingPolicy {}
+export interface IndexingPolicy {
+  automatic: boolean;
+  indexingMode: string;
+  includedPaths: any;
+  excludedPaths: any;
+  compositeIndexes?: any;
+  spatialIndexes?: any;
+}
 
 export interface PartitionKey {
   paths: string[];
@@ -320,12 +327,24 @@ export interface AutoPilotOfferSettings {
   targetMaxThroughput?: number;
 }
 
-export interface CreateDatabaseRequest {
+export interface CreateDatabaseParams {
+  autoPilotMaxThroughput?: number;
   databaseId: string;
   databaseLevelThroughput?: boolean;
   offerThroughput?: number;
-  autoPilot?: AutoPilotCreationSettings;
-  hasAutoPilotV2FeatureFlag?: boolean;
+}
+
+export interface CreateCollectionParams {
+  createNewDatabase: boolean;
+  collectionId: string;
+  databaseId: string;
+  databaseLevelThroughput: boolean;
+  offerThroughput: number;
+  analyticalStorageTtl?: number;
+  autoPilotMaxThroughput?: number;
+  indexingPolicy?: IndexingPolicy;
+  partitionKey?: PartitionKey;
+  uniqueKeyPolicy?: UniqueKeyPolicy;
 }
 
 export interface SharedThroughputRange {
@@ -690,11 +709,6 @@ export interface SparkPool extends ArmResource {
   properties: SparkPoolProperties;
 }
 
-export interface MemoryUsageInfo {
-  freeKB: number;
-  totalKB: number;
-}
-
 export interface resourceTokenConnectionStringProperties {
   accountEndpoint: string;
   collectionId: string;

src/Explorer/Controls/CommandButton/CommandButtonComponent.tsx

@@ -1,6 +1,6 @@
 import { StringUtils } from "../../../Utils/StringUtils";
 import { KeyCodes } from "../../../Common/Constants";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../../Shared/Telemetry/TelemetryConstants";
 import CollapseChevronDownIcon from "../../../../images/QueryBuilder/CollapseChevronDown_16x.png";
 

src/Explorer/Controls/Directory/__snapshots__/DirectoryListComponent.test.tsx.snap

@@ -265,6 +265,9 @@ exports[`test render renders with filters 1`] = `
             "buttonTextDisabled": "#a19f9d",
             "buttonTextHovered": "#201f1e",
             "buttonTextPressed": "#201f1e",
+            "cardShadow": "0 1.6px 3.6px 0 rgba(0, 0, 0, 0.132), 0 0.3px 0.9px 0 rgba(0, 0, 0, 0.108)",
+            "cardShadowHovered": "0 3.2px 7.2px 0 rgba(0, 0, 0, 0.132), 0 0.6px 1.8px 0 rgba(0, 0, 0, 0.108)",
+            "cardStandoutBackground": "#ffffff",
             "defaultStateBackground": "#faf9f8",
             "disabledBackground": "#f3f2f1",
             "disabledBodySubtext": "#c8c6c4",
@@ -604,6 +607,9 @@ exports[`test render renders with filters 1`] = `
                             "buttonTextDisabled": "#a19f9d",
                             "buttonTextHovered": "#201f1e",
                             "buttonTextPressed": "#201f1e",
+                            "cardShadow": "0 1.6px 3.6px 0 rgba(0, 0, 0, 0.132), 0 0.3px 0.9px 0 rgba(0, 0, 0, 0.108)",
+                            "cardShadowHovered": "0 3.2px 7.2px 0 rgba(0, 0, 0, 0.132), 0 0.6px 1.8px 0 rgba(0, 0, 0, 0.108)",
+                            "cardStandoutBackground": "#ffffff",
                             "defaultStateBackground": "#faf9f8",
                             "disabledBackground": "#f3f2f1",
                             "disabledBodySubtext": "#c8c6c4",
@@ -997,6 +1003,9 @@ exports[`test render renders with filters 1`] = `
                               "buttonTextDisabled": "#a19f9d",
                               "buttonTextHovered": "#201f1e",
                               "buttonTextPressed": "#201f1e",
+                              "cardShadow": "0 1.6px 3.6px 0 rgba(0, 0, 0, 0.132), 0 0.3px 0.9px 0 rgba(0, 0, 0, 0.108)",
+                              "cardShadowHovered": "0 3.2px 7.2px 0 rgba(0, 0, 0, 0.132), 0 0.6px 1.8px 0 rgba(0, 0, 0, 0.108)",
+                              "cardStandoutBackground": "#ffffff",
                               "defaultStateBackground": "#faf9f8",
                               "disabledBackground": "#f3f2f1",
                               "disabledBodySubtext": "#c8c6c4",
@@ -1113,6 +1122,11 @@ exports[`test render renders with filters 1`] = `
                               },
                               "iconDisabled": Object {
                                 "color": "#a19f9d",
+                                "selectors": Object {
+                                  "@media screen and (-ms-high-contrast: active)": Object {
+                                    "color": "GrayText",
+                                  },
+                                },
                               },
                               "label": Array [
                                 Object {
@@ -1134,6 +1148,11 @@ exports[`test render renders with filters 1`] = `
                               },
                               "menuIconDisabled": Object {
                                 "color": "#a19f9d",
+                                "selectors": Object {
+                                  "@media screen and (-ms-high-contrast: active)": Object {
+                                    "color": "GrayText",
+                                  },
+                                },
                               },
                               "root": Array [
                                 Object {
@@ -1150,7 +1169,6 @@ exports[`test render renders with filters 1`] = `
                                       "right": 2,
                                       "selectors": Object {
                                         "@media screen and (-ms-high-contrast: active)": Object {
-                                          "border": "none",
                                           "bottom": -2,
                                           "left": -2,
                                           "outlineColor": "ButtonText",
@@ -1230,7 +1248,6 @@ exports[`test render renders with filters 1`] = `
                                       "right": 2,
                                       "selectors": Object {
                                         "@media screen and (-ms-high-contrast: active)": Object {
-                                          "border": "none",
                                           "bottom": -2,
                                           "left": -2,
                                           "outlineColor": "ButtonText",
@@ -1259,10 +1276,6 @@ exports[`test render renders with filters 1`] = `
                                     ":hover": Object {
                                       "outline": 0,
                                     },
-                                    "@media screen and (-ms-high-contrast: active)": Object {
-                                      "borderColor": "grayText",
-                                      "color": "grayText",
-                                    },
                                   },
                                 },
                                 Object {
@@ -1362,13 +1375,21 @@ exports[`test render renders with filters 1`] = `
                                       "selectors": Object {
                                         "@media screen and (-ms-high-contrast: active)": Object {
                                           "MsHighContrastAdjust": "none",
-                                          "backgroundColor": "WindowText",
-                                          "color": "Window",
+                                          "backgroundColor": "Window",
+                                          "border": "1px solid WindowText",
+                                          "borderRightWidth": "0",
+                                          "color": "WindowText",
                                         },
                                       },
                                     },
                                     ".ms-Button--primary + .ms-Button": Object {
                                       "border": "none",
+                                      "selectors": Object {
+                                        "@media screen and (-ms-high-contrast: active)": Object {
+                                          "border": "1px solid WindowText",
+                                          "borderLeftWidth": "0",
+                                        },
+                                      },
                                     },
                                   },
                                 },
@@ -1408,6 +1429,9 @@ exports[`test render renders with filters 1`] = `
                                     "borderColor": "GrayText",
                                     "color": "GrayText",
                                   },
+                                  "@media screen and (forced-colors: active)": Object {
+                                    "forcedColorAdjust": "none",
+                                  },
                                 },
                               },
                               "splitButtonContainerFocused": Object {
@@ -1554,6 +1578,13 @@ exports[`test render renders with filters 1`] = `
                                         },
                                       },
                                     },
+                                    ".ms-Button-menuIcon": Object {
+                                      "selectors": Object {
+                                        "@media screen and (-ms-high-contrast: active)": Object {
+                                          "color": "GrayText",
+                                        },
+                                      },
+                                    },
                                     ":hover": Object {
                                       "cursor": "default",
                                     },
@@ -1775,6 +1806,9 @@ exports[`test render renders with filters 1`] = `
                                 "buttonTextDisabled": "#a19f9d",
                                 "buttonTextHovered": "#201f1e",
                                 "buttonTextPressed": "#201f1e",
+                                "cardShadow": "0 1.6px 3.6px 0 rgba(0, 0, 0, 0.132), 0 0.3px 0.9px 0 rgba(0, 0, 0, 0.108)",
+                                "cardShadowHovered": "0 3.2px 7.2px 0 rgba(0, 0, 0, 0.132), 0 0.6px 1.8px 0 rgba(0, 0, 0, 0.108)",
+                                "cardStandoutBackground": "#ffffff",
                                 "defaultStateBackground": "#faf9f8",
                                 "disabledBackground": "#f3f2f1",
                                 "disabledBodySubtext": "#c8c6c4",

src/Explorer/Controls/GitHub/AddRepoComponent.tsx

@@ -6,7 +6,7 @@ import { RepoListItem } from "./GitHubReposComponent";
 import { ChildrenMargin } from "./GitHubStyleConstants";
 import * as GitHubUtils from "../../../Utils/GitHubUtils";
 import { IGitHubRepo } from "../../../GitHub/GitHubClient";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 import UrlUtility from "../../../Common/UrlUtility";
 import Explorer from "../../Explorer";
 

src/Explorer/Controls/QueriesGridReactComponent/QueriesGridComponent.tsx

@@ -24,7 +24,7 @@ import {
 } from "office-ui-fabric-react/lib/utilities/selection/index";
 import { StyleConstants } from "../../../Common/Constants";
 import { TextField, ITextFieldProps, ITextField } from "office-ui-fabric-react/lib/TextField";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 
 import SaveQueryBannerIcon from "../../../../images/save_query_banner.png";
 import { QueriesClient } from "../../../Common/QueriesClient";

src/Explorer/DataSamples/ContainerSampleGenerator.test.ts

@@ -1,4 +1,5 @@
 jest.mock("../../Common/DocumentClientUtilityBase");
+jest.mock("../../Common/dataAccess/createCollection");
 import * as ko from "knockout";
 import * as sinon from "sinon";
 import * as ViewModels from "../../Contracts/ViewModels";
@@ -33,8 +34,8 @@ describe("ContainerSampleGenerator", () => {
       databaseId: sampleDatabaseId,
       offerThroughput: 400,
       databaseLevelThroughput: false,
+      createNewDatabase: true,
       collectionId: sampleCollectionId,
-      rupmEnabled: false,
       data: [
         {
           firstname: "Eva",
@@ -99,8 +100,8 @@ describe("ContainerSampleGenerator", () => {
       databaseId: sampleDatabaseId,
       offerThroughput: 400,
       databaseLevelThroughput: false,
+      createNewDatabase: true,
       collectionId: sampleCollectionId,
-      rupmEnabled: false,
       data: [
         "g.addV('person').property(id, '1').property('_partitionKey','pk').property('name', 'Eva').property('age', 44)"
       ]

src/Explorer/DataSamples/ContainerSampleGenerator.ts

@@ -1,4 +1,3 @@
-import * as Constants from "../../Common/Constants";
 import * as DataModels from "../../Contracts/DataModels";
 import * as ViewModels from "../../Contracts/ViewModels";
 import GraphTab from ".././Tabs/GraphTab";
@@ -6,10 +5,11 @@ import { ConsoleDataType } from "../Menus/NotificationConsole/NotificationConsol
 import { GremlinClient } from "../Graph/GraphExplorerComponent/GremlinClient";
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
 import Explorer from "../Explorer";
-import { createDocument, getOrCreateDatabaseAndCollection } from "../../Common/DocumentClientUtilityBase";
+import { createDocument } from "../../Common/DocumentClientUtilityBase";
+import { createCollection } from "../../Common/dataAccess/createCollection";
 import { userContext } from "../../UserContext";
 
-interface SampleDataFile extends DataModels.CreateDatabaseAndCollectionRequest {
+interface SampleDataFile extends DataModels.CreateCollectionParams {
   data: any[];
 }
 
@@ -54,18 +54,11 @@ export class ContainerSampleGenerator {
   }
 
   private async createContainerAsync(): Promise<ViewModels.Collection> {
-    const createRequest: DataModels.CreateDatabaseAndCollectionRequest = {
+    const createRequest: DataModels.CreateCollectionParams = {
       ...this.sampleDataFile
     };
 
-    const options: any = {};
-    if (this.container.isPreferredApiMongoDB()) {
-      options.initialHeaders = options.initialHeaders || {};
-      options.initialHeaders[Constants.HttpHeaders.supportSpatialLegacyCoordinates] = true;
-      options.initialHeaders[Constants.HttpHeaders.usePolygonsSmallerThanAHemisphere] = true;
-    }
-
-    await getOrCreateDatabaseAndCollection(createRequest, options);
+    await createCollection(createRequest);
     await this.container.refreshAllDatabases();
     const database = this.container.findDatabaseWithId(this.sampleDataFile.databaseId);
     if (!database) {

src/Explorer/Explorer.ts

@@ -26,7 +26,7 @@ import NewVertexPane from "./Panes/NewVertexPane";
 import NotebookV2Tab, { NotebookTabOptions } from "./Tabs/NotebookV2Tab";
 import Q from "q";
 import ResourceTokenCollection from "./Tree/ResourceTokenCollection";
-import TelemetryProcessor from "../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../Shared/Telemetry/TelemetryProcessor";
 import TerminalTab from "./Tabs/TerminalTab";
 import { Action, ActionModifiers } from "../Shared/Telemetry/TelemetryConstants";
 import { ActionContracts, MessageTypes } from "../Contracts/ExplorerContracts";
@@ -37,7 +37,7 @@ import { BindingHandlersRegisterer } from "../Bindings/BindingHandlersRegisterer
 import { BrowseQueriesPane } from "./Panes/BrowseQueriesPane";
 import { CassandraAPIDataClient, TableDataClient, TablesAPIDataClient } from "./Tables/TableDataClient";
 import { CommandBarComponentAdapter } from "./Menus/CommandBar/CommandBarComponentAdapter";
-import { configContext } from "../ConfigContext";
+import { configContext, updateConfigContext } from "../ConfigContext";
 import { ConsoleData, ConsoleDataType } from "./Menus/NotificationConsole/NotificationConsoleComponent";
 import { decryptJWTToken, getAuthorizationHeader } from "../Utils/AuthorizationUtils";
 import { DefaultExperienceUtility } from "../Shared/DefaultExperienceUtility";
@@ -243,7 +243,6 @@ export default class Explorer {
   public arcadiaWorkspaces: ko.ObservableArray<ArcadiaWorkspaceItem>;
   public hasStorageAnalyticsAfecFeature: ko.Observable<boolean>;
   public isSynapseLinkUpdating: ko.Observable<boolean>;
-  public memoryUsageInfo: ko.Observable<DataModels.MemoryUsageInfo>;
   public notebookManager?: any; // This is dynamically loaded
 
   private _panes: ContextualPaneBase[] = [];
@@ -374,7 +373,6 @@ export default class Explorer {
         );
       }
     });
-    this.memoryUsageInfo = ko.observable<DataModels.MemoryUsageInfo>();
     this.notificationsClient = options.notificationsClient;
     this.isEmulator = options.isEmulator;
 
@@ -975,6 +973,10 @@ export default class Explorer {
         this.sparkClusterConnectionInfo.valueHasMutated();
       }
 
+      if (this.isFeatureEnabled(Constants.Features.enableSDKoperations)) {
+        updateUserContext({ useSDKOperations: true });
+      }
+
       featureSubcription.dispose();
     });
 
@@ -1475,38 +1477,33 @@ export default class Explorer {
       );
     };
 
-    if (this.isServerlessEnabled()) {
-      // Serverless accounts don't support offers call
-      refreshDatabases();
-    } else {
-      const offerPromise: Q.Promise<DataModels.Offer[]> = readOffers();
-      this._setLoadingStatusText("Fetching offers...");
-      offerPromise.then(
-        (offers: DataModels.Offer[]) => {
-          this._setLoadingStatusText("Successfully fetched offers.");
-          refreshDatabases(offers);
-        },
-        error => {
-          this._setLoadingStatusText("Failed to fetch offers.");
-          this.isRefreshingExplorer(false);
-          deferred.reject(error);
-          TelemetryProcessor.traceFailure(
-            Action.LoadDatabases,
-            {
-              databaseAccountName: this.databaseAccount().name,
-              defaultExperience: this.defaultExperience(),
-              dataExplorerArea: Constants.Areas.ResourceTree,
-              error: JSON.stringify(error)
-            },
-            startKey
-          );
-          NotificationConsoleUtils.logConsoleMessage(
-            ConsoleDataType.Error,
-            `Error while refreshing databases: ${JSON.stringify(error)}`
-          );
-        }
-      );
-    }
+    const offerPromise: Q.Promise<DataModels.Offer[]> = readOffers({ isServerless: this.isServerlessEnabled() });
+    this._setLoadingStatusText("Fetching offers...");
+    offerPromise.then(
+      (offers: DataModels.Offer[]) => {
+        this._setLoadingStatusText("Successfully fetched offers.");
+        refreshDatabases(offers);
+      },
+      error => {
+        this._setLoadingStatusText("Failed to fetch offers.");
+        this.isRefreshingExplorer(false);
+        deferred.reject(error);
+        TelemetryProcessor.traceFailure(
+          Action.LoadDatabases,
+          {
+            databaseAccountName: this.databaseAccount().name,
+            defaultExperience: this.defaultExperience(),
+            dataExplorerArea: Constants.Areas.ResourceTree,
+            error: JSON.stringify(error)
+          },
+          startKey
+        );
+        NotificationConsoleUtils.logConsoleMessage(
+          ConsoleDataType.Error,
+          `Error while refreshing databases: ${JSON.stringify(error)}`
+        );
+      }
+    );
 
     return deferred.promise.then(
       () => {
@@ -1954,12 +1951,17 @@ export default class Explorer {
 
       this._importExplorerConfigComplete = true;
 
+      updateConfigContext({
+        ARM_ENDPOINT: this.armEndpoint()
+      });
+
       updateUserContext({
         authorizationToken,
         masterKey,
-        databaseAccount
+        databaseAccount,
+        resourceGroup: inputs.resourceGroup,
+        subscriptionId: inputs.subscriptionId
       });
-      updateUserContext({ resourceGroup: inputs.resourceGroup, subscriptionId: inputs.subscriptionId });
       TelemetryProcessor.traceSuccess(
         Action.LoadDatabaseAccount,
         {
@@ -3113,12 +3115,6 @@ export default class Explorer {
     } else {
       loadingTitle.innerHTML = title;
     }
-
-    TelemetryProcessor.trace(
-      Action.LoadingStatus,
-      ActionModifiers.Mark,
-      title !== "Welcome to Azure Cosmos DB" ? `Title: ${title}, Text: ${text}` : text
-    );
   }
 
   private _openSetupNotebooksPaneForQuickstart(): void {

src/Explorer/Graph/GraphExplorerComponent/GraphExplorer.test.tsx

@@ -87,13 +87,31 @@ describe("getPkIdFromDocumentId", () => {
     expect(GraphExplorer.getPkIdFromDocumentId(doc, "mypk")).toEqual("['pkvalue', 'id']");
   });
 
+  it("should create pkid pair from partitioned graph (pk as number)", () => {
+    const doc = createFakeDoc({ id: "id", mypk: 234 });
+    expect(GraphExplorer.getPkIdFromDocumentId(doc, "mypk")).toEqual("[234, 'id']");
+  });
+
+  it("should create pkid pair from partitioned graph (pk as boolean)", () => {
+    const doc = createFakeDoc({ id: "id", mypk: true });
+    expect(GraphExplorer.getPkIdFromDocumentId(doc, "mypk")).toEqual("[true, 'id']");
+  });
+
   it("should create pkid pair from partitioned graph (pk as valid array value)", () => {
     const doc = createFakeDoc({ id: "id", mypk: [{ id: "someid", _value: "pkvalue" }] });
     expect(GraphExplorer.getPkIdFromDocumentId(doc, "mypk")).toEqual("['pkvalue', 'id']");
   });
 
-  it("should error if id is not a string", () => {
-    const doc = createFakeDoc({ id: { foo: 1 } });
+  it("should error if id is not a string or number", () => {
+    let doc = createFakeDoc({ id: { foo: 1 } });
+    try {
+      GraphExplorer.getPkIdFromDocumentId(doc, undefined);
+      expect(true).toBe(false);
+    } catch (e) {
+      expect(true).toBe(true);
+    }
+
+    doc = createFakeDoc({ id: true });
     try {
       GraphExplorer.getPkIdFromDocumentId(doc, undefined);
       expect(true).toBe(false);
@@ -102,16 +120,8 @@ describe("getPkIdFromDocumentId", () => {
     }
   });
 
-  it("should error if pk not string nor non-empty array", () => {
-    let doc = createFakeDoc({ mypk: { foo: 1 } });
-
-    try {
-      GraphExplorer.getPkIdFromDocumentId(doc, "mypk");
-    } catch (e) {
-      expect(true).toBe(true);
-    }
-
-    doc = createFakeDoc({ mypk: [] });
+  it("should error if pk is empty array", () => {
+    let doc = createFakeDoc({ mypk: [] });
     try {
       GraphExplorer.getPkIdFromDocumentId(doc, "mypk");
       expect(true).toBe(false);

src/Explorer/Graph/GraphExplorerComponent/GraphExplorer.tsx

@@ -23,7 +23,7 @@ import { GraphConfig } from "../../Tabs/GraphTab";
 import { EditorReact } from "../../Controls/Editor/EditorReact";
 import LoadGraphIcon from "../../../../images/LoadGraph.png";
 import { Action } from "../../../Shared/Telemetry/TelemetryConstants";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 import * as Constants from "../../../Common/Constants";
 import { InputProperty } from "../../../Contracts/ViewModels";
 import { QueryIterator, ItemDefinition, Resource } from "@azure/cosmos";
@@ -1371,7 +1371,7 @@ export class GraphExplorer extends React.Component<GraphExplorerProps, GraphExpl
 
     if (collectionPartitionKeyProperty && d.hasOwnProperty(collectionPartitionKeyProperty)) {
       let pk = (d as any)[collectionPartitionKeyProperty];
-      if (typeof pk !== "string") {
+      if (typeof pk !== "string" && typeof pk !== "number" && typeof pk !== "boolean") {
         if (Array.isArray(pk) && pk.length > 0) {
           // pk is [{ id: 'id', _value: 'value' }]
           pk = pk[0]["_value"];

src/Explorer/Menus/CommandBar/CommandBarComponentAdapter.tsx

@@ -82,9 +82,7 @@ export class CommandBarComponentAdapter implements ReactAdapter {
     uiFabricControlButtons.forEach((btn: ICommandBarItemProps) => (btn.iconOnly = true));
 
     if (this.isNotebookTabActive()) {
-      uiFabricControlButtons.unshift(
-        CommandBarUtil.createMemoryTracker("memoryTracker", this.container.memoryUsageInfo)
-      );
+      uiFabricControlButtons.unshift(CommandBarUtil.createMemoryTracker("memoryTracker"));
     }
 
     return (

src/Explorer/Menus/CommandBar/CommandBarComponentButtonFactory.ts

@@ -2,7 +2,7 @@ import * as ViewModels from "../../../Contracts/ViewModels";
 import { PlatformType } from "../../../PlatformType";
 import { Action, ActionModifiers } from "../../../Shared/Telemetry/TelemetryConstants";
 import { Areas } from "../../../Common/Constants";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 
 import AddDatabaseIcon from "../../../../images/AddDatabase.svg";
 import AddCollectionIcon from "../../../../images/AddCollection.svg";

src/Explorer/Menus/CommandBar/CommandBarUtil.tsx

@@ -1,16 +1,14 @@
-import _ from "underscore";
-import * as React from "react";
-import { Observable } from "knockout";
+import { ICommandBarItemProps } from "office-ui-fabric-react/lib/CommandBar";
+import { Dropdown, IDropdownOption, IDropdownStyles } from "office-ui-fabric-react/lib/Dropdown";
 import { IconType } from "office-ui-fabric-react/lib/Icon";
 import { IComponentAsProps } from "office-ui-fabric-react/lib/Utilities";
-import { StyleConstants } from "../../../Common/Constants";
-import { ICommandBarItemProps } from "office-ui-fabric-react/lib/CommandBar";
-import { Dropdown, IDropdownStyles, IDropdownOption } from "office-ui-fabric-react/lib/Dropdown";
-import { CommandButtonComponentProps } from "../../Controls/CommandButton/CommandButtonComponent";
+import * as React from "react";
+import _ from "underscore";
 import ChevronDownIcon from "../../../../images/Chevron_down.svg";
+import { StyleConstants } from "../../../Common/Constants";
 import { ArcadiaMenuPicker } from "../../Controls/Arcadia/ArcadiaMenuPicker";
+import { CommandButtonComponentProps } from "../../Controls/CommandButton/CommandButtonComponent";
 import { MemoryTrackerComponent } from "./MemoryTrackerComponent";
-import { MemoryUsageInfo } from "../../../Contracts/DataModels";
 
 /**
  * Utilities for CommandBar
@@ -178,10 +176,10 @@ export class CommandBarUtil {
     };
   }
 
-  public static createMemoryTracker(key: string, memoryUsageInfo: Observable<MemoryUsageInfo>): ICommandBarItemProps {
+  public static createMemoryTracker(key: string): ICommandBarItemProps {
     return {
       key,
-      onRender: () => <MemoryTrackerComponent memoryUsageInfo={memoryUsageInfo} />
+      onRender: () => <MemoryTrackerComponent />
     };
   }
 }

src/Explorer/Menus/CommandBar/MemoryTrackerComponent.tsx

@@ -1,50 +1,71 @@
-import * as React from "react";
-import { Observable, Subscription } from "knockout";
-import { MemoryUsageInfo } from "../../../Contracts/DataModels";
+import React, { FunctionComponent } from "react";
+import useSWR from "swr";
 import { ProgressIndicator } from "office-ui-fabric-react/lib/ProgressIndicator";
 import { Spinner, SpinnerSize } from "office-ui-fabric-react/lib/Spinner";
 import { Stack } from "office-ui-fabric-react/lib/Stack";
+import { listConnectionInfo } from "../../../Utils/arm/generatedClients/2020-04-01-notebook/notebookWorkspaces";
+import { NotebookWorkspaceConnectionInfoResult } from "../../../Utils/arm/generatedClients/2020-04-01-notebook/types";
+import { userContext } from "../../../UserContext";
 
-interface MemoryTrackerProps {
-  memoryUsageInfo: Observable<MemoryUsageInfo>;
+export interface MemoryUsageInfo {
+  total: number;
+  free: number;
 }
 
-export class MemoryTrackerComponent extends React.Component<MemoryTrackerProps> {
-  private memoryUsageInfoSubscription: Subscription;
+const kbInGB = 1048576;
 
-  public componentDidMount(): void {
-    this.memoryUsageInfoSubscription = this.props.memoryUsageInfo.subscribe(() => {
-      this.forceUpdate();
-    });
-  }
-
-  public componentWillUnmount(): void {
-    this.memoryUsageInfoSubscription && this.memoryUsageInfoSubscription.dispose();
-  }
-
-  public render(): JSX.Element {
-    const memoryUsageInfo: MemoryUsageInfo = this.props.memoryUsageInfo();
-    if (!memoryUsageInfo) {
-      return (
-        <Stack className="memoryTrackerContainer" horizontal>
-          <span>Memory</span>
-          <Spinner size={SpinnerSize.medium} />
-        </Stack>
-      );
+const fetchMemoryInfo = async (_key: unknown, connectionInfo: NotebookWorkspaceConnectionInfoResult) => {
+  const response = await fetch(`${connectionInfo.notebookServerEndpoint}/api/metrics/memory`, {
+    method: "GET",
+    headers: {
+      Authorization: `Token ${connectionInfo.authToken}`,
+      "content-type": "application/json"
     }
+  });
+  if (!response.ok) {
+    throw new Error(await response.text());
+  }
+  const memoryUsageInfo = (await response.json()) as MemoryUsageInfo;
+  return {
+    totalKB: memoryUsageInfo.total,
+    freeKB: memoryUsageInfo.free
+  };
+};
 
-    const totalGB = memoryUsageInfo.totalKB / 1048576;
-    const usedGB = totalGB - memoryUsageInfo.freeKB / 1048576;
+export const MemoryTrackerComponent: FunctionComponent = () => {
+  const { data: connectionInfo } = useSWR(
+    [
+      "notebooksConnectionInfo",
+      userContext.subscriptionId,
+      userContext.resourceGroup,
+      userContext.databaseAccount.name,
+      "default"
+    ],
+    (_key, subscriptionId, resourceGroup, accountName, workspace) =>
+      listConnectionInfo(subscriptionId, resourceGroup, accountName, workspace)
+  );
+  const { data } = useSWR(connectionInfo ? ["memoryUsage", connectionInfo] : null, fetchMemoryInfo, {
+    refreshInterval: 2000
+  });
 
+  if (!data) {
     return (
       <Stack className="memoryTrackerContainer" horizontal>
         <span>Memory</span>
-        <ProgressIndicator
-          className={usedGB / totalGB > 0.8 ? "lowMemory" : ""}
-          description={usedGB.toFixed(1) + " of " + totalGB.toFixed(1) + " GB"}
-          percentComplete={usedGB / totalGB}
-        />
+        <Spinner size={SpinnerSize.medium} />
       </Stack>
     );
   }
-}
+  const totalGB = data.totalKB / kbInGB;
+  const usedGB = totalGB - data.freeKB / kbInGB;
+  return (
+    <Stack className="memoryTrackerContainer" horizontal>
+      <span>Memory</span>
+      <ProgressIndicator
+        className={usedGB / totalGB > 0.8 ? "lowMemory" : ""}
+        description={usedGB.toFixed(1) + " of " + totalGB.toFixed(1) + " GB"}
+        percentComplete={usedGB / totalGB}
+      />
+    </Stack>
+  );
+};

src/Explorer/Notebook/NotebookClientV2.ts

@@ -32,7 +32,7 @@ import { Store, AnyAction, MiddlewareAPI, Middleware, Dispatch } from "redux";
 import configureStore from "./NotebookComponent/store";
 
 import { Notification } from "react-notification-system";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 
 export type KernelSpecsDisplay = { name: string; displayName: string };

src/Explorer/Notebook/NotebookComponent/NotebookComponentBootstrapper.tsx

@@ -98,7 +98,7 @@ export class NotebookComponentBootstrapper {
       actions.fetchContentFulfilled({
         filepath: undefined,
         model: NotebookComponentBootstrapper.wrapModelIntoContent(name, undefined, content),
-        kernelRef: createKernelRef(),
+        kernelRef: undefined, // must be undefined or it will be auto-started by the epic
         contentRef: this.contentRef
       })
     );

src/Explorer/Notebook/NotebookComponent/epics.test.ts

@@ -1,13 +1,13 @@
 import * as Immutable from "immutable";
 import { ActionsObservable, StateObservable } from "redux-observable";
-import { Subject } from "rxjs";
+import { Subject, empty } from "rxjs";
 import { toArray } from "rxjs/operators";
 import { makeNotebookRecord } from "@nteract/commutable";
 import { actions, state } from "@nteract/core";
 import * as sinon from "sinon";
 
 import { CdbAppState, makeCdbRecord } from "./types";
-import { launchWebSocketKernelEpic } from "./epics";
+import { launchWebSocketKernelEpic, autoStartKernelEpic } from "./epics";
 import { NotebookUtil } from "../NotebookUtil";
 
 import { sessions } from "rx-jupyter";
@@ -74,46 +74,47 @@ describe("Extract kernel from notebook", () => {
   });
 });
 
+const initialState = {
+  app: state.makeAppRecord({
+    host: state.makeJupyterHostRecord({
+      type: "jupyter",
+      token: "eh",
+      basePath: "/"
+    })
+  }),
+  comms: state.makeCommsRecord(),
+  config: Immutable.Map({}),
+  core: state.makeStateRecord({
+    kernelRef: "fake",
+    entities: state.makeEntitiesRecord({
+      contents: state.makeContentsRecord({
+        byRef: Immutable.Map({
+          fakeContentRef: state.makeNotebookContentRecord()
+        })
+      }),
+      kernels: state.makeKernelsRecord({
+        byRef: Immutable.Map({
+          fake: state.makeRemoteKernelRecord({
+            type: "websocket",
+            channels: new Subject<any>(),
+            kernelSpecName: "fancy",
+            id: "0"
+          })
+        })
+      })
+    })
+  }),
+  cdb: makeCdbRecord({
+    databaseAccountName: "dbAccountName",
+    defaultExperience: "defaultExperience"
+  })
+};
+
 describe("launchWebSocketKernelEpic", () => {
   const createSpy = sinon.spy(sessions, "create");
 
   const contentRef = "fakeContentRef";
   const kernelRef = "fake";
-  const initialState = {
-    app: state.makeAppRecord({
-      host: state.makeJupyterHostRecord({
-        type: "jupyter",
-        token: "eh",
-        basePath: "/"
-      })
-    }),
-    comms: state.makeCommsRecord(),
-    config: Immutable.Map({}),
-    core: state.makeStateRecord({
-      kernelRef: "fake",
-      entities: state.makeEntitiesRecord({
-        contents: state.makeContentsRecord({
-          byRef: Immutable.Map({
-            fakeContentRef: state.makeNotebookContentRecord()
-          })
-        }),
-        kernels: state.makeKernelsRecord({
-          byRef: Immutable.Map({
-            fake: state.makeRemoteKernelRecord({
-              type: "websocket",
-              channels: new Subject<any>(),
-              kernelSpecName: "fancy",
-              id: "0"
-            })
-          })
-        })
-      })
-    }),
-    cdb: makeCdbRecord({
-      databaseAccountName: "dbAccountName",
-      defaultExperience: "defaultExperience"
-    })
-  };
 
   it("launches remote kernels", async () => {
     const state$ = new StateObservable(new Subject<CdbAppState>(), initialState);
@@ -490,3 +491,55 @@ describe("launchWebSocketKernelEpic", () => {
     });
   });
 });
+
+describe("autoStartKernelEpic", () => {
+  const contentRef = "fakeContentRef";
+  const kernelRef = "fake";
+
+  it("automatically starts kernel when content fetch is successful if kernelRef is defined", async () => {
+    const state$ = new StateObservable(new Subject<CdbAppState>(), initialState);
+
+    const action$ = ActionsObservable.of(
+      actions.fetchContentFulfilled({
+        contentRef,
+        kernelRef,
+        filepath: "filepath",
+        model: {}
+      })
+    );
+
+    const responseActions = await autoStartKernelEpic(action$, state$)
+      .pipe(toArray())
+      .toPromise();
+
+    expect(responseActions).toMatchObject([
+      {
+        type: actions.RESTART_KERNEL,
+        payload: {
+          contentRef,
+          kernelRef,
+          outputHandling: "None"
+        }
+      }
+    ]);
+  });
+
+  it("Don't start kernel when content fetch is successful if kernelRef is not defined", async () => {
+    const state$ = new StateObservable(new Subject<CdbAppState>(), initialState);
+
+    const action$ = ActionsObservable.of(
+      actions.fetchContentFulfilled({
+        contentRef,
+        kernelRef: undefined,
+        filepath: "filepath",
+        model: {}
+      })
+    );
+
+    const responseActions = await autoStartKernelEpic(action$, state$)
+      .pipe(toArray())
+      .toPromise();
+
+    expect(responseActions).toMatchObject([]);
+  });
+});

src/Explorer/Notebook/NotebookComponent/epics.ts

@@ -1,4 +1,4 @@
-import { empty, merge, of, timer, concat, Subject, Subscriber, Observable, Observer } from "rxjs";
+import { EMPTY, merge, of, timer, concat, Subject, Subscriber, Observable, Observer } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
 import { ActionsObservable, StateObservable } from "redux-observable";
 import { ofType } from "redux-observable";
@@ -37,7 +37,7 @@ import * as Constants from "../../../Common/Constants";
 import * as NotificationConsoleUtils from "../../../Utils/NotificationConsoleUtils";
 import { ConsoleDataType } from "../../Menus/NotificationConsole/NotificationConsoleComponent";
 import * as CdbActions from "./actions";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 import { Action as TelemetryAction } from "../../../Shared/Telemetry/TelemetryConstants";
 import { CdbAppState } from "./types";
 import { decryptJWTToken } from "../../../Utils/AuthorizationUtils";
@@ -77,7 +77,7 @@ const addInitialCodeCellEpic = (
 
       // If it's not a notebook, we shouldn't be here
       if (!model || model.type !== "notebook") {
-        return empty();
+        return EMPTY;
       }
 
       const cellOrder = selectors.notebook.cellOrder(model);
@@ -90,7 +90,40 @@ const addInitialCodeCellEpic = (
         );
       }
 
-      return empty();
+      return EMPTY;
+    })
+  );
+};
+
+/**
+ * Automatically start kernel if kernelRef is present.
+ * The kernel is normally lazy-started when a cell is being executed, but a running kernel is
+ * required for code completion to work.
+ * For notebook viewer, there is no kernel
+ * @param action$
+ * @param state$
+ */
+export const autoStartKernelEpic = (
+  action$: ActionsObservable<actions.FetchContentFulfilled>,
+  state$: StateObservable<AppState>
+): Observable<{} | actions.CreateCellBelow> => {
+  return action$.pipe(
+    ofType(actions.FETCH_CONTENT_FULFILLED),
+    mergeMap(action => {
+      const state = state$.value;
+      const { contentRef, kernelRef } = action.payload;
+
+      if (!kernelRef) {
+        return EMPTY;
+      }
+
+      return of(
+        actions.restartKernel({
+          contentRef,
+          kernelRef,
+          outputHandling: "None"
+        })
+      );
     })
   );
 };
@@ -288,7 +321,7 @@ export const launchWebSocketKernelEpic = (
       const state = state$.value;
       const host = selectors.currentHost(state);
       if (host.type !== "jupyter") {
-        return empty();
+        return EMPTY;
       }
       const serverConfig: NotebookServiceConfig = selectors.serverConfig(host);
       serverConfig.userPuid = getUserPuid();
@@ -299,7 +332,7 @@ export const launchWebSocketKernelEpic = (
 
       const content = selectors.content(state, { contentRef });
       if (!content || content.type !== "notebook") {
-        return empty();
+        return EMPTY;
       }
 
       let kernelSpecToLaunch = kernelSpecName;
@@ -513,26 +546,26 @@ const changeWebSocketKernelEpic = (
       const state = state$.value;
       const host = selectors.currentHost(state);
       if (host.type !== "jupyter") {
-        return empty();
+        return EMPTY;
       }
 
       const serverConfig: NotebookServiceConfig = selectors.serverConfig(host);
       if (!oldKernelRef) {
-        return empty();
+        return EMPTY;
       }
 
       const oldKernel = selectors.kernel(state, { kernelRef: oldKernelRef });
       if (!oldKernel || oldKernel.type !== "websocket") {
-        return empty();
+        return EMPTY;
       }
       const { sessionId } = oldKernel;
       if (!sessionId) {
-        return empty();
+        return EMPTY;
       }
 
       const content = selectors.content(state, { contentRef });
       if (!content || content.type !== "notebook") {
-        return empty();
+        return EMPTY;
       }
       const {
         filepath,
@@ -593,7 +626,7 @@ const focusInitialCodeCellEpic = (
 
       // If it's not a notebook, we shouldn't be here
       if (!model || model.type !== "notebook") {
-        return empty();
+        return EMPTY;
       }
 
       const cellOrder = selectors.notebook.cellOrder(model);
@@ -608,7 +641,7 @@ const focusInitialCodeCellEpic = (
         );
       }
 
-      return empty();
+      return EMPTY;
     })
   );
 };
@@ -661,7 +694,7 @@ const notificationsToUserEpic = (
           break;
         }
       }
-      return empty();
+      return EMPTY;
     })
   );
 };
@@ -701,7 +734,7 @@ const handleKernelConnectionLostEpic = (
         if (explorer) {
           explorer.showOkModalDialog("kernel restarts", msg);
         }
-        return of(empty());
+        return of(EMPTY);
       }
 
       return concat(
@@ -814,7 +847,7 @@ const closeUnsupportedMimetypesEpic = (
         explorer.showOkModalDialog("File cannot be rendered", msg);
         NotificationConsoleUtils.logConsoleMessage(ConsoleDataType.Error, msg);
       }
-      return empty();
+      return EMPTY;
     })
   );
 };
@@ -842,13 +875,14 @@ const closeContentFailedToFetchEpic = (
         explorer.showOkModalDialog("Failure to load", msg);
         NotificationConsoleUtils.logConsoleMessage(ConsoleDataType.Error, msg);
       }
-      return empty();
+      return EMPTY;
     })
   );
 };
 
 export const allEpics = [
   addInitialCodeCellEpic,
+  autoStartKernelEpic,
   focusInitialCodeCellEpic,
   notificationsToUserEpic,
   launchWebSocketKernelEpic,

src/Explorer/Notebook/NotebookComponent/reducers.ts

@@ -1,7 +1,7 @@
 import { actions, CoreRecord, reducers as nteractReducers } from "@nteract/core";
 import { Action } from "redux";
 import { Areas } from "../../../Common/Constants";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 import * as cdbActions from "./actions";
 import { CdbRecord } from "./types";
 

src/Explorer/Notebook/NotebookContainerClient.ts

@@ -2,89 +2,13 @@
  * Notebook container related stuff
  */
 import * as DataModels from "../../Contracts/DataModels";
-import * as Constants from "../../Common/Constants";
-import { ConsoleDataType } from "../Menus/NotificationConsole/NotificationConsoleComponent";
-import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
 import * as Logger from "../../Common/Logger";
 
 export class NotebookContainerClient {
   private reconnectingNotificationId: string;
   private isResettingWorkspace: boolean;
 
-  constructor(
-    private notebookServerInfo: ko.Observable<DataModels.NotebookWorkspaceConnectionInfo>,
-    private onConnectionLost: () => void,
-    private onMemoryUsageInfoUpdate: (update: DataModels.MemoryUsageInfo) => void
-  ) {
-    if (notebookServerInfo() && notebookServerInfo().notebookServerEndpoint) {
-      this.scheduleHeartbeat(Constants.Notebook.heartbeatDelayMs);
-    } else {
-      const subscription = notebookServerInfo.subscribe((newServerInfo: DataModels.NotebookWorkspaceConnectionInfo) => {
-        if (newServerInfo && newServerInfo.notebookServerEndpoint) {
-          this.scheduleHeartbeat(Constants.Notebook.heartbeatDelayMs);
-        }
-        subscription.dispose();
-      });
-    }
-  }
-
-  /**
-   * Heartbeat: each ping schedules another ping
-   */
-  private scheduleHeartbeat(delayMs: number): void {
-    setTimeout(() => {
-      this.getMemoryUsage()
-        .then(memoryUsageInfo => this.onMemoryUsageInfoUpdate(memoryUsageInfo))
-        .finally(() => this.scheduleHeartbeat(Constants.Notebook.heartbeatDelayMs));
-    }, delayMs);
-  }
-
-  private async getMemoryUsage(): Promise<DataModels.MemoryUsageInfo> {
-    if (!this.notebookServerInfo() || !this.notebookServerInfo().notebookServerEndpoint) {
-      const error = "No server endpoint detected";
-      Logger.logError(error, "NotebookContainerClient/getMemoryUsage");
-      return Promise.reject(error);
-    }
-
-    if (this.isResettingWorkspace) {
-      return undefined;
-    }
-
-    const { notebookServerEndpoint, authToken } = this.getNotebookServerConfig();
-    try {
-      const response = await fetch(`${notebookServerEndpoint}/api/metrics/memory`, {
-        method: "GET",
-        headers: {
-          Authorization: authToken,
-          "content-type": "application/json"
-        }
-      });
-      if (response.ok) {
-        if (this.reconnectingNotificationId) {
-          NotificationConsoleUtils.clearInProgressMessageWithId(this.reconnectingNotificationId);
-          this.reconnectingNotificationId = "";
-        }
-        const memoryUsageInfo = await response.json();
-        if (memoryUsageInfo) {
-          return {
-            totalKB: memoryUsageInfo.total,
-            freeKB: memoryUsageInfo.free
-          };
-        }
-      }
-      return undefined;
-    } catch (error) {
-      Logger.logError(error, "NotebookContainerClient/getMemoryUsage");
-      if (!this.reconnectingNotificationId) {
-        this.reconnectingNotificationId = NotificationConsoleUtils.logConsoleMessage(
-          ConsoleDataType.InProgress,
-          "Connection lost with Notebook server. Attempting to reconnect..."
-        );
-      }
-      this.onConnectionLost();
-      return undefined;
-    }
-  }
+  constructor(private notebookServerInfo: ko.Observable<DataModels.NotebookWorkspaceConnectionInfo>) {}
 
   public async resetWorkspace(): Promise<void> {
     this.isResettingWorkspace = true;

src/Explorer/Notebook/NotebookManager.ts

@@ -9,14 +9,13 @@ import * as Logger from "../../Common/Logger";
 import { HttpStatusCodes, Areas } from "../../Common/Constants";
 import { GitHubReposPane } from "../Panes/GitHubReposPane";
 import ko from "knockout";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { IContentProvider } from "@nteract/core";
 import { NotebookContentProvider } from "./NotebookComponent/NotebookContentProvider";
 import { GitHubContentProvider } from "../../GitHub/GitHubContentProvider";
 import { contents } from "rx-jupyter";
 import { NotebookContainerClient } from "./NotebookContainerClient";
-import { MemoryUsageInfo } from "../../Contracts/DataModels";
 import { NotebookContentClient } from "./NotebookContentClient";
 import { DialogProps } from "../Controls/DialogReactComponent/DialogComponent";
 import { ResourceTreeAdapter } from "../Tree/ResourceTreeAdapter";
@@ -76,11 +75,7 @@ export default class NotebookManager {
       contents.JupyterContentProvider
     );
 
-    this.notebookClient = new NotebookContainerClient(
-      this.params.container.notebookServerInfo,
-      () => this.params.container.initNotebooks(this.params.container.databaseAccount()),
-      (update: MemoryUsageInfo) => this.params.container.memoryUsageInfo(update)
-    );
+    this.notebookClient = new NotebookContainerClient(this.params.container.notebookServerInfo);
 
     this.notebookContentClient = new NotebookContentClient(
       this.params.container.notebookServerInfo,

src/Explorer/Panes/AddCollectionPane.html

@@ -25,7 +25,7 @@
                                                                 <!-- Add collection header - Start -->
   <div class="firstdivbg headerline">
       <span id="containerTitle" data-bind="text: title"></span>
-      <div class="closeImg" id="closeBtnAddCollection" role="button" aria-label="Close pane"
+      <div class="closeImg" id="closeBtnAddCollection" role="button" aria-label="Add collection close pane"
           data-bind="click: cancel, event: { keypress: onCloseKeyPress }" tabindex="0">
           <img src="../../../images/close-black.svg" title="Close" alt="Close" />
       </div>

src/Explorer/Panes/AddCollectionPane.ts

@@ -9,18 +9,15 @@ import * as PricingUtils from "../../Utils/PricingUtils";
 import * as SharedConstants from "../../Shared/Constants";
 import * as ViewModels from "../../Contracts/ViewModels";
 import editable from "../../Common/EditableUtility";
-import EnvironmentUtility from "../../Common/EnvironmentUtility";
-import Q from "q";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { configContext, Platform } from "../../ConfigContext";
 import { ContextualPaneBase } from "./ContextualPaneBase";
-import { createMongoCollectionWithARM, createMongoCollectionWithProxy } from "../../Common/MongoProxyClient";
 import { DynamicListItem } from "../Controls/DynamicList/DynamicListComponent";
 import { HashMap } from "../../Common/HashMap";
 import { PlatformType } from "../../PlatformType";
-import { refreshCachedResources, getOrCreateDatabaseAndCollection } from "../../Common/DocumentClientUtilityBase";
-import { userContext } from "../../UserContext";
+import { refreshCachedResources } from "../../Common/DocumentClientUtilityBase";
+import { createCollection } from "../../Common/dataAccess/createCollection";
 
 export interface AddCollectionPaneOptions extends ViewModels.PaneOptions {
   isPreferredApiTable: ko.Computed<boolean>;
@@ -811,7 +808,6 @@ export default class AddCollectionPane extends ContextualPaneBase {
 
     let databaseId: string = this.databaseCreateNew() ? this.databaseId().trim() : this.databaseId();
     let collectionId: string = this.collectionId().trim();
-    let rupm: boolean = this.rupm() === Constants.RUPMStates.on;
 
     let indexingPolicy: DataModels.IndexingPolicy;
     // todo - remove mongo indexing policy ticket # 616274
@@ -828,130 +824,28 @@ export default class AddCollectionPane extends ContextualPaneBase {
     }
 
     this.formErrors("");
-
     this.isExecuting(true);
 
-    const createRequest: DataModels.CreateDatabaseAndCollectionRequest = {
+    const databaseLevelThroughput: boolean = this.databaseCreateNew()
+      ? this.databaseCreateNewShared()
+      : this.databaseHasSharedOffer() && !this.collectionWithThroughputInShared();
+    const autoPilotMaxThroughput: number = databaseLevelThroughput
+      ? this.isSharedAutoPilotSelected() && this.sharedAutoPilotThroughput()
+      : this.isAutoPilotSelected() && this.autoPilotThroughput();
+    const createCollectionParams: DataModels.CreateCollectionParams = {
+      createNewDatabase: this.databaseCreateNew(),
       collectionId,
       databaseId,
+      databaseLevelThroughput,
       offerThroughput,
-      databaseLevelThroughput: this.databaseHasSharedOffer() && !this.collectionWithThroughputInShared(),
-      rupmEnabled: rupm,
-      partitionKey,
-      indexingPolicy,
-      uniqueKeyPolicy,
-      autoPilot,
       analyticalStorageTtl: this._getAnalyticalStorageTtl(),
-      hasAutoPilotV2FeatureFlag: this.hasAutoPilotV2FeatureFlag()
+      autoPilotMaxThroughput,
+      indexingPolicy,
+      partitionKey,
+      uniqueKeyPolicy
     };
 
-    const options: any = {};
-    if (this.container.isPreferredApiMongoDB()) {
-      options.initialHeaders = options.initialHeaders || {};
-      options.initialHeaders[Constants.HttpHeaders.supportSpatialLegacyCoordinates] = true;
-      options.initialHeaders[Constants.HttpHeaders.usePolygonsSmallerThanAHemisphere] = true;
-    }
-
-    const databaseCreateNew = this.databaseCreateNew();
-    const useDatabaseSharedOffer = this.shouldUseDatabaseThroughput();
-    const isSharded: boolean = !!partitionKeyPath;
-    const autopilotSettings: DataModels.RpOptions = this._getAutopilotSettings();
-
-    let createCollectionFunc: () => Q.Promise<DataModels.Collection | DataModels.CreateCollectionWithRpResponse>;
-
-    if (this.container.isPreferredApiMongoDB()) {
-      const isFixedCollectionWithSharedThroughputBeingCreated =
-        this.container.isFixedCollectionWithSharedThroughputSupported() &&
-        !this.isUnlimitedStorageSelected() &&
-        this.databaseHasSharedOffer();
-      const isAadUser = EnvironmentUtility.isAadUser();
-
-      // note: v3 autopilot not supported yet for Mongo fixed collections (only tier supported)
-      if (!isAadUser || isFixedCollectionWithSharedThroughputBeingCreated) {
-        createCollectionFunc = () =>
-          Q(
-            createMongoCollectionWithProxy(
-              databaseId,
-              collectionId,
-              offerThroughput,
-              partitionKeyPath,
-              databaseCreateNew,
-              useDatabaseSharedOffer,
-              isSharded,
-              autopilotSettings
-            )
-          );
-      } else {
-        createCollectionFunc = () =>
-          Q(
-            createMongoCollectionWithARM(
-              this.container.armEndpoint(),
-              databaseId,
-              this._getAnalyticalStorageTtl(),
-              collectionId,
-              offerThroughput,
-              partitionKeyPath,
-              databaseCreateNew,
-              useDatabaseSharedOffer,
-              isSharded,
-              autopilotSettings
-            )
-          );
-      }
-    } else if (this.container.isPreferredApiTable() && EnvironmentUtility.isAadUser()) {
-      createCollectionFunc = () =>
-        Q(
-          AddCollectionUtility.Utilities.createAzureTableWithARM(
-            this.container.armEndpoint(),
-            createRequest,
-            autopilotSettings
-          )
-        );
-    } else if (this.container.isPreferredApiGraph() && EnvironmentUtility.isAadUser()) {
-      createCollectionFunc = () =>
-        Q(
-          AddCollectionUtility.CreateCollectionUtilities.createGremlinGraph(
-            this.container.armEndpoint(),
-            databaseId,
-            collectionId,
-            indexingPolicy,
-            offerThroughput,
-            partitionKeyPath,
-            partitionKey.version,
-            databaseCreateNew,
-            useDatabaseSharedOffer,
-            userContext.subscriptionId,
-            userContext.resourceGroup,
-            userContext.databaseAccount.name,
-            autopilotSettings
-          )
-        );
-    } else if (this.container.isPreferredApiDocumentDB() && EnvironmentUtility.isAadUser()) {
-      createCollectionFunc = () =>
-        Q(
-          AddCollectionUtility.CreateSqlCollectionUtilities.createSqlCollection(
-            this.container.armEndpoint(),
-            databaseId,
-            this._getAnalyticalStorageTtl(),
-            collectionId,
-            indexingPolicy,
-            offerThroughput,
-            partitionKeyPath,
-            partitionKey.version,
-            databaseCreateNew,
-            useDatabaseSharedOffer,
-            userContext.subscriptionId,
-            userContext.resourceGroup,
-            userContext.databaseAccount.name,
-            uniqueKeyPolicy,
-            autopilotSettings
-          )
-        );
-    } else {
-      createCollectionFunc = () => getOrCreateDatabaseAndCollection(createRequest, options);
-    }
-
-    createCollectionFunc().then(
+    createCollection(createCollectionParams).then(
       () => {
         this.isExecuting(false);
         this.close();
@@ -1049,7 +943,7 @@ export default class AddCollectionPane extends ContextualPaneBase {
     const defaultThroughput = this.container.collectionCreationDefaults.throughput;
     this.throughputSinglePartition(defaultThroughput.fixed);
     this.throughputMultiPartition(
-      AddCollectionUtility.Utilities.getMaxThroughput(this.container.collectionCreationDefaults, this.container)
+      AddCollectionUtility.getMaxThroughput(this.container.collectionCreationDefaults, this.container)
     );
 
     this.throughputDatabase(defaultThroughput.shared);
@@ -1234,35 +1128,6 @@ export default class AddCollectionPane extends ContextualPaneBase {
 
     return undefined;
   }
-  private _getAutopilotSettings(): DataModels.RpOptions {
-    if (
-      (!this.hasAutoPilotV2FeatureFlag() &&
-        this.databaseCreateNewShared() &&
-        this.isSharedAutoPilotSelected() &&
-        this.sharedAutoPilotThroughput()) ||
-      (this.hasAutoPilotV2FeatureFlag() &&
-        this.databaseCreateNewShared() &&
-        this.isSharedAutoPilotSelected() &&
-        this.selectedSharedAutoPilotTier())
-    ) {
-      return !this.hasAutoPilotV2FeatureFlag()
-        ? {
-            [Constants.HttpHeaders.autoPilotThroughput]: { maxThroughput: this.sharedAutoPilotThroughput() * 1 }
-          }
-        : { [Constants.HttpHeaders.autoPilotTier]: this.selectedSharedAutoPilotTier().toString() };
-    }
-    if (
-      (!this.hasAutoPilotV2FeatureFlag() && this.isAutoPilotSelected() && this.autoPilotThroughput()) ||
-      (this.hasAutoPilotV2FeatureFlag() && this.isAutoPilotSelected() && this.selectedAutoPilotTier())
-    ) {
-      return !this.hasAutoPilotV2FeatureFlag()
-        ? {
-            [Constants.HttpHeaders.autoPilotThroughput]: { maxThroughput: this.autoPilotThroughput() * 1 }
-          }
-        : { [Constants.HttpHeaders.autoPilotTier]: this.selectedAutoPilotTier().toString() };
-    }
-    return undefined;
-  }
 
   private _calculateNumberOfPartitions(): number {
     // Note: this will not validate properly on accounts that have been set up for custom partitioning,
@@ -1302,17 +1167,19 @@ export default class AddCollectionPane extends ContextualPaneBase {
 
   private _updateThroughputLimitByCollectionStorage() {
     const storage = this.storage();
-    const minThroughputRU = AddCollectionUtility.Utilities.getMinRUForStorageOption(
-      this.container.collectionCreationDefaults,
-      storage
-    );
+    const minThroughputRU =
+      storage === SharedConstants.CollectionCreation.storage10Gb
+        ? SharedConstants.CollectionCreation.DefaultCollectionRUs400
+        : this.container.collectionCreationDefaults.throughput.unlimitedmin;
 
-    let maxThroughputRU = AddCollectionUtility.Utilities.getMaxRUForStorageOption(
-      this.container.collectionCreationDefaults,
-      storage
-    );
+    let maxThroughputRU;
     if (this.isTryCosmosDBSubscription()) {
       maxThroughputRU = Constants.TryCosmosExperience.maxRU;
+    } else {
+      maxThroughputRU =
+        storage === SharedConstants.CollectionCreation.storage10Gb
+          ? SharedConstants.CollectionCreation.DefaultCollectionRUs10K
+          : this.container.collectionCreationDefaults.throughput.unlimitedmax;
     }
 
     this.minThroughputRU(minThroughputRU);

src/Explorer/Panes/AddDatabasePane.ts

@@ -1,4 +1,3 @@
-import * as AddCollectionUtility from "../../Shared/AddCollectionUtility";
 import * as AutoPilotUtils from "../../Utils/AutoPilotUtils";
 import * as Constants from "../../Common/Constants";
 import * as DataModels from "../../Contracts/DataModels";
@@ -8,15 +7,11 @@ import * as PricingUtils from "../../Utils/PricingUtils";
 import * as SharedConstants from "../../Shared/Constants";
 import * as ViewModels from "../../Contracts/ViewModels";
 import editable from "../../Common/EditableUtility";
-import EnvironmentUtility from "../../Common/EnvironmentUtility";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
-import { AddDbUtilities } from "../../Shared/AddDatabaseUtility";
-import { CassandraAPIDataClient } from "../Tables/TableDataClient";
 import { ContextualPaneBase } from "./ContextualPaneBase";
+import { createDatabase } from "../../Common/dataAccess/createDatabase";
 import { PlatformType } from "../../PlatformType";
-import { refreshCachedOffers, refreshCachedResources, createDatabase } from "../../Common/DocumentClientUtilityBase";
-import { userContext } from "../../UserContext";
 
 export default class AddDatabasePane extends ContextualPaneBase {
   public defaultExperience: ko.Computed<string>;
@@ -304,76 +299,23 @@ export default class AddDatabasePane extends ContextualPaneBase {
     this.formErrors("");
     this.isExecuting(true);
 
-    const createDatabaseParameters: DataModels.RpParameters = {
-      db: addDatabasePaneStartMessage.database.id,
-      st: addDatabasePaneStartMessage.database.shared,
-      offerThroughput: addDatabasePaneStartMessage.offerThroughput,
-      sid: userContext.subscriptionId,
-      rg: userContext.resourceGroup,
-      dba: addDatabasePaneStartMessage.databaseAccountName
+    const createDatabaseParams: DataModels.CreateDatabaseParams = {
+      autoPilotMaxThroughput: this.maxAutoPilotThroughputSet(),
+      databaseId: addDatabasePaneStartMessage.database.id,
+      databaseLevelThroughput: addDatabasePaneStartMessage.database.shared,
+      offerThroughput: addDatabasePaneStartMessage.offerThroughput
     };
 
-    const autopilotSettings = this._getAutopilotSettings();
-
-    if (this.container.isPreferredApiCassandra()) {
-      this._createKeyspace(createDatabaseParameters, autopilotSettings, startKey);
-    } else if (this.container.isPreferredApiMongoDB() && EnvironmentUtility.isAadUser()) {
-      this._createMongoDatabase(createDatabaseParameters, autopilotSettings, startKey);
-    } else if (this.container.isPreferredApiGraph() && EnvironmentUtility.isAadUser()) {
-      this._createGremlinDatabase(createDatabaseParameters, autopilotSettings, startKey);
-    } else if (this.container.isPreferredApiDocumentDB() && EnvironmentUtility.isAadUser()) {
-      this._createSqlDatabase(createDatabaseParameters, autopilotSettings, startKey);
-    } else {
-      this._createDatabase(offerThroughput, startKey);
-    }
-  }
-
-  private _createSqlDatabase(
-    createDatabaseParameters: DataModels.RpParameters,
-    autoPilotSettings: DataModels.RpOptions,
-    startKey: number
-  ) {
-    AddDbUtilities.createSqlDatabase(this.container.armEndpoint(), createDatabaseParameters, autoPilotSettings).then(
-      () => {
-        Promise.all([refreshCachedOffers(), refreshCachedResources()]).then(() => {
-          this._onCreateDatabaseSuccess(createDatabaseParameters.offerThroughput, startKey);
-        });
+    createDatabase(createDatabaseParams).then(
+      (database: DataModels.Database) => {
+        this._onCreateDatabaseSuccess(offerThroughput, startKey);
+      },
+      (reason: any) => {
+        this._onCreateDatabaseFailure(reason, offerThroughput, reason);
       }
     );
   }
 
-  private _createMongoDatabase(
-    createDatabaseParameters: DataModels.RpParameters,
-    autoPilotSettings: DataModels.RpOptions,
-    startKey: number
-  ) {
-    AddDbUtilities.createMongoDatabaseWithARM(
-      this.container.armEndpoint(),
-      createDatabaseParameters,
-      autoPilotSettings
-    ).then(() => {
-      Promise.all([refreshCachedOffers(), refreshCachedResources()]).then(() => {
-        this._onCreateDatabaseSuccess(createDatabaseParameters.offerThroughput, startKey);
-      });
-    });
-  }
-
-  private _createGremlinDatabase(
-    createDatabaseParameters: DataModels.RpParameters,
-    autoPilotSettings: DataModels.RpOptions,
-    startKey: number
-  ) {
-    AddDbUtilities.createGremlinDatabase(
-      this.container.armEndpoint(),
-      createDatabaseParameters,
-      autoPilotSettings
-    ).then(() => {
-      Promise.all([refreshCachedOffers(), refreshCachedResources()]).then(() => {
-        this._onCreateDatabaseSuccess(createDatabaseParameters.offerThroughput, startKey);
-      });
-    });
-  }
-
   public resetData() {
     this.databaseId("");
     this.databaseCreateNewShared(this.getSharedThroughputDefault());
@@ -396,72 +338,6 @@ export default class AddDatabasePane extends ContextualPaneBase {
     return true;
   }
 
-  private _createDatabase(offerThroughput: number, telemetryStartKey: number): void {
-    const autoPilot: DataModels.AutoPilotCreationSettings = this._isAutoPilotSelectedAndWhatTier();
-    const createRequest: DataModels.CreateDatabaseRequest = {
-      databaseId: this.databaseId().trim(),
-      offerThroughput,
-      databaseLevelThroughput: this.databaseCreateNewShared(),
-      autoPilot,
-      hasAutoPilotV2FeatureFlag: this.hasAutoPilotV2FeatureFlag()
-    };
-    createDatabase(createRequest).then(
-      (database: DataModels.Database) => {
-        this._onCreateDatabaseSuccess(offerThroughput, telemetryStartKey);
-      },
-      (reason: any) => {
-        this._onCreateDatabaseFailure(reason, offerThroughput, reason);
-      }
-    );
-  }
-
-  private _createKeyspace(
-    createDatabaseParameters: DataModels.RpParameters,
-    autoPilotSettings: DataModels.RpOptions,
-    startKey: number
-  ): void {
-    if (EnvironmentUtility.isAadUser()) {
-      this._createKeyspaceUsingRP(this.container.armEndpoint(), createDatabaseParameters, autoPilotSettings, startKey);
-    } else {
-      this._createKeyspaceUsingProxy(createDatabaseParameters.offerThroughput, startKey);
-    }
-  }
-
-  private _createKeyspaceUsingProxy(offerThroughput: number, telemetryStartKey: number): void {
-    const provisionThroughputQueryPart: string = this.databaseCreateNewShared()
-      ? `AND cosmosdb_provisioned_throughput=${offerThroughput}`
-      : "";
-    const createKeyspaceQuery: string = `CREATE KEYSPACE ${this.databaseId().trim()} WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 3 } ${provisionThroughputQueryPart};`;
-    (this.container.tableDataClient as CassandraAPIDataClient)
-      .createKeyspace(
-        this.container.databaseAccount().properties.cassandraEndpoint,
-        this.container.databaseAccount().id,
-        this.container,
-        createKeyspaceQuery
-      )
-      .then(
-        () => {
-          this._onCreateDatabaseSuccess(offerThroughput, telemetryStartKey);
-        },
-        (reason: any) => {
-          this._onCreateDatabaseFailure(reason, offerThroughput, telemetryStartKey);
-        }
-      );
-  }
-
-  private _createKeyspaceUsingRP(
-    armEndpoint: string,
-    createKeyspaceParameters: DataModels.RpParameters,
-    autoPilotSettings: DataModels.RpOptions,
-    startKey: number
-  ): void {
-    AddDbUtilities.createCassandraKeyspace(armEndpoint, createKeyspaceParameters, autoPilotSettings).then(() => {
-      Promise.all([refreshCachedOffers(), refreshCachedResources()]).then(() => {
-        this._onCreateDatabaseSuccess(createKeyspaceParameters.offerThroughput, startKey);
-      });
-    });
-  }
-
   private _onCreateDatabaseSuccess(offerThroughput: number, startKey: number): void {
     this.isExecuting(false);
     this.close();
@@ -582,20 +458,6 @@ export default class AddDatabasePane extends ContextualPaneBase {
     return undefined;
   }
 
-  private _getAutopilotSettings(): DataModels.RpOptions {
-    if (
-      (!this.hasAutoPilotV2FeatureFlag() && this.isAutoPilotSelected() && this.maxAutoPilotThroughputSet()) ||
-      (this.hasAutoPilotV2FeatureFlag() && this.isAutoPilotSelected() && this.selectedAutoPilotTier())
-    ) {
-      return !this.hasAutoPilotV2FeatureFlag()
-        ? {
-            [Constants.HttpHeaders.autoPilotThroughput]: { maxThroughput: this.maxAutoPilotThroughputSet() * 1 }
-          }
-        : { [Constants.HttpHeaders.autoPilotTier]: this.selectedAutoPilotTier().toString() };
-    }
-    return undefined;
-  }
-
   private _updateThroughputLimitByDatabase() {
     const throughputDefaults = this.container.collectionCreationDefaults.throughput;
     this.throughput(throughputDefaults.shared);

src/Explorer/Panes/BrowseQueriesPane.ts

@@ -5,7 +5,7 @@ import { Areas } from "../../Common/Constants";
 import { ContextualPaneBase } from "./ContextualPaneBase";
 import * as Logger from "../../Common/Logger";
 import { QueriesGridComponentAdapter } from "../Controls/QueriesGridReactComponent/QueriesGridComponentAdapter";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import QueryTab from "../Tabs/QueryTab";
 
 export class BrowseQueriesPane extends ContextualPaneBase {

src/Explorer/Panes/CassandraAddCollectionPane.ts

@@ -7,7 +7,7 @@ import * as ko from "knockout";
 import * as PricingUtils from "../../Utils/PricingUtils";
 import * as SharedConstants from "../../Shared/Constants";
 import * as ViewModels from "../../Contracts/ViewModels";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { CassandraAPIDataClient } from "../Tables/TableDataClient";
 import { ContextualPaneBase } from "./ContextualPaneBase";
@@ -494,9 +494,7 @@ export default class CassandraAddCollectionPane extends ContextualPaneBase {
     this.selectedSharedAutoPilotTier(null);
     this.selectedAutoPilotThroughput(AutoPilotUtils.minAutoPilotThroughput);
     this.sharedAutoPilotThroughput(AutoPilotUtils.minAutoPilotThroughput);
-    this.throughput(
-      AddCollectionUtility.Utilities.getMaxThroughput(this.container.collectionCreationDefaults, this.container)
-    );
+    this.throughput(AddCollectionUtility.getMaxThroughput(this.container.collectionCreationDefaults, this.container));
     this.keyspaceThroughput(throughputDefaults.shared);
     this.maxThroughputRU(throughputDefaults.unlimitedmax);
     this.minThroughputRU(throughputDefaults.unlimitedmin);

src/Explorer/Panes/ContextualPaneBase.ts

@@ -4,7 +4,7 @@ import * as Constants from "../../Common/Constants";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { KeyCodes } from "../../Common/Constants";
 import { WaitsForTemplateViewModel } from "../WaitsForTemplateViewModel";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import Explorer from "../Explorer";
 
 // TODO: Use specific actions for logging telemetry data

src/Explorer/Panes/DeleteCollectionConfirmationPane.test.ts

@@ -8,7 +8,7 @@ import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstan
 import DeleteCollectionConfirmationPane from "./DeleteCollectionConfirmationPane";
 import DeleteFeedback from "../../Common/DeleteFeedback";
 import Explorer from "../Explorer";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { TreeNode } from "../../Contracts/ViewModels";
 import { deleteCollection } from "../../Common/dataAccess/deleteCollection";
 

src/Explorer/Panes/DeleteCollectionConfirmationPane.ts

@@ -10,7 +10,7 @@ import { ContextualPaneBase } from "./ContextualPaneBase";
 import { DefaultExperienceUtility } from "../../Shared/DefaultExperienceUtility";
 import DeleteFeedback from "../../Common/DeleteFeedback";
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { deleteCollection } from "../../Common/dataAccess/deleteCollection";
 
 export default class DeleteCollectionConfirmationPane extends ContextualPaneBase {

src/Explorer/Panes/DeleteDatabaseConfirmationPane.test.ts

@@ -8,7 +8,7 @@ import * as ViewModels from "../../Contracts/ViewModels";
 import DeleteDatabaseConfirmationPane from "./DeleteDatabaseConfirmationPane";
 import DeleteFeedback from "../../Common/DeleteFeedback";
 import Explorer from "../Explorer";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { TreeNode } from "../../Contracts/ViewModels";
 import { TabsManager } from "../Tabs/TabsManager";
 import { deleteDatabase } from "../../Common/dataAccess/deleteDatabase";

src/Explorer/Panes/DeleteDatabaseConfirmationPane.ts

@@ -11,7 +11,7 @@ import { DefaultExperienceUtility } from "../../Shared/DefaultExperienceUtility"
 import DeleteFeedback from "../../Common/DeleteFeedback";
 
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { deleteDatabase } from "../../Common/dataAccess/deleteDatabase";
 
 export default class DeleteDatabaseConfirmationPane extends ContextualPaneBase {

src/Explorer/Panes/GenericRightPaneComponent.tsx

@@ -16,7 +16,7 @@ export interface GenericRightPaneProps {
   onSubmit: () => void;
   submitButtonText: string;
   title: string;
-  isSubmitButtonVisible?: boolean;
+  isSubmitButtonHidden?: boolean;
 }
 
 export interface GenericRightPaneState {
@@ -108,7 +108,7 @@ export class GenericRightPaneComponent extends React.Component<GenericRightPaneP
       <div className="paneFooter">
         <div className="leftpanel-okbut">
           <PrimaryButton
-            style={{ visibility: this.props.isSubmitButtonVisible ? "visible" : "hidden" }}
+            style={{ visibility: this.props.isSubmitButtonHidden ? "hidden" : "visible" }}
             ariaLabel="Submit"
             title="Submit"
             onClick={this.props.onSubmit}

src/Explorer/Panes/GitHubReposPane.ts

@@ -5,7 +5,7 @@ import * as ViewModels from "../../Contracts/ViewModels";
 import { GitHubClient, IGitHubPageInfo, IGitHubRepo } from "../../GitHub/GitHubClient";
 import { IPinnedRepo, JunoClient } from "../../Juno/JunoClient";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import * as GitHubUtils from "../../Utils/GitHubUtils";
 import { JunoUtils } from "../../Utils/JunoUtils";
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";

src/Explorer/Panes/PublishNotebookPaneAdapter.tsx

@@ -52,7 +52,7 @@ export class PublishNotebookPaneAdapter implements ReactAdapter {
       submitButtonText: "Publish",
       onClose: () => this.close(),
       onSubmit: () => this.submit(),
-      isSubmitButtonVisible: this.isCodeOfConductAccepted
+      isSubmitButtonHidden: !this.isCodeOfConductAccepted
     };
 
     const publishNotebookPaneProps: PublishNotebookPaneProps = {

src/Explorer/Panes/PublishNotebookPaneComponent.tsx

@@ -285,7 +285,7 @@ export class PublishNotebookPaneComponent extends React.Component<PublishNoteboo
             <GalleryCardComponent
               data={{
                 id: undefined,
-                name: this.props.notebookName,
+                name: this.state.notebookName,
                 description: this.state.notebookDescription,
                 gitSha: undefined,
                 tags: this.state.notebookTags.split(","),

src/Explorer/Panes/SaveQueryPane.ts

@@ -6,7 +6,7 @@ import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 import { ContextualPaneBase } from "./ContextualPaneBase";
 import { ConsoleDataType } from "../Menus/NotificationConsole/NotificationConsoleComponent";
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import QueryTab from "../Tabs/QueryTab";
 
 export class SaveQueryPane extends ContextualPaneBase {

src/Explorer/Panes/SetupNotebooksPane.ts

@@ -4,7 +4,7 @@ import { Areas, KeyCodes } from "../../Common/Constants";
 import { ConsoleDataType } from "../Menus/NotificationConsole/NotificationConsoleComponent";
 import { ContextualPaneBase } from "./ContextualPaneBase";
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import * as ko from "knockout";
 
 export class SetupNotebooksPane extends ContextualPaneBase {

src/Explorer/Panes/SwitchDirectoryPane.ts

@@ -5,7 +5,7 @@ import { DirectoryListProps } from "../Controls/Directory/DirectoryListComponent
 import { DefaultDirectoryDropdownProps } from "../Controls/Directory/DefaultDirectoryDropdownComponent";
 import { DirectoryComponentAdapter } from "../Controls/Directory/DirectoryComponentAdapter";
 import SwitchDirectoryPaneTemplate from "./SwitchDirectoryPane.html";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 
 class PaneComponent {
   constructor(data: any) {

src/Explorer/Panes/UploadItemsPaneAdapter.tsx

@@ -39,7 +39,6 @@ export class UploadItemsPaneAdapter implements ReactAdapter {
       formErrorDetail: this.formErrorDetail,
       id: "uploaditemspane",
       isExecuting: this.isExecuting,
-      isSubmitButtonVisible: true,
       title: "Upload Items",
       submitButtonText: "Upload",
       onClose: () => this.close(),

src/Explorer/SplashScreen/SplashScreenComponent.tsx

@@ -45,7 +45,7 @@ export class SplashScreenComponent extends React.Component<SplashScreenComponent
                 tabIndex={0}
                 role="button"
               >
-                <img src={item.iconSrc} alt={item.title} />
+                <img src={item.iconSrc} alt="" />
                 <div className="legendContainer">
                   <div className="legend">{item.title}</div>
                   <div className="description">{item.description}</div>
@@ -66,7 +66,7 @@ export class SplashScreenComponent extends React.Component<SplashScreenComponent
                     tabIndex={0}
                     role="button"
                   >
-                    <img src={item.iconSrc} alt={item.title} />
+                    <img src={item.iconSrc} alt="" />
                     <span className="oneLineContent" title={item.info}>
                       {item.title}
                     </span>
@@ -79,7 +79,7 @@ export class SplashScreenComponent extends React.Component<SplashScreenComponent
               <ul>
                 {this.props.recentItems.map((item: SplashScreenItem, index: number) => (
                   <li key={`${item.title}${item.description}${index}`}>
-                    <img src={item.iconSrc} alt={item.title} />
+                    <img src={item.iconSrc} alt="" />
                     <span className="twoLineContent">
                       <Link onClick={item.onClick} title={item.info}>
                         {item.title}

src/Explorer/Tables/DataTable/DataTableViewModel.ts

@@ -7,7 +7,7 @@ import * as CommonConstants from "../../../Common/Constants";
 import * as Constants from "../Constants";
 import * as Entities from "../Entities";
 import QueryTablesTab from "../../Tabs/QueryTablesTab";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 import { QueryIterator, ItemDefinition, Resource } from "@azure/cosmos";
 
 // This is the format of the data we will have to pass to Datatable render callback,

src/Explorer/Tables/DataTable/TableEntityListViewModel.ts

@@ -15,7 +15,7 @@ import * as Utilities from "../Utilities";
 import * as Entities from "../Entities";
 import QueryTablesTab from "../../Tabs/QueryTablesTab";
 import * as TableEntityProcessor from "../TableEntityProcessor";
-import TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../../Shared/Telemetry/TelemetryProcessor";
 import * as ErrorParserUtility from "../../../Common/ErrorParserUtility";
 import * as DataModels from "../../../Contracts/DataModels";
 import * as ViewModels from "../../../Contracts/ViewModels";

src/Explorer/Tabs/ConflictsTab.ts

@@ -13,7 +13,7 @@ import * as HeadersUtility from "../../Common/HeadersUtility";
 import TabsBase from "./TabsBase";
 import { DocumentsGridMetrics } from "../../Common/Constants";
 import { Splitter, SplitterBounds, SplitterDirection } from "../../Common/Splitter";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import SaveIcon from "../../../images/save-cosmos.svg";
 import DiscardIcon from "../../../images/discard.svg";
 import DeleteIcon from "../../../images/delete.svg";

src/Explorer/Tabs/DatabaseSettingsTab.ts

@@ -11,7 +11,7 @@ import editable from "../../Common/EditableUtility";
 import Q from "q";
 import SaveIcon from "../../../images/save-cosmos.svg";
 import TabsBase from "./TabsBase";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 import { PlatformType } from "../../PlatformType";
 import { RequestOptions } from "@azure/cosmos/dist-esm";

src/Explorer/Tabs/DocumentsTab.ts

@@ -14,7 +14,7 @@ import TabsBase from "./TabsBase";
 import { DocumentsGridMetrics } from "../../Common/Constants";
 import { QueryUtils } from "../../Utils/QueryUtils";
 import { Splitter, SplitterBounds, SplitterDirection } from "../../Common/Splitter";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import NewDocumentIcon from "../../../images/NewDocument.svg";
 import SaveIcon from "../../../images/save-cosmos.svg";
 import DiscardIcon from "../../../images/discard.svg";

src/Explorer/Tabs/MongoDocumentsTab.ts

@@ -8,7 +8,7 @@ import * as ErrorParserUtility from "../../Common/ErrorParserUtility";
 import MongoUtility from "../../Common/MongoUtility";
 import ObjectId from "../Tree/ObjectId";
 import Q from "q";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 import {
   createDocument,

src/Explorer/Tabs/MongoShellTab.ts

@@ -6,7 +6,7 @@ import EnvironmentUtility from "../../Common/EnvironmentUtility";
 import { isInvalidParentFrameOrigin } from "../../Utils/MessageValidation";
 import Q from "q";
 import TabsBase from "./TabsBase";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { ConsoleDataType } from "../Menus/NotificationConsole/NotificationConsoleComponent";
 import { HashMap } from "../../Common/HashMap";

src/Explorer/Tabs/NotebookV2Tab.ts

@@ -17,7 +17,7 @@ import SaveIcon from "../../../images/save-cosmos.svg";
 import ClearAllOutputsIcon from "../../../images/notebook/Notebook-clear-all-outputs.svg";
 import InterruptKernelIcon from "../../../images/notebook/Notebook-stop.svg";
 import KillKernelIcon from "../../../images/notebook/Notebook-stop.svg";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { Areas, ArmApiVersions } from "../../Common/Constants";
 import { CommandBarComponentButtonFactory } from "../Menus/CommandBar/CommandBarComponentButtonFactory";
@@ -147,6 +147,30 @@ export default class NotebookTabV2 extends TabsBase {
     const cellCodeType = "code";
     const cellMarkdownType = "markdown";
     const cellRawType = "raw";
+
+    const saveButtonChildren = [];
+    if (this.container.notebookManager?.gitHubOAuthService.isLoggedIn()) {
+      saveButtonChildren.push({
+        iconName: "Copy",
+        onCommandClick: () => this.copyNotebook(),
+        commandButtonLabel: copyToLabel,
+        hasPopup: false,
+        disabled: false,
+        ariaLabel: copyToLabel
+      });
+    }
+
+    if (this.container.isGalleryPublishEnabled()) {
+      saveButtonChildren.push({
+        iconName: "PublishContent",
+        onCommandClick: async () => await this.publishToGallery(),
+        commandButtonLabel: publishLabel,
+        hasPopup: false,
+        disabled: false,
+        ariaLabel: publishLabel
+      });
+    }
+
     let buttons: CommandButtonComponentProps[] = [
       {
         iconSrc: SaveIcon,
@@ -156,34 +180,17 @@ export default class NotebookTabV2 extends TabsBase {
         hasPopup: false,
         disabled: false,
         ariaLabel: saveLabel,
-        children: this.container.isGalleryPublishEnabled()
-          ? [
-              {
-                iconName: "Save",
-                onCommandClick: () => this.notebookComponentAdapter.notebookSave(),
-                commandButtonLabel: saveLabel,
-                hasPopup: false,
-                disabled: false,
-                ariaLabel: saveLabel
-              },
-              {
-                iconName: "Copy",
-                onCommandClick: () => this.copyNotebook(),
-                commandButtonLabel: copyToLabel,
-                hasPopup: false,
-                disabled: false,
-                ariaLabel: copyToLabel
-              },
-              {
-                iconName: "PublishContent",
-                onCommandClick: async () => await this.publishToGallery(),
-                commandButtonLabel: publishLabel,
-                hasPopup: false,
-                disabled: false,
-                ariaLabel: publishLabel
-              }
-            ]
-          : undefined
+        children: saveButtonChildren.length && [
+          {
+            iconName: "Save",
+            onCommandClick: () => this.notebookComponentAdapter.notebookSave(),
+            commandButtonLabel: saveLabel,
+            hasPopup: false,
+            disabled: false,
+            ariaLabel: saveLabel
+          },
+          ...saveButtonChildren
+        ]
       },
       {
         iconSrc: null,

src/Explorer/Tabs/QueryTab.ts

@@ -10,7 +10,7 @@ import { HashMap } from "../../Common/HashMap";
 import * as HeadersUtility from "../../Common/HeadersUtility";
 import * as Logger from "../../Common/Logger";
 import { Splitter, SplitterBounds, SplitterDirection } from "../../Common/Splitter";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import ExecuteQueryIcon from "../../../images/ExecuteQuery.svg";
 import { QueryUtils } from "../../Utils/QueryUtils";
 import SaveQueryIcon from "../../../images/save-cosmos.svg";

src/Explorer/Tabs/SettingsTab.test.ts

@@ -7,6 +7,7 @@ import Database from "../Tree/Database";
 import Explorer from "../Explorer";
 import SettingsTab from "../Tabs/SettingsTab";
 import { CommandButtonComponentProps } from "../Controls/CommandButton/CommandButtonComponent";
+import { IndexingPolicies } from "../../Shared/Constants";
 
 describe("Settings tab", () => {
   const baseCollection: DataModels.Collection = {
@@ -16,7 +17,7 @@ describe("Settings tab", () => {
       mode: DataModels.ConflictResolutionMode.LastWriterWins,
       conflictResolutionPath: "/_ts"
     },
-    indexingPolicy: {},
+    indexingPolicy: IndexingPolicies.SharedDatabaseDefault,
     _rid: "",
     _self: "",
     _etag: "",
@@ -51,7 +52,7 @@ describe("Settings tab", () => {
         defaultTtl: 200,
         partitionKey: null,
         conflictResolutionPolicy: null,
-        indexingPolicy: {},
+        indexingPolicy: IndexingPolicies.SharedDatabaseDefault,
         _rid: "",
         _self: "",
         _etag: "",
@@ -345,7 +346,6 @@ describe("Settings tab", () => {
 
       const offer: DataModels.Offer = null;
       const defaultTtl = 200;
-      const indexingPolicy = {};
       const database = new Database(explorer, baseDatabase, null);
       const conflictResolutionPolicy = {
         mode: DataModels.ConflictResolutionMode.LastWriterWins,
@@ -367,7 +367,7 @@ describe("Settings tab", () => {
                 }
               : null,
           conflictResolutionPolicy: conflictResolutionPolicy,
-          indexingPolicy: indexingPolicy,
+          indexingPolicy: IndexingPolicies.SharedDatabaseDefault,
           _rid: "",
           _self: "",
           _etag: "",

src/Explorer/Tabs/SettingsTab.ts

@@ -12,12 +12,13 @@ import editable from "../../Common/EditableUtility";
 import Q from "q";
 import SaveIcon from "../../../images/save-cosmos.svg";
 import TabsBase from "./TabsBase";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 import { PlatformType } from "../../PlatformType";
 import { RequestOptions } from "@azure/cosmos/dist-esm";
 import Explorer from "../Explorer";
-import { updateOffer, updateCollection } from "../../Common/DocumentClientUtilityBase";
+import { updateOffer } from "../../Common/DocumentClientUtilityBase";
+import { updateCollection } from "../../Common/dataAccess/updateCollection";
 import { CommandButtonComponentProps } from "../Controls/CommandButton/CommandButtonComponent";
 import { userContext } from "../../UserContext";
 import { updateOfferThroughputBeyondLimit } from "../../Common/dataAccess/updateOfferThroughputBeyondLimit";
@@ -1009,8 +1010,7 @@ export default class SettingsTab extends TabsBase implements ViewModels.WaitsFor
     );
   }
 
-  public onSaveClick = (): Q.Promise<any> => {
-    let promises: Q.Promise<void>[] = [];
+  public onSaveClick = async (): Promise<any> => {
     this.isExecutionError(false);
 
     this.isExecuting(true);
@@ -1023,50 +1023,60 @@ export default class SettingsTab extends TabsBase implements ViewModels.WaitsFor
 
     const newCollectionAttributes: any = {};
 
-    if (this.shouldUpdateCollection()) {
-      let defaultTtl: number;
-      switch (this.timeToLive()) {
-        case "on":
-          defaultTtl = Number(this.timeToLiveSeconds());
-          break;
-        case "on-nodefault":
-          defaultTtl = -1;
-          break;
-        case "off":
-        default:
-          defaultTtl = undefined;
-          break;
-      }
+    try {
+      if (this.shouldUpdateCollection()) {
+        let defaultTtl: number;
+        switch (this.timeToLive()) {
+          case "on":
+            defaultTtl = Number(this.timeToLiveSeconds());
+            break;
+          case "on-nodefault":
+            defaultTtl = -1;
+            break;
+          case "off":
+          default:
+            defaultTtl = undefined;
+            break;
+        }
 
-      newCollectionAttributes.defaultTtl = defaultTtl;
+        newCollectionAttributes.defaultTtl = defaultTtl;
 
-      newCollectionAttributes.indexingPolicy = this.indexingPolicyContent();
+        newCollectionAttributes.indexingPolicy = this.indexingPolicyContent();
 
-      newCollectionAttributes.changeFeedPolicy =
-        this.changeFeedPolicyVisible() && this.changeFeedPolicyToggled() === ChangeFeedPolicyToggledState.On
-          ? ({
-              retentionDuration: Constants.BackendDefaults.maxChangeFeedRetentionDuration
-            } as DataModels.ChangeFeedPolicy)
+        newCollectionAttributes.changeFeedPolicy =
+          this.changeFeedPolicyVisible() && this.changeFeedPolicyToggled() === ChangeFeedPolicyToggledState.On
+            ? ({
+                retentionDuration: Constants.BackendDefaults.maxChangeFeedRetentionDuration
+              } as DataModels.ChangeFeedPolicy)
+            : undefined;
+
+        newCollectionAttributes.analyticalStorageTtl = this.isAnalyticalStorageEnabled
+          ? this.analyticalStorageTtlSelection() === "on"
+            ? Number(this.analyticalStorageTtlSeconds())
+            : Constants.AnalyticalStorageTtl.Infinite
           : undefined;
 
-      newCollectionAttributes.analyticalStorageTtl = this.isAnalyticalStorageEnabled
-        ? this.analyticalStorageTtlSelection() === "on"
-          ? Number(this.analyticalStorageTtlSeconds())
-          : Constants.AnalyticalStorageTtl.Infinite
-        : undefined;
+        newCollectionAttributes.geospatialConfig = {
+          type: this.geospatialConfigType()
+        };
 
-      newCollectionAttributes.geospatialConfig = {
-        type: this.geospatialConfigType()
-      };
+        const conflictResolutionChanges: DataModels.ConflictResolutionPolicy = this.getUpdatedConflictResolutionPolicy();
+        if (!!conflictResolutionChanges) {
+          newCollectionAttributes.conflictResolutionPolicy = conflictResolutionChanges;
+        }
 
-      const conflictResolutionChanges: DataModels.ConflictResolutionPolicy = this.getUpdatedConflictResolutionPolicy();
-      if (!!conflictResolutionChanges) {
-        newCollectionAttributes.conflictResolutionPolicy = conflictResolutionChanges;
-      }
+        const newCollection: DataModels.Collection = _.extend(
+          {},
+          this.collection.rawDataModel,
+          newCollectionAttributes
+        );
+        const updatedCollection: DataModels.Collection = await updateCollection(
+          this.collection.databaseId,
+          this.collection.id(),
+          newCollection
+        );
 
-      const newCollection: DataModels.Collection = _.extend({}, this.collection.rawDataModel, newCollectionAttributes);
-      const updateCollectionPromise = updateCollection(this.collection.databaseId, this.collection, newCollection).then(
-        (updatedCollection: DataModels.Collection) => {
+        if (updatedCollection) {
           this.collection.rawDataModel = updatedCollection;
           this.collection.defaultTtl(updatedCollection.defaultTtl);
           this.collection.analyticalStorageTtl(updatedCollection.analyticalStorageTtl);
@@ -1076,164 +1086,133 @@ export default class SettingsTab extends TabsBase implements ViewModels.WaitsFor
           this.collection.changeFeedPolicy(updatedCollection.changeFeedPolicy);
           this.collection.geospatialConfig(updatedCollection.geospatialConfig);
         }
-      );
-
-      promises.push(updateCollectionPromise);
-    }
-
-    if (
-      this.throughput.editableIsDirty() ||
-      this.rupm.editableIsDirty() ||
-      this._isAutoPilotDirty() ||
-      this._hasProvisioningTypeChanged()
-    ) {
-      const newThroughput = this.throughput();
-      const isRUPerMinuteThroughputEnabled: boolean = this.rupm() === Constants.RUPMStates.on;
-      let newOffer: DataModels.Offer = _.extend({}, this.collection.offer());
-      const originalThroughputValue: number = this.throughput.getEditableOriginalValue();
-
-      if (newOffer.content) {
-        newOffer.content.offerThroughput = newThroughput;
-        newOffer.content.offerIsRUPerMinuteThroughputEnabled = isRUPerMinuteThroughputEnabled;
-      } else {
-        newOffer = _.extend({}, newOffer, {
-          content: {
-            offerThroughput: newThroughput,
-            offerIsRUPerMinuteThroughputEnabled: isRUPerMinuteThroughputEnabled
-          }
-        });
-      }
-
-      const headerOptions: RequestOptions = { initialHeaders: {} };
-
-      if (this.isAutoPilotSelected()) {
-        if (!this.hasAutoPilotV2FeatureFlag()) {
-          newOffer.content.offerAutopilotSettings = {
-            maxThroughput: this.autoPilotThroughput()
-          };
-        } else {
-          newOffer.content.offerAutopilotSettings = {
-            tier: this.selectedAutoPilotTier()
-          };
-        }
-
-        // user has changed from provisioned --> autoscale
-        if (!this.hasAutoPilotV2FeatureFlag() && this._hasProvisioningTypeChanged()) {
-          headerOptions.initialHeaders[Constants.HttpHeaders.migrateOfferToAutopilot] = "true";
-          delete newOffer.content.offerAutopilotSettings;
-        } else {
-          delete newOffer.content.offerThroughput;
-        }
-      } else {
-        this.isAutoPilotSelected(false);
-        this.userCanChangeProvisioningTypes(false || !this.hasAutoPilotV2FeatureFlag());
-
-        // user has changed from autoscale --> provisioned
-        if (!this.hasAutoPilotV2FeatureFlag() && this._hasProvisioningTypeChanged()) {
-          headerOptions.initialHeaders[Constants.HttpHeaders.migrateOfferToManualThroughput] = "true";
-        } else {
-          delete newOffer.content.offerAutopilotSettings;
-        }
       }
 
       if (
-        this.maxRUs() <= SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
-        newThroughput > SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
-        this.container != null
+        this.throughput.editableIsDirty() ||
+        this.rupm.editableIsDirty() ||
+        this._isAutoPilotDirty() ||
+        this._hasProvisioningTypeChanged()
       ) {
-        const requestPayload = {
-          subscriptionId: userContext.subscriptionId,
-          databaseAccountName: userContext.databaseAccount.name,
-          resourceGroup: userContext.resourceGroup,
-          databaseName: this.collection.databaseId,
-          collectionName: this.collection.id(),
-          throughput: newThroughput,
-          offerIsRUPerMinuteThroughputEnabled: isRUPerMinuteThroughputEnabled
-        };
-        const updateOfferBeyondLimitPromise = updateOfferThroughputBeyondLimit(requestPayload).then(
-          () => {
-            this.collection.offer().content.offerThroughput = originalThroughputValue;
-            this.throughput(originalThroughputValue);
-            this.notificationStatusInfo(
-              throughputApplyDelayedMessage(
-                this.isAutoPilotSelected(),
-                originalThroughputValue,
-                this._getThroughputUnit(),
-                this.collection.databaseId,
-                this.collection.id(),
-                newThroughput
-              )
-            );
-            this.throughput.valueHasMutated(); // force component re-render
-          },
-          (error: any) => {
-            TelemetryProcessor.traceFailure(
-              Action.UpdateSettings,
-              {
-                databaseAccountName: this.container.databaseAccount().name,
-                databaseName: this.collection && this.collection.databaseId,
-                collectionName: this.collection && this.collection.id(),
-                defaultExperience: this.container.defaultExperience(),
-                dataExplorerArea: Constants.Areas.Tab,
-                tabTitle: this.tabTitle(),
-                error: error
-              },
-              startKey
-            );
-          }
-        );
-        promises.push(Q(updateOfferBeyondLimitPromise));
-      } else {
-        const updateOfferPromise = updateOffer(this.collection.offer(), newOffer, headerOptions).then(
-          (updatedOffer: DataModels.Offer) => {
-            this.collection.offer(updatedOffer);
-            this.collection.offer.valueHasMutated();
-          }
-        );
+        const newThroughput = this.throughput();
+        const isRUPerMinuteThroughputEnabled: boolean = this.rupm() === Constants.RUPMStates.on;
+        let newOffer: DataModels.Offer = _.extend({}, this.collection.offer());
+        const originalThroughputValue: number = this.throughput.getEditableOriginalValue();
 
-        promises.push(updateOfferPromise);
-      }
-    }
-
-    if (promises.length === 0) {
-      this.isExecuting(false);
-    }
-
-    return Q.all(promises)
-      .then(
-        () => {
-          this.container.isRefreshingExplorer(false);
-          this._setBaseline();
-          this.collection.readSettings();
-          this._wasAutopilotOriginallySet(this.isAutoPilotSelected());
-          TelemetryProcessor.traceSuccess(
-            Action.UpdateSettings,
-            {
-              databaseAccountName: this.container.databaseAccount().name,
-              defaultExperience: this.container.defaultExperience(),
-              dataExplorerArea: Constants.Areas.Tab,
-              tabTitle: this.tabTitle()
-            },
-            startKey
-          );
-        },
-        (reason: any) => {
-          this.container.isRefreshingExplorer(false);
-          this.isExecutionError(true);
-          console.error(reason);
-          TelemetryProcessor.traceFailure(
-            Action.UpdateSettings,
-            {
-              databaseAccountName: this.container.databaseAccount().name,
-              defaultExperience: this.container.defaultExperience(),
-              dataExplorerArea: Constants.Areas.Tab,
-              tabTitle: this.tabTitle()
-            },
-            startKey
-          );
+        if (newOffer.content) {
+          newOffer.content.offerThroughput = newThroughput;
+          newOffer.content.offerIsRUPerMinuteThroughputEnabled = isRUPerMinuteThroughputEnabled;
+        } else {
+          newOffer = _.extend({}, newOffer, {
+            content: {
+              offerThroughput: newThroughput,
+              offerIsRUPerMinuteThroughputEnabled: isRUPerMinuteThroughputEnabled
+            }
+          });
         }
-      )
-      .finally(() => this.isExecuting(false));
+
+        const headerOptions: RequestOptions = { initialHeaders: {} };
+
+        if (this.isAutoPilotSelected()) {
+          if (!this.hasAutoPilotV2FeatureFlag()) {
+            newOffer.content.offerAutopilotSettings = {
+              maxThroughput: this.autoPilotThroughput()
+            };
+          } else {
+            newOffer.content.offerAutopilotSettings = {
+              tier: this.selectedAutoPilotTier()
+            };
+          }
+
+          // user has changed from provisioned --> autoscale
+          if (!this.hasAutoPilotV2FeatureFlag() && this._hasProvisioningTypeChanged()) {
+            headerOptions.initialHeaders[Constants.HttpHeaders.migrateOfferToAutopilot] = "true";
+            delete newOffer.content.offerAutopilotSettings;
+          } else {
+            delete newOffer.content.offerThroughput;
+          }
+        } else {
+          this.isAutoPilotSelected(false);
+          this.userCanChangeProvisioningTypes(false || !this.hasAutoPilotV2FeatureFlag());
+
+          // user has changed from autoscale --> provisioned
+          if (!this.hasAutoPilotV2FeatureFlag() && this._hasProvisioningTypeChanged()) {
+            headerOptions.initialHeaders[Constants.HttpHeaders.migrateOfferToManualThroughput] = "true";
+          } else {
+            delete newOffer.content.offerAutopilotSettings;
+          }
+        }
+
+        if (
+          this.maxRUs() <= SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
+          newThroughput > SharedConstants.CollectionCreation.DefaultCollectionRUs1Million &&
+          this.container != null
+        ) {
+          const requestPayload = {
+            subscriptionId: userContext.subscriptionId,
+            databaseAccountName: userContext.databaseAccount.name,
+            resourceGroup: userContext.resourceGroup,
+            databaseName: this.collection.databaseId,
+            collectionName: this.collection.id(),
+            throughput: newThroughput,
+            offerIsRUPerMinuteThroughputEnabled: isRUPerMinuteThroughputEnabled
+          };
+
+          await updateOfferThroughputBeyondLimit(requestPayload);
+          this.collection.offer().content.offerThroughput = originalThroughputValue;
+          this.throughput(originalThroughputValue);
+          this.notificationStatusInfo(
+            throughputApplyDelayedMessage(
+              this.isAutoPilotSelected(),
+              originalThroughputValue,
+              this._getThroughputUnit(),
+              this.collection.databaseId,
+              this.collection.id(),
+              newThroughput
+            )
+          );
+          this.throughput.valueHasMutated(); // force component re-render
+        } else {
+          const updatedOffer: DataModels.Offer = await updateOffer(this.collection.offer(), newOffer, headerOptions);
+          this.collection.offer(updatedOffer);
+          this.collection.offer.valueHasMutated();
+        }
+      }
+
+      this.container.isRefreshingExplorer(false);
+      this._setBaseline();
+      this.collection.readSettings();
+      this._wasAutopilotOriginallySet(this.isAutoPilotSelected());
+      TelemetryProcessor.traceSuccess(
+        Action.UpdateSettings,
+        {
+          databaseAccountName: this.container.databaseAccount().name,
+          defaultExperience: this.container.defaultExperience(),
+          dataExplorerArea: Constants.Areas.Tab,
+          tabTitle: this.tabTitle()
+        },
+        startKey
+      );
+    } catch (error) {
+      this.container.isRefreshingExplorer(false);
+      this.isExecutionError(true);
+      console.error(error);
+      TelemetryProcessor.traceFailure(
+        Action.UpdateSettings,
+        {
+          databaseAccountName: this.container.databaseAccount().name,
+          databaseName: this.collection && this.collection.databaseId,
+          collectionName: this.collection && this.collection.id(),
+          defaultExperience: this.container.defaultExperience(),
+          dataExplorerArea: Constants.Areas.Tab,
+          tabTitle: this.tabTitle(),
+          error: error
+        },
+        startKey
+      );
+    }
+
+    this.isExecuting(false);
   };
 
   public onRevertClick = (): Q.Promise<any> => {

src/Explorer/Tabs/StoredProcedureTab.ts

@@ -7,7 +7,7 @@ import * as ViewModels from "../../Contracts/ViewModels";
 import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 import editable from "../../Common/EditableUtility";
 import ScriptTabBase from "./ScriptTabBase";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import ExecuteQueryIcon from "../../../images/ExecuteQuery.svg";
 import StoredProcedure from "../Tree/StoredProcedure";
 import { createStoredProcedure, updateStoredProcedure } from "../../Common/DocumentClientUtilityBase";

src/Explorer/Tabs/TabsBase.ts

@@ -5,7 +5,7 @@ import * as ViewModels from "../../Contracts/ViewModels";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { RouteHandler } from "../../RouteHandlers/RouteHandler";
 import { WaitsForTemplateViewModel } from "../WaitsForTemplateViewModel";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import ThemeUtility from "../../Common/ThemeUtility";
 import Explorer from "../Explorer";
 import { CommandButtonComponentProps } from "../Controls/CommandButton/CommandButtonComponent";

src/Explorer/Tabs/TriggerTab.ts

@@ -5,7 +5,7 @@ import * as ViewModels from "../../Contracts/ViewModels";
 import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 import ScriptTabBase from "./ScriptTabBase";
 import editable from "../../Common/EditableUtility";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import Trigger from "../Tree/Trigger";
 import { createTrigger, updateTrigger } from "../../Common/DocumentClientUtilityBase";
 

src/Explorer/Tabs/UserDefinedFunctionTab.ts

@@ -4,7 +4,7 @@ import * as DataModels from "../../Contracts/DataModels";
 import * as ViewModels from "../../Contracts/ViewModels";
 import { Action } from "../../Shared/Telemetry/TelemetryConstants";
 import ScriptTabBase from "./ScriptTabBase";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import UserDefinedFunction from "../Tree/UserDefinedFunction";
 import { createUserDefinedFunction, updateUserDefinedFunction } from "../../Common/DocumentClientUtilityBase";
 

src/Explorer/Tree/Collection.ts

@@ -9,7 +9,7 @@ import * as DataModels from "../../Contracts/DataModels";
 import * as ViewModels from "../../Contracts/ViewModels";
 import { PlatformType } from "../../PlatformType";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
 import { OfferUtils } from "../../Utils/OfferUtils";
 import { StartUploadMessageParams, UploadDetails, UploadDetailsRecord } from "../../workers/upload/definitions";
@@ -648,7 +648,9 @@ export default class Collection implements ViewModels.Collection {
     });
     // 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();
+    const offerInfoPromise: Q.Promise<DataModels.Offer[]> = readOffers({
+      isServerless: this.container.isServerlessEnabled()
+    });
     Q.all([quotaInfoPromise, offerInfoPromise]).then(
       () => {
         this.container.isRefreshingExplorer(false);
@@ -657,9 +659,7 @@ export default class Collection implements ViewModels.Collection {
         const quotaInfo = _.omit(quotaInfoWithUniqueKeyPolicy, "uniqueKeyPolicy");
 
         const collectionOffer = this._getOfferForCollection(offerInfoPromise.valueOf(), collectionDataModel);
-        const isDatabaseShared = this.getDatabase() && this.getDatabase().isDatabaseShared();
-        const isServerless = this.container.isServerlessEnabled();
-        if ((isDatabaseShared || isServerless) && !collectionOffer) {
+        if (!collectionOffer) {
           this.quotaInfo(quotaInfo);
           TelemetryProcessor.traceSuccess(
             Action.LoadOffers,

src/Explorer/Tree/Database.ts

@@ -7,7 +7,7 @@ import * as DataModels from "../../Contracts/DataModels";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import DatabaseSettingsTab from "../Tabs/DatabaseSettingsTab";
 import Collection from "./Collection";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
 import { ConsoleDataType } from "../Menus/NotificationConsole/NotificationConsoleComponent";
 import * as Logger from "../../Common/Logger";
@@ -123,10 +123,6 @@ export default class Database implements ViewModels.Database {
 
   public readSettings(): Q.Promise<void> {
     const deferred: Q.Deferred<void> = Q.defer<void>();
-    if (this.container.isServerlessEnabled()) {
-      deferred.resolve();
-    }
-
     this.container.isRefreshingExplorer(true);
     const databaseDataModel: DataModels.Database = <DataModels.Database>{
       id: this.id(),
@@ -138,7 +134,9 @@ export default class Database implements ViewModels.Database {
       defaultExperience: this.container.defaultExperience()
     });
 
-    const offerInfoPromise: Q.Promise<DataModels.Offer[]> = readOffers();
+    const offerInfoPromise: Q.Promise<DataModels.Offer[]> = readOffers({
+      isServerless: this.container.isServerlessEnabled()
+    });
     Q.all([offerInfoPromise]).then(
       () => {
         this.container.isRefreshingExplorer(false);
@@ -147,6 +145,11 @@ export default class Database implements ViewModels.Database {
           offerInfoPromise.valueOf(),
           databaseDataModel
         );
+
+        if (!databaseOffer) {
+          return;
+        }
+
         readOffer(databaseOffer).then((offerDetail: DataModels.OfferWithHeaders) => {
           const offerThroughputInfo: DataModels.OfferThroughputInfo = {
             minimumRUForCollection:

src/Explorer/Tree/ResourceTokenCollection.ts

@@ -7,7 +7,7 @@ import DocumentId from "./DocumentId";
 import DocumentsTab from "../Tabs/DocumentsTab";
 import Q from "q";
 import QueryTab from "../Tabs/QueryTab";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import Explorer from "../Explorer";
 import TabsBase from "../Tabs/TabsBase";
 

src/Explorer/Tree/ResourceTreeAdapter.test.ts

@@ -0,0 +1,112 @@
+import Explorer from "../Explorer";
+import * as ko from "knockout";
+import { ResourceTreeAdapter } from "./ResourceTreeAdapter";
+import * as ViewModels from "../../Contracts/ViewModels";
+import TabsBase from "../Tabs/TabsBase";
+
+describe("ResourceTreeAdapter", () => {
+  const mockContainer = (): Explorer =>
+    (({
+      selectedNode: ko.observable<ViewModels.TreeNode>({
+        nodeKind: "nodeKind",
+        rid: "rid",
+        id: ko.observable<string>("id")
+      }),
+      tabsManager: {
+        activeTab: ko.observable<TabsBase>({
+          tabKind: ViewModels.CollectionTabKind.Documents
+        } as TabsBase)
+      },
+      isNotebookEnabled: ko.observable<boolean>(true),
+      nonSystemDatabases: ko.observable<ViewModels.Database[]>([])
+    } as unknown) as Explorer);
+
+  // TODO isDataNodeSelected needs a better design and refactor, but for now, we protect some of the code paths
+  describe("isDataNodeSelected", () => {
+    it("it should not select if no selected node", () => {
+      const explorer = mockContainer();
+      explorer.selectedNode(undefined);
+      const resourceTreeAdapter = new ResourceTreeAdapter(explorer);
+      const isDataNodeSelected = resourceTreeAdapter.isDataNodeSelected("foo", "bar", undefined);
+      expect(isDataNodeSelected).toBeFalsy();
+    });
+
+    it("it should not select incorrect subnodekinds", () => {
+      const resourceTreeAdapter = new ResourceTreeAdapter(mockContainer());
+      const isDataNodeSelected = resourceTreeAdapter.isDataNodeSelected("foo", "bar", undefined);
+      expect(isDataNodeSelected).toBeFalsy();
+    });
+
+    it("it should not select if no active tab", () => {
+      const explorer = mockContainer();
+      explorer.tabsManager.activeTab(undefined);
+      const resourceTreeAdapter = new ResourceTreeAdapter(explorer);
+      const isDataNodeSelected = resourceTreeAdapter.isDataNodeSelected("foo", "bar", undefined);
+      expect(isDataNodeSelected).toBeFalsy();
+    });
+
+    it("should select if correct database node regardless of subnodekinds", () => {
+      const subNodeKind = ViewModels.CollectionTabKind.Documents;
+      const explorer = mockContainer();
+      explorer.selectedNode(({
+        nodeKind: "Database",
+        rid: "dbrid",
+        id: ko.observable<string>("id"),
+        selectedSubnodeKind: ko.observable<ViewModels.CollectionTabKind>(subNodeKind)
+      } as unknown) as ViewModels.TreeNode);
+      const resourceTreeAdapter = new ResourceTreeAdapter(explorer);
+      const isDataNodeSelected = resourceTreeAdapter.isDataNodeSelected("dbrid", "Database", [
+        ViewModels.CollectionTabKind.Documents
+      ]);
+      expect(isDataNodeSelected).toBeTruthy();
+    });
+
+    it("should select correct collection node (documents or graph node)", () => {
+      let subNodeKind = ViewModels.CollectionTabKind.Documents;
+      const explorer = mockContainer();
+      explorer.tabsManager.activeTab({
+        tabKind: subNodeKind
+      } as TabsBase);
+      explorer.selectedNode(({
+        nodeKind: "Collection",
+        rid: "collrid",
+        id: ko.observable<string>("id"),
+        selectedSubnodeKind: ko.observable<ViewModels.CollectionTabKind>(subNodeKind)
+      } as unknown) as ViewModels.TreeNode);
+      const resourceTreeAdapter = new ResourceTreeAdapter(explorer);
+      let isDataNodeSelected = resourceTreeAdapter.isDataNodeSelected("collrid", "Collection", [subNodeKind]);
+      expect(isDataNodeSelected).toBeTruthy();
+
+      subNodeKind = ViewModels.CollectionTabKind.Graph;
+      explorer.tabsManager.activeTab({
+        tabKind: subNodeKind
+      } as TabsBase);
+      explorer.selectedNode(({
+        nodeKind: "Collection",
+        rid: "collrid",
+        id: ko.observable<string>("id"),
+        selectedSubnodeKind: ko.observable<ViewModels.CollectionTabKind>(subNodeKind)
+      } as unknown) as ViewModels.TreeNode);
+      isDataNodeSelected = resourceTreeAdapter.isDataNodeSelected("collrid", "Collection", [subNodeKind]);
+      expect(isDataNodeSelected).toBeTruthy();
+    });
+
+    it("should not select incorrect collection node (e.g. Settings)", () => {
+      const explorer = mockContainer();
+      explorer.selectedNode(({
+        nodeKind: "Collection",
+        rid: "collrid",
+        id: ko.observable<string>("id"),
+        selectedSubnodeKind: ko.observable<ViewModels.CollectionTabKind>(ViewModels.CollectionTabKind.Documents)
+      } as unknown) as ViewModels.TreeNode);
+      explorer.tabsManager.activeTab({
+        tabKind: ViewModels.CollectionTabKind.Documents
+      } as TabsBase);
+      const resourceTreeAdapter = new ResourceTreeAdapter(explorer);
+      const isDataNodeSelected = resourceTreeAdapter.isDataNodeSelected("collrid", "Collection", [
+        ViewModels.CollectionTabKind.Settings
+      ]);
+      expect(isDataNodeSelected).toBeFalsy();
+    });
+  });
+});

src/Explorer/Tree/ResourceTreeAdapter.tsx

@@ -19,7 +19,7 @@ import { ArrayHashMap } from "../../Common/ArrayHashMap";
 import { NotebookUtil } from "../Notebook/NotebookUtil";
 import _ from "underscore";
 import { IPinnedRepo } from "../../Juno/JunoClient";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import { Areas } from "../../Common/Constants";
 import * as GitHubUtils from "../../Utils/GitHubUtils";
@@ -191,7 +191,7 @@ export class ResourceTreeAdapter implements ReactAdapter {
         databaseNode.children.push({
           label: "Scale",
           isSelected: () =>
-            this.isDataNodeSelected(database.rid, "Database", ViewModels.CollectionTabKind.DatabaseSettings),
+            this.isDataNodeSelected(database.rid, "Database", [ViewModels.CollectionTabKind.DatabaseSettings]),
           onClick: database.onSettingsClick.bind(database)
         });
       }
@@ -235,14 +235,18 @@ export class ResourceTreeAdapter implements ReactAdapter {
           data: collection.rid
         });
       },
-      isSelected: () => this.isDataNodeSelected(collection.rid, "Collection", ViewModels.CollectionTabKind.Documents),
+      isSelected: () =>
+        this.isDataNodeSelected(collection.rid, "Collection", [
+          ViewModels.CollectionTabKind.Documents,
+          ViewModels.CollectionTabKind.Graph
+        ]),
       contextMenu: ResourceTreeContextMenuButtonFactory.createCollectionContextMenuButton(this.container, collection)
     });
 
     children.push({
       label: database.isDatabaseShared() || this.container.isServerlessEnabled() ? "Settings" : "Scale & Settings",
       onClick: collection.onSettingsClick.bind(collection),
-      isSelected: () => this.isDataNodeSelected(collection.rid, "Collection", ViewModels.CollectionTabKind.Settings)
+      isSelected: () => this.isDataNodeSelected(collection.rid, "Collection", [ViewModels.CollectionTabKind.Settings])
     });
 
     if (ResourceTreeAdapter.showScriptNodes(this.container)) {
@@ -264,7 +268,8 @@ export class ResourceTreeAdapter implements ReactAdapter {
       children.push({
         label: "Conflicts",
         onClick: collection.onConflictsClick.bind(collection),
-        isSelected: () => this.isDataNodeSelected(collection.rid, "Collection", ViewModels.CollectionTabKind.Conflicts)
+        isSelected: () =>
+          this.isDataNodeSelected(collection.rid, "Collection", [ViewModels.CollectionTabKind.Conflicts])
       });
     }
 
@@ -302,7 +307,7 @@ export class ResourceTreeAdapter implements ReactAdapter {
         label: sp.id(),
         onClick: sp.open.bind(sp),
         isSelected: () =>
-          this.isDataNodeSelected(collection.rid, "Collection", ViewModels.CollectionTabKind.StoredProcedures),
+          this.isDataNodeSelected(collection.rid, "Collection", [ViewModels.CollectionTabKind.StoredProcedures]),
         contextMenu: ResourceTreeContextMenuButtonFactory.createStoreProcedureContextMenuItems(this.container, sp)
       })),
       onClick: () => {
@@ -321,7 +326,7 @@ export class ResourceTreeAdapter implements ReactAdapter {
         label: udf.id(),
         onClick: udf.open.bind(udf),
         isSelected: () =>
-          this.isDataNodeSelected(collection.rid, "Collection", ViewModels.CollectionTabKind.UserDefinedFunctions),
+          this.isDataNodeSelected(collection.rid, "Collection", [ViewModels.CollectionTabKind.UserDefinedFunctions]),
         contextMenu: ResourceTreeContextMenuButtonFactory.createUserDefinedFunctionContextMenuItems(this.container, udf)
       })),
       onClick: () => {
@@ -339,7 +344,8 @@ export class ResourceTreeAdapter implements ReactAdapter {
       children: collection.triggers().map((trigger: Trigger) => ({
         label: trigger.id(),
         onClick: trigger.open.bind(trigger),
-        isSelected: () => this.isDataNodeSelected(collection.rid, "Collection", ViewModels.CollectionTabKind.Triggers),
+        isSelected: () =>
+          this.isDataNodeSelected(collection.rid, "Collection", [ViewModels.CollectionTabKind.Triggers]),
         contextMenu: ResourceTreeContextMenuButtonFactory.createTriggerContextMenuItems(this.container, trigger)
       })),
       onClick: () => {
@@ -546,43 +552,52 @@ export class ResourceTreeAdapter implements ReactAdapter {
           (activeTab as any).notebookPath() === item.path
         );
       },
-      contextMenu: createFileContextMenu
-        ? [
-            {
-              label: "Rename",
-              iconSrc: NotebookIcon,
-              onClick: () => this.container.renameNotebook(item)
-            },
-            {
-              label: "Delete",
-              iconSrc: DeleteIcon,
-              onClick: () => {
-                this.container.showOkCancelModalDialog(
-                  "Confirm delete",
-                  `Are you sure you want to delete "${item.name}"`,
-                  "Delete",
-                  () => this.container.deleteNotebookFile(item).then(() => this.triggerRender()),
-                  "Cancel",
-                  undefined
-                );
-              }
-            },
-            {
-              label: "Copy to ...",
-              iconSrc: CopyIcon,
-              onClick: () => this.copyNotebook(item)
-            },
-            {
-              label: "Download",
-              iconSrc: NotebookIcon,
-              onClick: () => this.container.downloadFile(item)
-            }
-          ]
-        : undefined,
+      contextMenu: createFileContextMenu && this.createFileContextMenu(item),
       data: item
     };
   }
 
+  private createFileContextMenu(item: NotebookContentItem): TreeNodeMenuItem[] {
+    let items: TreeNodeMenuItem[] = [
+      {
+        label: "Rename",
+        iconSrc: NotebookIcon,
+        onClick: () => this.container.renameNotebook(item)
+      },
+      {
+        label: "Delete",
+        iconSrc: DeleteIcon,
+        onClick: () => {
+          this.container.showOkCancelModalDialog(
+            "Confirm delete",
+            `Are you sure you want to delete "${item.name}"`,
+            "Delete",
+            () => this.container.deleteNotebookFile(item).then(() => this.triggerRender()),
+            "Cancel",
+            undefined
+          );
+        }
+      },
+      {
+        label: "Copy to ...",
+        iconSrc: CopyIcon,
+        onClick: () => this.copyNotebook(item)
+      },
+      {
+        label: "Download",
+        iconSrc: NotebookIcon,
+        onClick: () => this.container.downloadFile(item)
+      }
+    ];
+
+    // "Copy to ..." isn't needed if github locations are not available
+    if (!this.container.notebookManager?.gitHubOAuthService.isLoggedIn()) {
+      items = items.filter(item => item.label !== "Copy to ...");
+    }
+
+    return items;
+  }
+
   private copyNotebook = async (item: NotebookContentItem) => {
     const content = await this.container.readFile(item);
     if (content) {
@@ -688,13 +703,19 @@ export class ResourceTreeAdapter implements ReactAdapter {
     window.requestAnimationFrame(() => this.parameters(Date.now()));
   }
 
-  private isDataNodeSelected(rid: string, nodeKind: string, subnodeKind: ViewModels.CollectionTabKind): boolean {
+  /**
+   * public for testing purposes
+   * @param rid
+   * @param nodeKind
+   * @param subnodeKinds
+   */
+  public isDataNodeSelected(rid: string, nodeKind: string, subnodeKinds: ViewModels.CollectionTabKind[]): boolean {
     if (!this.container.selectedNode || !this.container.selectedNode()) {
       return false;
     }
     const selectedNode = this.container.selectedNode();
 
-    if (subnodeKind === undefined) {
+    if (subnodeKinds === undefined || !Array.isArray(subnodeKinds)) {
       return selectedNode.rid === rid && selectedNode.nodeKind === nodeKind;
     } else {
       const activeTab = this.container.tabsManager.activeTab();
@@ -707,10 +728,10 @@ export class ResourceTreeAdapter implements ReactAdapter {
 
       return (
         activeTab &&
-        activeTab.tabKind === subnodeKind &&
+        subnodeKinds.includes(activeTab.tabKind) &&
         selectedNode.rid === rid &&
         selectedSubnodeKind !== undefined &&
-        selectedSubnodeKind === subnodeKind
+        subnodeKinds.includes(selectedSubnodeKind)
       );
     }
   }

src/Explorer/Tree/StoredProcedure.ts

@@ -5,7 +5,7 @@ import * as DataModels from "../../Contracts/DataModels";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 
 import StoredProcedureTab from "../Tabs/StoredProcedureTab";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import Explorer from "../Explorer";
 import { deleteStoredProcedure, executeStoredProcedure } from "../../Common/DocumentClientUtilityBase";
 import TabsBase from "../Tabs/TabsBase";

src/Explorer/Tree/Trigger.ts

@@ -4,7 +4,7 @@ import * as Constants from "../../Common/Constants";
 import * as DataModels from "../../Contracts/DataModels";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import TriggerTab from "../Tabs/TriggerTab";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import Explorer from "../Explorer";
 import { deleteTrigger } from "../../Common/DocumentClientUtilityBase";
 

src/Explorer/Tree/UserDefinedFunction.ts

@@ -4,7 +4,7 @@ import * as Constants from "../../Common/Constants";
 import * as DataModels from "../../Contracts/DataModels";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import UserDefinedFunctionTab from "../Tabs/UserDefinedFunctionTab";
-import TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
 import Explorer from "../Explorer";
 import { deleteUserDefinedFunction } from "../../Common/DocumentClientUtilityBase";
 

src/HostedExplorer.ts

@@ -29,7 +29,7 @@ import { MeControlComponentAdapter } from "./Explorer/Menus/NavBar/MeControlComp
 import { MessageTypes } from "./Contracts/ExplorerContracts";
 import * as ReactBindingHandler from "./Bindings/ReactBindingHandler";
 import { SwitchDirectoryPane, SwitchDirectoryPaneComponent } from "./Explorer/Panes/SwitchDirectoryPane";
-import TelemetryProcessor from "./Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "./Shared/Telemetry/TelemetryProcessor";
 import { isInvalidParentFrameOrigin } from "./Utils/MessageValidation";
 import "../less/hostedexplorer.less";
 import "./Explorer/Menus/NavBar/MeControlComponent.less";

src/Main.ts

@@ -60,7 +60,7 @@ import "url-polyfill/url-polyfill.min";
 // import "./ReactDevTools"
 
 import * as ko from "knockout";
-import TelemetryProcessor from "./Shared/Telemetry/TelemetryProcessor";
+import * as TelemetryProcessor from "./Shared/Telemetry/TelemetryProcessor";
 import * as ViewModels from "./Contracts/ViewModels";
 import { Action, ActionModifiers } from "./Shared/Telemetry/TelemetryConstants";
 

src/Shared/AddCollectionUtility.test.ts

@@ -1,162 +1,64 @@
-import * as SharedConstants from "../Shared/Constants";
-import { AddDbUtilities } from "../Shared/AddDatabaseUtility";
-import { CreateCollectionUtilities, CreateSqlCollectionUtilities, Utilities } from "./AddCollectionUtility";
-jest.mock("AddDatabaseUtility");
+import * as ko from "knockout";
+import { Collection, Database } from "../Contracts/ViewModels";
+import { getMaxThroughput } from "./AddCollectionUtility";
+import Explorer from "../Explorer/Explorer";
 
-const armEndpoint = "https://management.azure.com";
+describe("getMaxThroughput", () => {
+  it("default unlimited throughput setting", () => {
+    const defaults = {
+      storage: "100",
+      throughput: {
+        fixed: 400,
+        unlimited: 400,
+        unlimitedmax: 1000000,
+        unlimitedmin: 400,
+        shared: 400
+      }
+    };
 
-describe("Add Collection Utitlity", () => {
-  describe("createSqlCollection", () => {
-    it("should invoke createSqlCollectionWithARM if create database is false", () => {
-      const properties = {
-        uniqueKeyPolicy: { uniqueKeys: [{ paths: [""] }] },
-        cd: false,
-        coll: "abc-collection",
-        db: "a1-db",
-        dba: "main",
-        offerThroughput: 50000,
-        pk: "state",
-        sid: "a1",
-        rg: "b1",
-        st: true,
-        defaultTtl: -1,
-        indexingPolicy: SharedConstants.IndexingPolicies.AllPropertiesIndexed,
-        partitionKeyVersion: 2
-      };
-      const additionalOptions = {};
-      const createSqlCollectionWithARMSpy = jest.spyOn(CreateSqlCollectionUtilities, "createSqlCollectionWithARM");
-      CreateSqlCollectionUtilities.createSqlCollection(
-        armEndpoint,
-        properties.db,
-        properties.defaultTtl,
-        properties.coll,
-        properties.indexingPolicy,
-        properties.offerThroughput,
-        properties.pk,
-        properties.partitionKeyVersion,
-        properties.cd,
-        properties.st,
-        properties.sid,
-        properties.rg,
-        properties.dba,
-        properties.uniqueKeyPolicy,
-        additionalOptions
+    expect(getMaxThroughput(defaults, {} as Explorer)).toEqual(defaults.throughput.unlimited);
+  });
+
+  describe("no unlimited throughput setting", () => {
+    const defaults = {
+      storage: "100",
+      throughput: {
+        fixed: 400,
+        unlimited: {
+          collectionThreshold: 3,
+          lessThanOrEqualToThreshold: 400,
+          greatThanThreshold: 500
+        },
+        unlimitedmax: 1000000,
+        unlimitedmin: 400,
+        shared: 400
+      }
+    };
+
+    const mockCollection1 = { id: ko.observable("collection1") } as Collection;
+    const mockCollection2 = { id: ko.observable("collection2") } as Collection;
+    const mockCollection3 = { id: ko.observable("collection3") } as Collection;
+    const mockCollection4 = { id: ko.observable("collection4") } as Collection;
+    const mockDatabase = {} as Database;
+    const mockContainer = {
+      databases: ko.observableArray([mockDatabase])
+    } as Explorer;
+
+    it("less than or equal to collection threshold", () => {
+      mockDatabase.collections = ko.observableArray([mockCollection1, mockCollection2]);
+      expect(getMaxThroughput(defaults, mockContainer)).toEqual(
+        defaults.throughput.unlimited.lessThanOrEqualToThreshold
       );
-      expect(createSqlCollectionWithARMSpy).toHaveBeenCalled();
     });
 
-    it("should invoke createSqlDatabase + createSqlCollectionWithARM if create database is true", () => {
-      const properties = {
-        uniqueKeyPolicy: { uniqueKeys: [{ paths: [""] }] },
-        cd: true,
-        coll: "abc-collection",
-        db: "a1-db",
-        dba: "main",
-        offerThroughput: 50000,
-        pk: "state",
-        sid: "a1",
-        rg: "b1",
-        st: true,
-        analyticalStorageTtl: -1,
-        indexingPolicy: SharedConstants.IndexingPolicies.AllPropertiesIndexed,
-        partitionKeyVersion: 2
-      };
-      const additionalOptions = {};
-      const createSqlCollectionWithARMSpy = jest.spyOn(CreateSqlCollectionUtilities, "createSqlCollectionWithARM");
-      const createSqlDatabaseSpy = jest.spyOn(AddDbUtilities, "createSqlDatabase");
-      CreateSqlCollectionUtilities.createSqlCollection(
-        armEndpoint,
-        properties.db,
-        properties.analyticalStorageTtl,
-        properties.coll,
-        properties.indexingPolicy,
-        properties.offerThroughput,
-        properties.pk,
-        properties.partitionKeyVersion,
-        properties.cd,
-        properties.st,
-        properties.sid,
-        properties.rg,
-        properties.dba,
-        properties.uniqueKeyPolicy,
-        additionalOptions
-      );
-      expect(createSqlCollectionWithARMSpy).toHaveBeenCalled();
-      expect(createSqlDatabaseSpy).toHaveBeenCalled();
-    });
-  });
-});
-
-describe("Add Collection Utitlity", () => {
-  describe("createGremlinGraph", () => {
-    it("should invoke createGremlinGraphWithARM if create database is false", () => {
-      const properties = {
-        cd: false,
-        coll: "abc-collection",
-        db: "a1-db",
-        dba: "main",
-        offerThroughput: 50000,
-        pk: "state",
-        sid: "a1",
-        rg: "b1",
-        st: true,
-        indexingPolicy: SharedConstants.IndexingPolicies.AllPropertiesIndexed,
-        partitionKeyVersion: 2
-      };
-      const additionalOptions = {};
-      const createGremlinGraphWithARMSpy = jest.spyOn(CreateCollectionUtilities, "createGremlinGraphWithARM");
-      CreateCollectionUtilities.createGremlinGraph(
-        armEndpoint,
-        properties.db,
-        properties.coll,
-        properties.indexingPolicy,
-        properties.offerThroughput,
-        properties.pk,
-        properties.partitionKeyVersion,
-        properties.cd,
-        properties.st,
-        properties.sid,
-        properties.rg,
-        properties.dba,
-        additionalOptions
-      );
-      expect(createGremlinGraphWithARMSpy).toHaveBeenCalled();
-    });
-
-    it("should invoke createGremlinDatabase + createGremlinGraphWithARM if create database is true", () => {
-      const properties = {
-        cd: true,
-        coll: "abc-collection",
-        db: "a1-db",
-        dba: "main",
-        offerThroughput: 50000,
-        pk: "state",
-        sid: "a1",
-        rg: "b1",
-        st: true,
-        indexingPolicy: SharedConstants.IndexingPolicies.AllPropertiesIndexed,
-        partitionKeyVersion: 2
-      };
-      const additionalOptions = {};
-      const createGremlinGraphWithARMSpy = jest.spyOn(CreateCollectionUtilities, "createGremlinGraphWithARM");
-      const createGremlinDatabaseSpy = jest.spyOn(AddDbUtilities, "createGremlinDatabase");
-      CreateCollectionUtilities.createGremlinGraph(
-        armEndpoint,
-        properties.db,
-        properties.coll,
-        properties.indexingPolicy,
-        properties.offerThroughput,
-        properties.pk,
-        properties.partitionKeyVersion,
-        properties.cd,
-        properties.st,
-        properties.sid,
-        properties.rg,
-        properties.dba,
-        additionalOptions
-      );
-      expect(createGremlinDatabaseSpy).toHaveBeenCalled();
-      expect(createGremlinGraphWithARMSpy).toHaveBeenCalled();
+    it("exceeds collection threshold", () => {
+      mockDatabase.collections = ko.observableArray([
+        mockCollection1,
+        mockCollection2,
+        mockCollection3,
+        mockCollection4
+      ]);
+      expect(getMaxThroughput(defaults, mockContainer)).toEqual(defaults.throughput.unlimited.greatThanThreshold);
     });
   });
 });

src/Shared/AddCollectionUtility.ts

@@ -1,303 +1,23 @@
-import * as _ from "underscore";
-import * as DataExplorerConstants from "../Common/Constants";
-import * as DataModels from "../Contracts/DataModels";
-import * as SharedConstants from "./Constants";
-import * as ViewModels from "../Contracts/ViewModels";
-import { AddDbUtilities } from "../Shared/AddDatabaseUtility";
-import { ConsoleDataType } from "../Explorer/Menus/NotificationConsole/NotificationConsoleComponent";
-import { HttpStatusCodes } from "../Common/Constants";
-import { sendMessage } from "../Common/MessageHandler";
-import { MessageTypes } from "../Contracts/ExplorerContracts";
-import * as NotificationConsoleUtils from "../Utils/NotificationConsoleUtils";
-import { ResourceProviderClient } from "../ResourceProvider/ResourceProviderClient";
+import { any } from "underscore";
+import { CollectionCreationDefaults } from "../Contracts/ViewModels";
 import Explorer from "../Explorer/Explorer";
-import { userContext } from "../UserContext";
 
-export class CreateSqlCollectionUtilities {
-  public static createSqlCollection(
-    armEndpoint: string,
-    databaseId: string,
-    analyticalStorageTtl: number,
-    collectionId: string,
-    indexingPolicy: DataModels.IndexingPolicy,
-    offerThroughput: number,
-    partitionKey: string,
-    partitionKeyVersion: number,
-    createDatabase: boolean,
-    useDatabaseSharedOffer: boolean,
-    sid: string,
-    rg: string,
-    dba: string,
-    uniqueKeyPolicy: DataModels.UniqueKeyPolicy,
-    additionalOptions: DataModels.RpOptions
-  ): Promise<DataModels.CreateCollectionWithRpResponse> {
-    const params: DataModels.SqlCollectionParameters = {
-      uniqueKeyPolicy,
-      db: databaseId,
-      coll: collectionId,
-      pk: partitionKey,
-      offerThroughput,
-      cd: createDatabase,
-      st: useDatabaseSharedOffer,
-      sid,
-      rg,
-      dba,
-      analyticalStorageTtl,
-      indexingPolicy,
-      partitionKeyVersion
-    };
-
-    if (params.cd) {
-      return AddDbUtilities.createSqlDatabase(armEndpoint, params, additionalOptions).then(() => {
-        return CreateSqlCollectionUtilities.createSqlCollectionWithARM(armEndpoint, params, additionalOptions);
-      });
-    }
-    return CreateSqlCollectionUtilities.createSqlCollectionWithARM(armEndpoint, params, additionalOptions);
+export const getMaxThroughput = (defaults: CollectionCreationDefaults, container: Explorer): number => {
+  const throughput = defaults.throughput.unlimited;
+  if (typeof throughput === "number") {
+    return throughput;
+  } else {
+    return _exceedsThreshold(throughput.collectionThreshold, container)
+      ? throughput.greatThanThreshold
+      : throughput.lessThanOrEqualToThreshold;
   }
+};
 
-  public static async createSqlCollectionWithARM(
-    armEndpoint: string,
-    params: DataModels.SqlCollectionParameters,
-    rpOptions: DataModels.RpOptions
-  ): Promise<DataModels.CreateCollectionWithRpResponse> {
-    const rpPayloadToCreateCollection: DataModels.SqlCollectionCreationRequest = {
-      properties: {
-        resource: {
-          id: params.coll,
-          partitionKey: {
-            paths: [params.pk],
-            kind: "Hash",
-            version: params.partitionKeyVersion
-          }
-        },
-        options: {}
-      }
-    };
-
-    if (params.analyticalStorageTtl) {
-      rpPayloadToCreateCollection.properties.resource.analyticalStorageTtl = params.analyticalStorageTtl;
-    }
-
-    if (params.indexingPolicy) {
-      rpPayloadToCreateCollection.properties.resource.indexingPolicy = params.indexingPolicy;
-    }
-
-    if (!params.st) {
-      if (rpOptions) {
-        rpPayloadToCreateCollection.properties.options = rpOptions;
-      } else {
-        rpPayloadToCreateCollection.properties.options["throughput"] =
-          params.offerThroughput && params.offerThroughput.toString();
-      }
-    }
-
-    if (params.uniqueKeyPolicy) {
-      rpPayloadToCreateCollection.properties.resource.uniqueKeyPolicy = params.uniqueKeyPolicy;
-    }
-
-    try {
-      let response = await new ResourceProviderClient<DataModels.CreateCollectionWithRpResponse>(armEndpoint).putAsync(
-        CreateSqlCollectionUtilities.getSqlCollectionUri(params),
-        DataExplorerConstants.ArmApiVersions.publicVersion,
-        rpPayloadToCreateCollection
-      );
-      return response;
-    } catch (response) {
-      NotificationConsoleUtils.logConsoleMessage(
-        ConsoleDataType.Error,
-        `Error creating collection: ${JSON.stringify(response)}`
-      );
-      if (response.status === HttpStatusCodes.Forbidden) {
-        sendMessage({ type: MessageTypes.ForbiddenError });
-      }
-      throw new Error(`Error creating collection`);
-    }
-  }
-
-  public static getSqlCollectionUri(params: DataModels.SqlCollectionParameters): string {
-    return `subscriptions/${params.sid}/resourceGroups/${params.rg}/providers/Microsoft.DocumentDB/databaseAccounts/${params.dba}/sqlDatabases/${params.db}/containers/${params.coll}`;
-  }
-}
-
-export class CreateCollectionUtilities {
-  public static createGremlinGraph(
-    armEndpoint: string,
-    databaseId: string,
-    collectionId: string,
-    indexingPolicy: DataModels.IndexingPolicy,
-    offerThroughput: number,
-    partitionKey: string,
-    partitionKeyVersion: number,
-    createDatabase: boolean,
-    useDatabaseSharedOffer: boolean,
-    sid: string,
-    rg: string,
-    dba: string,
-    additionalOptions: DataModels.RpOptions
-  ): Promise<DataModels.CreateCollectionWithRpResponse> {
-    const params: DataModels.GraphParameters = {
-      db: databaseId,
-      coll: collectionId,
-      pk: partitionKey,
-      offerThroughput,
-      cd: createDatabase,
-      st: useDatabaseSharedOffer,
-      sid,
-      rg,
-      dba,
-      indexingPolicy,
-      partitionKeyVersion
-    };
-
-    if (params.cd) {
-      return AddDbUtilities.createGremlinDatabase(armEndpoint, params, additionalOptions).then(() => {
-        return CreateCollectionUtilities.createGremlinGraphWithARM(armEndpoint, params, additionalOptions);
-      });
-    }
-    return CreateCollectionUtilities.createGremlinGraphWithARM(armEndpoint, params, additionalOptions);
-  }
-
-  public static async createGremlinGraphWithARM(
-    armEndpoint: string,
-    params: DataModels.GraphParameters,
-    rpOptions: DataModels.RpOptions
-  ): Promise<DataModels.CreateCollectionWithRpResponse> {
-    const rpPayloadToCreateCollection: DataModels.GraphCreationRequest = {
-      properties: {
-        resource: {
-          id: params.coll,
-          partitionKey: {
-            paths: [params.pk],
-            kind: "Hash",
-            version: params.partitionKeyVersion
-          }
-        },
-        options: {}
-      }
-    };
-
-    if (params.indexingPolicy) {
-      rpPayloadToCreateCollection.properties.resource.indexingPolicy = params.indexingPolicy;
-    }
-
-    if (!params.st) {
-      if (rpOptions) {
-        rpPayloadToCreateCollection.properties.options = rpOptions;
-      } else {
-        rpPayloadToCreateCollection.properties.options["throughput"] =
-          params.offerThroughput && params.offerThroughput.toString();
-      }
-    }
-
-    try {
-      let response = await new ResourceProviderClient<DataModels.CreateCollectionWithRpResponse>(armEndpoint).putAsync(
-        CreateCollectionUtilities.getGremlinGraphUri(params),
-        DataExplorerConstants.ArmApiVersions.publicVersion,
-        rpPayloadToCreateCollection
-      );
-      return response;
-    } catch (response) {
-      NotificationConsoleUtils.logConsoleMessage(
-        ConsoleDataType.Error,
-        `Error creating graph: ${JSON.stringify(response)}`
-      );
-      if (response.status === HttpStatusCodes.Forbidden) {
-        sendMessage({ type: MessageTypes.ForbiddenError });
-      }
-      throw new Error(`Error creating graph`);
-    }
-  }
-
-  public static getGremlinGraphUri(params: DataModels.GraphParameters): string {
-    return `subscriptions/${params.sid}/resourceGroups/${params.rg}/providers/Microsoft.DocumentDB/databaseAccounts/${params.dba}/gremlinDatabases/${params.db}/graphs/${params.coll}`;
-  }
-}
-export class Utilities {
-  public static async createAzureTableWithARM(
-    armEndpoint: string,
-    params: DataModels.CreateDatabaseAndCollectionRequest,
-    rpOptions: DataModels.RpOptions
-  ): Promise<any> {
-    const rpPayloadToCreateDatabase: DataModels.CreationRequest = {
-      properties: {
-        resource: {
-          id: params.collectionId
-        },
-        options: {}
-      }
-    };
-
-    if (!params.databaseLevelThroughput) {
-      if (rpOptions) {
-        rpPayloadToCreateDatabase.properties.options = rpOptions;
-      } else {
-        rpPayloadToCreateDatabase.properties.options["throughput"] =
-          params.offerThroughput && params.offerThroughput.toString();
-      }
-    }
-
-    try {
-      await new ResourceProviderClient(armEndpoint).putAsync(
-        Utilities._getAzureTableUri(params),
-        DataExplorerConstants.ArmApiVersions.publicVersion,
-        rpPayloadToCreateDatabase
-      );
-    } catch (reason) {
-      NotificationConsoleUtils.logConsoleMessage(
-        ConsoleDataType.Error,
-        `Error creating table: ${JSON.stringify(reason)}, Payload: ${params}`
-      );
-      if (reason.status === HttpStatusCodes.Forbidden) {
-        sendMessage({ type: MessageTypes.ForbiddenError });
-        return;
-      }
-      throw new Error(`Error creating table`);
-    }
-  }
-
-  public static getMaxRUForStorageOption(
-    defaults: ViewModels.CollectionCreationDefaults,
-    storageOption: string
-  ): number {
-    if (storageOption === SharedConstants.CollectionCreation.storage10Gb) {
-      return SharedConstants.CollectionCreation.DefaultCollectionRUs10K;
-    }
-
-    return defaults.throughput.unlimitedmax;
-  }
-
-  public static getMinRUForStorageOption(
-    defaults: ViewModels.CollectionCreationDefaults,
-    storageOption: string
-  ): number {
-    if (storageOption === SharedConstants.CollectionCreation.storage10Gb) {
-      return SharedConstants.CollectionCreation.DefaultCollectionRUs400;
-    }
-
-    return defaults.throughput.unlimitedmin;
-  }
-
-  public static getMaxThroughput(defaults: ViewModels.CollectionCreationDefaults, container: Explorer): number {
-    const throughput = defaults.throughput.unlimited;
-    if (typeof throughput === "number") {
-      return throughput;
-    } else {
-      return this._exceedsThreshold(throughput.collectionThreshold, container)
-        ? throughput.greatThanThreshold
-        : throughput.lessThanOrEqualToThreshold;
-    }
-  }
-
-  private static _exceedsThreshold(unlimitedThreshold: number, container: Explorer): boolean {
-    const databases = (container && container.databases && container.databases()) || [];
-    return _.any(
-      databases,
-      database =>
-        database && database.collections && database.collections() && database.collections().length > unlimitedThreshold
-    );
-  }
-
-  private static _getAzureTableUri(params: DataModels.CreateDatabaseAndCollectionRequest): string {
-    return `subscriptions/${userContext.subscriptionId}/resourceGroups/${userContext.resourceGroup}/providers/Microsoft.DocumentDB/databaseAccounts/${userContext.databaseAccount.name}/tables/${params.collectionId}`;
-  }
-}
+const _exceedsThreshold = (unlimitedThreshold: number, container: Explorer): boolean => {
+  const databases = (container && container.databases && container.databases()) || [];
+  return any(
+    databases,
+    database =>
+      database && database.collections && database.collections() && database.collections().length > unlimitedThreshold
+  );
+};

src/Shared/AddDatabaseUtility.test.ts

@@ -1,153 +0,0 @@
-import { AddDbUtilities } from "./AddDatabaseUtility";
-import { ResourceProviderClient } from "../ResourceProvider/ResourceProviderClient";
-jest.mock("../ResourceProvider/ResourceProviderClient.ts");
-
-describe("Add Database Utitlity", () => {
-  const armEndpoint = "https://management.azure.com";
-  const properties = {
-    pk: "state",
-    coll: "abc-collection",
-    cd: true,
-    db: "a1-db",
-    offerThroughput: 50000,
-    st: true,
-    sid: "a1",
-    rg: "b1",
-    dba: "main"
-  };
-
-  describe("getRpClient", () => {
-    it("should return an instance of ResourceProviderClient", () => {
-      expect(AddDbUtilities.getRpClient()).not.toBeFalsy();
-      expect(AddDbUtilities.getRpClient()).toBeInstanceOf(ResourceProviderClient);
-    });
-  });
-
-  describe("getGremlinDatabaseUri", () => {
-    it("should return a uri in the correct format", () => {
-      expect(AddDbUtilities.getGremlinDatabaseUri(properties)).toEqual(
-        "subscriptions/a1/resourceGroups/b1/providers/Microsoft.DocumentDB/databaseAccounts/main/gremlinDatabases/a1-db"
-      );
-    });
-  });
-
-  describe("createGremlinDatabase", () => {
-    it("should utilize resource provider client", () => {
-      const resourceProviderClientSpy = spyOn<any>(AddDbUtilities, "getRpClient");
-      AddDbUtilities.createGremlinDatabase(armEndpoint, properties, undefined);
-      expect(resourceProviderClientSpy).toHaveBeenCalled();
-    });
-
-    it("should invoke getGremlinDatabaseUri", () => {
-      const getGremlinDatabaseUriSpy = spyOn<any>(AddDbUtilities, "getGremlinDatabaseUri");
-      AddDbUtilities.createGremlinDatabase(armEndpoint, properties, undefined);
-      expect(getGremlinDatabaseUriSpy).toHaveBeenCalled();
-    });
-
-    it("should invoke a put call via resource provider client to create a database and set throughput if shared throughtput is true", () => {
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      AddDbUtilities.createGremlinDatabase(armEndpoint, properties, undefined);
-      expect(
-        resourceProviderClientPutAsyncSpy
-      ).toHaveBeenCalledWith(
-        "subscriptions/a1/resourceGroups/b1/providers/Microsoft.DocumentDB/databaseAccounts/main/gremlinDatabases/a1-db",
-        "2020-04-01",
-        { properties: { options: { throughput: "50000" }, resource: { id: "a1-db" } } }
-      );
-    });
-
-    it("should invoke a put call via resource provider client to create a database and set autopilot if shared throughtput is true and autopilot settings are passed", () => {
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      AddDbUtilities.createGremlinDatabase(armEndpoint, properties, { "x-ms-cosmos-offer-autopilot-tier": "1" });
-      expect(
-        resourceProviderClientPutAsyncSpy
-      ).toHaveBeenCalledWith(
-        "subscriptions/a1/resourceGroups/b1/providers/Microsoft.DocumentDB/databaseAccounts/main/gremlinDatabases/a1-db",
-        "2020-04-01",
-        { properties: { options: { "x-ms-cosmos-offer-autopilot-tier": "1" }, resource: { id: "a1-db" } } }
-      );
-    });
-
-    it("should invoke a put call via resource provider client to create a database and not set throughput if shared throughtput is false", () => {
-      const properties = {
-        pk: "state",
-        coll: "abc-collection",
-        cd: true,
-        db: "a2-db",
-        st: false,
-        sid: "a2",
-        rg: "c1",
-        dba: "main"
-      };
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      AddDbUtilities.createGremlinDatabase(armEndpoint, properties, undefined);
-      expect(
-        resourceProviderClientPutAsyncSpy
-      ).toHaveBeenCalledWith(
-        "subscriptions/a2/resourceGroups/c1/providers/Microsoft.DocumentDB/databaseAccounts/main/gremlinDatabases/a2-db",
-        "2020-04-01",
-        { properties: { options: {}, resource: { id: "a2-db" } } }
-      );
-    });
-  });
-
-  describe("createSqlDatabase", () => {
-    it("should utilize resource provider client", () => {
-      const resourceProviderClientSpy = spyOn<any>(AddDbUtilities, "getRpClient");
-      AddDbUtilities.createSqlDatabase(armEndpoint, properties, undefined);
-      expect(resourceProviderClientSpy).toHaveBeenCalled();
-    });
-
-    it("should invoke getSqlDatabaseUri", () => {
-      const getSqlDatabaseUriSpy = spyOn<any>(AddDbUtilities, "getSqlDatabaseUri");
-      AddDbUtilities.createSqlDatabase(armEndpoint, properties, undefined);
-      expect(getSqlDatabaseUriSpy).toHaveBeenCalled();
-    });
-
-    it("should invoke a put call via resource provider client to create a database and set throughput if shared throughtput is true", () => {
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      AddDbUtilities.createSqlDatabase(armEndpoint, properties, undefined);
-      expect(
-        resourceProviderClientPutAsyncSpy
-      ).toHaveBeenCalledWith(
-        "subscriptions/a1/resourceGroups/b1/providers/Microsoft.DocumentDB/databaseAccounts/main/sqlDatabases/a1-db",
-        "2020-04-01",
-        { properties: { options: { throughput: "50000" }, resource: { id: "a1-db" } } }
-      );
-    });
-
-    it("should invoke a put call via resource provider client to create a database and set autopilot if shared throughtput is true and autopilot settings are passed", () => {
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      AddDbUtilities.createSqlDatabase(armEndpoint, properties, { "x-ms-cosmos-offer-autopilot-tier": "1" });
-      expect(
-        resourceProviderClientPutAsyncSpy
-      ).toHaveBeenCalledWith(
-        "subscriptions/a1/resourceGroups/b1/providers/Microsoft.DocumentDB/databaseAccounts/main/sqlDatabases/a1-db",
-        "2020-04-01",
-        { properties: { options: { "x-ms-cosmos-offer-autopilot-tier": "1" }, resource: { id: "a1-db" } } }
-      );
-    });
-
-    it("should invoke a put call via resource provider client to create a database and not set throughput if shared throughtput is false", () => {
-      const properties = {
-        pk: "state",
-        coll: "abc-collection",
-        cd: true,
-        db: "a2-db",
-        st: false,
-        sid: "a2",
-        rg: "c1",
-        dba: "main"
-      };
-      const resourceProviderClientPutAsyncSpy = jest.spyOn(ResourceProviderClient.prototype, "putAsync");
-      AddDbUtilities.createSqlDatabase(armEndpoint, properties, undefined);
-      expect(
-        resourceProviderClientPutAsyncSpy
-      ).toHaveBeenCalledWith(
-        "subscriptions/a2/resourceGroups/c1/providers/Microsoft.DocumentDB/databaseAccounts/main/sqlDatabases/a2-db",
-        "2020-04-01",
-        { properties: { options: {}, resource: { id: "a2-db" } } }
-      );
-    });
-  });
-});

src/Shared/AddDatabaseUtility.ts

@@ -1,188 +0,0 @@
-import * as DataExplorerConstants from "../Common/Constants";
-import * as DataModels from "../Contracts/DataModels";
-import { configContext } from "../ConfigContext";
-import { ConsoleDataType } from "../Explorer/Menus/NotificationConsole/NotificationConsoleComponent";
-import { HttpStatusCodes } from "../Common/Constants";
-import { sendMessage } from "../Common/MessageHandler";
-import { MessageTypes } from "../Contracts/ExplorerContracts";
-import * as NotificationConsoleUtils from "../Utils/NotificationConsoleUtils";
-import { ResourceProviderClient } from "../ResourceProvider/ResourceProviderClient";
-import { userContext } from "../UserContext";
-
-export class AddDbUtilities {
-  // todo - remove any
-  public static async createMongoDatabaseWithARM(
-    armEndpoint: string,
-    params: DataModels.RpParameters,
-    rpOptions: DataModels.RpOptions
-  ): Promise<any> {
-    const rpPayloadToCreateDatabase: DataModels.MongoCreationRequest = {
-      properties: {
-        resource: {
-          id: params.db
-        },
-        options: {}
-      }
-    };
-
-    if (params.st) {
-      if (rpOptions) {
-        rpPayloadToCreateDatabase.properties.options = rpOptions;
-      } else {
-        rpPayloadToCreateDatabase.properties.options["throughput"] =
-          params.offerThroughput && params.offerThroughput.toString();
-      }
-    }
-
-    try {
-      await AddDbUtilities.getRpClient<DataModels.CreateDatabaseWithRpResponse>(armEndpoint).putAsync(
-        AddDbUtilities._getMongoDatabaseUri(params),
-        DataExplorerConstants.ArmApiVersions.publicVersion,
-        rpPayloadToCreateDatabase
-      );
-    } catch (reason) {
-      AddDbUtilities._handleCreationError(reason, params);
-    }
-  }
-
-  // todo - remove any
-  public static async createCassandraKeyspace(
-    armEndpoint: string,
-    params: DataModels.RpParameters,
-    rpOptions: DataModels.RpOptions
-  ): Promise<any> {
-    const rpPayloadToCreateKeyspace: DataModels.CreationRequest = {
-      properties: {
-        resource: {
-          id: params.db
-        },
-        options: {}
-      }
-    };
-
-    if (params.st) {
-      if (rpOptions) {
-        rpPayloadToCreateKeyspace.properties.options = rpOptions;
-      } else {
-        rpPayloadToCreateKeyspace.properties.options["throughput"] =
-          params.offerThroughput && params.offerThroughput.toString();
-      }
-    }
-
-    try {
-      await AddDbUtilities.getRpClient<DataModels.CreateDatabaseWithRpResponse>(armEndpoint).putAsync(
-        AddDbUtilities._getCassandraKeyspaceUri(params),
-        DataExplorerConstants.ArmApiVersions.publicVersion,
-        rpPayloadToCreateKeyspace
-      );
-    } catch (reason) {
-      AddDbUtilities._handleCreationError(reason, params, "keyspace");
-    }
-  }
-
-  public static async createSqlDatabase(
-    armEndpoint: string,
-    params: DataModels.RpParameters,
-    rpOptions: DataModels.RpOptions
-  ): Promise<any> {
-    const rpPayloadToCreateSqlDatabase: DataModels.CreationRequest = {
-      properties: {
-        resource: {
-          id: params.db
-        },
-        options: {}
-      }
-    };
-
-    if (params.st) {
-      if (rpOptions) {
-        rpPayloadToCreateSqlDatabase.properties.options = rpOptions;
-      } else {
-        rpPayloadToCreateSqlDatabase.properties.options["throughput"] =
-          params.offerThroughput && params.offerThroughput.toString();
-      }
-    }
-
-    try {
-      await AddDbUtilities.getRpClient<DataModels.CreateDatabaseWithRpResponse>(armEndpoint).putAsync(
-        AddDbUtilities.getSqlDatabaseUri(params),
-        DataExplorerConstants.ArmApiVersions.publicVersion,
-        rpPayloadToCreateSqlDatabase
-      );
-    } catch (reason) {
-      AddDbUtilities._handleCreationError(reason, params, "database");
-    }
-  }
-
-  public static getRpClient<T>(armEndpoint?: string): ResourceProviderClient<T> {
-    return new ResourceProviderClient<T>(armEndpoint || configContext.ARM_ENDPOINT);
-  }
-
-  public static async createGremlinDatabase(
-    armEndpoint: string,
-    params: DataModels.RpParameters,
-    autoPilotSettings: DataModels.RpOptions
-  ): Promise<DataModels.CreateDatabaseWithRpResponse> {
-    const rpPayloadToCreateDatabase: DataModels.CreationRequest = {
-      properties: {
-        resource: {
-          id: params.db
-        },
-        options: {}
-      }
-    };
-
-    const uri = AddDbUtilities.getGremlinDatabaseUri(params);
-
-    if (params.st) {
-      if (autoPilotSettings) {
-        rpPayloadToCreateDatabase.properties.options = autoPilotSettings;
-      } else {
-        rpPayloadToCreateDatabase.properties.options["throughput"] =
-          params.offerThroughput && params.offerThroughput.toString();
-      }
-    }
-
-    return new Promise<DataModels.CreateDatabaseWithRpResponse>((resolve, reject) => {
-      AddDbUtilities.getRpClient<DataModels.CreateDatabaseWithRpResponse>(armEndpoint)
-        .putAsync(uri, DataExplorerConstants.ArmApiVersions.publicVersion, rpPayloadToCreateDatabase)
-        .then(
-          () => {
-            resolve();
-          },
-          reason => {
-            AddDbUtilities._handleCreationError(reason, params);
-            reject();
-          }
-        );
-    });
-  }
-
-  private static _handleCreationError(reason: any, params: DataModels.RpParameters, dbType: string = "database") {
-    NotificationConsoleUtils.logConsoleMessage(
-      ConsoleDataType.Error,
-      `Error creating ${dbType}: ${JSON.stringify(reason)}, Payload: ${params}`
-    );
-    if (reason.status === HttpStatusCodes.Forbidden) {
-      sendMessage({ type: MessageTypes.ForbiddenError });
-      return;
-    }
-    throw new Error(`Error creating ${dbType}`);
-  }
-
-  private static _getMongoDatabaseUri(params: DataModels.RpParameters): string {
-    return `subscriptions/${params.sid}/resourceGroups/${params.rg}/providers/Microsoft.DocumentDB/databaseAccounts/${userContext.databaseAccount.name}/mongodbDatabases/${params.db}`;
-  }
-
-  private static _getCassandraKeyspaceUri(params: DataModels.RpParameters): string {
-    return `subscriptions/${params.sid}/resourceGroups/${params.rg}/providers/Microsoft.DocumentDB/databaseAccounts/${userContext.databaseAccount.name}/cassandraKeyspaces/${params.db}`;
-  }
-
-  public static getGremlinDatabaseUri(params: DataModels.RpParameters): string {
-    return `subscriptions/${params.sid}/resourceGroups/${params.rg}/providers/Microsoft.DocumentDB/databaseAccounts/${params.dba}/gremlinDatabases/${params.db}`;
-  }
-
-  public static getSqlDatabaseUri(params: DataModels.RpParameters): string {
-    return `subscriptions/${params.sid}/resourceGroups/${params.rg}/providers/Microsoft.DocumentDB/databaseAccounts/${params.dba}/sqlDatabases/${params.db}`;
-  }
-}

src/Shared/Telemetry/TelemetryConstants.ts

@@ -1,13 +1,3 @@
-/**
- * Defines constants related to logging telemetry. Everything except Action should be kept in sync with the one in the Portal code as much as possible.
- *
- * TODO: Move this to ExplorerContracts (265329)
- */
-export class General {
-  public static ExtensionName: string = "Microsoft_Azure_DocumentDB";
-  public static BladeNamePrefix: string = "Extension/Microsoft_Azure_DocumentDB/Blade/";
-}
-
 // Data Explorer specific actions. No need to keep this in sync with the one in Portal.
 export enum Action {
   CollapseTreeNode,
@@ -83,24 +73,19 @@ export enum Action {
   NotebooksGitHubDisconnect
 }
 
-export class ActionModifiers {
-  public static Start: string = "start";
-  public static Success: string = "success";
-  public static Failed: string = "failed";
-  public static Mark: string = "mark";
-  public static Open: string = "open";
-  public static IFrameReady: string = "iframeready";
-  public static Close: string = "close";
-  public static Submit: string = "submit";
-  public static IndexAll: string = "index all properties";
-  public static NoIndex: string = "no indexing";
-  public static Cancel: string = "cancel";
-}
-
-export class CosmosDBEndpointNames {
-  public static Gateway: string = "CosmosDBGateway";
-  public static ResourceProvider: string = "DocumentDBResourceProvider";
-}
+export const ActionModifiers = {
+  Start: "start",
+  Success: "success",
+  Failed: "failed",
+  Mark: "mark",
+  Open: "open",
+  IFrameReady: "iframeready",
+  Close: "close",
+  Submit: "submit",
+  IndexAll: "index all properties",
+  NoIndex: "no indexing",
+  Cancel: "cancel"
+} as const;
 
 export enum SourceBlade {
   AddCollection,
@@ -126,17 +111,3 @@ export enum SourceBlade {
   ScriptExplorer,
   Keys
 }
-
-export class BladeLoadRequirements {
-  public static collections: string = "Collections";
-  public static collectionsWithOffers: string = "CollectionsWithOffers";
-  public static databaseAccount: string = "DatabaseAccount";
-  public static keys: string = "Keys";
-  public static metrics: string = "Metrics";
-  public static notifications: string = "Notifications";
-  public static singleCollection: string = "SingleCollection";
-
-  public static keysBlade: string[] = [BladeLoadRequirements.databaseAccount, BladeLoadRequirements.keys];
-  public static metricsBlade: string[] = [BladeLoadRequirements.databaseAccount];
-  public static overview: string[] = [BladeLoadRequirements.databaseAccount, BladeLoadRequirements.notifications];
-}

src/Shared/Telemetry/TelemetryProcessor.ts

@@ -8,119 +8,124 @@ import { userContext } from "../../UserContext";
 /**
  * Class that persists telemetry data to the portal tables.
  */
-// TODO: Move to a separate Diagnostics folder
-// TODO: Log telemetry for StorageExplorer case/other clients as well
-export default class TelemetryProcessor {
-  public static trace(action: Action, actionModifier: string = ActionModifiers.Mark, data?: any): void {
-    sendMessage({
-      type: MessageTypes.TelemetryInfo,
-      data: {
-        action: Action[action],
-        actionModifier: actionModifier,
-        data: JSON.stringify(data)
-      }
-    });
 
-    appInsights.trackEvent({ name: Action[action] }, TelemetryProcessor.getData(data));
+export function trace(action: Action, actionModifier: string = ActionModifiers.Mark, data?: unknown): void {
+  sendMessage({
+    type: MessageTypes.TelemetryInfo,
+    data: {
+      action: Action[action],
+      actionModifier: actionModifier,
+      data: JSON.stringify(data)
+    }
+  });
+
+  appInsights.trackEvent({ name: Action[action] }, getData(data));
+}
+
+export function traceStart(action: Action, data?: unknown): number {
+  const timestamp: number = Date.now();
+  sendMessage({
+    type: MessageTypes.TelemetryInfo,
+    data: {
+      action: Action[action],
+      actionModifier: ActionModifiers.Start,
+      timestamp: timestamp,
+      data: JSON.stringify(data)
+    }
+  });
+
+  appInsights.startTrackEvent(Action[action]);
+  return timestamp;
+}
+
+export function traceSuccess(action: Action, data?: unknown, timestamp?: number): void {
+  sendMessage({
+    type: MessageTypes.TelemetryInfo,
+    data: {
+      action: Action[action],
+      actionModifier: ActionModifiers.Success,
+      timestamp: timestamp || Date.now(),
+      data: JSON.stringify(data)
+    }
+  });
+
+  appInsights.stopTrackEvent(Action[action], getData(data));
+}
+
+export function traceFailure(action: Action, data?: unknown, timestamp?: number): void {
+  sendMessage({
+    type: MessageTypes.TelemetryInfo,
+    data: {
+      action: Action[action],
+      actionModifier: ActionModifiers.Failed,
+      timestamp: timestamp || Date.now(),
+      data: JSON.stringify(data)
+    }
+  });
+
+  appInsights.stopTrackEvent(Action[action], getData(data));
+}
+
+export function traceCancel(action: Action, data?: unknown, timestamp?: number): void {
+  sendMessage({
+    type: MessageTypes.TelemetryInfo,
+    data: {
+      action: Action[action],
+      actionModifier: ActionModifiers.Cancel,
+      timestamp: timestamp || Date.now(),
+      data: JSON.stringify(data)
+    }
+  });
+
+  appInsights.stopTrackEvent(Action[action], getData(data));
+}
+
+export function traceOpen(action: Action, data?: unknown, timestamp?: number): number {
+  const validTimestamp = timestamp || Date.now();
+  sendMessage({
+    type: MessageTypes.TelemetryInfo,
+    data: {
+      action: Action[action],
+      actionModifier: ActionModifiers.Open,
+      timestamp: validTimestamp,
+      data: JSON.stringify(data)
+    }
+  });
+
+  appInsights.startTrackEvent(Action[action]);
+  return validTimestamp;
+}
+
+export function traceMark(action: Action, data?: unknown, timestamp?: number): number {
+  const validTimestamp = timestamp || Date.now();
+  sendMessage({
+    type: MessageTypes.TelemetryInfo,
+    data: {
+      action: Action[action],
+      actionModifier: ActionModifiers.Mark,
+      timestamp: validTimestamp,
+      data: JSON.stringify(data)
+    }
+  });
+
+  appInsights.startTrackEvent(Action[action]);
+  return validTimestamp;
+}
+
+function getData(data: unknown = {}): { [key: string]: string } | undefined {
+  if (typeof data === "string") {
+    data = { message: data };
   }
-
-  public static traceStart(action: Action, data?: any): number {
-    const timestamp: number = Date.now();
-    sendMessage({
-      type: MessageTypes.TelemetryInfo,
-      data: {
-        action: Action[action],
-        actionModifier: ActionModifiers.Start,
-        timestamp: timestamp,
-        data: JSON.stringify(data)
-      }
-    });
-
-    appInsights.startTrackEvent(Action[action]);
-    return timestamp;
-  }
-
-  public static traceSuccess(action: Action, data?: any, timestamp?: number): void {
-    sendMessage({
-      type: MessageTypes.TelemetryInfo,
-      data: {
-        action: Action[action],
-        actionModifier: ActionModifiers.Success,
-        timestamp: timestamp || Date.now(),
-        data: JSON.stringify(data)
-      }
-    });
-
-    appInsights.stopTrackEvent(Action[action], TelemetryProcessor.getData(data));
-  }
-
-  public static traceFailure(action: Action, data?: any, timestamp?: number): void {
-    sendMessage({
-      type: MessageTypes.TelemetryInfo,
-      data: {
-        action: Action[action],
-        actionModifier: ActionModifiers.Failed,
-        timestamp: timestamp || Date.now(),
-        data: JSON.stringify(data)
-      }
-    });
-
-    appInsights.stopTrackEvent(Action[action], TelemetryProcessor.getData(data));
-  }
-
-  public static traceCancel(action: Action, data?: any, timestamp?: number): void {
-    sendMessage({
-      type: MessageTypes.TelemetryInfo,
-      data: {
-        action: Action[action],
-        actionModifier: ActionModifiers.Cancel,
-        timestamp: timestamp || Date.now(),
-        data: JSON.stringify(data)
-      }
-    });
-
-    appInsights.stopTrackEvent(Action[action], TelemetryProcessor.getData(data));
-  }
-
-  public static traceOpen(action: Action, data?: any, timestamp?: number): number {
-    const validTimestamp = timestamp || Date.now();
-    sendMessage({
-      type: MessageTypes.TelemetryInfo,
-      data: {
-        action: Action[action],
-        actionModifier: ActionModifiers.Open,
-        timestamp: validTimestamp,
-        data: JSON.stringify(data)
-      }
-    });
-
-    appInsights.startTrackEvent(Action[action]);
-    return validTimestamp;
-  }
-
-  public static traceMark(action: Action, data?: any, timestamp?: number): number {
-    const validTimestamp = timestamp || Date.now();
-    sendMessage({
-      type: MessageTypes.TelemetryInfo,
-      data: {
-        action: Action[action],
-        actionModifier: ActionModifiers.Mark,
-        timestamp: validTimestamp,
-        data: JSON.stringify(data)
-      }
-    });
-
-    appInsights.startTrackEvent(Action[action]);
-    return validTimestamp;
-  }
-
-  private static getData(data?: any): any {
+  if (typeof data === "object") {
     return {
       // TODO: Need to `any` here since the window imports Explorer which can't be in strict mode yet
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       authType: (window as any).authType,
-      subscriptionId: userContext.subscriptionId,
+      subscriptionId: userContext.subscriptionId as string,
       platform: configContext.platform,
-      ...(data ? data : [])
+      env: process.env.NODE_ENV as string,
+      ...data
     };
   }
+  return undefined;
 }

src/Shared/appInsights.ts

@@ -1,7 +1,9 @@
 import { ApplicationInsights } from "@microsoft/applicationinsights-web";
+
 const appInsights = new ApplicationInsights({
   config: {
-    instrumentationKey: "fa645d97-6237-4656-9559-0ee0cb55ee49"
+    instrumentationKey: "fa645d97-6237-4656-9559-0ee0cb55ee49",
+    disableFetchTracking: false
   }
 });
 appInsights.loadAppInsights();

src/UserContext.ts

@@ -11,6 +11,7 @@ interface UserContext {
   authorizationToken?: string;
   resourceToken?: string;
   defaultExperience?: DefaultAccountExperienceType;
+  useSDKOperations?: boolean;
 }
 
 const userContext: Readonly<UserContext> = {} as const;

src/Utils/NotificationConsoleUtils.ts

@@ -3,7 +3,10 @@ import { ConsoleDataType } from "../Explorer/Menus/NotificationConsole/Notificat
 
 const _global = typeof self === "undefined" ? window : self;
 
-// DEPRECATED: Use logConsoleInfo, logConsoleError, logConsoleProgress instead
+/**
+ * @deprecated
+ * Use logConsoleInfo, logConsoleError, logConsoleProgress instead
+ * */
 export function logConsoleMessage(type: ConsoleDataType, message: string, id?: string): string {
   const dataExplorer = _global.dataExplorer;
   if (dataExplorer) {

src/Utils/PricingUtils.ts

@@ -193,7 +193,7 @@ export function getAutoPilotV3SpendHtml(maxAutoPilotThroughputSet: number, isDat
     maxAutoPilotThroughputSet
   )} GB of data stored, the max RU/s will be automatically upgraded based on the new storage value. <a href='${
     Constants.AutopilotDocumentation.Url
-  }' target='_blank'>Learn more</a>.`;
+  }' target='_blank' aria-label='Learn more about autoscale throughput'>Learn more</a>.`;
 }
 
 export function computeAutoscaleUsagePriceHourly(

src/Utils/arm/generatedClients/2020-04-01-cosmos-db/cassandraResources.ts

@@ -39,7 +39,7 @@ export async function createUpdateCassandraKeyspace(
   body: Types.CassandraKeyspaceCreateUpdateParameters
 ): Promise<Types.CassandraKeyspaceGetResults | void> {
   const path = `/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}`;
-  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body: JSON.stringify(body) });
+  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body });
 }
 
 /* Deletes an existing Azure Cosmos DB Cassandra keyspace. */
@@ -73,7 +73,7 @@ export async function updateCassandraKeyspaceThroughput(
   body: Types.ThroughputSettingsUpdateParameters
 ): Promise<Types.ThroughputSettingsGetResults | void> {
   const path = `/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/throughputSettings/default`;
-  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body: JSON.stringify(body) });
+  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body });
 }
 
 /* Migrate an Azure Cosmos DB Cassandra Keyspace from manual throughput to autoscale */
@@ -131,7 +131,7 @@ export async function createUpdateCassandraTable(
   body: Types.CassandraTableCreateUpdateParameters
 ): Promise<Types.CassandraTableGetResults | void> {
   const path = `/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables/${tableName}`;
-  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body: JSON.stringify(body) });
+  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body });
 }
 
 /* Deletes an existing Azure Cosmos DB Cassandra table. */
@@ -168,7 +168,7 @@ export async function updateCassandraTableThroughput(
   body: Types.ThroughputSettingsUpdateParameters
 ): Promise<Types.ThroughputSettingsGetResults | void> {
   const path = `/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables/${tableName}/throughputSettings/default`;
-  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body: JSON.stringify(body) });
+  return armRequest({ host: configContext.ARM_ENDPOINT, path, method: "PUT", apiVersion, body });
 }
 
 /* Migrate an Azure Cosmos DB Cassandra table from manual throughput to autoscale */