Add .github/fabricbot.json

.github/fabricbot.json

@@ -0,0 +1,30 @@
+{
+  "version": "1.0",
+  "tasks": [
+    {
+      "taskType": "trigger",
+      "capabilityId": "AutoMerge",
+      "subCapability": "AutoMerge",
+      "version": "1.0",
+      "id": "LUEPwPETV",
+      "config": {
+        "taskName": "Auto Merge",
+        "label": "automerge",
+        "minMinutesOpen": "5",
+        "mergeType": "squash",
+        "deleteBranches": true,
+        "requireAllStatuses": true,
+        "requireSpecificCheckRuns": false,
+        "usePrDescriptionAsCommitMessage": true,
+        "requireAllStatuses_exemptList": [
+          "Azure Pipelines",
+          "Dependabot",
+          "GitHub Pages",
+          "Check Enforcer"
+        ],
+        "silentMode": true
+      }
+    }
+  ],
+  "userGroups": []
+}

package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "dependencies": {
         "@azure/arm-cosmosdb": "9.1.0",
-        "@azure/cosmos": "3.16.2",
+        "@azure/cosmos": "3.16.1",
         "@azure/cosmos-language-service": "0.0.5",
         "@azure/identity": "1.2.1",
         "@azure/ms-rest-nodeauth": "3.0.7",
@@ -396,9 +396,9 @@
       "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ=="
     },
     "node_modules/@azure/cosmos": {
-      "version": "3.16.2",
-      "resolved": "https://registry.npmjs.org/@azure/cosmos/-/cosmos-3.16.2.tgz",
-      "integrity": "sha512-sceY5LWj0BHGj8PSyaVCfDRQLVZyoCfIY78kyIROJVEw0k+p9XFs8fhpykN8JklkCftL0WlaVY+X25SQwnhZsw==",
+      "version": "3.16.1",
+      "resolved": "https://registry.npmjs.org/@azure/cosmos/-/cosmos-3.16.1.tgz",
+      "integrity": "sha512-9J76EMiF+ypZwO/Z7OS4PjrU/3hdRLe18dQh/Hj+jwXG2gKJ1NwgkYqcwu1HiCiX73A8+NCeA3PRDbegEnuuNQ==",
       "dependencies": {
         "@azure/core-auth": "^1.3.0",
         "@azure/core-rest-pipeline": "^1.2.0",
@@ -31458,9 +31458,9 @@
       }
     },
     "@azure/cosmos": {
-      "version": "3.16.2",
-      "resolved": "https://registry.npmjs.org/@azure/cosmos/-/cosmos-3.16.2.tgz",
-      "integrity": "sha512-sceY5LWj0BHGj8PSyaVCfDRQLVZyoCfIY78kyIROJVEw0k+p9XFs8fhpykN8JklkCftL0WlaVY+X25SQwnhZsw==",
+      "version": "3.16.1",
+      "resolved": "https://registry.npmjs.org/@azure/cosmos/-/cosmos-3.16.1.tgz",
+      "integrity": "sha512-9J76EMiF+ypZwO/Z7OS4PjrU/3hdRLe18dQh/Hj+jwXG2gKJ1NwgkYqcwu1HiCiX73A8+NCeA3PRDbegEnuuNQ==",
       "requires": {
         "@azure/core-auth": "^1.3.0",
         "@azure/core-rest-pipeline": "^1.2.0",

package.json

@@ -5,7 +5,7 @@
   "main": "index.js",
   "dependencies": {
     "@azure/arm-cosmosdb": "9.1.0",
-    "@azure/cosmos": "3.16.2",
+    "@azure/cosmos": "3.16.1",
     "@azure/cosmos-language-service": "0.0.5",
     "@azure/identity": "1.2.1",
     "@azure/ms-rest-nodeauth": "3.0.7",

src/Common/dataAccess/createCollection.ts

@@ -24,7 +24,7 @@ export const createCollection = async (params: DataModels.CreateCollectionParams
   );
   try {
     let collection: DataModels.Collection;
-    if (userContext.authType === AuthType.AAD && !userContext.features.enableSDKoperations) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations) {
       if (params.createNewDatabase) {
         const createDatabaseParams: DataModels.CreateDatabaseParams = {
           autoPilotMaxThroughput: params.autoPilotMaxThroughput,

src/Common/dataAccess/createDatabase.ts

@@ -25,8 +25,7 @@ export async function createDatabase(params: DataModels.CreateDatabaseParams): P
     if (userContext.apiType === "Tables") {
       throw new Error("Creating database resources is not allowed for tables accounts");
     }
-    const database: DataModels.Database = await (userContext.authType === AuthType.AAD &&
-    !userContext.features.enableSDKoperations
+    const database: DataModels.Database = await (userContext.authType === AuthType.AAD && !userContext.useSDKOperations
       ? createDatabaseWithARM(params)
       : createDatabaseWithSDK(params));
 

src/Common/dataAccess/createStoredProcedure.ts

@@ -20,11 +20,7 @@ export async function createStoredProcedure(
 ): Promise<StoredProcedureDefinition & Resource> {
   const clearMessage = logConsoleProgress(`Creating stored procedure ${storedProcedure.id}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       try {
         const getResponse = await getSqlStoredProcedure(
           userContext.subscriptionId,

src/Common/dataAccess/createTrigger.ts

@@ -14,11 +14,7 @@ export async function createTrigger(
 ): Promise<TriggerDefinition | SqlTriggerResource> {
   const clearMessage = logConsoleProgress(`Creating trigger ${trigger.id}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       try {
         const getResponse = await getSqlTrigger(
           userContext.subscriptionId,

src/Common/dataAccess/createUserDefinedFunction.ts

@@ -20,11 +20,7 @@ export async function createUserDefinedFunction(
 ): Promise<UserDefinedFunctionDefinition & Resource> {
   const clearMessage = logConsoleProgress(`Creating user defined function ${userDefinedFunction.id}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       try {
         const getResponse = await getSqlUserDefinedFunction(
           userContext.subscriptionId,

src/Common/dataAccess/deleteCollection.ts

@@ -12,7 +12,7 @@ import { handleError } from "../ErrorHandlingUtils";
 export async function deleteCollection(databaseId: string, collectionId: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting container ${collectionId}`);
   try {
-    if (userContext.authType === AuthType.AAD && !userContext.features.enableSDKoperations) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations) {
       await deleteCollectionWithARM(databaseId, collectionId);
     } else {
       await client().database(databaseId).container(collectionId).delete();

src/Common/dataAccess/deleteDatabase.ts

@@ -12,7 +12,10 @@ export async function deleteDatabase(databaseId: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting database ${databaseId}`);
 
   try {
-    if (userContext.authType === AuthType.AAD && !userContext.features.enableSDKoperations) {
+    if (userContext.apiType === "Tables") {
+      throw new Error("Deleting database resources is not allowed for tables accounts");
+    }
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations) {
       await deleteDatabaseWithARM(databaseId);
     } else {
       await client().database(databaseId).delete();

src/Common/dataAccess/deleteStoredProcedure.ts

@@ -12,11 +12,7 @@ export async function deleteStoredProcedure(
 ): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting stored procedure ${storedProcedureId}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       await deleteSqlStoredProcedure(
         userContext.subscriptionId,
         userContext.resourceGroup,

src/Common/dataAccess/deleteTrigger.ts

@@ -8,11 +8,7 @@ import { handleError } from "../ErrorHandlingUtils";
 export async function deleteTrigger(databaseId: string, collectionId: string, triggerId: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting trigger ${triggerId}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       await deleteSqlTrigger(
         userContext.subscriptionId,
         userContext.resourceGroup,

src/Common/dataAccess/deleteUserDefinedFunction.ts

@@ -8,11 +8,7 @@ import { handleError } from "../ErrorHandlingUtils";
 export async function deleteUserDefinedFunction(databaseId: string, collectionId: string, id: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting user defined function ${id}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       await deleteSqlUserDefinedFunction(
         userContext.subscriptionId,
         userContext.resourceGroup,

src/Common/dataAccess/readCollectionOffer.ts

@@ -14,11 +14,7 @@ export const readCollectionOffer = async (params: ReadCollectionOfferParams): Pr
   const clearMessage = logConsoleProgress(`Querying offer for collection ${params.collectionId}`);
 
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType !== "Tables"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType !== "Tables") {
       return await readCollectionOfferWithARM(params.databaseId, params.collectionId);
     }
 

src/Common/dataAccess/readCollections.ts

@@ -13,11 +13,7 @@ import { handleError } from "../ErrorHandlingUtils";
 export async function readCollections(databaseId: string): Promise<DataModels.Collection[]> {
   const clearMessage = logConsoleProgress(`Querying containers for database ${databaseId}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType !== "Tables"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType !== "Tables") {
       return await readCollectionsWithARM(databaseId);
     }
 

src/Common/dataAccess/readDatabaseOffer.ts

@@ -13,11 +13,7 @@ export const readDatabaseOffer = async (params: ReadDatabaseOfferParams): Promis
   const clearMessage = logConsoleProgress(`Querying offer for database ${params.databaseId}`);
 
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType !== "Tables"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType !== "Tables") {
       return await readDatabaseOfferWithARM(params.databaseId);
     }
 

src/Common/dataAccess/readDatabases.ts

@@ -13,11 +13,7 @@ export async function readDatabases(): Promise<DataModels.Database[]> {
   let databases: DataModels.Database[];
   const clearMessage = logConsoleProgress(`Querying databases`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType !== "Tables"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType !== "Tables") {
       databases = await readDatabasesWithARM();
     } else {
       const sdkResponse = await client().databases.readAll().fetchAll();

src/Common/dataAccess/readStoredProcedures.ts

@@ -12,11 +12,7 @@ export async function readStoredProcedures(
 ): Promise<(StoredProcedureDefinition & Resource)[]> {
   const clearMessage = logConsoleProgress(`Querying stored procedures for container ${collectionId}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       const rpResponse = await listSqlStoredProcedures(
         userContext.subscriptionId,
         userContext.resourceGroup,

src/Common/dataAccess/readTriggers.ts

@@ -13,11 +13,7 @@ export async function readTriggers(
 ): Promise<SqlTriggerResource[] | TriggerDefinition[]> {
   const clearMessage = logConsoleProgress(`Querying triggers for container ${collectionId}`);
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType === "SQL"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType === "SQL") {
       const rpResponse = await listSqlTriggers(
         userContext.subscriptionId,
         userContext.resourceGroup,

src/Common/dataAccess/readUserDefinedFunctions.ts

@@ -11,9 +11,9 @@ export async function readUserDefinedFunctions(
   collectionId: string
 ): Promise<(UserDefinedFunctionDefinition & Resource)[]> {
   const clearMessage = logConsoleProgress(`Querying user defined functions for container ${collectionId}`);
-  const { authType, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
+  const { authType, useSDKOperations, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
   try {
-    if (authType === AuthType.AAD && !userContext.features.enableSDKoperations && apiType === "SQL") {
+    if (authType === AuthType.AAD && !useSDKOperations && apiType === "SQL") {
       const rpResponse = await listSqlUserDefinedFunctions(
         subscriptionId,
         resourceGroup,

src/Common/dataAccess/updateCollection.ts

@@ -33,11 +33,7 @@ export async function updateCollection(
   const clearMessage = logConsoleProgress(`Updating container ${collectionId}`);
 
   try {
-    if (
-      userContext.authType === AuthType.AAD &&
-      !userContext.features.enableSDKoperations &&
-      userContext.apiType !== "Tables"
-    ) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations && userContext.apiType !== "Tables") {
       collection = await updateCollectionWithARM(databaseId, collectionId, newCollection);
     } else {
       const sdkResponse = await client()

src/Common/dataAccess/updateOffer.ts

@@ -56,7 +56,7 @@ export const updateOffer = async (params: UpdateOfferParams): Promise<Offer> =>
   const clearMessage = logConsoleProgress(`Updating offer for ${offerResourceText}`);
 
   try {
-    if (userContext.authType === AuthType.AAD && !userContext.features.enableSDKoperations) {
+    if (userContext.authType === AuthType.AAD && !userContext.useSDKOperations) {
       if (params.collectionId) {
         updatedOffer = await updateCollectionOfferWithARM(params);
       } else if (userContext.apiType === "Tables") {

src/Common/dataAccess/updateStoredProcedure.ts

@@ -20,9 +20,9 @@ export async function updateStoredProcedure(
 ): Promise<StoredProcedureDefinition & Resource> {
   const clearMessage = logConsoleProgress(`Updating stored procedure ${storedProcedure.id}`);
   try {
-    const { authType, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
+    const { authType, useSDKOperations, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
 
-    if (authType === AuthType.AAD && !userContext.features.enableSDKoperations && apiType === "SQL") {
+    if (authType === AuthType.AAD && !useSDKOperations && apiType === "SQL") {
       const getResponse = await getSqlStoredProcedure(
         subscriptionId,
         resourceGroup,

src/Common/dataAccess/updateTrigger.ts

@@ -13,9 +13,9 @@ export async function updateTrigger(
   trigger: SqlTriggerResource
 ): Promise<SqlTriggerResource | TriggerDefinition> {
   const clearMessage = logConsoleProgress(`Updating trigger ${trigger.id}`);
-  const { authType, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
+  const { authType, useSDKOperations, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
   try {
-    if (authType === AuthType.AAD && !userContext.features.enableSDKoperations && apiType === "SQL") {
+    if (authType === AuthType.AAD && !useSDKOperations && apiType === "SQL") {
       const getResponse = await getSqlTrigger(
         subscriptionId,
         resourceGroup,

src/Common/dataAccess/updateUserDefinedFunction.ts

@@ -19,9 +19,9 @@ export async function updateUserDefinedFunction(
   userDefinedFunction: UserDefinedFunctionDefinition
 ): Promise<UserDefinedFunctionDefinition & Resource> {
   const clearMessage = logConsoleProgress(`Updating user defined function ${userDefinedFunction.id}`);
-  const { authType, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
+  const { authType, useSDKOperations, apiType, subscriptionId, resourceGroup, databaseAccount } = userContext;
   try {
-    if (authType === AuthType.AAD && !userContext.features.enableSDKoperations && apiType === "SQL") {
+    if (authType === AuthType.AAD && !useSDKOperations && apiType === "SQL") {
       const getResponse = await getSqlUserDefinedFunction(
         subscriptionId,
         resourceGroup,

src/Contracts/DataModels.ts

@@ -563,7 +563,6 @@ export interface ContainerConnectionInfo {
 }
 
 export enum PhoenixErrorType {
-  UserMissingPermissionsError = "UserMissingPermissionsError",
   MaxAllocationTimeExceeded = "MaxAllocationTimeExceeded",
   MaxDbAccountsPerUserExceeded = "MaxDbAccountsPerUserExceeded",
   MaxUsersPerDbAccountExceeded = "MaxUsersPerDbAccountExceeded",

src/Explorer/ContextMenuButtonFactory.tsx

@@ -44,7 +44,7 @@ export const createDatabaseContextMenu = (container: Explorer, databaseId: strin
     },
   ];
 
-  if (userContext.apiType !== "Tables" || userContext.features.enableSDKoperations) {
+  if (userContext.apiType !== "Tables") {
     items.push({
       iconSrc: DeleteDatabaseIcon,
       onClick: () =>

src/Explorer/SplashScreen/SplashScreen.tsx

@@ -3,25 +3,35 @@
  */
 import { Coachmark, DirectionalHint, Image, Link, Stack, TeachingBubbleContent, Text } from "@fluentui/react";
 import { useCarousel } from "hooks/useCarousel";
-import { ReactTabKind, useTabs } from "hooks/useTabs";
+import { useTabs } from "hooks/useTabs";
 import * as React from "react";
 import { Action } from "Shared/Telemetry/TelemetryConstants";
 import { traceOpen } from "Shared/Telemetry/TelemetryProcessor";
+import AddDatabaseIcon from "../../../images/AddDatabase.svg";
+import NewQueryIcon from "../../../images/AddSqlQuery_16x16.svg";
+import NewStoredProcedureIcon from "../../../images/AddStoredProcedure.svg";
+import OpenQueryIcon from "../../../images/BrowseQuery.svg";
 import ConnectIcon from "../../../images/Connect_color.svg";
 import ContainersIcon from "../../../images/Containers.svg";
 import LinkIcon from "../../../images/Link_blue.svg";
 import NotebookIcon from "../../../images/notebook/Notebook-resource.svg";
 import NotebookColorIcon from "../../../images/Notebooks.svg";
 import QuickStartIcon from "../../../images/Quickstart_Lightning.svg";
+import ScaleAndSettingsIcon from "../../../images/Scale_15x15.svg";
 import CollectionIcon from "../../../images/tree-collection.svg";
+import { AuthType } from "../../AuthType";
 import * as Constants from "../../Common/Constants";
+import * as ViewModels from "../../Contracts/ViewModels";
+import { useSidePanel } from "../../hooks/useSidePanel";
 import { userContext } from "../../UserContext";
-import { getCollectionName } from "../../Utils/APITypeUtils";
+import { getCollectionName, getDatabaseName } from "../../Utils/APITypeUtils";
 import { FeaturePanelLauncher } from "../Controls/FeaturePanel/FeaturePanelLauncher";
 import { DataSamplesUtil } from "../DataSamples/DataSamplesUtil";
 import Explorer from "../Explorer";
 import * as MostRecentActivity from "../MostRecentActivity/MostRecentActivity";
 import { useNotebook } from "../Notebook/useNotebook";
+import { AddDatabasePanel } from "../Panes/AddDatabasePanel/AddDatabasePanel";
+import { BrowseQueriesPane } from "../Panes/BrowseQueriesPane/BrowseQueriesPane";
 import { useDatabases } from "../useDatabases";
 import { useSelectedNode } from "../useSelectedNode";
 
@@ -224,13 +234,103 @@ export class SplashScreen extends React.Component<SplashScreenProps> {
       iconSrc: ConnectIcon,
       title: "Connect",
       description: "Prefer using your own choice of tooling? Find the connection string you need to connect",
-      onClick: () => useTabs.getState().openAndActivateReactTab(ReactTabKind.Connect),
+      onClick: () => useTabs.getState().openAndActivateConnectTab(),
     };
     heroes.push(connectBtn);
 
     return heroes;
   }
 
+  private createCommonTaskItems(): SplashScreenItem[] {
+    const items: SplashScreenItem[] = [];
+
+    if (userContext.authType === AuthType.ResourceToken) {
+      return items;
+    }
+
+    if (!useSelectedNode.getState().isDatabaseNodeOrNoneSelected()) {
+      if (userContext.apiType === "SQL" || userContext.apiType === "Gremlin") {
+        items.push({
+          iconSrc: NewQueryIcon,
+          onClick: () => {
+            const selectedCollection: ViewModels.Collection = useSelectedNode.getState().findSelectedCollection();
+            selectedCollection && selectedCollection.onNewQueryClick(selectedCollection, undefined);
+          },
+          title: "New SQL Query",
+          description: undefined,
+        });
+      } else if (userContext.apiType === "Mongo") {
+        items.push({
+          iconSrc: NewQueryIcon,
+          onClick: () => {
+            const selectedCollection: ViewModels.Collection = useSelectedNode.getState().findSelectedCollection();
+            selectedCollection && selectedCollection.onNewMongoQueryClick(selectedCollection, undefined);
+          },
+          title: "New Query",
+          description: undefined,
+        });
+      }
+
+      if (userContext.apiType === "SQL") {
+        items.push({
+          iconSrc: OpenQueryIcon,
+          title: "Open Query",
+          description: undefined,
+          onClick: () =>
+            useSidePanel
+              .getState()
+              .openSidePanel("Open Saved Queries", <BrowseQueriesPane explorer={this.container} />),
+        });
+      }
+
+      if (userContext.apiType !== "Cassandra") {
+        items.push({
+          iconSrc: NewStoredProcedureIcon,
+          title: "New Stored Procedure",
+          description: undefined,
+          onClick: () => {
+            const selectedCollection: ViewModels.Collection = useSelectedNode.getState().findSelectedCollection();
+            selectedCollection && selectedCollection.onNewStoredProcedureClick(selectedCollection, undefined);
+          },
+        });
+      }
+
+      /* Scale & Settings */
+      const isShared = useDatabases.getState().findSelectedDatabase()?.isDatabaseShared();
+
+      const label = isShared ? "Settings" : "Scale & Settings";
+      items.push({
+        iconSrc: ScaleAndSettingsIcon,
+        title: label,
+        description: undefined,
+        onClick: () => {
+          const selectedCollection: ViewModels.Collection = useSelectedNode.getState().findSelectedCollection();
+          selectedCollection && selectedCollection.onSettingsClick();
+        },
+      });
+    } else {
+      items.push({
+        iconSrc: AddDatabaseIcon,
+        title: "New " + getDatabaseName(),
+        description: undefined,
+        onClick: async () => {
+          const throughputCap = userContext.databaseAccount?.properties.capacity?.totalThroughputLimit;
+          if (throughputCap && throughputCap !== -1) {
+            await useDatabases.getState().loadAllOffers();
+          }
+          useSidePanel
+            .getState()
+            .openSidePanel(
+              "New " + getDatabaseName(),
+              <AddDatabasePanel explorer={this.container} buttonElement={document.activeElement as HTMLElement} />
+            );
+        },
+      });
+    }
+
+    return items;
+  }
+
   private decorateOpenCollectionActivity({ databaseId, collectionId }: MostRecentActivity.OpenCollectionItem) {
     return {
       iconSrc: CollectionIcon,
@@ -272,6 +372,29 @@ export class SplashScreen extends React.Component<SplashScreenProps> {
     });
   }
 
+  private createTipsItems(): SplashScreenItem[] {
+    return [
+      {
+        iconSrc: undefined,
+        title: "Data Modeling",
+        description: "Learn more about modeling",
+        onClick: () => window.open(SplashScreen.dataModelingUrl),
+      },
+      {
+        iconSrc: undefined,
+        title: "Cost & Throughput Calculation",
+        description: "Learn more about cost calculation",
+        onClick: () => window.open(SplashScreen.throughputEstimatorUrl),
+      },
+      {
+        iconSrc: undefined,
+        title: "Configure automatic failover",
+        description: "Learn more about Cosmos DB high-availability",
+        onClick: () => window.open(SplashScreen.failoverUrl),
+      },
+    ];
+  }
+
   private onSplashScreenItemKeyPress(event: React.KeyboardEvent, callback: () => void) {
     if (event.charCode === Constants.KeyCodes.Space || event.charCode === Constants.KeyCodes.Enter) {
       callback();

src/Explorer/Tabs/QueryTab/QueryTabComponent.tsx

@@ -600,43 +600,56 @@ export default class QueryTabComponent extends React.Component<IQueryTabComponen
     metricsMap.forEach((queryMetrics) => {
       if (queryMetrics) {
         aggregatedMetrics.documentLoadTime =
+          queryMetrics.documentLoadTime &&
           this._normalize(queryMetrics.documentLoadTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.documentLoadTime);
+            this._normalize(aggregatedMetrics.documentLoadTime);
         aggregatedMetrics.documentWriteTime =
+          queryMetrics.documentWriteTime &&
           this._normalize(queryMetrics.documentWriteTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.documentWriteTime);
+            this._normalize(aggregatedMetrics.documentWriteTime);
         aggregatedMetrics.indexHitDocumentCount =
+          queryMetrics.indexHitDocumentCount &&
           this._normalize(queryMetrics.indexHitDocumentCount) +
-          this._normalize(aggregatedMetrics.indexHitDocumentCount);
+            this._normalize(aggregatedMetrics.indexHitDocumentCount);
         aggregatedMetrics.outputDocumentCount =
+          queryMetrics.outputDocumentCount &&
           this._normalize(queryMetrics.outputDocumentCount) + this._normalize(aggregatedMetrics.outputDocumentCount);
         aggregatedMetrics.outputDocumentSize =
+          queryMetrics.outputDocumentSize &&
           this._normalize(queryMetrics.outputDocumentSize) + this._normalize(aggregatedMetrics.outputDocumentSize);
         aggregatedMetrics.indexLookupTime =
+          queryMetrics.indexLookupTime &&
           this._normalize(queryMetrics.indexLookupTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.indexLookupTime);
+            this._normalize(aggregatedMetrics.indexLookupTime);
         aggregatedMetrics.retrievedDocumentCount =
+          queryMetrics.retrievedDocumentCount &&
           this._normalize(queryMetrics.retrievedDocumentCount) +
-          this._normalize(aggregatedMetrics.retrievedDocumentCount);
+            this._normalize(aggregatedMetrics.retrievedDocumentCount);
         aggregatedMetrics.retrievedDocumentSize =
+          queryMetrics.retrievedDocumentSize &&
           this._normalize(queryMetrics.retrievedDocumentSize) +
-          this._normalize(aggregatedMetrics.retrievedDocumentSize);
+            this._normalize(aggregatedMetrics.retrievedDocumentSize);
         aggregatedMetrics.vmExecutionTime =
+          queryMetrics.vmExecutionTime &&
           this._normalize(queryMetrics.vmExecutionTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.vmExecutionTime);
+            this._normalize(aggregatedMetrics.vmExecutionTime);
         aggregatedMetrics.totalQueryExecutionTime =
+          queryMetrics.totalQueryExecutionTime &&
           this._normalize(queryMetrics.totalQueryExecutionTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.totalQueryExecutionTime);
+            this._normalize(aggregatedMetrics.totalQueryExecutionTime);
 
         aggregatedMetrics.runtimeExecutionTimes.queryEngineExecutionTime =
+          aggregatedMetrics.runtimeExecutionTimes &&
           this._normalize(queryMetrics.runtimeExecutionTimes.queryEngineExecutionTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.runtimeExecutionTimes.queryEngineExecutionTime);
+            this._normalize(aggregatedMetrics.runtimeExecutionTimes.queryEngineExecutionTime);
         aggregatedMetrics.runtimeExecutionTimes.systemFunctionExecutionTime =
+          aggregatedMetrics.runtimeExecutionTimes &&
           this._normalize(queryMetrics.runtimeExecutionTimes.systemFunctionExecutionTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.runtimeExecutionTimes.systemFunctionExecutionTime);
+            this._normalize(aggregatedMetrics.runtimeExecutionTimes.systemFunctionExecutionTime);
         aggregatedMetrics.runtimeExecutionTimes.userDefinedFunctionExecutionTime =
+          aggregatedMetrics.runtimeExecutionTimes &&
           this._normalize(queryMetrics.runtimeExecutionTimes.userDefinedFunctionExecutionTime.totalMilliseconds()) +
-          this._normalize(aggregatedMetrics.runtimeExecutionTimes.userDefinedFunctionExecutionTime);
+            this._normalize(aggregatedMetrics.runtimeExecutionTimes.userDefinedFunctionExecutionTime);
       }
     });
 

src/Explorer/Tabs/Tabs.tsx

@@ -1,6 +1,4 @@
 import { CollectionTabKind } from "Contracts/ViewModels";
-import Explorer from "Explorer/Explorer";
-import { SplashScreen } from "Explorer/SplashScreen/SplashScreen";
 import { ConnectTab } from "Explorer/Tabs/ConnectTab";
 import { useTeachingBubble } from "hooks/useTeachingBubble";
 import ko from "knockout";
@@ -8,33 +6,28 @@ import React, { MutableRefObject, useEffect, useRef, useState } from "react";
 import loadingIcon from "../../../images/circular_loader_black_16x16.gif";
 import errorIcon from "../../../images/close-black.svg";
 import { useObservable } from "../../hooks/useObservable";
-import { ReactTabKind, useTabs } from "../../hooks/useTabs";
+import { useTabs } from "../../hooks/useTabs";
 import TabsBase from "./TabsBase";
 
 type Tab = TabsBase | (TabsBase & { render: () => JSX.Element });
 
-interface TabsProps {
-  explorer: Explorer;
-}
-
-export const Tabs = ({ explorer }: TabsProps): JSX.Element => {
-  const { openedTabs, openedReactTabs, activeTab, activeReactTab } = useTabs();
-
+export const Tabs = (): JSX.Element => {
+  const { openedTabs, activeTab } = useTabs();
+  const isConnectTabOpen = useTabs((state) => state.isConnectTabOpen);
+  const isConnectTabActive = useTabs((state) => state.isConnectTabActive);
   return (
     <div className="tabsManagerContainer">
       <div id="content" className="flexContainer hideOverflows">
         <div className="nav-tabs-margin">
           <ul className="nav nav-tabs level navTabHeight" id="navTabs" role="tablist">
-            {openedReactTabs.map((tab) => (
-              <TabNav key={ReactTabKind[tab]} active={activeReactTab === tab} tabKind={tab} />
-            ))}
+            {isConnectTabOpen && <TabNav key="connect" tab={undefined} active={isConnectTabActive} />}
             {openedTabs.map((tab) => (
               <TabNav key={tab.tabId} tab={tab} active={activeTab === tab} />
             ))}
           </ul>
         </div>
         <div className="tabPanesContainer">
-          {activeReactTab !== undefined && getReactTabContent(activeReactTab, explorer)}
+          {isConnectTabActive && <ConnectTab />}
           {openedTabs.map((tab) => (
             <TabPane key={tab.tabId} tab={tab} active={activeTab === tab} />
           ))}
@@ -44,7 +37,7 @@ export const Tabs = ({ explorer }: TabsProps): JSX.Element => {
   );
 };
 
-function TabNav({ tab, active, tabKind }: { tab?: Tab; active: boolean; tabKind?: ReactTabKind }) {
+function TabNav({ tab, active }: { tab: Tab; active: boolean }) {
   const [hovering, setHovering] = useState(false);
   const focusTab = useRef<HTMLLIElement>() as MutableRefObject<HTMLLIElement>;
   const tabId = tab ? tab.tabId : "connect";
@@ -58,20 +51,8 @@ function TabNav({ tab, active, tabKind }: { tab?: Tab; active: boolean; tabKind?
     <li
       onMouseOver={() => setHovering(true)}
       onMouseLeave={() => setHovering(false)}
-      onClick={() => {
-        if (tab) {
-          tab.onTabClick();
-        } else if (tabKind !== undefined) {
-          useTabs.getState().activateReactTab(tabKind);
-        }
-      }}
-      onKeyPress={({ nativeEvent: e }) => {
-        if (tab) {
-          tab.onKeyPressActivate(undefined, e);
-        } else if (tabKind !== undefined) {
-          onKeyPressReactTab(e, tabKind);
-        }
-      }}
+      onClick={() => (tab ? tab.onTabClick() : useTabs.getState().activateConnectTab())}
+      onKeyPress={({ nativeEvent: e }) => (tab ? tab.onKeyPressActivate(undefined, e) : onKeyPressConnectTab(e))}
       className={active ? "active tabList" : "tabList"}
       title={useObservable(tab?.tabPath || ko.observable(""))}
       aria-selected={active}
@@ -84,18 +65,16 @@ function TabNav({ tab, active, tabKind }: { tab?: Tab; active: boolean; tabKind?
       <span className="tabNavContentContainer">
         <a data-toggle="tab" href={"#" + tabId} tabIndex={-1}>
           <div className="tab_Content">
-            <span className="statusIconContainer" style={{ width: tabKind === ReactTabKind.Home ? 0 : 18 }}>
+            <span className="statusIconContainer">
               {useObservable(tab?.isExecutionError || ko.observable(false)) && <ErrorIcon tab={tab} active={active} />}
               {useObservable(tab?.isExecuting || ko.observable(false)) && (
                 <img className="loadingIcon" title="Loading" src={loadingIcon} alt="Loading" />
               )}
             </span>
-            <span className="tabNavText">{useObservable(tab?.tabTitle || ko.observable(ReactTabKind[tabKind]))}</span>
-            {tabKind !== ReactTabKind.Home && (
-              <span className="tabIconSection">
-                <CloseButton tab={tab} active={active} hovering={hovering} tabKind={tabKind} />
-              </span>
-            )}
+            <span className="tabNavText">{useObservable(tab?.tabTitle || ko.observable("Connect"))}</span>
+            <span className="tabIconSection">
+              <CloseButton tab={tab} active={active} hovering={hovering} />
+            </span>
           </div>
         </a>
       </span>
@@ -103,24 +82,14 @@ function TabNav({ tab, active, tabKind }: { tab?: Tab; active: boolean; tabKind?
   );
 }
 
-const CloseButton = ({
-  tab,
-  active,
-  hovering,
-  tabKind,
-}: {
-  tab: Tab;
-  active: boolean;
-  hovering: boolean;
-  tabKind?: ReactTabKind;
-}) => (
+const CloseButton = ({ tab, active, hovering }: { tab: Tab; active: boolean; hovering: boolean }) => (
   <span
     style={{ display: hovering || active ? undefined : "none" }}
     title="Close"
     role="button"
     aria-label="Close Tab"
     className="cancelButton"
-    onClick={() => (tab ? tab.onCloseTabButtonClick() : useTabs.getState().closeReactTab(tabKind))}
+    onClick={() => (tab ? tab.onCloseTabButtonClick() : useTabs.getState().closeConnectTab())}
     tabIndex={active ? 0 : undefined}
     onKeyPress={({ nativeEvent: e }) => tab.onKeyPressClose(undefined, e)}
   >
@@ -175,20 +144,9 @@ function TabPane({ tab, active }: { tab: Tab; active: boolean }) {
   return <div {...attrs} ref={ref} data-bind="html:html" />;
 }
 
-const onKeyPressReactTab = (e: KeyboardEvent, tabKind: ReactTabKind): void => {
+const onKeyPressConnectTab = (e: KeyboardEvent): void => {
   if (e.key === "Enter" || e.key === "Space") {
-    useTabs.getState().activateReactTab(tabKind);
+    useTabs.getState().activateConnectTab();
     e.stopPropagation();
   }
 };
-
-const getReactTabContent = (activeReactTab: ReactTabKind, explorer: Explorer): JSX.Element => {
-  switch (activeReactTab) {
-    case ReactTabKind.Connect:
-      return <ConnectTab />;
-    case ReactTabKind.Home:
-      return <SplashScreen explorer={explorer} />;
-    default:
-      throw Error(`Unsupported tab kind ${ReactTabKind[activeReactTab]}`);
-  }
-};

src/Explorer/Tutorials/QuickstartTutorial.tsx

@@ -1,9 +1,9 @@
 import { Link, Stack, TeachingBubble, Text } from "@fluentui/react";
-import { ReactTabKind, useTabs } from "hooks/useTabs";
+import { useTabs } from "hooks/useTabs";
 import { useTeachingBubble } from "hooks/useTeachingBubble";
 import React from "react";
 import { Action } from "Shared/Telemetry/TelemetryConstants";
-import { traceCancel, traceSuccess } from "Shared/Telemetry/TelemetryProcessor";
+import { traceCancel } from "Shared/Telemetry/TelemetryProcessor";
 
 export const QuickstartTutorial: React.FC = (): JSX.Element => {
   const { step, isSampleDBExpanded, isDocumentsTabOpened, sampleCollection, setStep } = useTeachingBubble();
@@ -146,10 +146,7 @@ export const QuickstartTutorial: React.FC = (): JSX.Element => {
           hasCloseButton
           primaryButtonProps={{
             text: "Launch connect",
-            onClick: () => {
-              traceSuccess(Action.CompleteUITour);
-              useTabs.getState().openAndActivateReactTab(ReactTabKind.Connect);
-            },
+            onClick: () => useTabs.getState().openAndActivateConnectTab(),
           }}
           secondaryButtonProps={{
             text: "Previous",

src/Main.tsx

@@ -46,10 +46,12 @@ import "./Explorer/Menus/NotificationConsole/NotificationConsole.less";
 import { NotificationConsole } from "./Explorer/Menus/NotificationConsole/NotificationConsoleComponent";
 import "./Explorer/Panes/PanelComponent.less";
 import { SidePanel } from "./Explorer/Panes/PanelContainerComponent";
+import { SplashScreen } from "./Explorer/SplashScreen/SplashScreen";
 import "./Explorer/SplashScreen/SplashScreen.less";
 import { Tabs } from "./Explorer/Tabs/Tabs";
 import { useConfig } from "./hooks/useConfig";
 import { useKnockoutExplorer } from "./hooks/useKnockoutExplorer";
+import { useTabs } from "./hooks/useTabs";
 import "./Libs/jquery";
 import "./Shared/appInsights";
 
@@ -57,6 +59,8 @@ initializeIcons();
 
 const App: React.FunctionComponent = () => {
   const [isLeftPaneExpanded, setIsLeftPaneExpanded] = useState<boolean>(true);
+  const openedTabs = useTabs((state) => state.openedTabs);
+  const isConnectTabOpen = useTabs((state) => state.isConnectTabOpen);
   const isCarouselOpen = useCarousel((state) => state.shouldOpen);
 
   const config = useConfig();
@@ -100,7 +104,9 @@ const App: React.FunctionComponent = () => {
               {/* Collections Tree Collapsed - End */}
             </div>
           </div>
-          <Tabs explorer={explorer} />
+          {/* Collections Tree - End */}
+          {openedTabs.length === 0 && !isConnectTabOpen && <SplashScreen explorer={explorer} />}
+          <Tabs />
         </div>
         {/* Collections Tree and Tabs - End */}
         <div

src/Phoenix/PhoenixClient.ts

@@ -266,7 +266,6 @@ export class PhoenixClient {
           "."
         );
       }
-      case PhoenixErrorType.UserMissingPermissionsError:
       case PhoenixErrorType.AllocationValidationResult:
       case PhoenixErrorType.RegionNotServicable:
       case PhoenixErrorType.SubscriptionNotAllowed: {

src/Shared/Telemetry/TelemetryConstants.ts

@@ -130,7 +130,6 @@ export enum Action {
   CompleteCarousel,
   LaunchUITour,
   CancelUITour,
-  CompleteUITour,
 }
 
 export const ActionModifiers = {

src/UserContext.ts

@@ -36,6 +36,7 @@ interface UserContext {
   readonly accessToken?: string;
   readonly authorizationToken?: string;
   readonly resourceToken?: string;
+  readonly useSDKOperations: boolean;
   readonly subscriptionType?: SubscriptionType;
   readonly quotaId?: string;
   // API Type is not yet provided by ARM. You need to manually inspect all the capabilities+kind so we abstract that logic in userContext
@@ -60,6 +61,7 @@ export type PortalEnv = "localhost" | "blackforest" | "fairfax" | "mooncake" | "
 const ONE_WEEK_IN_MS = 604800000;
 
 const features = extractFeatures();
+const { enableSDKoperations: useSDKOperations } = features;
 
 const userContext: UserContext = {
   apiType: "SQL",
@@ -67,6 +69,7 @@ const userContext: UserContext = {
   isTryCosmosDBSubscription: false,
   portalEnv: "prod",
   features,
+  useSDKOperations,
   addCollectionFlight: CollectionCreation.DefaultAddCollectionDefaultFlight,
   subscriptionType: CollectionCreation.DefaultSubscriptionType,
   collectionCreationDefaults: CollectionCreationDefaults,

src/hooks/useTabs.ts

@@ -6,43 +6,37 @@ import TabsBase from "../Explorer/Tabs/TabsBase";
 
 interface TabsState {
   openedTabs: TabsBase[];
-  openedReactTabs: ReactTabKind[];
   activeTab: TabsBase;
-  activeReactTab: ReactTabKind;
+  isConnectTabOpen: boolean;
+  isConnectTabActive: boolean;
   activateTab: (tab: TabsBase) => void;
   activateNewTab: (tab: TabsBase) => void;
-  activateReactTab: (tabkind: ReactTabKind) => void;
   updateTab: (tab: TabsBase) => void;
   getTabs: (tabKind: ViewModels.CollectionTabKind, comparator?: (tab: TabsBase) => boolean) => TabsBase[];
   refreshActiveTab: (comparator: (tab: TabsBase) => boolean) => void;
   closeTabsByComparator: (comparator: (tab: TabsBase) => boolean) => void;
   closeTab: (tab: TabsBase) => void;
   closeAllNotebookTabs: (hardClose: boolean) => void;
-  openAndActivateReactTab: (tabKind: ReactTabKind) => void;
-  closeReactTab: (tabKind: ReactTabKind) => void;
-}
-
-export enum ReactTabKind {
-  Connect,
-  Home,
+  activateConnectTab: () => void;
+  openAndActivateConnectTab: () => void;
+  closeConnectTab: () => void;
 }
 
 export const useTabs: UseStore<TabsState> = create((set, get) => ({
   openedTabs: [],
-  openedReactTabs: [ReactTabKind.Home],
   activeTab: undefined,
-  activeReactTab: ReactTabKind.Home,
+  isConnectTabOpen: false,
+  isConnectTabActive: false,
   activateTab: (tab: TabsBase): void => {
     if (get().openedTabs.some((openedTab) => openedTab.tabId === tab.tabId)) {
-      set({ activeTab: tab, activeReactTab: undefined });
+      set({ activeTab: tab, isConnectTabActive: false });
       tab.onActivate();
     }
   },
   activateNewTab: (tab: TabsBase): void => {
-    set((state) => ({ openedTabs: [...state.openedTabs, tab], activeTab: tab, activeReactTab: undefined }));
+    set((state) => ({ openedTabs: [...state.openedTabs, tab], activeTab: tab, isConnectTabActive: false }));
     tab.onActivate();
   },
-  activateReactTab: (tabKind: ReactTabKind): void => set({ activeTab: undefined, activeReactTab: tabKind }),
   updateTab: (tab: TabsBase) => {
     if (get().activeTab?.tabId === tab.tabId) {
       set({ activeTab: tab });
@@ -79,7 +73,7 @@ export const useTabs: UseStore<TabsState> = create((set, get) => ({
       return true;
     });
     if (updatedTabs.length === 0) {
-      set({ activeTab: undefined, activeReactTab: ReactTabKind.Home });
+      set({ activeTab: undefined, isConnectTabActive: get().isConnectTabOpen });
     }
 
     if (tab.tabId === activeTab.tabId && tabIndex !== -1) {
@@ -117,27 +111,21 @@ export const useTabs: UseStore<TabsState> = create((set, get) => ({
       });
 
       if (get().openedTabs.length === 0) {
-        set({ activeTab: undefined, activeReactTab: ReactTabKind.Home });
+        set({ activeTab: undefined, isConnectTabActive: get().isConnectTabOpen });
       }
     }
   },
-  openAndActivateReactTab: (tabKind: ReactTabKind) => {
-    if (get().openedReactTabs.indexOf(tabKind) === -1) {
-      set((state) => ({
-        openedReactTabs: [...state.openedReactTabs, tabKind],
-      }));
+  activateConnectTab: () => {
+    if (get().isConnectTabOpen) {
+      set({ isConnectTabActive: true, activeTab: undefined });
     }
-
-    set({ activeTab: undefined, activeReactTab: tabKind });
   },
-  closeReactTab: (tabKind: ReactTabKind) => {
-    const { activeReactTab, openedTabs, openedReactTabs } = get();
-    if (activeReactTab === tabKind) {
-      openedTabs?.length > 0
-        ? set({ activeTab: openedTabs[0], activeReactTab: undefined })
-        : set({ activeTab: undefined, activeReactTab: openedReactTabs[0] });
+  openAndActivateConnectTab: () => set({ isConnectTabActive: true, isConnectTabOpen: true, activeTab: undefined }),
+  closeConnectTab: () => {
+    const { isConnectTabActive, openedTabs } = get();
+    if (isConnectTabActive && openedTabs?.length > 0) {
+      set({ activeTab: openedTabs[0] });
     }
-
-    set({ openedReactTabs: openedReactTabs.filter((tab: ReactTabKind) => tabKind !== tab) });
+    set({ isConnectTabActive: false, isConnectTabOpen: false });
   },
 }));