Move stored procedure operations to RP (#281)

- move read, delete, create, and update stored procedure calls to RP
- fixed a bug where the console message never clears when reading offers with SDK

src/Common/dataAccess/createStoredProcedure.ts

@@ -1,28 +1,53 @@
+import { AuthType } from "../../AuthType";
 import { Resource, StoredProcedureDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import {
+  SqlStoredProcedureCreateUpdateParameters,
+  SqlStoredProcedureResource
+} from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
+import { createUpdateSqlStoredProcedure } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
+import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
 
 export async function createStoredProcedure(
   databaseId: string,
   collectionId: string,
   storedProcedure: StoredProcedureDefinition
 ): Promise<StoredProcedureDefinition & Resource> {
-  let createdStoredProcedure: StoredProcedureDefinition & Resource;
   const clearMessage = logConsoleProgress(`Creating stored procedure ${storedProcedure.id}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      const createSprocParams: SqlStoredProcedureCreateUpdateParameters = {
+        properties: {
+          resource: storedProcedure as SqlStoredProcedureResource,
+          options: {}
+        }
+      };
+      const rpResponse = await createUpdateSqlStoredProcedure(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        storedProcedure.id,
+        createSprocParams
+      );
+      return rpResponse && (rpResponse.properties?.resource as StoredProcedureDefinition & Resource);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.storedProcedures.create(storedProcedure);
-    createdStoredProcedure = response.resource;
+    return response?.resource;
   } catch (error) {
     logConsoleError(`Error while creating stored procedure ${storedProcedure.id}:\n ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "CreateStoredProcedure", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return createdStoredProcedure;
+  }
 }

src/Common/dataAccess/deleteStoredProcedure.ts

@@ -1,7 +1,10 @@
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import { AuthType } from "../../AuthType";
 import { client } from "../CosmosClient";
+import { deleteSqlStoredProcedure } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
+import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
 
 export async function deleteStoredProcedure(
   databaseId: string,
@@ -10,17 +13,28 @@ export async function deleteStoredProcedure(
 ): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting stored procedure ${storedProcedureId}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      await deleteSqlStoredProcedure(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        storedProcedureId
+      );
+    } else {
       await client()
         .database(databaseId)
         .container(collectionId)
         .scripts.storedProcedure(storedProcedureId)
         .delete();
+    }
   } catch (error) {
     logConsoleError(`Error while deleting stored procedure ${storedProcedureId}:\n ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "DeleteStoredProcedure", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return undefined;
+  }
 }

src/Common/dataAccess/readOffers.ts

@@ -13,10 +13,13 @@ export const readOffers = async (): Promise<Offer[]> => {
   const clearMessage = logConsoleProgress(`Querying offers`);
   try {
     if (configContext.platform === Platform.Portal) {
-      return sendCachedDataMessage<Offer[]>(MessageTypes.AllOffers, [
+      const offers = sendCachedDataMessage<Offer[]>(MessageTypes.AllOffers, [
         userContext.databaseAccount.id,
         ClientDefaults.portalCacheTimeoutMs
       ]);
+      clearMessage();
+
+      return offers;
     }
   } catch (error) {
     // If error getting cached Offers, continue on and read via SDK

src/Common/dataAccess/readStoredProcedures.ts

@@ -1,27 +1,41 @@
+import { AuthType } from "../../AuthType";
 import { Resource, StoredProcedureDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { client } from "../CosmosClient";
+import { listSqlStoredProcedures } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
+import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
 
 export async function readStoredProcedures(
   databaseId: string,
   collectionId: string
 ): Promise<(StoredProcedureDefinition & Resource)[]> {
-  let sprocs: (StoredProcedureDefinition & Resource)[];
   const clearMessage = logConsoleProgress(`Querying stored procedures for container ${collectionId}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      const rpResponse = await listSqlStoredProcedures(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId
+      );
+      return rpResponse?.value?.map(sproc => sproc.properties?.resource as StoredProcedureDefinition & Resource);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.storedProcedures.readAll()
       .fetchAll();
-    sprocs = response.resources;
+    return response?.resources;
   } catch (error) {
     logConsoleError(`Failed to query stored procedures for container ${collectionId}: ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "ReadStoredProcedures", error.code);
     sendNotificationForError(error);
-  }
+    throw error;
+  } finally {
     clearMessage();
-  return sprocs;
+  }
 }

src/Common/dataAccess/updateStoredProcedure.ts

@@ -1,29 +1,70 @@
+import { AuthType } from "../../AuthType";
 import { Resource, StoredProcedureDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import {
+  SqlStoredProcedureCreateUpdateParameters,
+  SqlStoredProcedureResource
+} from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
+import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import {
+  createUpdateSqlStoredProcedure,
+  getSqlStoredProcedure
+} from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
+import { userContext } from "../../UserContext";
 
 export async function updateStoredProcedure(
   databaseId: string,
   collectionId: string,
   storedProcedure: StoredProcedureDefinition
 ): Promise<StoredProcedureDefinition & Resource> {
-  let updatedStoredProcedure: StoredProcedureDefinition & Resource;
   const clearMessage = logConsoleProgress(`Updating stored procedure ${storedProcedure.id}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      const getResponse = await getSqlStoredProcedure(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        storedProcedure.id
+      );
+
+      if (getResponse?.properties?.resource) {
+        const createSprocParams: SqlStoredProcedureCreateUpdateParameters = {
+          properties: {
+            resource: storedProcedure as SqlStoredProcedureResource,
+            options: {}
+          }
+        };
+        const rpResponse = await createUpdateSqlStoredProcedure(
+          userContext.subscriptionId,
+          userContext.resourceGroup,
+          userContext.databaseAccount.name,
+          databaseId,
+          collectionId,
+          storedProcedure.id,
+          createSprocParams
+        );
+        return rpResponse && (rpResponse.properties?.resource as StoredProcedureDefinition & Resource);
+      }
+
+      throw new Error(`Failed to update stored procedure: ${storedProcedure.id} does not exist.`);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.storedProcedure(storedProcedure.id)
       .replace(storedProcedure);
-    updatedStoredProcedure = response.resource;
+    return response?.resource;
   } catch (error) {
     logConsoleError(`Error while updating stored procedure ${storedProcedure.id}:\n ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "UpdateStoredProcedure", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return updatedStoredProcedure;
+  }
 }