@pipedream/google_calendar 0.6.1 → 0.8.0

package/actions/add-attendees-to-event/add-attendees-to-event.mjs

@@ -5,7 +5,7 @@ export default {
   key: "google_calendar-add-attendees-to-event",
   name: "Add Attendees To Event",
   description: "Add attendees to an existing event. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Events.html#update)",
-  version: "0.0.4",
+  version: "0.0.6",
   annotations: {
     destructiveHint: true,
     openWorldHint: true,

package/actions/common/create-event-common.mjs

@@ -82,31 +82,48 @@ export default {
       });
       return timeZone;
     },
-    formatAttendees(selectedAttendees, currentAttendees) {
-      /**
-      * Format for the attendees
-      *
-      * [
-      *   { "email": "lpage@example.com",},
-      *   { "email": "sbrin@example.com",},
-      * ]
-      */
-      let attendees = [];
-      if (typeof selectedAttendees === "string") {
-        selectedAttendees = selectedAttendees.includes("[") && selectedAttendees.includes("]")
-          ? JSON.parse(selectedAttendees)
-          : selectedAttendees.replaceAll(" ", "").split(",");
+    parseEmails(input) {
+      if (typeof input === "string") {
+        return input.split(",")
+          .map((e) => e.trim())
+          .filter(Boolean);
+      }
+      if (Array.isArray(input)) {
+        return input
+          .filter((e) => typeof e === "string")
+          .map((e) => e.trim())
+          .filter(Boolean);
       }
-      if (selectedAttendees && Array.isArray(selectedAttendees)) {
-        attendees = selectedAttendees.map((email) => ({
+      return [];
+    },
+    formatAttendees(selectedAttendees, currentAttendees) {
+      const emails = this.parseEmails(selectedAttendees);
+
+      if (emails.length) {
+        return emails.map((email) => ({
           email,
         }));
-      } else if (currentAttendees && Array.isArray(currentAttendees)) {
-        return currentAttendees.map((attendee) => ({
-          email: attendee.email,
+      }
+
+      // Fall back to currentAttendees if no selectedAttendees
+      const fallbackEmails = this.parseEmails(currentAttendees);
+      if (fallbackEmails.length) {
+        return fallbackEmails.map((email) => ({
+          email,
         }));
       }
-      return attendees;
+
+      // Handle currentAttendees as array of attendee objects
+      if (Array.isArray(currentAttendees) && currentAttendees.length) {
+        return currentAttendees
+          .filter((a) => a && typeof a.email === "string")
+          .map((attendee) => ({
+            email: attendee.email.trim(),
+          }))
+          .filter((a) => a.email);
+      }
+
+      return [];
     },
     checkDateOrDateTimeInput(date, type) {
       if (type === "date") {

package/actions/create-event/create-event.mjs

@@ -7,7 +7,7 @@ export default {
   key: "google_calendar-create-event",
   name: "Create Event",
   description: "Create an event in a Google Calendar. [See the documentation](https://developers.google.com/calendar/api/v3/reference/events/insert)",
-  version: "0.2.7",
+  version: "1.0.0",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,
@@ -16,68 +16,68 @@ export default {
   type: "action",
   props: {
     googleCalendar,
-    addType: {
-      type: "string",
-      label: "Type of Add",
-      description: "Whether to perform a quick add or a detailed event",
-      options: [
-        {
-          label: "Add Detailed Event",
-          value: "detailed",
-        },
-        {
-          label: "Add Quick Event using Natural Language",
-          value: "quick",
-        },
-      ],
-      reloadProps: true,
-    },
     calendarId: {
       propDefinition: [
         googleCalendar,
         "calendarId",
       ],
     },
-    text: {
-      type: "string",
-      label: "Describe Event",
-      description: "Write a plain text description of event, and Google will parse this string to create the event. eg. 'Meet with Michael 10am 7/22/2024' or 'Call Sarah at 1:30PM on Friday'",
-      hidden: true,
-    },
     summary: {
       label: "Event Title",
       type: "string",
       description: "Enter a title for the event, (e.g., `My event`)",
+    },
+    eventStartDate: {
+      label: "Event Start Date",
+      type: "string",
+      description: "For all-day events, enter the date in the format `yyyy-mm-dd` (e.g., `2025-01-15`). For events with time, format according to [RFC3339](https://www.rfc-editor.org/rfc/rfc3339.html#section-1): `yyyy-mm-ddThh:mm:ss+01:00` (e.g., `2025-01-15T10:00:00-05:00`). A time zone offset is required unless a time zone is explicitly specified in timeZone.",
+    },
+    eventEndDate: {
+      label: "Event End Date",
+      type: "string",
+      description: "For all-day events, enter the date in the format `yyyy-mm-dd` (e.g., `2025-01-15`). For events with time, format according to [RFC3339](https://www.rfc-editor.org/rfc/rfc3339.html#section-1): `yyyy-mm-ddThh:mm:ss+01:00` (e.g., `2025-01-15T11:00:00-05:00`). A time zone offset is required unless a time zone is explicitly specified in timeZone.",
+    },
+    location: {
+      label: "Event Location",
+      type: "string",
+      description: "Specify the location of the event",
+      optional: true,
+    },
+    description: {
+      label: "Event Description",
+      type: "string",
+      description: "Enter a description for the event",
+      optional: true,
+    },
+    attendees: {
+      label: "Attendees",
+      type: "string[]",
+      description: "An array of email addresses (e.g., `[\"alice@example.com\", \"bob@example.com\"]`)",
       optional: true,
-      hidden: true,
     },
     colorId: {
       propDefinition: [
         googleCalendar,
         "colorId",
       ],
-      hidden: true,
     },
     timeZone: {
       propDefinition: [
         googleCalendar,
         "timeZone",
       ],
-      hidden: true,
     },
     sendUpdates: {
       propDefinition: [
         googleCalendar,
         "sendUpdates",
       ],
-      hidden: true,
     },
     createMeetRoom: {
       type: "boolean",
       label: "Create Meet Room",
       description: "Whether to create a Google Meet room for this event.",
       optional: true,
-      hidden: true,
     },
     visibility: {
       type: "string",
@@ -90,49 +90,45 @@ export default {
         "confidential",
       ],
       optional: true,
-      hidden: true,
+    },
+    repeatFrequency: {
+      type: "string",
+      label: "Repeat Frequency",
+      description: "Select a frequency to make this event repeating",
+      optional: true,
+      options: Object.keys(constants.REPEAT_FREQUENCIES),
+      reloadProps: true,
     },
   },
-  async additionalProps(props) {
-    const isDetailed = this.addType === "detailed";
-
-    props.text.hidden = isDetailed;
-
-    props.summary.hidden = !isDetailed;
-    props.colorId.hidden = !isDetailed;
-    props.timeZone.hidden = !isDetailed;
-    props.sendUpdates.hidden = !isDetailed;
-    props.createMeetRoom.hidden = !isDetailed;
-    props.visibility.hidden = !isDetailed;
-
-    if (isDetailed) {
-      const commonProps = createEventCommon.props({
-        isUpdate: false,
-      });
-      if (this.repeatFrequency) {
-        const frequency = constants.REPEAT_FREQUENCIES[this.repeatFrequency];
-        commonProps.repeatInterval.description = `Enter 1 to "repeat every ${frequency}", enter 2 to "repeat every other ${frequency}", etc. Defaults to 1.`;
-        commonProps.repeatInterval.hidden = !this.repeatFrequency;
-        commonProps.repeatUntil.hidden = !this.repeatFrequency;
-        commonProps.repeatTimes.hidden = !this.repeatFrequency;
-      }
-      return commonProps;
+  async additionalProps() {
+    const props = {};
+    const frequency = constants.REPEAT_FREQUENCIES[this.repeatFrequency];
+    if (frequency) {
+      props.repeatInterval = {
+        type: "integer",
+        label: "Repeat Interval",
+        description: `Enter 1 to "repeat every ${frequency}", enter 2 to "repeat every other ${frequency}", etc. Defaults to 1.`,
+        optional: true,
+      };
+      props.repeatUntil = {
+        type: "string",
+        label: "Repeat Until",
+        description: "The event will repeat only until this date (format: `yyyy-mm-dd`, e.g., `2025-12-31`)",
+        optional: true,
+      };
+      props.repeatTimes = {
+        type: "integer",
+        label: "Repeat How Many Times?",
+        description: "Limit the number of times this event will occur",
+        optional: true,
+      };
     }
-    return {};
+    return props;
   },
   methods: {
     ...createEventCommon.methods,
   },
   async run({ $ }) {
-    if (this.addType === "quick") {
-      const quickResponse = await this.googleCalendar.quickAddEvent({
-        calendarId: this.calendarId,
-        text: this.text,
-      });
-      $.export("$summary", `Successfully added a quick event: "${quickResponse.id}"`);
-      return quickResponse;
-    }
-
     const timeZone = await this.getTimeZone(this.timeZone);
     const attendees = this.formatAttendees(this.attendees);
     const recurrence = this.formatRecurrence({
@@ -142,6 +138,9 @@ export default {
       repeatUntil: this.repeatUntil,
     });
 
+    const trimmedStart = this.eventStartDate?.trim();
+    const trimmedEnd = this.eventEndDate?.trim();
+
     const data = {
       calendarId: this.calendarId,
       sendUpdates: this.sendUpdates,
@@ -150,20 +149,20 @@ export default {
         location: this.location,
         description: this.description,
         start: {
-          date: this.eventStartDate?.length <= 10
-            ? this.eventStartDate
+          date: trimmedStart?.length <= 10
+            ? trimmedStart
             : undefined,
-          dateTime: this.eventStartDate?.length > 10
-            ? this.eventStartDate
+          dateTime: trimmedStart?.length > 10
+            ? trimmedStart
             : undefined,
           timeZone,
         },
         end: {
-          date: this.eventEndDate?.length <= 10
-            ? this.eventEndDate
+          date: trimmedEnd?.length <= 10
+            ? trimmedEnd
             : undefined,
-          dateTime: this.eventEndDate?.length > 10
-            ? this.eventEndDate
+          dateTime: trimmedEnd?.length > 10
+            ? trimmedEnd
             : undefined,
           timeZone,
         },

package/actions/delete-event/delete-event.mjs

@@ -4,7 +4,7 @@ export default {
   key: "google_calendar-delete-event",
   name: "Delete an Event",
   description: "Delete an event from a Google Calendar. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Events.html#delete)",
-  version: "0.1.8",
+  version: "0.1.9",
   annotations: {
     destructiveHint: true,
     openWorldHint: true,

package/actions/get-calendar/get-calendar.mjs

@@ -4,7 +4,7 @@ export default {
   key: "google_calendar-get-calendar",
   name: "Retrieve Calendar Details",
   description: "Retrieve calendar details of a Google Calendar. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Calendars.html#get)",
-  version: "0.1.9",
+  version: "0.1.10",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,

package/actions/get-current-user/get-current-user.mjs

@@ -7,7 +7,7 @@ export default {
   key: "google_calendar-get-current-user",
   name: "Get Current User",
   description: "Retrieve information about the authenticated Google Calendar account, including the primary calendar (summary, timezone, ACL flags), a list of accessible calendars, user-level settings (timezone, locale, week start), and the color palette that controls events and calendars. Ideal for confirming which calendar account is in use, customizing downstream scheduling, or equipping LLMs with the user’s context (timezones, available calendars) prior to creating or updating events. [See the documentation](https://developers.google.com/calendar/api/v3/reference/calendars/get).",
-  version: "0.0.1",
+  version: "0.0.2",
   type: "action",
   annotations: {
     destructiveHint: false,

package/actions/get-date-time/get-date-time.mjs

@@ -0,0 +1,59 @@
+import googleCalendar from "../../google_calendar.app.mjs";
+
+export default {
+  key: "google_calendar-get-date-time",
+  name: "Get Date Time",
+  description: "Get current date and time for use in Google Calendar actions. Useful for agents that need datetime awareness and timezone context before calling other Google Calendar tools.",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    googleCalendar,
+  },
+  async run({ $ }) {
+    const now = new Date();
+
+    // Date in local timezone (YYYY-MM-DD)
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const date = `${year}-${month}-${day}`;
+
+    // Time in local timezone (HH:MM:SS)
+    const time = now.toTimeString().split(" ")[0];
+
+    // Timezone (IANA name)
+    // eslint-disable-next-line no-undef
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+    // Timezone offset (±HH:MM)
+    const tzDate = new Date();
+    const tzDateUTC = new Date(tzDate.toLocaleString("en-US", {
+      timeZone: "UTC",
+    }));
+    const diff = (tzDate - tzDateUTC) / 60000;
+    const hours = Math.floor(Math.abs(diff) / 60);
+    const mins = Math.abs(diff) % 60;
+    const offsetSign = diff >= 0
+      ? "+"
+      : "-";
+    const timezoneOffset = `${offsetSign}${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}`;
+
+    const result = {
+      date,
+      time,
+      timezone,
+      timezoneOffset,
+      timestamp: now.getTime(),
+      isoString: now.toISOString(),
+      rfc3339: `${date}T${time}${timezoneOffset}`,
+    };
+
+    $.export("$summary", `Retrieved current date time: ${date} ${time} (${timezone || ""} ${timezoneOffset})`);
+    return result;
+  },
+};

package/actions/get-event/get-event.mjs

@@ -4,7 +4,7 @@ export default {
   key: "google_calendar-get-event",
   name: "Retrieve Event Details",
   description: "Retrieve event details from Google Calendar. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Events.html#get)",
-  version: "0.1.9",
+  version: "0.1.10",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,

package/actions/list-calendars/list-calendars.mjs

@@ -4,7 +4,7 @@ export default {
   key: "google_calendar-list-calendars",
   name: "List Calendars",
   description: "Retrieve a list of calendars from Google Calendar. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Calendarlist.html#list)",
-  version: "0.1.9",
+  version: "0.1.10",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,

package/actions/list-event-instances/list-event-instances.mjs

@@ -0,0 +1,99 @@
+import googleCalendar from "../../google_calendar.app.mjs";
+import utils from "../../common/utils.mjs";
+
+export default {
+  key: "google_calendar-list-event-instances",
+  name: "List Event Instances",
+  description: "Retrieve instances of a recurring event. [See the documentation](https://developers.google.com/calendar/api/v3/reference/events/instances)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    googleCalendar,
+    calendarId: {
+      propDefinition: [
+        googleCalendar,
+        "calendarId",
+      ],
+    },
+    eventId: {
+      propDefinition: [
+        googleCalendar,
+        "eventId",
+        (c) => ({
+          calendarId: c.calendarId,
+        }),
+      ],
+      description: "The recurring event identifier. Select an event from Google Calendar.",
+    },
+    maxAttendees: {
+      propDefinition: [
+        googleCalendar,
+        "maxAttendees",
+      ],
+    },
+    maxResults: {
+      propDefinition: [
+        googleCalendar,
+        "maxResults",
+      ],
+    },
+    showDeleted: {
+      propDefinition: [
+        googleCalendar,
+        "showDeleted",
+      ],
+    },
+    timeMax: {
+      propDefinition: [
+        googleCalendar,
+        "timeMax",
+      ],
+    },
+    timeMin: {
+      propDefinition: [
+        googleCalendar,
+        "timeMin",
+      ],
+    },
+    timeZone: {
+      propDefinition: [
+        googleCalendar,
+        "timeZone",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const args = utils.filterEmptyValues({
+      calendarId: this.calendarId,
+      eventId: this.eventId,
+      maxAttendees: this.maxAttendees,
+      showDeleted: this.showDeleted,
+      timeMax: this.timeMax,
+      timeMin: this.timeMin,
+      timeZone: this.timeZone,
+    });
+
+    const instances = [];
+    do {
+      const {
+        items, nextPageToken,
+      } = await this.googleCalendar.listEventInstances(args);
+      instances.push(...items);
+      args.pageToken = nextPageToken;
+    } while (args.pageToken && (!this.maxResults || instances.length < this.maxResults));
+    if (instances.length > this.maxResults) {
+      instances.length = this.maxResults;
+    }
+
+    $.export("$summary", `Successfully retrieved ${instances.length} instance${instances.length === 1
+      ? ""
+      : "s"} of recurring event`);
+
+    return instances;
+  },
+};

package/actions/list-events/list-events.mjs

@@ -6,7 +6,7 @@ export default {
   key: "google_calendar-list-events",
   name: "List Events",
   description: "Retrieve a list of event from the Google Calendar. [See the documentation](https://developers.google.com/calendar/api/v3/reference/events/list)",
-  version: "0.0.9",
+  version: "0.0.10",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,

package/actions/query-free-busy-calendars/query-free-busy-calendars.mjs

@@ -4,7 +4,7 @@ export default {
   key: "google_calendar-query-free-busy-calendars",
   name: "Retrieve Free/Busy Calendar Details",
   description: "Retrieve free/busy calendar details from Google Calendar. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Freebusy.html#query)",
-  version: "0.1.9",
+  version: "0.1.10",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,

package/actions/quick-add-event/quick-add-event.mjs

@@ -6,7 +6,7 @@ export default {
   key: "google_calendar-quick-add-event",
   name: "Add Quick Event",
   description: "Create a quick event to the Google Calendar. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Events.html#quickAdd)",
-  version: "0.1.9",
+  version: "0.1.11",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,

package/actions/update-event/update-event.mjs

@@ -6,7 +6,7 @@ export default {
   key: "google_calendar-update-event",
   name: "Update Event",
   description: "Update an event from Google Calendar. [See the documentation](https://googleapis.dev/nodejs/googleapis/latest/calendar/classes/Resource$Events.html#update)",
-  version: "0.0.11",
+  version: "0.0.13",
   annotations: {
     destructiveHint: true,
     openWorldHint: true,

package/actions/update-event-instance/update-event-instance.mjs

@@ -0,0 +1,135 @@
+import googleCalendar from "../../google_calendar.app.mjs";
+import createEventCommon from "../common/create-event-common.mjs";
+
+export default {
+  key: "google_calendar-update-event-instance",
+  name: "Update Event Instance",
+  description: "Update a specific instance of a recurring event. Changes apply only to the selected instance. [See the documentation](https://developers.google.com/calendar/api/v3/reference/events/update)",
+  version: "0.0.2",
+  type: "action",
+  annotations: {
+    destructiveHint: true,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  props: {
+    googleCalendar,
+    calendarId: {
+      propDefinition: [
+        googleCalendar,
+        "calendarId",
+      ],
+    },
+    recurringEventId: {
+      propDefinition: [
+        googleCalendar,
+        "recurringEventId",
+        ({ calendarId }) => ({
+          calendarId,
+        }),
+      ],
+    },
+    instanceId: {
+      propDefinition: [
+        googleCalendar,
+        "instanceId",
+        ({
+          calendarId,
+          recurringEventId,
+        }) => ({
+          calendarId,
+          recurringEventId,
+        }),
+      ],
+    },
+    summary: {
+      label: "Event Title",
+      type: "string",
+      description: "Enter a new title for this instance",
+      optional: true,
+    },
+    eventStartDate: {
+      label: "Event Start Date",
+      type: "string",
+      description: "For all-day events, enter the Event day in the format `yyyy-mm-dd`. For events with time, format according to [RFC3339](https://www.rfc-editor.org/rfc/rfc3339.html#section-1): `yyyy-mm-ddThh:mm:ss+01:00`. A time zone offset is required unless a time zone is explicitly specified in timeZone.",
+      optional: true,
+    },
+    eventEndDate: {
+      label: "Event End Date",
+      type: "string",
+      description: "For all-day events, enter the Event day in the format `yyyy-mm-dd`. For events with time, format according to [RFC3339](https://www.rfc-editor.org/rfc/rfc3339.html#section-1): `yyyy-mm-ddThh:mm:ss+01:00`. A time zone offset is required unless a time zone is explicitly specified in timeZone.",
+      optional: true,
+    },
+    location: {
+      label: "Event Location",
+      type: "string",
+      description: "Specify a new location for this instance",
+      optional: true,
+    },
+    description: {
+      label: "Event Description",
+      type: "string",
+      description: "Enter a new description for this instance",
+      optional: true,
+    },
+    attendees: {
+      label: "Attendees",
+      type: "string",
+      description: "Enter either an array or a comma separated list of email addresses of attendees",
+      optional: true,
+    },
+    colorId: {
+      propDefinition: [
+        googleCalendar,
+        "colorId",
+      ],
+    },
+    timeZone: {
+      propDefinition: [
+        googleCalendar,
+        "timeZone",
+      ],
+    },
+    sendUpdates: {
+      propDefinition: [
+        googleCalendar,
+        "sendUpdates",
+      ],
+    },
+  },
+  methods: createEventCommon.methods,
+  async run({ $ }) {
+    const currentEvent = await this.googleCalendar.getEvent({
+      calendarId: this.calendarId,
+      eventId: this.instanceId,
+    });
+
+    const timeZone = await this.getTimeZone(this.timeZone || currentEvent.start.timeZone);
+    const attendees = this.formatAttendees(this.attendees, currentEvent.attendees);
+
+    const response = await this.googleCalendar.updateEvent({
+      calendarId: this.calendarId,
+      eventId: this.instanceId,
+      sendUpdates: this.sendUpdates,
+      requestBody: {
+        summary: this.summary || currentEvent.summary,
+        location: this.location || currentEvent.location,
+        description: this.description || currentEvent.description,
+        start: this.getDateParam({
+          date: this.eventStartDate || currentEvent.start.dateTime || currentEvent.start.date,
+          timeZone: timeZone || currentEvent.start.timeZone,
+        }),
+        end: this.getDateParam({
+          date: this.eventEndDate || currentEvent.end.dateTime || currentEvent.end.date,
+          timeZone: timeZone || currentEvent.end.timeZone,
+        }),
+        attendees,
+        colorId: this.colorId || currentEvent.colorId,
+      },
+    });
+
+    $.export("$summary", `Successfully updated event instance \`${response.id}\``);
+
+    return response;
+  },
+};

package/actions/update-following-instances/update-following-instances.mjs

@@ -0,0 +1,259 @@
+import googleCalendar from "../../google_calendar.app.mjs";
+import createEventCommon from "../common/create-event-common.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  key: "google_calendar-update-following-instances",
+  name: "Update Following Event Instances",
+  description: "Update all instances of a recurring event following a specific instance. This creates a new recurring event starting from the selected instance. [See the documentation](https://developers.google.com/calendar/api/guides/recurringevents#modifying_all_following_instances)",
+  version: "0.0.2",
+  type: "action",
+  annotations: {
+    destructiveHint: true,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  props: {
+    googleCalendar,
+    calendarId: {
+      propDefinition: [
+        googleCalendar,
+        "calendarId",
+      ],
+    },
+    recurringEventId: {
+      propDefinition: [
+        googleCalendar,
+        "recurringEventId",
+        ({ calendarId }) => ({
+          calendarId,
+        }),
+      ],
+    },
+    instanceId: {
+      propDefinition: [
+        googleCalendar,
+        "instanceId",
+        ({
+          calendarId,
+          recurringEventId,
+        }) => ({
+          calendarId,
+          recurringEventId,
+        }),
+      ],
+      description: "The instance where the split will occur. All instances from this point forward will be updated with your changes, while earlier instances remain unchanged. For example, selecting the 4th instance will keep instances 1-3 as-is and update instances 4 onwards.",
+    },
+    summary: {
+      label: "Event Title",
+      type: "string",
+      description: "Enter a new title for all following instances",
+      optional: true,
+    },
+    eventStartDate: {
+      label: "Event Start Date",
+      type: "string",
+      description: "For all-day events, enter the Event day in the format `yyyy-mm-dd`. For events with time, format according to [RFC3339](https://www.rfc-editor.org/rfc/rfc3339.html#section-1): `yyyy-mm-ddThh:mm:ss+01:00`. A time zone offset is required unless a time zone is explicitly specified in timeZone.",
+      optional: true,
+    },
+    eventEndDate: {
+      label: "Event End Date",
+      type: "string",
+      description: "For all-day events, enter the Event day in the format `yyyy-mm-dd`. For events with time, format according to [RFC3339](https://www.rfc-editor.org/rfc/rfc3339.html#section-1): `yyyy-mm-ddThh:mm:ss+01:00`. A time zone offset is required unless a time zone is explicitly specified in timeZone.",
+      optional: true,
+    },
+    location: {
+      label: "Event Location",
+      type: "string",
+      description: "Specify a new location for all following instances",
+      optional: true,
+    },
+    description: {
+      label: "Event Description",
+      type: "string",
+      description: "Enter a new description for all following instances",
+      optional: true,
+    },
+    attendees: {
+      label: "Attendees",
+      type: "string",
+      description: "Enter either an array or a comma separated list of email addresses of attendees",
+      optional: true,
+    },
+    repeatFrequency: {
+      type: "string",
+      label: "New Repeat Frequency",
+      description: "Optionally change the repeat frequency for following instances",
+      optional: true,
+      options: Object.keys(constants.REPEAT_FREQUENCIES),
+      reloadProps: true,
+    },
+    repeatInterval: {
+      type: "integer",
+      label: "Repeat Interval",
+      description: "Repeat interval (e.g., 1 for every day, 2 for every other day)",
+      optional: true,
+      hidden: true,
+    },
+    repeatUntil: {
+      type: "string",
+      label: "Repeat Until",
+      description: "The event will repeat only until this date (format: yyyy-mm-dd)",
+      optional: true,
+      hidden: true,
+    },
+    repeatTimes: {
+      type: "integer",
+      label: "Number of Occurrences",
+      description: "Limit the number of times this event will occur",
+      optional: true,
+      hidden: true,
+    },
+    colorId: {
+      propDefinition: [
+        googleCalendar,
+        "colorId",
+      ],
+    },
+    timeZone: {
+      propDefinition: [
+        googleCalendar,
+        "timeZone",
+      ],
+    },
+    sendUpdates: {
+      propDefinition: [
+        googleCalendar,
+        "sendUpdates",
+      ],
+    },
+  },
+  async additionalProps(props) {
+    if (this.repeatFrequency) {
+      const frequency = constants.REPEAT_FREQUENCIES[this.repeatFrequency];
+      props.repeatInterval.description = `Enter 1 to "repeat every ${frequency}", enter 2 to "repeat every other ${frequency}", etc. Defaults to 1.`;
+    }
+    props.repeatInterval.hidden = !this.repeatFrequency;
+    props.repeatUntil.hidden = !this.repeatFrequency;
+    props.repeatTimes.hidden = !this.repeatFrequency;
+    return {};
+  },
+  methods: {
+    ...createEventCommon.methods,
+    calculateUntilDate(instanceStartDate) {
+      // Calculate UNTIL date (one second before the instance start)
+      // Format: YYYYMMDDTHHMMSSZ (UTC)
+      const targetDate = new Date(instanceStartDate);
+      targetDate.setSeconds(targetDate.getSeconds() - 1);
+
+      const year = targetDate.getUTCFullYear();
+      const month = String(targetDate.getUTCMonth() + 1).padStart(2, "0");
+      const day = String(targetDate.getUTCDate()).padStart(2, "0");
+      const hours = String(targetDate.getUTCHours()).padStart(2, "0");
+      const minutes = String(targetDate.getUTCMinutes()).padStart(2, "0");
+      const seconds = String(targetDate.getUTCSeconds()).padStart(2, "0");
+
+      return `${year}${month}${day}T${hours}${minutes}${seconds}Z`;
+    },
+    modifyRecurrenceRule(recurrenceArray, untilDate) {
+      // Modify the RRULE to add/update UNTIL parameter
+      if (!recurrenceArray || !recurrenceArray.length) {
+        return recurrenceArray;
+      }
+
+      return recurrenceArray.map((rule) => {
+        if (!rule.startsWith("RRULE:")) {
+          return rule;
+        }
+
+        // Remove existing UNTIL or COUNT if present
+        let modifiedRule = rule.replace(/;UNTIL=[^;]+/g, "").replace(/;COUNT=[^;]+/g, "");
+
+        // Add new UNTIL
+        return `${modifiedRule};UNTIL=${untilDate}`;
+      });
+    },
+  },
+  async run({ $ }) {
+    // Step 1: Get the original recurring event
+    const originalEvent = await this.googleCalendar.getEvent({
+      calendarId: this.calendarId,
+      eventId: this.recurringEventId,
+    });
+
+    // Step 2: Get the target instance
+    const targetInstance = await this.googleCalendar.getEvent({
+      calendarId: this.calendarId,
+      eventId: this.instanceId,
+    });
+
+    // Calculate UNTIL date (one second before the target instance)
+    const instanceStartDate = targetInstance.start.dateTime || targetInstance.start.date;
+    const untilDate = this.calculateUntilDate(instanceStartDate);
+
+    // Step 3: Trim the original recurring event
+    const trimmedRecurrence = this.modifyRecurrenceRule(
+      originalEvent.recurrence,
+      untilDate,
+    );
+
+    await this.googleCalendar.updateEvent({
+      calendarId: this.calendarId,
+      eventId: this.recurringEventId,
+      sendUpdates: this.sendUpdates,
+      requestBody: {
+        ...originalEvent,
+        recurrence: trimmedRecurrence,
+      },
+    });
+
+    // Step 4: Create new recurring event with changes
+    const timeZone = await this.getTimeZone(this.timeZone || targetInstance.start.timeZone);
+    const attendees = this.formatAttendees(this.attendees, originalEvent.attendees);
+
+    // Determine recurrence for new event
+    let newRecurrence;
+    if (this.repeatFrequency) {
+      newRecurrence = this.formatRecurrence({
+        repeatFrequency: this.repeatFrequency,
+        repeatInterval: this.repeatInterval,
+        repeatTimes: this.repeatTimes,
+        repeatUntil: this.repeatUntil,
+      });
+    } else {
+      // Use original recurrence rules
+      newRecurrence = originalEvent.recurrence;
+    }
+
+    const newEvent = await this.googleCalendar.createEvent({
+      calendarId: this.calendarId,
+      sendUpdates: this.sendUpdates,
+      resource: {
+        summary: this.summary || originalEvent.summary,
+        location: this.location || originalEvent.location,
+        description: this.description || originalEvent.description,
+        start: this.getDateParam({
+          date: this.eventStartDate || instanceStartDate,
+          timeZone: timeZone || targetInstance.start.timeZone,
+        }),
+        end: this.getDateParam({
+          date: this.eventEndDate || targetInstance.end.dateTime || targetInstance.end.date,
+          timeZone: timeZone || targetInstance.end.timeZone,
+        }),
+        recurrence: newRecurrence,
+        attendees,
+        colorId: this.colorId || originalEvent.colorId,
+      },
+    });
+
+    $.export("$summary", `Successfully split recurring event. Original trimmed, new event created with ID: \`${newEvent.id}\``);
+
+    return {
+      originalEvent: {
+        id: this.recurringEventId,
+        trimmedRecurrence,
+      },
+      newEvent,
+    };
+  },
+};

package/google_calendar.app.mjs

@@ -278,6 +278,72 @@ export default {
         "workingLocation",
       ],
     },
+    recurringEventId: {
+      label: "Recurring Event ID",
+      type: "string",
+      description: "The ID of the recurring event",
+      async options({ calendarId }) {
+        const monthAgo = new Date(new Date().setMonth(new Date().getMonth() - 1)).toISOString();
+        const response = await this.listEvents({
+          calendarId,
+          maxResults: 100,
+          timeMin: monthAgo,
+        });
+        const recurringEvents = response.items.filter((item) => item.recurrence);
+        const options = recurringEvents.map((item) => {
+          let label = item.summary || item.id;
+          const date = item.start && (item.start.date
+            ? item.start.date
+            : item.start.dateTime.slice(0, 10));
+          if (date) {
+            label += ` - ${date}`;
+          }
+          return {
+            label,
+            value: item.id,
+          };
+        });
+        return options.reverse();
+      },
+    },
+    instanceId: {
+      label: "Event Instance ID",
+      type: "string",
+      description: "The ID of the specific instance to update. Use List Event Instances action to get instance IDs.",
+      async options({
+        calendarId, recurringEventId,
+      }) {
+        if (!recurringEventId) {
+          return [];
+        }
+        const response = await this.listEventInstances({
+          calendarId,
+          eventId: recurringEventId,
+          maxResults: 50,
+          timeMin: new Date().toISOString(),
+        });
+        const options = response.items.map((item) => {
+          let label = item.summary || item.id;
+          const date = item.start && (item.start.date
+            ? item.start.date
+            : item.start.dateTime.slice(0, 10));
+          const time = item.start?.dateTime
+            ? item.start.dateTime.slice(11, 16)
+            : "";
+          if (date) {
+            label += ` - ${date}`;
+          }
+          if (time) {
+            label += ` ${time}`;
+          }
+          return {
+            label,
+            value: item.id,
+          };
+        });
+        return options;
+      },
+    },
   },
   methods: {
     _tokens() {
@@ -502,5 +568,12 @@ export default {
         args,
       });
     },
+    async listEventInstances(args = {}) {
+      return this.requestHandler({
+        api: constants.API.EVENTS.NAME,
+        method: constants.API.EVENTS.METHOD.INSTANCES,
+        args,
+      });
+    },
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/google_calendar",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Pipedream Google_calendar Components",
   "main": "google_calendar.app.mjs",
   "keywords": [

package/sources/event-cancelled/event-cancelled.mjs

@@ -6,7 +6,7 @@ export default {
   key: "google_calendar-event-cancelled",
   name: "New Cancelled Event",
   description: "Emit new event when a Google Calendar event is cancelled or deleted",
-  version: "0.1.11",
+  version: "0.1.12",
   type: "source",
   dedupe: "unique",
   props: {

package/sources/event-ended/event-ended.mjs

@@ -6,7 +6,7 @@ export default {
   key: "google_calendar-event-ended",
   name: "New Ended Event",
   description: "Emit new event when a Google Calendar event ends",
-  version: "0.1.11",
+  version: "0.1.12",
   type: "source",
   dedupe: "unique",
   props: {

package/sources/new-calendar/new-calendar.mjs

@@ -5,7 +5,7 @@ export default {
   key: "google_calendar-new-calendar",
   name: "New Calendar Created",
   description: "Emit new event when a calendar is created.",
-  version: "0.1.11",
+  version: "0.1.12",
   type: "source",
   dedupe: "unique",
   props: {

package/sources/new-event-search/new-event-search.mjs

@@ -5,7 +5,7 @@ export default {
   key: "google_calendar-new-event-search",
   name: "New Event Matching a Search",
   description: "Emit new event when a Google Calendar event is created that matches a search",
-  version: "0.1.11",
+  version: "0.1.12",
   type: "source",
   dedupe: "unique",
   props: {

package/sources/new-or-updated-event-instant/new-or-updated-event-instant.mjs

@@ -8,7 +8,7 @@ export default {
   type: "source",
   name: "New Created or Updated Event (Instant)",
   description: "Emit new event when a Google Calendar events is created or updated (does not emit cancelled events)",
-  version: "0.1.16",
+  version: "0.1.17",
   dedupe: "unique",
   props: {
     googleCalendar,

package/sources/upcoming-event-alert/upcoming-event-alert.mjs

@@ -6,7 +6,7 @@ export default {
   key: "google_calendar-upcoming-event-alert",
   name: "New Upcoming Event Alert",
   description: "Emit new event based on a time interval before an upcoming event in the calendar.",
-  version: "0.1.1",
+  version: "0.1.2",
   type: "source",
   props: {
     googleCalendar,

package/sources/upcoming-event-alert-polling/upcoming-event-alert-polling.mjs

@@ -6,7 +6,7 @@ export default {
   key: "google_calendar-upcoming-event-alert-polling",
   name: "New Upcoming Event Alert (Polling)",
   description: "Emit new event based on a time interval before an upcoming event in the calendar. [See the documentation](https://developers.google.com/calendar/api/v3/reference/events/list)",
-  version: "0.0.1",
+  version: "0.0.2",
   type: "source",
   dedupe: "unique",
   props: {