Move UDF and trigger operations to RP (#283)

Move UDF and trigger operations to RP

src/Common/dataAccess/createStoredProcedure.ts

@@ -5,7 +5,10 @@ import {
   SqlStoredProcedureResource
 } from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
-import { createUpdateSqlStoredProcedure } from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
+import {
+  createUpdateSqlStoredProcedure,
+  getSqlStoredProcedure
+} from "../../Utils/arm/generatedClients/2020-04-01/sqlResources";
 import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
@@ -19,6 +22,26 @@ export async function createStoredProcedure(
   const clearMessage = logConsoleProgress(`Creating stored procedure ${storedProcedure.id}`);
   try {
     if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      try {
+        const getResponse = await getSqlStoredProcedure(
+          userContext.subscriptionId,
+          userContext.resourceGroup,
+          userContext.databaseAccount.name,
+          databaseId,
+          collectionId,
+          storedProcedure.id
+        );
+        if (getResponse?.properties?.resource) {
+          throw new Error(
+            `Create stored procedure failed: stored procedure with id ${storedProcedure.id} already exists`
+          );
+        }
+      } catch (error) {
+        if (error.code !== "NotFound") {
+          throw error;
+        }
+      }
+
       const createSprocParams: SqlStoredProcedureCreateUpdateParameters = {
         properties: {
           resource: storedProcedure as SqlStoredProcedureResource,

src/Common/dataAccess/createTrigger.ts

@@ -1,28 +1,71 @@
+import { AuthType } from "../../AuthType";
 import { Resource, TriggerDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import {
+  SqlTriggerCreateUpdateParameters,
+  SqlTriggerResource
+} from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
+import { createUpdateSqlTrigger, getSqlTrigger } 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 createTrigger(
   databaseId: string,
   collectionId: string,
   trigger: TriggerDefinition
 ): Promise<TriggerDefinition & Resource> {
-  let createdTrigger: TriggerDefinition & Resource;
   const clearMessage = logConsoleProgress(`Creating trigger ${trigger.id}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      try {
+        const getResponse = await getSqlTrigger(
+          userContext.subscriptionId,
+          userContext.resourceGroup,
+          userContext.databaseAccount.name,
+          databaseId,
+          collectionId,
+          trigger.id
+        );
+        if (getResponse?.properties?.resource) {
+          throw new Error(`Create trigger failed: trigger with id ${trigger.id} already exists`);
+        }
+      } catch (error) {
+        if (error.code !== "NotFound") {
+          throw error;
+        }
+      }
+
+      const createTriggerParams: SqlTriggerCreateUpdateParameters = {
+        properties: {
+          resource: trigger as SqlTriggerResource,
+          options: {}
+        }
+      };
+      const rpResponse = await createUpdateSqlTrigger(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        trigger.id,
+        createTriggerParams
+      );
+      return rpResponse && (rpResponse.properties?.resource as TriggerDefinition & Resource);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.triggers.create(trigger);
-    createdTrigger = response.resource;
+    return response.resource;
   } catch (error) {
     logConsoleError(`Error while creating trigger ${trigger.id}:\n ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "CreateTrigger", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return createdTrigger;
+  }
 }

src/Common/dataAccess/createUserDefinedFunction.ts

@@ -1,28 +1,76 @@
+import { AuthType } from "../../AuthType";
 import { Resource, UserDefinedFunctionDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import {
+  SqlUserDefinedFunctionCreateUpdateParameters,
+  SqlUserDefinedFunctionResource
+} from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
+import {
+  createUpdateSqlUserDefinedFunction,
+  getSqlUserDefinedFunction
+} 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 createUserDefinedFunction(
   databaseId: string,
   collectionId: string,
   userDefinedFunction: UserDefinedFunctionDefinition
 ): Promise<UserDefinedFunctionDefinition & Resource> {
-  let createdUserDefinedFunction: UserDefinedFunctionDefinition & Resource;
   const clearMessage = logConsoleProgress(`Creating user defined function ${userDefinedFunction.id}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      try {
+        const getResponse = await getSqlUserDefinedFunction(
+          userContext.subscriptionId,
+          userContext.resourceGroup,
+          userContext.databaseAccount.name,
+          databaseId,
+          collectionId,
+          userDefinedFunction.id
+        );
+        if (getResponse?.properties?.resource) {
+          throw new Error(
+            `Create user defined function failed: user defined function with id ${userDefinedFunction.id} already exists`
+          );
+        }
+      } catch (error) {
+        if (error.code !== "NotFound") {
+          throw error;
+        }
+      }
+
+      const createUDFParams: SqlUserDefinedFunctionCreateUpdateParameters = {
+        properties: {
+          resource: userDefinedFunction as SqlUserDefinedFunctionResource,
+          options: {}
+        }
+      };
+      const rpResponse = await createUpdateSqlUserDefinedFunction(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        userDefinedFunction.id,
+        createUDFParams
+      );
+      return rpResponse && (rpResponse.properties?.resource as UserDefinedFunctionDefinition & Resource);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.userDefinedFunctions.create(userDefinedFunction);
-    createdUserDefinedFunction = response.resource;
+    return response?.resource;
   } catch (error) {
     logConsoleError(`Error while creating user defined function ${userDefinedFunction.id}:\n ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "CreateUserupdateUserDefinedFunction", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return createdUserDefinedFunction;
+  }
 }

src/Common/dataAccess/deleteTrigger.ts

@@ -1,22 +1,36 @@
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import { AuthType } from "../../AuthType";
 import { client } from "../CosmosClient";
+import { deleteSqlTrigger } 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 deleteTrigger(databaseId: string, collectionId: string, triggerId: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting trigger ${triggerId}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      await deleteSqlTrigger(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        triggerId
+      );
+    } else {
       await client()
         .database(databaseId)
         .container(collectionId)
         .scripts.trigger(triggerId)
         .delete();
+    }
   } catch (error) {
     logConsoleError(`Error while deleting trigger ${triggerId}:\n ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "DeleteTrigger", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return undefined;
+  }
 }

src/Common/dataAccess/deleteUserDefinedFunction.ts

@@ -1,22 +1,36 @@
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import { AuthType } from "../../AuthType";
 import { client } from "../CosmosClient";
+import { deleteSqlUserDefinedFunction } 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 deleteUserDefinedFunction(databaseId: string, collectionId: string, id: string): Promise<void> {
   const clearMessage = logConsoleProgress(`Deleting user defined function ${id}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      await deleteSqlUserDefinedFunction(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        id
+      );
+    } else {
       await client()
         .database(databaseId)
         .container(collectionId)
         .scripts.userDefinedFunction(id)
         .delete();
+    }
   } catch (error) {
     logConsoleError(`Error while deleting user defined function ${id}:\n ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "DeleteUserDefinedFunction", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return undefined;
+  }
 }

src/Common/dataAccess/readTriggers.ts

@@ -1,27 +1,41 @@
+import { AuthType } from "../../AuthType";
 import { Resource, TriggerDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { client } from "../CosmosClient";
+import { listSqlTriggers } 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 readTriggers(
   databaseId: string,
   collectionId: string
 ): Promise<(TriggerDefinition & Resource)[]> {
-  let triggers: (TriggerDefinition & Resource)[];
   const clearMessage = logConsoleProgress(`Querying triggers for container ${collectionId}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      const rpResponse = await listSqlTriggers(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId
+      );
+      return rpResponse?.value?.map(trigger => trigger.properties?.resource as TriggerDefinition & Resource);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.triggers.readAll()
       .fetchAll();
-    triggers = response.resources;
+    return response?.resources;
   } catch (error) {
     logConsoleError(`Failed to query triggers for container ${collectionId}: ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "ReadTriggers", error.code);
     sendNotificationForError(error);
-  }
+    throw error;
+  } finally {
     clearMessage();
-  return triggers;
+  }
 }

src/Common/dataAccess/readUserDefinedFunctions.ts

@@ -1,27 +1,41 @@
+import { AuthType } from "../../AuthType";
 import { Resource, UserDefinedFunctionDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { client } from "../CosmosClient";
+import { listSqlUserDefinedFunctions } 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 readUserDefinedFunctions(
   databaseId: string,
   collectionId: string
 ): Promise<(UserDefinedFunctionDefinition & Resource)[]> {
-  let udfs: (UserDefinedFunctionDefinition & Resource)[];
   const clearMessage = logConsoleProgress(`Querying user defined functions for container ${collectionId}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      const rpResponse = await listSqlUserDefinedFunctions(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId
+      );
+      return rpResponse?.value?.map(udf => udf.properties?.resource as UserDefinedFunctionDefinition & Resource);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.userDefinedFunctions.readAll()
       .fetchAll();
-    udfs = response.resources;
+    return response?.resources;
   } catch (error) {
     logConsoleError(`Failed to query user defined functions for container ${collectionId}: ${JSON.stringify(error)}`);
     logError(JSON.stringify(error), "ReadUserDefinedFunctions", error.code);
     sendNotificationForError(error);
-  }
+    throw error;
+  } finally {
     clearMessage();
-  return udfs;
+  }
 }

src/Common/dataAccess/updateStoredProcedure.ts

@@ -5,11 +5,11 @@ import {
   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 { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { logError } from "../Logger";
 import { sendNotificationForError } from "./sendNotificationForError";
 import { userContext } from "../../UserContext";
@@ -60,8 +60,9 @@ export async function updateStoredProcedure(
       .replace(storedProcedure);
     return response?.resource;
   } catch (error) {
-    logConsoleError(`Error while updating stored procedure ${storedProcedure.id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "UpdateStoredProcedure", error.code);
+    const errorMessage = error.code === "NotFound" ? `${storedProcedure.id} does not exist.` : JSON.stringify(error);
+    logConsoleError(`Error while updating stored procedure ${storedProcedure.id}:\n ${errorMessage}`);
+    logError(errorMessage, "UpdateStoredProcedure", error.code);
     sendNotificationForError(error);
     throw error;
   } finally {

src/Common/dataAccess/updateTrigger.ts

@@ -1,29 +1,68 @@
+import { AuthType } from "../../AuthType";
+import {
+  SqlTriggerCreateUpdateParameters,
+  SqlTriggerResource
+} from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { TriggerDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
 import { client } from "../CosmosClient";
+import { createUpdateSqlTrigger, getSqlTrigger } 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 updateTrigger(
   databaseId: string,
   collectionId: string,
   trigger: TriggerDefinition
 ): Promise<TriggerDefinition> {
-  let updatedTrigger: TriggerDefinition;
   const clearMessage = logConsoleProgress(`Updating trigger ${trigger.id}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      const getResponse = await getSqlTrigger(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        trigger.id
+      );
+
+      if (getResponse?.properties?.resource) {
+        const createTriggerParams: SqlTriggerCreateUpdateParameters = {
+          properties: {
+            resource: trigger as SqlTriggerResource,
+            options: {}
+          }
+        };
+        const rpResponse = await createUpdateSqlTrigger(
+          userContext.subscriptionId,
+          userContext.resourceGroup,
+          userContext.databaseAccount.name,
+          databaseId,
+          collectionId,
+          trigger.id,
+          createTriggerParams
+        );
+        return rpResponse && (rpResponse.properties?.resource as TriggerDefinition);
+      }
+
+      throw new Error(`Failed to update trigger: ${trigger.id} does not exist.`);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.trigger(trigger.id)
       .replace(trigger);
-    updatedTrigger = response.resource;
+    return response?.resource;
   } catch (error) {
-    logConsoleError(`Error while updating trigger ${trigger.id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "UpdateTrigger", error.code);
+    const errorMessage = error.code === "NotFound" ? `${trigger.id} does not exist.` : JSON.stringify(error);
+    logConsoleError(`Error while updating trigger ${trigger.id}:\n ${errorMessage}`);
+    logError(errorMessage, "UpdateTrigger", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return updatedTrigger;
+  }
 }

src/Common/dataAccess/updateUserDefinedFunction.ts

@@ -1,29 +1,72 @@
+import { AuthType } from "../../AuthType";
 import { Resource, UserDefinedFunctionDefinition } from "@azure/cosmos";
-import { logConsoleError, logConsoleProgress } from "../../Utils/NotificationConsoleUtils";
+import {
+  SqlUserDefinedFunctionCreateUpdateParameters,
+  SqlUserDefinedFunctionResource
+} from "../../Utils/arm/generatedClients/2020-04-01/types";
 import { client } from "../CosmosClient";
+import {
+  createUpdateSqlUserDefinedFunction,
+  getSqlUserDefinedFunction
+} 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 updateUserDefinedFunction(
   databaseId: string,
   collectionId: string,
   userDefinedFunction: UserDefinedFunctionDefinition
 ): Promise<UserDefinedFunctionDefinition & Resource> {
-  let updatedUserDefinedFunction: UserDefinedFunctionDefinition & Resource;
   const clearMessage = logConsoleProgress(`Updating user defined function ${userDefinedFunction.id}`);
   try {
+    if (window.authType === AuthType.AAD && !userContext.useSDKOperations) {
+      const getResponse = await getSqlUserDefinedFunction(
+        userContext.subscriptionId,
+        userContext.resourceGroup,
+        userContext.databaseAccount.name,
+        databaseId,
+        collectionId,
+        userDefinedFunction.id
+      );
+
+      if (getResponse?.properties?.resource) {
+        const createUDFParams: SqlUserDefinedFunctionCreateUpdateParameters = {
+          properties: {
+            resource: userDefinedFunction as SqlUserDefinedFunctionResource,
+            options: {}
+          }
+        };
+        const rpResponse = await createUpdateSqlUserDefinedFunction(
+          userContext.subscriptionId,
+          userContext.resourceGroup,
+          userContext.databaseAccount.name,
+          databaseId,
+          collectionId,
+          userDefinedFunction.id,
+          createUDFParams
+        );
+        return rpResponse && (rpResponse.properties?.resource as UserDefinedFunctionDefinition & Resource);
+      }
+
+      throw new Error(`Failed to update user defined function: ${userDefinedFunction.id} does not exist.`);
+    }
+
     const response = await client()
       .database(databaseId)
       .container(collectionId)
       .scripts.userDefinedFunction(userDefinedFunction.id)
       .replace(userDefinedFunction);
-    updatedUserDefinedFunction = response.resource;
+    return response?.resource;
   } catch (error) {
-    logConsoleError(`Error while updating user defined function ${userDefinedFunction.id}:\n ${JSON.stringify(error)}`);
-    logError(JSON.stringify(error), "UpdateUserupdateUserDefinedFunction", error.code);
+    const errorMessage =
+      error.code === "NotFound" ? `${userDefinedFunction.id} does not exist.` : JSON.stringify(error);
+    logConsoleError(`Error while updating user defined function ${userDefinedFunction.id}:\n ${errorMessage}`);
+    logError(errorMessage, "UpdateUserupdateUserDefinedFunction", error.code);
     sendNotificationForError(error);
-  }
-
+    throw error;
+  } finally {
     clearMessage();
-  return updatedUserDefinedFunction;
+  }
 }

src/Explorer/Tree/UserDefinedFunction.ts

@@ -56,7 +56,7 @@ export default class UserDefinedFunction {
 
     const userDefinedFunctionTabs: UserDefinedFunctionTab[] = this.container.tabsManager.getTabs(
       ViewModels.CollectionTabKind.UserDefinedFunctions,
-      tab => tab.collection && tab.collection.rid === this.rid
+      tab => tab.node?.rid === this.rid
     ) as UserDefinedFunctionTab[];
     let userDefinedFunctionTab: UserDefinedFunctionTab = userDefinedFunctionTabs && userDefinedFunctionTabs[0];