@guayaba/workflow-piece-google-calendar 0.9.1

package/src/lib/triggers/new-event-matching-search.ts

@@ -0,0 +1,225 @@
+import {
+  createTrigger,
+  AppConnectionValueForAuthProperty,
+  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;
+    search_term: string | undefined;
+    event_types: string[] | undefined;
+    search_fields: string[] | undefined;
+  }
+> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue, lastFetchEpochMS }) => {
+    const { calendar_id, search_term, event_types, search_fields } = propsValue;
+
+    if (!calendar_id || !search_term) {
+      return [];
+    }
+
+    let minUpdated: Date;
+    if (lastFetchEpochMS === 0) {
+      minUpdated = new Date();
+      minUpdated.setDate(minUpdated.getDate() - 1);
+    } else {
+      minUpdated = new Date(lastFetchEpochMS);
+    }
+
+    const queryParams: Record<string, string> = {
+      singleEvents: 'true',
+      orderBy: 'updated',
+      updatedMin: minUpdated.toISOString(),
+      q: search_term,
+    };
+
+    if (event_types && event_types.length > 0) {
+      event_types.forEach((type) => {
+        if (!queryParams.eventTypes) {
+          queryParams.eventTypes = type;
+        } else {
+          queryParams.eventTypes += '&eventTypes=' + type;
+        }
+      });
+    }
+
+    const request: HttpRequest = {
+      method: HttpMethod.GET,
+      url: `${googleCalendarCommon.baseUrl}/calendars/${calendar_id}/events`,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(auth),
+      },
+      queryParams: queryParams,
+    };
+
+    const response = await httpClient.sendRequest<GoogleCalendarEventList>(
+      request
+    );
+    const events = response.body.items;
+
+    const newEvents = events.filter((event) => {
+      const created = new Date(event.created ?? 0).getTime();
+      const updated = new Date(event.updated ?? 0).getTime();
+
+      const isNewEvent = updated - created < 5000;
+
+      if (!isNewEvent) return false;
+
+      if (search_fields && search_fields.length > 0) {
+        const searchTermLower = search_term.toLowerCase();
+        return search_fields.some((field) => {
+          switch (field) {
+            case 'summary':
+              return (
+                event.summary?.toLowerCase().includes(searchTermLower) || false
+              );
+            case 'description':
+              return (
+                event.description?.toLowerCase().includes(searchTermLower) ||
+                false
+              );
+            case 'location':
+              return (
+                event.location?.toLowerCase().includes(searchTermLower) || false
+              );
+            case 'attendees':
+              return (
+                event.attendees?.some(
+                  (attendee) =>
+                    attendee.email?.toLowerCase().includes(searchTermLower) ||
+                    attendee.displayName
+                      ?.toLowerCase()
+                      .includes(searchTermLower)
+                ) || false
+              );
+            default:
+              return false;
+          }
+        });
+      }
+
+      return true;
+    });
+
+    return newEvents.map((event) => {
+      return {
+        epochMilliSeconds: new Date(event.updated!).getTime(),
+        data: event,
+      };
+    });
+  },
+};
+
+export const newEventMatchingSearch = createTrigger({
+  auth: googleCalendarAuth,
+  name: 'new_event_matching_search',
+  displayName: 'New Event Matching Search',
+  description:
+    'Fires when a new event is created that matches a specified search term.',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    search_term: Property.ShortText({
+      displayName: 'Search Term',
+      description:
+        'The keyword(s) to search for in new events (searches across title, description, location, and attendees by default).',
+      required: true,
+    }),
+    event_types: Property.StaticMultiSelectDropdown({
+      displayName: 'Event Types',
+      description: 'Filter by specific event types (optional)',
+      required: false,
+      options: {
+        options: [
+          { label: 'Default Events', value: 'default' },
+          { label: 'Birthday Events', value: 'birthday' },
+          { label: 'Focus Time', value: 'focusTime' },
+          { label: 'Out of Office', value: 'outOfOffice' },
+          { label: 'Working Location', value: 'workingLocation' },
+          { label: 'From Gmail', value: 'fromGmail' },
+        ],
+      },
+    }),
+    search_fields: Property.StaticMultiSelectDropdown({
+      displayName: 'Search In Fields',
+      description:
+        "Specify which fields to search in (leave empty to use Google's default search across all fields)",
+      required: false,
+      options: {
+        options: [
+          { label: 'Event Title/Summary', value: 'summary' },
+          { label: 'Event Description', value: 'description' },
+          { label: 'Event Location', value: 'location' },
+          { label: 'Attendee Names/Emails', value: 'attendees' },
+        ],
+      },
+    }),
+  },
+  type: TriggerStrategy.POLLING,
+  sampleData: {
+    id: 'abc123def456',
+    summary: 'Final Project Review',
+    description: 'Review of the Q3 final project deliverables.',
+    status: 'confirmed',
+    created: '2025-08-14T09:05:00.000Z',
+    updated: '2025-08-14T09:05:01.000Z',
+    start: { dateTime: '2025-09-01T10:00:00-07:00' },
+    end: { dateTime: '2025-09-01T11:30:00-07:00' },
+    organizer: { email: 'project.manager@example.com' },
+  },
+
+  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-event.ts

@@ -0,0 +1,184 @@
+import {
+  createTrigger,
+  TriggerStrategy,
+  Property,
+} from '@guayaba/workflows-framework';
+import { googleCalendarCommon, googleCalendarAuth, GoogleCalendarAuthValue } from '../common';
+import { stopWatchEvent, watchEvent, getLatestEvent } from '../common/helper';
+import { GoogleWatchResponse, GoogleCalendarEvent } from '../common/types';
+
+export const newEvent = createTrigger({
+  auth: googleCalendarAuth,
+  name: 'new_event',
+  displayName: 'New Event',
+  description: 'Fires when a new event is created in a calendar.',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    event_types: Property.StaticMultiSelectDropdown({
+      displayName: 'Event Types to Monitor',
+      description:
+        'Filter by specific event types (leave empty to monitor all event types)',
+      required: false,
+      options: {
+        options: [
+          { label: 'Default Events', value: 'default' },
+          { label: 'Birthday Events', value: 'birthday' },
+          { label: 'Focus Time', value: 'focusTime' },
+          { label: 'Out of Office', value: 'outOfOffice' },
+          { label: 'Working Location', value: 'workingLocation' },
+          { label: 'From Gmail', value: 'fromGmail' },
+        ],
+      },
+    }),
+    search_filter: Property.ShortText({
+      displayName: 'Search Filter',
+      description:
+        'Only trigger for events containing this text in title, description, or location (optional)',
+      required: false,
+    }),
+    exclude_all_day: Property.Checkbox({
+      displayName: 'Exclude All-Day Events',
+      description: 'Skip triggering for all-day events',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  type: TriggerStrategy.WEBHOOK,
+  sampleData: {
+    kind: 'calendar#event',
+    etag: '"3419997894982000"',
+    id: 'sample_event_id_12345',
+    status: 'confirmed',
+    htmlLink:
+      'https://www.google.com/calendar/event?eid=c2FtcGxlX2V2ZW50X2lkXzEyMzQ1',
+    created: '2025-08-15T11:02:27.000Z',
+    updated: '2025-08-15T11:02:27.491Z',
+    summary: 'Team Sync',
+    creator: { email: 'creator@example.com' },
+    organizer: {
+      email: 'creator@example.com',
+      self: true,
+    },
+    start: {
+      dateTime: '2025-08-18T10:00:00-07:00',
+      timeZone: 'America/Los_Angeles',
+    },
+    end: {
+      dateTime: '2025-08-18T11:00:00-07:00',
+      timeZone: 'America/Los_Angeles',
+    },
+    iCalUID: 'sample_event_id_12345@google.com',
+    sequence: 0,
+    reminders: { useDefault: true },
+    eventType: 'default',
+  },
+
+  async onEnable(context) {
+    const calendarId = context.propsValue.calendar_id!;
+    const auth = context.auth as GoogleCalendarAuthValue;
+
+    const response = await watchEvent(calendarId, context.webhookUrl, auth);
+
+    await context.store.put<GoogleWatchResponse>(
+      'google_calendar_watch',
+      response
+    );
+  },
+
+  async onDisable(context) {
+    const auth = context.auth as GoogleCalendarAuthValue;
+    const watch = await context.store.get<GoogleWatchResponse>(
+      'google_calendar_watch'
+    );
+
+    if (watch) {
+      await stopWatchEvent(watch, auth);
+    }
+  },
+
+  async run(context) {
+    const payload = context.payload;
+    const headers = payload.headers as Record<string, string>;
+    const { event_types, search_filter, exclude_all_day } = context.propsValue;
+
+    if (headers['x-goog-resource-state'] === 'add') {
+      const eventData = payload.body as GoogleCalendarEvent;
+
+      if (event_types && event_types.length > 0) {
+        const eventType = eventData.eventType || 'default';
+        if (!event_types.includes(eventType)) {
+          return [];
+        }
+      }
+
+      if (search_filter && search_filter.trim()) {
+        const searchTerm = search_filter.toLowerCase().trim();
+        const summary = (eventData.summary || '').toLowerCase();
+        const description = (eventData.description || '').toLowerCase();
+        const location = (eventData.location || '').toLowerCase();
+
+        const matchesSearch =
+          summary.includes(searchTerm) ||
+          description.includes(searchTerm) ||
+          location.includes(searchTerm);
+
+        if (!matchesSearch) {
+          return [];
+        }
+      }
+
+      if (exclude_all_day) {
+        const isAllDay = eventData.start?.date && !eventData.start?.dateTime;
+        if (isAllDay) {
+          return [];
+        }
+      }
+
+      return [eventData];
+    } else {
+      return [];
+    }
+  },
+
+  async test(context) {
+    const auth = context.auth as GoogleCalendarAuthValue;
+    const { event_types, search_filter, exclude_all_day } = context.propsValue;
+
+    const latestEvent = await getLatestEvent(
+      context.propsValue.calendar_id!,
+      auth
+    );
+
+    if (event_types && event_types.length > 0) {
+      const eventType = latestEvent.eventType || 'default';
+      if (!event_types.includes(eventType)) {
+        return [];
+      }
+    }
+
+    if (search_filter && search_filter.trim()) {
+      const searchTerm = search_filter.toLowerCase().trim();
+      const summary = (latestEvent.summary || '').toLowerCase();
+      const description = (latestEvent.description || '').toLowerCase();
+      const location = (latestEvent.location || '').toLowerCase();
+
+      const matchesSearch =
+        summary.includes(searchTerm) ||
+        description.includes(searchTerm) ||
+        location.includes(searchTerm);
+
+      if (!matchesSearch) {
+        return [];
+      }
+    }
+
+    if (exclude_all_day) {
+      const isAllDay = latestEvent.start?.date && !latestEvent.start?.dateTime;
+      if (isAllDay) {
+        return [];
+      }
+    }
+
+    return [latestEvent];
+  },
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ],
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {},
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "types": ["node"]
+  },
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}