@guayaba/workflow-piece-google-calendar 0.9.1

package/src/lib/triggers/event-ends.ts

@@ -0,0 +1,201 @@
+import {
+  AppConnectionValueForAuthProperty,
+  createTrigger,
+  Property,
+} from '@guayaba/workflows-framework';
+import { TriggerStrategy } from '@guayaba/workflows-framework';
+import { googleCalendarCommon, googleCalendarAuth, getAccessToken } from '../common';
+import { GoogleCalendarEvent } from '../common/types';
+import {
+  DedupeStrategy,
+  Polling,
+  pollingHelper,
+} from '@guayaba/workflows-common';
+import {
+  AuthenticationType,
+  httpClient,
+  HttpMethod,
+  HttpRequest,
+} from '@guayaba/workflows-common';
+
+interface GoogleCalendarEventList {
+  items: GoogleCalendarEvent[];
+}
+
+const polling: Polling<
+  AppConnectionValueForAuthProperty<typeof googleCalendarAuth>,
+  {
+    calendar_id: string | undefined;
+    specific_event: boolean | undefined;
+    event_id: string | undefined;
+  }
+> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue, lastFetchEpochMS }) => {
+    if (lastFetchEpochMS === 0) {
+      return [];
+    }
+
+    const { calendar_id: calendarId, specific_event, event_id } = propsValue;
+
+    if (!calendarId) {
+      return [];
+    }
+
+    if (specific_event && !event_id) {
+      return [];
+    }
+
+    let events: GoogleCalendarEvent[] = [];
+
+    if (specific_event && event_id) {
+      const eventRequest: HttpRequest = {
+        method: HttpMethod.GET,
+        url: `${googleCalendarCommon.baseUrl}/calendars/${calendarId}/events/${event_id}`,
+        authentication: {
+          type: AuthenticationType.BEARER_TOKEN,
+          token: await getAccessToken(auth),
+        },
+      };
+
+      try {
+        const eventResponse = await httpClient.sendRequest<GoogleCalendarEvent>(
+          eventRequest
+        );
+        const event = eventResponse.body;
+
+        const endTimeString = event.end?.dateTime ?? event.end?.date;
+        if (endTimeString) {
+          const endTime = new Date(endTimeString).getTime();
+          if (endTime > lastFetchEpochMS) {
+            events = [event];
+          }
+        }
+      } catch (error) {
+        console.error('Error fetching specific event:', error);
+        return [];
+      }
+    } else {
+      const request: HttpRequest = {
+        method: HttpMethod.GET,
+        url: `${googleCalendarCommon.baseUrl}/calendars/${calendarId}/events`,
+        authentication: {
+          type: AuthenticationType.BEARER_TOKEN,
+          token: await getAccessToken(auth),
+        },
+        queryParams: {
+          singleEvents: 'true',
+          orderBy: 'startTime',
+          timeMin: new Date(lastFetchEpochMS).toISOString(),
+        },
+      };
+
+      const response = await httpClient.sendRequest<GoogleCalendarEventList>(
+        request
+      );
+      events = response.body.items;
+    }
+    const endedEvents: {
+      epochMilliSeconds: number;
+      data: GoogleCalendarEvent;
+    }[] = [];
+    const now = Date.now();
+
+    for (const event of events) {
+      const endTimeString = event.end?.dateTime ?? event.end?.date;
+      if (!endTimeString) continue;
+
+      const endTime = new Date(endTimeString).getTime();
+
+      if (endTime > lastFetchEpochMS && endTime <= now) {
+        endedEvents.push({
+          epochMilliSeconds: endTime,
+          data: event,
+        });
+      }
+    }
+
+    return endedEvents;
+  },
+};
+
+export const eventEnds = createTrigger({
+  auth: googleCalendarAuth,
+  name: 'event_ends',
+  displayName: 'Event Ends',
+  description: 'Fires when an event ends.',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    specific_event: Property.Checkbox({
+      displayName: 'Target Specific Event',
+      description:
+        'Enable to monitor a specific event instead of all events in the calendar.',
+      required: false,
+      defaultValue: false,
+    }),
+    event_id: googleCalendarCommon.eventDropdown(false),
+  },
+  type: TriggerStrategy.POLLING,
+  sampleData: {
+    kind: 'calendar#event',
+    etag: '"3419997894982000"',
+    id: 'sample_event_id_67890',
+    status: 'confirmed',
+    htmlLink:
+      'https://www.google.com/calendar/event?eid=c2FtcGxlX2V2ZW50X2lkXzY3ODkw',
+    created: '2025-08-14T09:00:00.000Z',
+    updated: '2025-08-14T09:00:00.000Z',
+    summary: 'Project Deadline',
+    creator: { email: 'manager@example.com' },
+    organizer: {
+      email: 'manager@example.com',
+      self: true,
+    },
+    start: {
+      dateTime: '2025-08-14T14:30:00+05:30',
+      timeZone: 'Asia/Kolkata',
+    },
+    end: {
+      dateTime: '2025-08-14T15:30:00+05:30',
+      timeZone: 'Asia/Kolkata',
+    },
+    iCalUID: 'sample_event_id_67890@google.com',
+    sequence: 0,
+    reminders: { useDefault: true },
+    eventType: 'default',
+  },
+
+  async onEnable(context) {
+    await pollingHelper.onEnable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+
+  async onDisable(context) {
+    await pollingHelper.onDisable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+
+  async run(context) {
+    return await pollingHelper.poll(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+      files: context.files,
+    });
+  },
+
+  async test(context) {
+    return await pollingHelper.test(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+      files: context.files,
+    });
+  },
+});

package/src/lib/triggers/event-start-time-before.ts

@@ -0,0 +1,201 @@
+import {
+  AppConnectionValueForAuthProperty,
+  createTrigger,
+  PiecePropValueSchema,
+  Property,
+} from '@guayaba/workflows-framework';
+import { TriggerStrategy } from '@guayaba/workflows-framework';
+import { googleCalendarCommon, googleCalendarAuth, getAccessToken } from '../common';
+import { GoogleCalendarEvent } from '../common/types';
+import {
+  DedupeStrategy,
+  Polling,
+  pollingHelper,
+} from '@guayaba/workflows-common';
+import {
+  AuthenticationType,
+  httpClient,
+  HttpMethod,
+  HttpRequest,
+} from '@guayaba/workflows-common';
+
+interface GoogleCalendarEventList {
+  items: GoogleCalendarEvent[];
+}
+
+const polling: Polling<
+  AppConnectionValueForAuthProperty<typeof googleCalendarAuth>,
+  {
+    calendar_id: string | undefined;
+    specific_event: boolean | undefined;
+    event_id: string | undefined;
+    time_value: number | undefined;
+    time_unit: string | undefined;
+  }
+> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue }) => {
+    const { calendar_id, specific_event, event_id, time_value, time_unit } =
+      propsValue;
+
+    if (!calendar_id || !time_value || !time_unit) {
+      return [];
+    }
+
+    if (specific_event && !event_id) {
+      return [];
+    }
+
+    let offset_ms = time_value * 60 * 1000;
+    if (time_unit === 'hours') {
+      offset_ms = time_value * 60 * 60 * 1000;
+    } else if (time_unit === 'days') {
+      offset_ms = time_value * 24 * 60 * 60 * 1000;
+    }
+
+    const now = Date.now();
+
+    const pollingIntervalMs = 5 * 60 * 1000;
+
+    const timeMin = new Date(now + offset_ms).toISOString();
+    const timeMax = new Date(now + offset_ms + pollingIntervalMs).toISOString();
+
+    let events: GoogleCalendarEvent[] = [];
+
+    if (specific_event && event_id) {
+      const eventRequest: HttpRequest = {
+        method: HttpMethod.GET,
+        url: `${googleCalendarCommon.baseUrl}/calendars/${calendar_id}/events/${event_id}`,
+        authentication: {
+          type: AuthenticationType.BEARER_TOKEN,
+          token: await getAccessToken(auth),
+        },
+      };
+
+      try {
+        const eventResponse = await httpClient.sendRequest<GoogleCalendarEvent>(
+          eventRequest
+        );
+        const event = eventResponse.body;
+
+        // Check if this specific event falls within our time window
+        const eventStartTime = new Date(
+          event.start?.dateTime ?? event.start?.date ?? 0
+        ).getTime();
+        const triggerTime = eventStartTime - offset_ms;
+
+        if (triggerTime >= now && triggerTime <= now + pollingIntervalMs) {
+          events = [event];
+        }
+      } catch (error) {
+        console.error('Error fetching specific event:', error);
+        return [];
+      }
+    } else {
+      const request: HttpRequest = {
+        method: HttpMethod.GET,
+        url: `${googleCalendarCommon.baseUrl}/calendars/${calendar_id}/events`,
+        authentication: {
+          type: AuthenticationType.BEARER_TOKEN,
+          token: await getAccessToken(auth),
+        },
+        queryParams: {
+          singleEvents: 'true',
+          orderBy: 'startTime',
+          timeMin: timeMin,
+          timeMax: timeMax,
+        },
+      };
+
+      const response = await httpClient.sendRequest<GoogleCalendarEventList>(
+        request
+      );
+      events = response.body.items;
+    }
+
+    return events.map((event) => {
+      const startTime = new Date(
+        event.start?.dateTime ?? event.start?.date ?? 0
+      ).getTime();
+
+      const triggerTime = startTime - offset_ms;
+      return {
+        epochMilliSeconds: triggerTime,
+        data: event,
+      };
+    });
+  },
+};
+
+export const eventStartTimeBefore = createTrigger({
+  auth: googleCalendarAuth,
+  name: 'event_starts_in',
+  displayName: 'Event Start (Time Before)',
+  description:
+    'Fires at a specified amount of time before an event starts (e.g., a reminder).',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    specific_event: Property.Checkbox({
+      displayName: 'Target Specific Event',
+      description:
+        'Enable to monitor a specific event instead of all events in the calendar.',
+      required: false,
+      defaultValue: false,
+    }),
+    event_id: googleCalendarCommon.eventDropdown(false),
+    time_value: Property.Number({
+      displayName: 'Time Before',
+      description: 'The amount of time before the event starts.',
+      required: true,
+      defaultValue: 15,
+    }),
+    time_unit: Property.StaticDropdown({
+      displayName: 'Time Unit',
+      required: true,
+      options: {
+        options: [
+          { label: 'Minutes', value: 'minutes' },
+          { label: 'Hours', value: 'hours' },
+          { label: 'Days', value: 'days' },
+        ],
+      },
+      defaultValue: 'minutes',
+    }),
+  },
+  type: TriggerStrategy.POLLING,
+  sampleData: {},
+
+  async onEnable(context) {
+    await pollingHelper.onEnable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+
+  async onDisable(context) {
+    await pollingHelper.onDisable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+
+  async run(context) {
+    return await pollingHelper.poll(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+      files: context.files,
+    });
+  },
+
+  async test(context) {
+    return await pollingHelper.test(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+      files: context.files,
+    });
+  },
+});

package/src/lib/triggers/new-calendar.ts

@@ -0,0 +1,203 @@
+import {
+  createTrigger,
+  AppConnectionValueForAuthProperty,
+  Property,
+} from '@guayaba/workflows-framework';
+import { TriggerStrategy } from '@guayaba/workflows-framework';
+import { googleCalendarAuth } from '../common';
+import {
+  DedupeStrategy,
+  Polling,
+  pollingHelper,
+} from '@guayaba/workflows-common';
+import { getCalendars } from '../common/helper';
+import { CalendarObject } from '../common/types';
+
+const polling: Polling<
+  AppConnectionValueForAuthProperty<typeof googleCalendarAuth>,
+  {
+    access_role_filter: string[] | undefined;
+    calendar_name_filter: string | undefined;
+    exclude_shared: boolean | undefined;
+  }
+> = {
+  strategy: DedupeStrategy.LAST_ITEM,
+  items: async ({ auth, store, propsValue }) => {
+    const { access_role_filter, calendar_name_filter, exclude_shared } =
+      propsValue;
+
+    const currentCalendars = await getCalendars(auth);
+
+    let filteredCalendars = currentCalendars;
+
+    if (access_role_filter && access_role_filter.length > 0) {
+      filteredCalendars = filteredCalendars.filter((cal) =>
+        access_role_filter.includes(cal.accessRole)
+      );
+    }
+
+    if (calendar_name_filter && calendar_name_filter.trim()) {
+      const searchTerm = calendar_name_filter.toLowerCase().trim();
+      filteredCalendars = filteredCalendars.filter(
+        (cal) =>
+          cal.summary?.toLowerCase().includes(searchTerm) ||
+          cal.description?.toLowerCase().includes(searchTerm)
+      );
+    }
+
+    if (exclude_shared) {
+      filteredCalendars = filteredCalendars.filter(
+        (cal) => cal.accessRole === 'owner' || cal.primary
+      );
+    }
+
+    const currentCalendarIds = filteredCalendars.map((cal) => cal.id);
+
+    const oldCalendarIds = (await store.get<string[]>('calendars')) || [];
+    const oldCalendarIdsSet = new Set(oldCalendarIds);
+
+    const newCalendars = filteredCalendars.filter(
+      (cal) => !oldCalendarIdsSet.has(cal.id)
+    );
+
+    await store.put('calendars', currentCalendarIds);
+
+    return newCalendars.map((cal) => ({
+      id: cal.id,
+      data: {
+        ...cal,
+        isOwned: cal.accessRole === 'owner' || cal.primary,
+        isShared: cal.accessRole !== 'owner' && !cal.primary,
+        calendarType: cal.primary
+          ? 'primary'
+          : cal.accessRole === 'owner'
+          ? 'owned'
+          : 'shared',
+      },
+    }));
+  },
+};
+
+export const newCalendar = createTrigger({
+  auth: googleCalendarAuth,
+  name: 'new_calendar',
+  displayName: 'New Calendar',
+  description: 'Fires when a new calendar is created or becomes accessible.',
+  props: {
+    access_role_filter: Property.StaticMultiSelectDropdown({
+      displayName: 'Access Role Filter',
+      description:
+        'Only trigger for calendars with specific access roles (optional)',
+      required: false,
+      options: {
+        options: [
+          { label: 'Owner', value: 'owner' },
+          { label: 'Writer', value: 'writer' },
+          { label: 'Reader', value: 'reader' },
+          { label: 'Free/Busy Reader', value: 'freeBusyReader' },
+        ],
+      },
+    }),
+    calendar_name_filter: Property.ShortText({
+      displayName: 'Calendar Name Filter',
+      description:
+        'Only trigger for calendars containing this text in name or description (optional)',
+      required: false,
+    }),
+    exclude_shared: Property.Checkbox({
+      displayName: 'Exclude Shared Calendars',
+      description: 'Only trigger for calendars you own, not shared calendars',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  type: TriggerStrategy.POLLING,
+  sampleData: {
+    id: 'sample_calendar_id@group.calendar.google.com',
+    summary: 'New Project Team Calendar',
+    description: 'A shared calendar for the new project team.',
+    timeZone: 'Asia/Kolkata',
+    backgroundColor: '#9fe1e7',
+    foregroundColor: '#000000',
+    accessRole: 'owner',
+    isOwned: true,
+    isShared: false,
+    calendarType: 'owned',
+    primary: false,
+  },
+
+  async onEnable(context) {
+    const calendars = await getCalendars(context.auth);
+
+    const { access_role_filter, calendar_name_filter, exclude_shared } =
+      context.propsValue;
+    let filteredCalendars = calendars;
+
+    if (access_role_filter && access_role_filter.length > 0) {
+      filteredCalendars = filteredCalendars.filter((cal) =>
+        access_role_filter.includes(cal.accessRole)
+      );
+    }
+
+    if (calendar_name_filter && calendar_name_filter.trim()) {
+      const searchTerm = calendar_name_filter.toLowerCase().trim();
+      filteredCalendars = filteredCalendars.filter(
+        (cal) =>
+          cal.summary?.toLowerCase().includes(searchTerm) ||
+          cal.description?.toLowerCase().includes(searchTerm)
+      );
+    }
+
+    if (exclude_shared) {
+      filteredCalendars = filteredCalendars.filter(
+        (cal) => cal.accessRole === 'owner' || cal.primary
+      );
+    }
+
+    await context.store.put(
+      'calendars',
+      filteredCalendars.map((cal) => cal.id)
+    );
+
+    await pollingHelper.onEnable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+
+  async onDisable(context) {
+    await pollingHelper.onDisable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+
+  async run(context) {
+    return await pollingHelper.poll(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+      files: context.files,
+    });
+  },
+
+  async test(context) {
+    const calendars = await getCalendars(context.auth);
+    const recentCalendars = calendars.slice(-1);
+    return recentCalendars.map((cal: CalendarObject) => ({
+      id: cal.id,
+      data: {
+        ...cal,
+        isOwned: cal.accessRole === 'owner' || cal.primary,
+        isShared: cal.accessRole !== 'owner' && !cal.primary,
+        calendarType: cal.primary
+          ? 'primary'
+          : cal.accessRole === 'owner'
+          ? 'owned'
+          : 'shared',
+      },
+    }));
+  },
+});