@guayaba/workflow-piece-google-calendar 0.9.1

package/src/lib/common/types.ts

@@ -0,0 +1,246 @@
+export enum GoogleWatchType {
+  WEBHOOK = 'web_hook',
+}
+
+export enum GoogleCalendarKind {
+  CALENDAR_LIST = 'calendar#calendarList',
+  CALENDAR_ENTRY = 'calendar#calendarListEntry',
+  CALENDAR_EVENT = 'calendar#event',
+  CALENDAR_EVENT_LIST = 'calendar#events',
+  EVENT_WATCH = 'api#channel',
+  CALENDAR_COLORS = 'calendar#colors',
+}
+
+export interface CalendarList {
+  kind: GoogleCalendarKind.CALENDAR_LIST;
+  etag: string;
+  nextPageToken: string;
+  nextSyncToken: string;
+  items: CalendarObject[];
+}
+
+export interface CalendarObject {
+  kind: GoogleCalendarKind.CALENDAR_ENTRY;
+  etag: string;
+  id: string;
+  summary: string;
+  description: string;
+  location: string;
+  timeZone: string;
+  summaryOverride: string;
+  colorId: string;
+  backgroundColor: string;
+  foregroundColor: string;
+  hidden: boolean;
+  selected: boolean;
+  accessRole: string;
+  defaultReminders: [
+    {
+      method: string;
+      minutes: number;
+    }
+  ];
+  notificationSettings: {
+    notifications: [
+      {
+        type: string;
+        method: string;
+      }
+    ];
+  };
+  primary: boolean;
+  deleted: boolean;
+  conferenceProperties: {
+    allowedConferenceSolutionTypes: string[];
+  };
+}
+
+export interface GoogleWatchResponse {
+  kind: GoogleCalendarKind.EVENT_WATCH;
+  id: string;
+  resourceId: string;
+  resourceUri: string;
+  token: string;
+  expiration: number;
+}
+
+interface Attendee {
+  id: string;
+  email: string;
+  displayName: string;
+  organizer: boolean;
+  self: boolean;
+  resource: boolean;
+  optional: boolean;
+  responseStatus: string;
+  comment: string;
+  additionalGuests: BigInteger;
+}
+
+export interface GoogleCalendarEvent {
+  kind: GoogleCalendarKind.CALENDAR_EVENT;
+  etag: string;
+  id: string;
+  status: string;
+  htmlLink: string;
+  created: string;
+  updated: string;
+  summary: string;
+  description: string;
+  location: string;
+  colorId: string;
+  creator: {
+    id: string;
+    email: string;
+    displayName: string;
+    self: boolean;
+  };
+  organizer: {
+    id: string;
+    email: string;
+    displayName: string;
+    self: boolean;
+  };
+  start: {
+    date: Date;
+    dateTime: Date;
+    timeZone: string;
+  };
+  end: {
+    date: Date;
+    dateTime: Date;
+    timeZone: string;
+  };
+  endTimeUnspecified: boolean;
+  recurrence: [string];
+  recurringEventId: string;
+  originalStartTime: {
+    date: Date;
+    dateTime: Date;
+    timeZone: string;
+  };
+  transparency: string;
+  visibility: string;
+  iCalUID: string;
+  sequence: BigInteger;
+  attendees: Attendee[];
+  attendeesOmitted: boolean;
+  extendedProperties: {
+    private: {
+      key: string;
+    };
+    shared: {
+      key: string;
+    };
+  };
+  hangoutLink: string;
+  conferenceData: {
+    createRequest: {
+      requestId: string;
+      conferenceSolutionKey: {
+        type: string;
+      };
+      status: {
+        statusCode: string;
+      };
+    };
+    entryPoints: [
+      {
+        entryPointType: string;
+        uri: string;
+        label: string;
+        pin: string;
+        accessCode: string;
+        meetingCode: string;
+        passcode: string;
+        password: string;
+      }
+    ];
+    conferenceSolution: {
+      key: {
+        type: string;
+      };
+      name: string;
+      iconUri: string;
+    };
+    conferenceId: string;
+    signature: string;
+    notes: string;
+  };
+  gadget: {
+    type: string;
+    title: string;
+    link: string;
+    iconLink: string;
+    width: BigInteger;
+    height: BigInteger;
+    display: string;
+    preferences: {
+      key: string;
+    };
+  };
+  anyoneCanAddSelf: boolean;
+  guestsCanInviteOthers: boolean;
+  guestsCanModify: boolean;
+  guestsCanSeeOtherGuests: boolean;
+  privateCopy: boolean;
+  locked: boolean;
+  reminders: {
+    useDefault: boolean;
+    overrides: [
+      {
+        method: string;
+        minutes: BigInteger;
+      }
+    ];
+  };
+  source: {
+    url: string;
+    title: string;
+  };
+  attachments: [
+    {
+      fileUrl: string;
+      title: string;
+      mimeType: string;
+      iconLink: string;
+      fileId: string;
+    }
+  ];
+  eventType: string;
+}
+
+export interface GoogleCalendarEventList {
+  kind: GoogleCalendarKind.CALENDAR_EVENT_LIST;
+  etag: string;
+  summary: string;
+  description: string;
+  updated: number;
+  timeZone: string;
+  accessRole: string;
+  defaultReminders: [
+    {
+      method: string;
+      minutes: BigInteger;
+    }
+  ];
+  nextPageToken: string;
+  nextSyncToken: string;
+  items: GoogleCalendarEvent[];
+}
+
+export interface GetColorsResponse {
+  kind: GoogleCalendarKind.CALENDAR_COLORS;
+  calendar: {
+    [s: string]: {
+      background: string;
+      foreground: string;
+    };
+  };
+  event: {
+    [s: string]: {
+      background: string;
+      foreground: string;
+    };
+  };
+}

package/src/lib/google-calendar.mdx

@@ -0,0 +1,25 @@
+---
+title: 'Google Calendar'
+description: ''
+---
+
+## Set up and run an app that calls a Google calendar API.
+
+1. In the Google Cloud console, enable the Google Calendar API.
+2. Click In the Google Cloud console, and go to Menu menu > APIs & Services > Credentials.
+3. Click Create Credentials > OAuth client ID.
+4. In the Name field, type a name for the credential. This name is only shown in the Google Cloud console.
+5. Click Create. The OAuth client created screen appears, showing your new Client ID and Client secret.
+6. Click OK. The newly created credential appears under OAuth 2.0 Client IDs.
+
+---
+
+## Triggers
+
+TRIGGERS
+
+---
+
+## Actions
+
+ACTIONS

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

@@ -0,0 +1,139 @@
+import { AppConnectionValueForAuthProperty, createTrigger, PiecePropValueSchema, Property } from '@guayaba/workflows-framework';
+import { TriggerStrategy } from '@guayaba/workflows-framework';
+import { googleCalendarCommon } from '../common';
+import { getEvents } from '../common/helper';
+import { GoogleCalendarEvent } from '../common/types';
+import { googleCalendarAuth } from '../common';
+import { DedupeStrategy, Polling, pollingHelper } from '@guayaba/workflows-common';
+
+const polling: Polling<
+    AppConnectionValueForAuthProperty<typeof googleCalendarAuth>,
+	{ calendarId?: string; expandRecurringEvent: boolean }
+> = {
+	strategy: DedupeStrategy.TIMEBASED,
+	items: async ({ auth, propsValue: { calendarId, expandRecurringEvent }, lastFetchEpochMS }) => {
+		let minUpdated = new Date(lastFetchEpochMS);
+		// Google Calendar API breaks if minUpdated is too far in the past
+		if (lastFetchEpochMS === 0) {
+			const now = new Date();
+			const yesterday = new Date();
+			yesterday.setDate(now.getDate() - 7);
+
+			minUpdated = yesterday;
+		}
+
+		const currentValues: GoogleCalendarEvent[] =
+			(await getEvents(calendarId!, expandRecurringEvent, auth, minUpdated)) ?? [];
+		const items = currentValues.map((item) => ({
+			epochMilliSeconds: new Date(item.updated).getTime(),
+			data: item,
+		}));
+		return items;
+	},
+};
+
+export const calendarEventChanged = createTrigger({
+	// docs: https://developers.google.com/calendar/api/guides/push
+	auth: googleCalendarAuth,
+	name: 'new_or_updated_event',
+	displayName: 'New or Updated Event',
+	description: 'Triggers when an event is added or updated',
+	props: {
+		calendar_id: googleCalendarCommon.calendarDropdown(),
+		expandRecurringEvent: Property.Checkbox({
+			displayName: 'Expand Recurring Event?',
+			description: 'If true, the trigger will activate for every occurrence of a recurring event.',
+			required: true,
+			defaultValue: false,
+		}),
+	},
+	sampleData: {
+		kind: 'calendar#event',
+		etag: '3350849506974000',
+		id: '0nsfi5ttd2b17ac76ma2f37oi9',
+		htmlLink: 'https://www.google.com/calendar/event?eid=kgjb90uioj4klrgfmdsnjsjvlgkm',
+		summary: 'ap-event-test',
+		created: '2023-02-03T11:36:36.000Z',
+		updated: '2023-02-03T11:45:53.487Z',
+		description: 'Sample description',
+		status: 'canceled',
+		creator: {
+			email: 'test@test.com',
+			self: true,
+		},
+		organizer: {
+			email: 'test@test.com',
+			self: true,
+		},
+		start: {
+			dateTime: '2023-02-02T22:30:00+03:00',
+			timeZone: 'Asia/Amman',
+		},
+		end: {
+			dateTime: '2023-02-02T23:30:00+03:00',
+			timeZone: 'Asia/Amman',
+		},
+		transparency: 'transparent',
+		iCalUID: '0nsfi5ttd2b17ac76ma2f37oi9@google.com',
+		sequence: 1,
+		attendees: [
+			{
+				email: 'attende@test.com',
+				responseStatus: 'needsAction',
+			},
+			{
+				email: 'test@test.com',
+				organizer: true,
+				self: true,
+				responseStatus: 'accepted',
+			},
+		],
+		reminders: {
+			useDefault: true,
+		},
+		eventType: 'default',
+	},
+	type: TriggerStrategy.POLLING,
+	async test({ store, auth, propsValue, files }) {
+		return await pollingHelper.test(polling, {
+			store,
+			auth,
+			propsValue: {
+				calendarId: propsValue.calendar_id,
+				expandRecurringEvent: propsValue.expandRecurringEvent,
+			},
+			files,
+		});
+	},
+	async onEnable({ store, auth, propsValue }) {
+		await pollingHelper.onEnable(polling, {
+			store,
+			auth,
+			propsValue: {
+				calendarId: propsValue.calendar_id,
+				expandRecurringEvent: propsValue.expandRecurringEvent,
+			},
+		});
+	},
+	async onDisable({ store, auth, propsValue }) {
+		await pollingHelper.onDisable(polling, {
+			store,
+			auth,
+			propsValue: {
+				calendarId: propsValue.calendar_id,
+				expandRecurringEvent: propsValue.expandRecurringEvent,
+			},
+		});
+	},
+	async run({ store, auth, propsValue, files }) {
+		return await pollingHelper.poll(polling, {
+			store,
+			auth,
+			propsValue: {
+				calendarId: propsValue.calendar_id,
+				expandRecurringEvent: propsValue.expandRecurringEvent,
+			},
+			files,
+		});
+	},
+});

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

@@ -0,0 +1,200 @@
+import {
+  AppConnectionValueForAuthProperty,
+  createTrigger,
+  PiecePropValueSchema,
+  Property,
+} from '@guayaba/workflows-framework';
+import { TriggerStrategy } from '@guayaba/workflows-framework';
+import { googleCalendarCommon, getAccessToken } from '../common';
+import { GoogleCalendarEvent } from '../common/types';
+import { googleCalendarAuth } from '../common';
+import {
+  DedupeStrategy,
+  Polling,
+  pollingHelper,
+} from '@guayaba/workflows-common';
+import {
+  AuthenticationType,
+  httpClient,
+  HttpMethod,
+  HttpRequest,
+} from '@guayaba/workflows-common';
+import { getEvents } from '../common/helper';
+
+
+const polling: Polling<
+  AppConnectionValueForAuthProperty<typeof googleCalendarAuth>,
+  {
+    calendar_id: string | undefined;
+    specific_event: boolean | undefined;
+    event_id: string | undefined;
+    cancellation_reason: string[] | undefined;
+  }
+> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue, lastFetchEpochMS }) => {
+    const {
+      calendar_id: calendarId,
+      specific_event,
+      event_id,
+      cancellation_reason,
+    } = propsValue;
+
+    if (!calendarId) {
+      return [];
+    }
+
+    if (specific_event && !event_id) {
+      return [];
+    }
+
+    let minUpdated: Date;
+    if (lastFetchEpochMS === 0) {
+      minUpdated = new Date();
+      minUpdated.setDate(minUpdated.getDate() - 1);
+    } else {
+      minUpdated = new Date(lastFetchEpochMS);
+    }
+
+    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 updatedTime = new Date(event.updated ?? 0).getTime();
+        if (updatedTime > lastFetchEpochMS && event.status === 'cancelled') {
+          events = [event];
+        }
+      } catch (error) {
+        console.error('Error fetching specific event:', error);
+        return [];
+      }
+    } else {
+      const allEvents = await getEvents(calendarId, true, auth, minUpdated);
+      events = allEvents.filter((event) => event.status === 'cancelled');
+    }
+
+    if (cancellation_reason && cancellation_reason.length > 0) {
+      events = events.filter((event) => {
+        return cancellation_reason.some((reason) => {
+          switch (reason) {
+            case 'deleted':
+              return !event.summary || event.summary.includes('Deleted');
+            case 'declined':
+              return (
+                event.attendees?.some(
+                  (attendee) => attendee.responseStatus === 'declined'
+                ) || false
+              );
+            case 'rescheduled':
+              return (
+                event.summary?.toLowerCase().includes('rescheduled') ||
+                event.description?.toLowerCase().includes('rescheduled') ||
+                false
+              );
+            case 'other':
+              return true;
+            default:
+              return true;
+          }
+        });
+      });
+    }
+
+    return events.map((event) => {
+      return {
+        epochMilliSeconds: new Date(event.updated!).getTime(),
+        data: event,
+      };
+    });
+  },
+};
+
+export const eventCancelled = createTrigger({
+  auth: googleCalendarAuth,
+  name: 'event_cancelled',
+  displayName: 'Event Cancelled',
+  description: 'Fires when an event is canceled or deleted.',
+  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),
+    cancellation_reason: Property.StaticMultiSelectDropdown({
+      displayName: 'Cancellation Reasons',
+      description: 'Filter by specific types of cancellations (optional)',
+      required: false,
+      options: {
+        options: [
+          { label: 'Event Deleted', value: 'deleted' },
+          { label: 'Attendee Declined', value: 'declined' },
+          { label: 'Event Rescheduled', value: 'rescheduled' },
+          { label: 'Other Cancellations', value: 'other' },
+        ],
+      },
+    }),
+  },
+  type: TriggerStrategy.POLLING,
+  sampleData: {
+    id: 'abc123def456_cancelled',
+    summary: 'Cancelled: Q3 Planning Session',
+    status: 'cancelled',
+    created: '2025-07-20T10:00:00.000Z',
+    updated: '2025-08-14T09:30:00.000Z',
+    organizer: { email: 'project.manager@example.com' },
+    start: { dateTime: '2025-08-25T10:00:00-07:00' },
+    end: { dateTime: '2025-08-25T11:30:00-07:00' },
+  },
+
+  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,
+    });
+  },
+});