fix: Add functionality for creating recurring events

src/constants.ts

@@ -529,8 +529,16 @@ export const REDIS_PASSWORD = process.env.REDIS_PASSWORD;
 
 export const MILLISECONDS_IN_A_WEEK = 7 * 24 * 60 * 60 * 1000;
 
-export const RECURRING_EVENT_INSTANCES_MONTH_LIMIT = 6;
+// recurring event frequencies
 export const RECURRENCE_FREQUENCIES = ["YEARLY", "MONTHLY", "WEEKLY", "DAILY"];
+
+// recurring instance generation date limit in years based on it's frequency
+export const RECURRING_EVENT_INSTANCES_DAILY_LIMIT = 1;
+export const RECURRING_EVENT_INSTANCES_WEEKLY_LIMIT = 2;
+export const RECURRING_EVENT_INSTANCES_MONTHLY_LIMIT = 5;
+export const RECURRING_EVENT_INSTANCES_YEARLY_LIMIT = 10;
+
+// recurring event days
 export const RECURRENCE_WEEKDAYS = [
   "MONDAY",
   "TUESDAY",

src/helpers/event/createEventHelpers/createRecurringEvent.ts

@@ -8,7 +8,6 @@ import {
   createRecurrenceRule,
   generateRecurringEventInstances,
 } from "../recurringEventHelpers";
-import { convertToUTCDate } from "../../../utilities/convertToUTCDate";
 
 /**
  * This function creates the instances of a recurring event upto a certain date.
@@ -49,20 +48,14 @@ export const createRecurringEvent = async (
     data?.endDate
   );
 
-  const convertedStartDate = convertToUTCDate(data.startDate);
-  let convertedEndDate = null;
-  if (data.endDate) {
-    convertedEndDate = convertToUTCDate(data.endDate);
-  }
-
   // create a base recurring event first, based on which all the
   // recurring instances would be dynamically generated
   const baseRecurringEvent = await Event.create(
     [
       {
         ...data,
-        startDate: convertedStartDate,
-        endDate: convertedEndDate,
+        startDate: data.startDate,
+        endDate: data.endDate,
         recurring: true,
         isBaseRecurringEvent: true,
         creatorId: currentUserId,
@@ -75,18 +68,20 @@ export const createRecurringEvent = async (
 
   // get the dates for the recurringInstances, and the date of the last instance
   // to be generated in this operation (rest would be generated dynamically during query)
-  const [recurringInstanceDates, latestInstanceDate] =
-    getRecurringInstanceDates(
-      recurrenceRuleString,
-      convertedStartDate,
-      convertedEndDate
-    );
+  const recurringInstanceDates = getRecurringInstanceDates(
+    recurrenceRuleString,
+    data.startDate,
+    data.endDate
+  );
 
+  // get the date for the latest created instance
+  const latestInstanceDate =
+    recurringInstanceDates[recurringInstanceDates.length - 1];
   // create a recurrenceRule document that would contain the recurrence pattern
   const recurrenceRule = await createRecurrenceRule(
     recurrenceRuleString,
-    convertedStartDate,
-    convertedEndDate,
+    data.startDate,
+    data.endDate,
     organizationId.toString(),
     baseRecurringEvent[0]?._id.toString(),
     latestInstanceDate,

src/helpers/event/recurringEventHelpers/generateRecurrenceRuleString.ts

@@ -1,14 +1,15 @@
 import { format } from "date-fns";
 import type { RecurrenceRuleInput } from "../../../types/generatedGraphQLTypes";
+import { adjustForTimezoneOffset } from "../../../utilities/recurrenceDatesUtil";
 
 /**
  * This function generates the recurrence rule (rrule) string.
  * @param recurrenceRuleData - the recurrenceRuleInput provided in the args.
  * @param recurrenceStartDate - start date of recurrence.
  * @param recurrenceEndDate - end date of recurrence.
  * @remarks The following steps are followed:
- * 1. Initiate an empty recurrenceRule string.
- * 2. Add the recurrence rules one by one.
+ * 1. Adjust the start and end dates of recurrence for timezone offsets.
+ * 2. Get the recurrence rules and make a recurrenceRuleString.
  * @returns The recurrence rule string that would be used to create a valid rrule object.
  */
 
@@ -17,21 +18,39 @@ export const generateRecurrenceRuleString = (
   recurrenceStartDate: Date,
   recurrenceEndDate?: Date
 ): string => {
-  // destructure the rules
-  const { frequency, count, weekDays } = recurrenceRuleData;
+  // adjust the dates according to the timezone offset
+  recurrenceStartDate = adjustForTimezoneOffset(recurrenceStartDate);
+  if (recurrenceEndDate) {
+    recurrenceEndDate = adjustForTimezoneOffset(recurrenceEndDate);
+  }
 
   // recurrence start date
   // (not necessarily the start date of the first recurring instance)
-  const formattedRecurrenceStartDate = format(
+  let formattedRecurrenceStartDate = format(
     recurrenceStartDate,
     "yyyyMMdd'T'HHmmss'Z'"
   );
 
+  // format it to be UTC midnight
+  formattedRecurrenceStartDate = formattedRecurrenceStartDate.replace(
+    /T\d{6}Z/,
+    "T000000Z"
+  );
+
   // date upto which instances would be generated
-  const formattedRecurrenceEndDate = recurrenceEndDate
+  let formattedRecurrenceEndDate = recurrenceEndDate
     ? format(recurrenceEndDate, "yyyyMMdd'T'HHmmss'Z'")
     : "";
 
+  // format it to be UTC midnight
+  formattedRecurrenceEndDate = formattedRecurrenceEndDate.replace(
+    /T\d{6}Z/,
+    "T000000Z"
+  );
+
+  // destructure the recurrence rules
+  const { frequency, count, weekDays } = recurrenceRuleData;
+
   // string representing the days of the week the event would recur
   const weekDaysString = weekDays?.length ? weekDays.join(",") : "";
 

src/helpers/event/recurringEventHelpers/generateRecurringEventInstances.ts

@@ -1,5 +1,4 @@
 import type mongoose from "mongoose";
-import { format } from "date-fns";
 import type { InterfaceEvent } from "../../../models";
 import { Event, EventAttendee, User } from "../../../models";
 import type { EventInput } from "../../../types/generatedGraphQLTypes";
@@ -51,12 +50,10 @@ export const generateRecurringEventInstances = async ({
 }: InterfaceGenerateRecurringInstances): Promise<InterfaceEvent> => {
   const recurringInstances: InterfaceRecurringEvent[] = [];
   recurringInstanceDates.map((date) => {
-    const formattedInstanceDate = format(date, "yyyy-MM-dd");
-
     const createdEventInstance = {
       ...data,
-      startDate: formattedInstanceDate,
-      endDate: formattedInstanceDate,
+      startDate: date,
+      endDate: date,
       recurring: true,
       isBaseRecurringEvent: false,
       recurrenceRuleId,

src/helpers/event/recurringEventHelpers/getRecurringInstanceDates.ts

@@ -1,49 +1,74 @@
-import { addMonths } from "date-fns";
-import { rrulestr } from "rrule";
-import { RECURRING_EVENT_INSTANCES_MONTH_LIMIT } from "../../../constants";
+import { addYears } from "date-fns";
+import { Frequency, rrulestr } from "rrule";
+import type { RRule } from "rrule";
+import {
+  RECURRING_EVENT_INSTANCES_DAILY_LIMIT,
+  RECURRING_EVENT_INSTANCES_WEEKLY_LIMIT,
+  RECURRING_EVENT_INSTANCES_MONTHLY_LIMIT,
+  RECURRING_EVENT_INSTANCES_YEARLY_LIMIT,
+} from "../../../constants";
 
 /**
  * This function generates the dates of recurrence for the recurring event.
  * @param recurrenceRuleString - the rrule string for the recurrenceRule.
  * @param recurrenceStartDate - the starting date from which we want to generate instances.
  * @param eventEndDate - the end date of the event
- * @param calendarDate - the last date of the current calendar month (To be used during query).
+ * @param calendarDate - the calendar date (To be used for dynamic instance generation during queries).
  * @remarks The following steps are followed:
- * 1. Limit the end date for instance creation.
- * 2. Getting the date upto which we would generate instances during this operation (leaving the rest for dynamic generation).
- * 3. Getting the dates for recurring instances.
- * @returns The recurring instance dates and the date of last instance generated during this operation.
+ * 1. Get the date limit for instance generation based on its recurrence frequency.
+ * 2. Get the dates for recurring event instances.
+ * @returns Dates for recurring instances to be generated during this operation.
  */
 
 export function getRecurringInstanceDates(
   recurrenceRuleString: string,
   recurrenceStartDate: Date,
   eventEndDate: Date | null,
   calendarDate: Date = recurrenceStartDate
-): [Date[], Date] {
-  const limitEndDate = addMonths(
+): Date[] {
+  // get the rrule object
+  const recurrenceRuleObject: RRule = rrulestr(recurrenceRuleString);
+
+  // get the recurrence frequency
+  const { freq: recurrenceFrequency } = recurrenceRuleObject.options;
+
+  // set limitEndDate according to the recurrence frequency
+  let limitEndDate = addYears(
     calendarDate,
-    RECURRING_EVENT_INSTANCES_MONTH_LIMIT
-    // generate instances upto this many months ahead
-    // leave the rest for dynamic generation during queries
+    RECURRING_EVENT_INSTANCES_DAILY_LIMIT
   );
 
+  if (recurrenceFrequency === Frequency.WEEKLY) {
+    limitEndDate = addYears(
+      calendarDate,
+      RECURRING_EVENT_INSTANCES_WEEKLY_LIMIT
+    );
+  } else if (recurrenceFrequency === Frequency.MONTHLY) {
+    limitEndDate = addYears(
+      calendarDate,
+      RECURRING_EVENT_INSTANCES_MONTHLY_LIMIT
+    );
+  } else if (recurrenceFrequency === Frequency.YEARLY) {
+    limitEndDate = addYears(
+      calendarDate,
+      RECURRING_EVENT_INSTANCES_YEARLY_LIMIT
+    );
+  }
+
+  // if the event has no endDate
   eventEndDate = eventEndDate || limitEndDate;
 
+  // the date upto which we would generate the instances in this operation
   const generateUptoDate = new Date(
     Math.min(eventEndDate.getTime(), limitEndDate.getTime())
   );
 
-  const recurrenceRuleObject = rrulestr(recurrenceRuleString);
-
+  // get the dates of recurrence
   const recurringInstanceDates = recurrenceRuleObject.between(
     recurrenceStartDate,
     generateUptoDate,
     true
   );
 
-  const latestInstanceDate =
-    recurringInstanceDates[recurringInstanceDates.length - 1];
-
-  return [recurringInstanceDates, latestInstanceDate];
+  return recurringInstanceDates;
 }

src/resolvers/Mutation/createEvent.ts

@@ -126,10 +126,13 @@ export const createEvent: MutationResolvers["createEvent"] = async (
     );
   }
 
+  /* c8 ignore start */
   if (session) {
+    // start a transaction
     session.startTransaction();
   }
 
+  /* c8 ignore stop */
   try {
     let createdEvent: InterfaceEvent;
 
@@ -151,16 +154,23 @@ export const createEvent: MutationResolvers["createEvent"] = async (
       );
     }
 
+    /* c8 ignore start */
     if (session) {
+      // commit transaction if everything's successful
       await session.commitTransaction();
     }
 
-    // Returns the createdEvent.
+    /* c8 ignore stop */
     return createdEvent;
   } catch (error) {
+    /* c8 ignore start */
     if (session) {
+      // abort transaction if something fails
       await session.abortTransaction();
     }
+
     throw error;
   }
+
+  /* c8 ignore stop */
 };

src/utilities/convertToUTCDate.ts → src/utilities/recurrenceDatesUtil.ts

@@ -14,3 +14,20 @@ export const convertToUTCDate = (date: Date): Date => {
 
   return utcMidnight;
 };
+
+/**
+ * This function adjusts for the timezone offset.
+ * @param date - the date to be adjusted.
+ * @returns adjusted date.
+ */
+export const adjustForTimezoneOffset = (date: Date): Date => {
+  const timeZoneOffset = new Date().getTimezoneOffset();
+
+  /* c8 ignore start */
+  if (timeZoneOffset > 0) {
+    date = new Date(date.getTime() + timeZoneOffset * 60 * 1000);
+  }
+
+  /* c8 ignore stop */
+  return date;
+};