Added better notifications for users when templates are updated.

Added confirmation dialogs for destructive actions.
Other improvements/changes
When deleting rule templates, we now clean up all resource rules that were created from the template.

server/routers/ruleTemplate/deleteRuleTemplate.ts

@@ -31,7 +31,26 @@ export async function deleteRuleTemplate(req: any, res: any) {
             });
         }
 
-        // Delete template rules first (due to foreign key constraint)
+        // Get all template rules for this template
+        const templateRulesToDelete = await db
+            .select({ ruleId: templateRules.ruleId })
+            .from(templateRules)
+            .where(eq(templateRules.templateId, templateId));
+
+        // Delete resource rules that reference these template rules first
+        if (templateRulesToDelete.length > 0) {
+            const { resourceRules } = await import("@server/db");
+            const templateRuleIds = templateRulesToDelete.map(rule => rule.ruleId);
+            
+            // Delete all resource rules that reference any of the template rules
+            for (const ruleId of templateRuleIds) {
+                await db
+                    .delete(resourceRules)
+                    .where(eq(resourceRules.templateRuleId, ruleId));
+            }
+        }
+
+        // Delete template rules
         await db
             .delete(templateRules)
             .where(eq(templateRules.templateId, templateId));

server/routers/ruleTemplate/deleteTemplateRule.ts

@@ -67,15 +67,20 @@ export async function deleteTemplateRule(
             );
         }
 
-        // Delete the rule
-        await db
-            .delete(templateRules)
-            .where(and(eq(templateRules.templateId, templateId), eq(templateRules.ruleId, parseInt(ruleId))));
-
-        // Also delete all resource rules that were created from this template rule
+        // Count affected resources for the response message
+        let affectedResourcesCount = 0;
         try {
             const { resourceRules } = await import("@server/db");
             
+            // Get affected resource rules before deletion for counting
+            const affectedResourceRules = await db
+                .select()
+                .from(resourceRules)
+                .where(eq(resourceRules.templateRuleId, parseInt(ruleId)));
+            
+            affectedResourcesCount = affectedResourceRules.length;
+
+            // Delete the resource rules first (due to foreign key constraint)
             await db
                 .delete(resourceRules)
                 .where(eq(resourceRules.templateRuleId, parseInt(ruleId)));
@@ -84,11 +89,20 @@ export async function deleteTemplateRule(
             // Don't fail the template rule deletion if resource rule deletion fails, just log it
         }
 
+        // Delete the template rule after resource rules are deleted
+        await db
+            .delete(templateRules)
+            .where(and(eq(templateRules.templateId, templateId), eq(templateRules.ruleId, parseInt(ruleId))));
+
+        const message = affectedResourcesCount > 0 
+            ? `Template rule deleted successfully. Removed from ${affectedResourcesCount} assigned resource${affectedResourcesCount > 1 ? 's' : ''}.`
+            : "Template rule deleted successfully.";
+
         return response(res, {
             data: null,
             success: true,
             error: false,
-            message: "Template rule deleted successfully",
+            message,
             status: HttpCode.OK
         });
     } catch (error) {

server/routers/ruleTemplate/getRuleTemplate.ts

@@ -9,6 +9,14 @@ import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 
+export type GetRuleTemplateResponse = {
+    templateId: string;
+    orgId: string;
+    name: string;
+    description: string | null;
+    createdAt: number;
+};
+
 const getRuleTemplateParamsSchema = z
     .object({
         orgId: z.string().min(1),

server/routers/ruleTemplate/updateTemplateRule.ts

@@ -144,8 +144,8 @@ export async function updateTemplateRule(
                 
                 // Remove undefined values
                 Object.keys(propagationData).forEach(key => {
-                    if (propagationData[key] === undefined) {
-                        delete propagationData[key];
+                    if ((propagationData as any)[key] === undefined) {
+                        delete (propagationData as any)[key];
                     }
                 });
 
@@ -161,11 +161,28 @@ export async function updateTemplateRule(
             // Don't fail the template rule update if propagation fails, just log it
         }
 
+        // Count affected resources for the response message
+        let affectedResourcesCount = 0;
+        try {
+            const { resourceTemplates } = await import("@server/db");
+            const affectedResources = await db
+                .select()
+                .from(resourceTemplates)
+                .where(eq(resourceTemplates.templateId, templateId));
+            affectedResourcesCount = affectedResources.length;
+        } catch (error) {
+            logger.error("Error counting affected resources:", error);
+        }
+
+        const message = affectedResourcesCount > 0 
+            ? `Template rule updated successfully. Changes propagated to ${affectedResourcesCount} assigned resource${affectedResourcesCount > 1 ? 's' : ''}.`
+            : "Template rule updated successfully.";
+
         return response(res, {
             data: updatedRule,
             success: true,
             error: false,
-            message: "Template rule updated successfully",
+            message,
             status: HttpCode.OK
         });
     } catch (error) {