@guayaba/workflow-piece-google-calendar 0.9.1

package/src/lib/actions/update-event.action.ts

@@ -0,0 +1,126 @@
+import { Property, createAction } from '@guayaba/workflows-framework';
+import { google, calendar_v3 } from 'googleapis';
+import { googleCalendarCommon, googleCalendarAuth, createGoogleClient } from '../common';
+import dayjs from 'dayjs';
+
+export const updateEventAction = createAction({
+  displayName: 'Update Event',
+  auth: googleCalendarAuth,
+  name: 'update_event',
+  description: 'Updates an event in Google Calendar.',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    eventId: Property.ShortText({
+      displayName: 'Event ID',
+      required: true,
+    }),
+    title: Property.ShortText({
+      displayName: 'Title of the event',
+      required: false,
+    }),
+    start_date_time: Property.DateTime({
+      displayName: 'Start date time of the event',
+      required: false,
+    }),
+    end_date_time: Property.DateTime({
+      displayName: 'End date time of the event',
+      required: false,
+    }),
+    location: Property.ShortText({
+      displayName: 'Location',
+      required: false,
+    }),
+    description: Property.LongText({
+      displayName: 'Description',
+      description: 'Description of the event. You can use HTML tags here.',
+      required: false,
+    }),
+    colorId: googleCalendarCommon.colorId,
+    attendees: Property.Array({
+      displayName: 'Attendees',
+      description: 'Emails of the attendees (guests)',
+      required: false,
+    }),
+    guests_can_modify: Property.Checkbox({
+      displayName: 'Guests can modify',
+      defaultValue: false,
+      required: false,
+    }),
+    guests_can_invite_others: Property.Checkbox({
+      displayName: 'Guests can invite others',
+      defaultValue: false,
+      required: false,
+    }),
+    guests_can_see_other_guests: Property.Checkbox({
+      displayName: 'Guests can see other guests',
+      defaultValue: false,
+      required: false,
+    }),
+  },
+  async run(context) {
+    const {
+      calendar_id,
+      eventId,
+      title,
+      start_date_time,
+      end_date_time,
+      location,
+      description,
+      colorId,
+      guests_can_invite_others,
+      guests_can_modify,
+      guests_can_see_other_guests,
+    } = context.propsValue;
+
+    const attendees = context.propsValue.attendees as string[];
+
+    const authClient = await createGoogleClient(context.auth);
+    const calendar = google.calendar({ version: 'v3', auth: authClient });
+
+    // Note that each patch request consumes three quota units;
+    // prefer using a get followed by an update
+    const currentEvent = await calendar.events.get({
+      calendarId: calendar_id,
+      eventId: eventId,
+    });
+
+    let attendeeFormattedList: calendar_v3.Schema$EventAttendee[] = [];
+    if (Array.isArray(attendees) && attendees.length > 0) {
+      attendeeFormattedList = attendees.map((email) => ({ email }));
+    } else if (
+      currentEvent.data.attendees &&
+      Array.isArray(currentEvent.data.attendees)
+    ) {
+      attendeeFormattedList = currentEvent.data.attendees;
+    }
+
+    const response = await calendar.events.update({
+      calendarId: calendar_id,
+      eventId: eventId,
+      requestBody: {
+        summary: title ?? currentEvent.data.summary,
+        attendees: attendeeFormattedList,
+        description: description ?? currentEvent.data.description,
+        colorId: colorId,
+        location: location ?? currentEvent.data.location,
+        start: start_date_time
+          ? {
+              dateTime: dayjs(start_date_time).format(
+                'YYYY-MM-DDTHH:mm:ss.sssZ'
+              ),
+            }
+          : currentEvent.data.start,
+        end: end_date_time
+          ? {
+              dateTime: dayjs(end_date_time).format('YYYY-MM-DDTHH:mm:ss.sssZ'),
+            }
+          : currentEvent.data.end,
+        guestsCanInviteOthers: guests_can_invite_others,
+        guestsCanModify: guests_can_modify,
+        guestsCanSeeOtherGuests: guests_can_see_other_guests,
+      },
+    });
+
+    return response.data;
+  },
+});

package/src/lib/auth.ts

@@ -0,0 +1,81 @@
+import { AppConnectionValueForAuthProperty, PieceAuth, Property } from '@guayaba/workflows-framework';
+import { AppConnectionType } from '@guayaba/workflows-shared';
+import { google } from 'googleapis';
+import { OAuth2Client } from 'googleapis-common';
+
+export const googleCalendarScopes = [
+  'https://www.googleapis.com/auth/calendar.events',
+  'https://www.googleapis.com/auth/calendar.readonly',
+  // TODO: Add the scope after Google App Verification
+  // 'https://www.googleapis.com/auth/calendar.calendarlist'
+];
+
+export const googleCalendarAuth = [PieceAuth.OAuth2({
+  description: '',
+  authUrl: 'https://accounts.google.com/o/oauth2/auth',
+  tokenUrl: 'https://oauth2.googleapis.com/token',
+  required: true,
+  pkce: true,
+  scope: googleCalendarScopes,
+}), PieceAuth.CustomAuth({
+  displayName: 'Service Account (Advanced)',
+  description: 'Authenticate via service account from https://console.cloud.google.com/ > IAM & Admin > Service Accounts > Create Service Account > Keys > Add key.  <br> <br> You can optionally use domain-wide delegation (https://support.google.com/a/answer/162106?hl=en#zippy=%2Cset-up-domain-wide-delegation-for-a-client) to access calendars without adding the service account to each one. <br> <br> **Note:** Without a user email, the service account only has access to calendars you explicitly share with it.',
+  required: true,
+  props: {
+    serviceAccount: Property.ShortText({
+      displayName: 'Service Account JSON Key',
+      required: true,
+    }),
+    userEmail: Property.ShortText({
+      displayName: 'User Email',
+      required: false,
+      description: 'Email address of the user to impersonate for domain-wide delegation.',
+    }),
+  },
+  validate: async ({ auth }) => {
+    try {
+      await getAccessToken({
+        type: AppConnectionType.CUSTOM_AUTH,
+        props: { ...auth },
+      });
+    } catch (e) {
+      return {
+        valid: false,
+        error: (e as Error).message,
+      };
+    }
+    return {
+      valid: true,
+    };
+  },
+})];
+
+export type GoogleCalendarAuthValue = AppConnectionValueForAuthProperty<typeof googleCalendarAuth>;
+
+export async function createGoogleClient(auth: GoogleCalendarAuthValue): Promise<OAuth2Client> {
+  if (auth.type === AppConnectionType.CUSTOM_AUTH) {
+    const serviceAccount = JSON.parse(auth.props.serviceAccount);
+    return new google.auth.JWT({
+      email: serviceAccount.client_email,
+      key: serviceAccount.private_key,
+      scopes: googleCalendarScopes,
+      subject: auth.props.userEmail,
+    });
+  }
+  const authClient = new OAuth2Client();
+  authClient.setCredentials(auth);
+  return authClient;
+}
+
+export const getAccessToken = async (auth: GoogleCalendarAuthValue): Promise<string> => {
+  if (auth.type === AppConnectionType.CUSTOM_AUTH) {
+    const googleClient = await createGoogleClient(auth);
+    const response = await googleClient.getAccessToken();
+    if (response.token) {
+      return response.token;
+    } else {
+      throw new Error('Could not retrieve access token from service account json');
+    }
+  }
+  return auth.access_token;
+};

package/src/lib/common/helper.ts

@@ -0,0 +1,228 @@
+import {
+  AuthenticationType,
+  httpClient,
+  HttpMethod,
+  HttpRequest,
+} from '@guayaba/workflows-common';
+import { randomUUID } from 'crypto';
+import { googleCalendarCommon, GoogleCalendarAuthValue, getAccessToken } from '.';
+import {
+  GoogleWatchResponse,
+  GoogleWatchType,
+  CalendarObject,
+  CalendarList,
+  GoogleCalendarEvent,
+  GoogleCalendarEventList,
+  GetColorsResponse,
+} from './types';
+
+export async function stopWatchEvent(
+  body: GoogleWatchResponse,
+  authProp: GoogleCalendarAuthValue
+) {
+  const request: HttpRequest = {
+    method: HttpMethod.POST,
+    url: `${googleCalendarCommon.baseUrl}/channels/stop`,
+    body: {
+      id: body?.id,
+      resourceId: body?.resourceId,
+    },
+    authentication: {
+      type: AuthenticationType.BEARER_TOKEN,
+      token: await getAccessToken(authProp),
+    },
+  };
+  await httpClient.sendRequest<any>(request);
+}
+
+export async function watchEvent(
+  calendarId: string,
+  webhookUrl: string,
+  authProp: GoogleCalendarAuthValue
+): Promise<GoogleWatchResponse> {
+  const request: HttpRequest = {
+    method: HttpMethod.POST,
+    url: `${googleCalendarCommon.baseUrl}/calendars/${calendarId}/events/watch`,
+    body: {
+      id: randomUUID(),
+      type: GoogleWatchType.WEBHOOK,
+      address: webhookUrl,
+    },
+    authentication: {
+      type: AuthenticationType.BEARER_TOKEN,
+      token: await getAccessToken(authProp),
+    },
+  };
+  const { body: webhook } = await httpClient.sendRequest<GoogleWatchResponse>(
+    request
+  );
+  return webhook;
+}
+
+export async function getCalendars(
+  authProp: GoogleCalendarAuthValue,
+  minAccessRole?: 'writer'
+): Promise<CalendarObject[]> {
+  // docs: https://developers.google.com/calendar/api/v3/reference/calendarList/list
+  const queryParams: Record<string, string> = {
+    showDeleted: 'false',
+  };
+  if (minAccessRole) {
+    queryParams['minAccessRole'] = minAccessRole;
+  }
+  const request: HttpRequest = {
+    method: HttpMethod.GET,
+    url: `${googleCalendarCommon.baseUrl}/users/me/calendarList`,
+    queryParams: queryParams,
+    authentication: {
+      type: AuthenticationType.BEARER_TOKEN,
+      token: await getAccessToken(authProp),
+    },
+  };
+  const response = await httpClient.sendRequest<CalendarList>(request);
+  return response.body.items;
+}
+
+export async function getColors(
+  authProp: GoogleCalendarAuthValue
+): Promise<GetColorsResponse> {
+  const request: HttpRequest = {
+    method: HttpMethod.GET,
+    url: `${googleCalendarCommon.baseUrl}/colors`,
+    authentication: {
+      type: AuthenticationType.BEARER_TOKEN,
+      token: await getAccessToken(authProp),
+    },
+  };
+  const response = await httpClient.sendRequest<GetColorsResponse>(request);
+  return response.body;
+}
+
+export async function getEvents(
+  calendarId: string,
+  expandRecurringEvent: boolean,
+  authProp: GoogleCalendarAuthValue,
+  minUpdated?: Date
+): Promise<GoogleCalendarEvent[]> {
+  // docs: https://developers.google.com/calendar/api/v3/reference/events/list
+  const now = new Date();
+  const yesterday = new Date();
+  yesterday.setDate(now.getDate() - 1);
+
+  const qParams: Record<string, string> = {
+    updatedMin: minUpdated?.toISOString() ?? yesterday.toISOString(),
+    maxResults: '2500', // Modified
+    orderBy: 'updated',
+    singleEvents: expandRecurringEvent ? 'true' : 'false',
+    showDeleted: 'true',
+  };
+
+  const accessToken = await getAccessToken(authProp);
+  const request: HttpRequest = {
+    method: HttpMethod.GET,
+    url: `${googleCalendarCommon.baseUrl}/calendars/${calendarId}/events`,
+    queryParams: qParams,
+    authentication: {
+      type: AuthenticationType.BEARER_TOKEN,
+      token: accessToken,
+    },
+  };
+
+  let eventList: GoogleCalendarEvent[] = [];
+  let pageToken = '';
+  do {
+    qParams['pageToken'] = pageToken;
+    const { body: res } = await httpClient.sendRequest<GoogleCalendarEventList>(
+      request
+    );
+    if (res.items.length > 0) {
+      eventList = [...eventList, ...res.items];
+    }
+    pageToken = res.nextPageToken;
+  } while (pageToken);
+
+  return eventList;
+}
+
+export async function getLatestEvent(
+  calendarId: string,
+  authProp: GoogleCalendarAuthValue
+): Promise<GoogleCalendarEvent> {
+  const eventList = await getEvents(calendarId, false, authProp);
+  const lastUpdatedEvent = eventList.pop()!; // You can retrieve the last updated event.
+  return lastUpdatedEvent;
+}
+
+export async function getEventsForDropdown(
+  authProp: GoogleCalendarAuthValue,
+  calendarId?: string,
+  maxResults = 50
+): Promise<{ label: string; value: string }[]> {
+  if (!calendarId) {
+    return [];
+  }
+
+  try {
+    const now = new Date();
+    const futureDate = new Date();
+    futureDate.setDate(now.getDate() + 30);
+
+    const queryParams: Record<string, string> = {
+      singleEvents: 'true',
+      orderBy: 'startTime',
+      timeMin: now.toISOString(),
+      timeMax: futureDate.toISOString(),
+      maxResults: maxResults.toString(),
+      showDeleted: 'false',
+    };
+
+    const request: HttpRequest = {
+      method: HttpMethod.GET,
+      url: `${googleCalendarCommon.baseUrl}/calendars/${encodeURIComponent(
+        calendarId
+      )}/events`,
+      queryParams: queryParams,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(authProp),
+      },
+    };
+
+    const response = await httpClient.sendRequest<GoogleCalendarEventList>(
+      request
+    );
+
+    if (!response.body.items || response.body.items.length === 0) {
+      return [];
+    }
+
+    return response.body.items
+      .map((event) => {
+        const startTime = event.start?.dateTime || event.start?.date || '';
+        const startDate = startTime
+          ? new Date(startTime).toLocaleDateString()
+          : '';
+        const startTimeFormatted = startTime
+          ? new Date(startTime).toLocaleTimeString()
+          : '';
+
+        let label = event.summary || 'Untitled Event';
+        if (startDate) {
+          label += ` (${startDate}`;
+          if (event.start?.dateTime) {
+            label += ` at ${startTimeFormatted}`;
+          }
+          label += ')';
+        }
+
+        return {
+          label: label,
+          value: event.id || '',
+        };
+      })
+      .filter((item) => item.value !== '');
+  } catch (error) {
+    console.error('Error fetching events for dropdown:', error);
+    return [];
+  }
+}

package/src/lib/common/index.ts

@@ -0,0 +1,95 @@
+import { Property } from '@guayaba/workflows-framework';
+import { getCalendars, getColors, getEventsForDropdown } from './helper';
+import { googleCalendarAuth, GoogleCalendarAuthValue, getAccessToken } from '../auth';
+
+export { googleCalendarAuth, GoogleCalendarAuthValue, getAccessToken, createGoogleClient, googleCalendarScopes } from '../auth';
+
+export const googleCalendarCommon = {
+  baseUrl: 'https://www.googleapis.com/calendar/v3',
+  calendarDropdown: (minAccessRole?: 'writer') => {
+    return Property.Dropdown<string,true,typeof googleCalendarAuth>({
+      auth: googleCalendarAuth,
+      displayName: 'Calendar',
+      refreshers: [],
+      required: true,
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Please connect your account first',
+            options: [],
+          };
+        }
+        const authValue = auth as GoogleCalendarAuthValue;
+        const calendars = await getCalendars(authValue, minAccessRole);
+        return {
+          disabled: false,
+          options: calendars.map((calendar) => {
+            return {
+              label: calendar.summary,
+              value: calendar.id,
+            };
+          }),
+        };
+      },
+    });
+  },
+  eventDropdown: (required = false) => {
+    return Property.Dropdown<string,boolean,typeof googleCalendarAuth>({
+      displayName: 'Event',
+      refreshers: ['calendar_id'],
+      required: required,
+      auth: googleCalendarAuth,
+      options: async ({ auth, calendar_id }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Please connect your account first',
+            options: [],
+          };
+        }
+        if (!calendar_id) {
+          return {
+            disabled: true,
+            placeholder: 'Please select a calendar first',
+            options: [],
+          };
+        }
+        const authValue = auth as GoogleCalendarAuthValue;
+        const events = await getEventsForDropdown(
+          authValue,
+          calendar_id as string
+        );
+        return {
+          disabled: false,
+          options: events,
+        };
+      },
+    });
+  },
+  colorId: Property.Dropdown({
+    auth: googleCalendarAuth,
+    displayName: 'Color',
+    refreshers: [],
+    required: false,
+    options: async ({ auth }) => {
+      if (!auth) {
+        return {
+          disabled: true,
+          placeholder: 'Please connect your account first',
+          options: [],
+        };
+      }
+      const response = await getColors(auth as GoogleCalendarAuthValue);
+      return {
+        disabled: false,
+        options: Object.entries(response.event).map(([key, value]) => {
+          return {
+            label: value.background,
+            value: key,
+          };
+        }),
+      };
+    },
+  }),
+};