feat: clean notifications

.gitignore

@@ -118,4 +118,9 @@ build
 ############################
 
 data/*
-!data/.gitkeep
+!data/.gitkeep
+
+############################
+# IDE
+############################
+.vscode

config/cron-tasks.ts

@@ -0,0 +1,56 @@
+export default {
+  /**
+   * Delete notifications that are over a week past their due date and orphaned notifications daily at midnight
+   */
+  cleanupExpiredNotifications: {
+    task: async ({ strapi }) => {
+      console.log("Running cleanupExpiredNotifications task");
+      try {
+        // Calculate date 1 week ago
+        const oneWeekAgo = new Date();
+        oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
+
+        // Find all notifications with templates due over a week ago
+        const expiredNotifications = await strapi.db
+          .query("api::notification.notification")
+          .findMany({
+            where: {
+              $or: [
+                {
+                  notification_template: {
+                    dueDate: {
+                      $lt: oneWeekAgo,
+                    },
+                  },
+                },
+                {
+                  notification_template: null,
+                },
+              ],
+            },
+          });
+
+        // Delete the expired and orphaned notifications
+        if (expiredNotifications.length > 0) {
+          await strapi.db.query("api::notification.notification").deleteMany({
+            where: {
+              id: {
+                $in: expiredNotifications.map((n) => n.id),
+              },
+            },
+          });
+          console.log(
+            `Deleted ${expiredNotifications.length} notifications that were over a week past due or orphaned`
+          );
+        }
+      } catch (error) {
+        console.error("Error cleaning up notifications:", error);
+      }
+      console.log("Finished cleanupExpiredNotifications task");
+    },
+    options: {
+      rule: "0 0 * * *", // Runs daily at midnight
+      tz: "UTC",
+    },
+  },
+};

config/server.ts

@@ -1,15 +1,21 @@
+import cronTasks from "./cron-tasks";
+
 export default ({ env }) => ({
-  host: env('HOST', '0.0.0.0'),
-  port: env.int('PORT', 1337),
+  host: env("HOST", "0.0.0.0"),
+  port: env.int("PORT", 1337),
   app: {
-    keys: env.array('APP_KEYS'),
+    keys: env.array("APP_KEYS"),
   },
   http: {
     serverOptions: {
       timeout: 120_000, // 2 minutes
     },
   },
   webhooks: {
-    populateRelations: env.bool('WEBHOOKS_POPULATE_RELATIONS', false),
+    populateRelations: env.bool("WEBHOOKS_POPULATE_RELATIONS", false),
+  },
+  cron: {
+    enabled: true,
+    tasks: cronTasks,
   },
 });

src/api/notification-template/content-types/notification-template/lifecycles.ts

@@ -0,0 +1,67 @@
+export default {
+  async beforeDelete(event) {
+    const { where } = event.params;
+    const { id } = where;
+
+    try {
+      await deleteAssociatedNotifications([id]);
+    } catch (error) {
+      console.error(`Error in beforeDelete for template ${id}:`, error);
+    }
+  },
+
+  async beforeDeleteMany(event) {
+    const { where } = event.params;
+    const { id } = where;
+
+    try {
+      // First get all template IDs that will be deleted
+      const templatesForDeletion = await strapi.db
+        .query("api::notification-template.notification-template")
+        .findMany({
+          where,
+          select: ["id"],
+        });
+
+      const templateIds = templatesForDeletion.map((template) => template.id);
+
+      if (templateIds.length > 0) {
+        await deleteAssociatedNotifications(templateIds);
+      }
+    } catch (error) {
+      console.error(`Error in beforeDeleteMany for templates:`, error);
+    }
+  },
+};
+
+// Helper function to delete notifications for given template IDs
+async function deleteAssociatedNotifications(templateIds: number[]) {
+  // Find all notifications associated with these templates
+  const notifications = await strapi.db
+    .query("api::notification.notification")
+    .findMany({
+      where: {
+        notification_template: {
+          id: {
+            $in: templateIds,
+          },
+        },
+      },
+    });
+
+  if (notifications.length > 0) {
+    // Delete all associated notifications
+    await strapi.db.query("api::notification.notification").deleteMany({
+      where: {
+        id: {
+          $in: notifications.map((n) => n.id),
+        },
+      },
+    });
+    console.log(
+      `Deleted ${
+        notifications.length
+      } notifications associated with template(s) ${templateIds.join(", ")}`
+    );
+  }
+}

src/extensions/documentation/documentation/1.0.0/full_documentation.json

@@ -14,7 +14,7 @@
       "name": "Apache 2.0",
       "url": "https://www.apache.org/licenses/LICENSE-2.0.html"
     },
-    "x-generation-date": "2025-02-13T15:53:59.140Z"
+    "x-generation-date": "2025-03-07T17:29:38.606Z"
   },
   "x-strapi-config": {
     "path": "/documentation",
@@ -10516,6 +10516,9 @@
                                                                   }
                                                                 }
                                                               },
+                                                              "isReducedBondingPool": {
+                                                                "type": "boolean"
+                                                              },
                                                               "createdAt": {
                                                                 "type": "string",
                                                                 "format": "date-time"
@@ -10565,6 +10568,17 @@
                                                     }
                                                   }
                                                 },
+                                                "isServiceFeeEnabled": {
+                                                  "type": "boolean"
+                                                },
+                                                "isColocated": {
+                                                  "type": "string",
+                                                  "enum": [
+                                                    "Yes",
+                                                    "No",
+                                                    "Partial"
+                                                  ]
+                                                },
                                                 "createdAt": {
                                                   "type": "string",
                                                   "format": "date-time"
@@ -10702,6 +10716,15 @@
                                         }
                                       }
                                     },
+                                    "isWhiteListed": {
+                                      "type": "boolean"
+                                    },
+                                    "isVouched": {
+                                      "type": "boolean"
+                                    },
+                                    "isColocated": {
+                                      "type": "boolean"
+                                    },
                                     "createdAt": {
                                       "type": "string",
                                       "format": "date-time"