@guayaba/workflow-piece-gmail 0.12.3

package/src/lib/common/props.ts

@@ -0,0 +1,256 @@
+import { Property } from '@guayaba/workflows-framework';
+import { GmailRequests } from './data';
+import { GmailLabel } from './models';
+import { gmailAuth, createGoogleClient, GmailAuthValue } from '../auth';
+import { google } from 'googleapis';
+
+export const GmailProps = {
+  from: Property.ShortText({
+    displayName: 'Email sender',
+    description:
+      'Optional filteration, leave empty to filter based on the email sender',
+    required: false,
+    defaultValue: '',
+  }),
+  to: Property.ShortText({
+    displayName: 'Email recipient',
+    description:
+      'Optional filteration, leave empty to filter based on the email recipient',
+    required: false,
+    defaultValue: '',
+  }),
+  subject: Property.ShortText({
+    displayName: 'Email subject',
+    description: 'The email subject',
+    required: false,
+    defaultValue: '',
+  }),
+  category: Property.StaticDropdown({
+    displayName: 'Category',
+    description:
+      'Optional filteration, leave unselected to filter based on the email category',
+    required: false,
+    options: {
+      disabled: false,
+      options: [
+        { label: 'Primary', value: 'primary' },
+        { label: 'Social', value: 'social' },
+        { label: 'Promotions', value: 'promotions' },
+        { label: 'Updates', value: 'updates' },
+        { label: 'Forums', value: 'forums' },
+        { label: 'Reservations', value: 'reservations' },
+        { label: 'Purchases', value: 'purchases' },
+      ],
+    },
+  }),
+  label: Property.Dropdown<GmailLabel, false, typeof gmailAuth>({
+    auth: gmailAuth,
+    displayName: 'Label',
+    description:
+      'Optional filteration, leave unselected to filter based on the email label',
+    required: false,
+    defaultValue: '',
+    refreshers: [],
+    options: async ({ auth }) => {
+      if (!auth) {
+        return {
+          disabled: true,
+          options: [],
+          placeholder: 'please authenticate first',
+        };
+      }
+
+      const response = await GmailRequests.getLabels(auth);
+
+      return {
+        disabled: false,
+        options: response.body.labels.map((label) => ({
+          label: label.name,
+          value: label,
+        })),
+      };
+    },
+  }),
+  unread: (required = false) =>
+    Property.Checkbox({
+      displayName: 'Is unread?',
+      description: 'Check if the email is unread or not',
+      required,
+      defaultValue: false,
+    }),
+  message: Property.Dropdown({
+    displayName: 'Message',
+    description:
+      'Select a message from the list or enter a message ID manually.',
+    required: true,
+    auth: gmailAuth,
+    refreshers: [],
+    options: async ({ auth }) => {
+      if (!auth) {
+        return {
+          disabled: true,
+          options: [],
+          placeholder: 'Please authenticate first',
+        };
+      }
+
+      try {
+        const authValue = auth as GmailAuthValue;
+        const authClient = await createGoogleClient(authValue);
+
+        const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+        const response = await GmailRequests.getRecentMessages(
+          authValue,
+          20 // Get last 20 messages
+        );
+
+        if (!response.body.messages || response.body.messages.length === 0) {
+          return {
+            disabled: false,
+            options: [],
+            placeholder:
+              'No recent messages found. You can enter a message ID manually.',
+          };
+        }
+
+        // Get message details for better display
+        const messageDetails = await Promise.all(
+          response.body.messages
+            .slice(0, 10)
+            .map(async (msg: { id: string; threadId: string }) => {
+              try {
+                const details = await gmail.users.messages.get({
+                  metadataHeaders: ['Subject'],
+                  format: 'metadata',
+                  id: msg.id,
+                  userId: 'me',
+                });
+
+                const headers = details.data.payload?.headers || [];
+                const subject =
+                  headers.find((h: any) => h.name === 'Subject')?.value ||
+                  'No Subject';
+
+                return {
+                  id: msg.id,
+                  subject:
+                    subject.length > 50
+                      ? subject.substring(0, 50) + '...'
+                      : subject,
+                };
+              } catch (error) {
+                console.log(error);
+                return {
+                  id: msg.id,
+                  subject: 'Unable to load details',
+                };
+              }
+            })
+        );
+
+        return {
+          disabled: false,
+          options: messageDetails.map((msg) => ({
+            label: msg.subject,
+            value: msg.id,
+          })),
+        };
+      } catch (error) {
+        return {
+          disabled: false,
+          options: [],
+          placeholder:
+            'Error loading recent messages. You can enter a message ID manually.',
+        };
+      }
+    },
+  }),
+  thread: Property.Dropdown({
+    displayName: 'Thread',
+    description: 'Select a thread from the list or enter a thread ID manually',
+    required: true,
+    refreshers: [],
+    auth: gmailAuth,
+    options: async ({ auth }) => {
+      if (!auth) {
+        return {
+          disabled: true,
+          options: [],
+          placeholder: 'Please authenticate first',
+        };
+      }
+
+      try {
+        const authValue = auth as GmailAuthValue;
+        const authClient = await createGoogleClient(authValue);
+
+        const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+        const response = await GmailRequests.getRecentThreads(
+          authValue,
+          15 // Get last 15 threads
+        );
+
+        if (!response.body.threads || response.body.threads.length === 0) {
+          return {
+            disabled: false,
+            options: [],
+            placeholder:
+              'No recent threads found. You can enter a thread ID manually.',
+          };
+        }
+
+        // Get thread details for better display
+        const threadDetails = await Promise.all(
+          response.body.threads
+            .slice(0, 10)
+            .map(async (thread: { id: string; snippet?: string }) => {
+              try {
+                const details = await await gmail.users.threads.get({
+                  metadataHeaders: ['Subject'],
+                  format: 'metadata',
+                  id: thread.id,
+                  userId: 'me',
+                });
+                // Get the first message to extract subject and participants
+                const firstMessage = details.data.messages?.[0];
+                const headers = firstMessage?.payload?.headers || [];
+                const subject =
+                  headers.find((h: any) => h.name === 'Subject')?.value ||
+                  'No Subject';
+
+                return {
+                  id: thread.id,
+                  subject:
+                    subject.length > 50
+                      ? subject.substring(0, 50) + '...'
+                      : subject,
+                };
+              } catch (error) {
+                return {
+                  id: thread.id,
+                  subject: 'Unable to load details',
+                };
+              }
+            })
+        );
+
+        return {
+          disabled: false,
+          options: threadDetails.map((thread) => ({
+            label: thread.subject,
+            value: thread.id,
+          })),
+        };
+      } catch (error) {
+        return {
+          disabled: false,
+          options: [],
+          placeholder:
+            'Error loading recent threads. You can enter a thread ID manually.',
+        };
+      }
+    },
+  }),
+};

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

@@ -0,0 +1,198 @@
+import {
+  createTrigger,
+  TriggerStrategy,
+  Property,
+  FilesService,
+} from '@guayaba/workflows-framework';
+import { GmailProps } from '../common/props';
+import { gmailAuth, createGoogleClient, GmailAuthValue } from '../auth';
+import { google } from 'googleapis';
+import {
+  parseStream,
+  convertAttachment,
+  getFirstFiveOrAll,
+} from '../common/data';
+import { GmailLabel } from '../common/models';
+
+type Props = {
+  from?: string;
+  to?: string;
+  subject?: string;
+  label?: GmailLabel;
+  category?: string;
+  filenameExtension?: string;
+};
+
+export const gmailNewAttachmentTrigger = createTrigger({
+  auth: gmailAuth,
+  name: 'new_attachment',
+  displayName: 'New Attachment',
+  description: 'Triggers when an email with an attachment arrives.',
+  props: {
+    from: {
+      ...GmailProps.from,
+      description: 'Filter by sender email.',
+      displayName: 'From',
+      required: false,
+    },
+    to: {
+      ...GmailProps.to,
+      description: 'Filter by recipient email.',
+      displayName: 'To',
+      required: false,
+    },
+    subject: Property.ShortText({
+      displayName: 'Subject Contains',
+      description:
+        'Only trigger for emails containing this text in the subject.',
+      required: false,
+    }),
+    label: {
+      ...GmailProps.label,
+      description: 'Filter by Gmail label.',
+      displayName: 'Label',
+      required: false,
+    },
+    category: {
+      ...GmailProps.category,
+      description: 'Filter by Gmail category.',
+      displayName: 'Category',
+      required: false,
+    },
+    filenameExtension: Property.ShortText({
+      displayName: 'File Extension',
+      description:
+        'Only trigger for attachments with this file extension (e.g., pdf, jpg, docx).',
+      required: false,
+    }),
+  },
+  sampleData: {},
+  type: TriggerStrategy.POLLING,
+  async onEnable(context) {
+    await context.store.put('lastPoll', Date.now());
+  },
+  async onDisable(context) {
+    return;
+  },
+  async run(context) {
+    const lastFetchEpochMS = (await context.store.get<number>('lastPoll')) ?? 0;
+
+    const items = await pollRecentMessages({
+      auth: context.auth,
+      props: context.propsValue,
+      files: context.files,
+      lastFetchEpochMS: lastFetchEpochMS,
+    });
+
+    const newLastEpochMilliSeconds = items.reduce(
+      (acc, item) => Math.max(acc, item.epochMilliSeconds),
+      lastFetchEpochMS
+    );
+    await context.store.put('lastPoll', newLastEpochMilliSeconds);
+    return items
+      .filter((f) => f.epochMilliSeconds > lastFetchEpochMS)
+      .map((item) => item.data);
+  },
+  async test(context) {
+    const lastFetchEpochMS = (await context.store.get<number>('lastPoll')) ?? 0;
+
+    const items = await pollRecentMessages({
+      auth: context.auth,
+      props: context.propsValue,
+      files: context.files,
+      lastFetchEpochMS: lastFetchEpochMS,
+    });
+
+    return getFirstFiveOrAll(items.map((item) => item.data));
+  },
+});
+
+async function pollRecentMessages({
+  auth,
+  props,
+  files,
+  lastFetchEpochMS,
+}: {
+  auth: GmailAuthValue;
+  props: Props;
+  files: FilesService;
+  lastFetchEpochMS: number;
+}): Promise<
+  {
+    epochMilliSeconds: number;
+    data: unknown;
+  }[]
+> {
+  const authClient = await createGoogleClient(auth);
+
+  const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+  // construct query
+  const query = ['has:attachment'];
+  const maxResults = lastFetchEpochMS === 0 ? 5 : 20;
+  const afterUnixSeconds = Math.floor(lastFetchEpochMS / 1000);
+
+  if (props.from) query.push(`from:(${props.from})`);
+  if (props.to) query.push(`to:(${props.to})`);
+  if (props.subject) query.push(`subject:(${props.subject})`);
+  if (props.label) query.push(`label:${props.label.name}`);
+  if (props.category) query.push(`category:${props.category}`);
+  if (props.filenameExtension)
+    query.push(`filename:${props.filenameExtension}`);
+  if (afterUnixSeconds != null && afterUnixSeconds > 0)
+    query.push(`after:${afterUnixSeconds}`);
+
+  // List Messages
+  const messagesResponse = await gmail.users.messages.list({
+    userId: 'me',
+    q: query.join(' '),
+    maxResults,
+  });
+
+  // Reverse to process oldest-first so partial progress doesn't skip messages
+  const messages = (messagesResponse.data.messages || []).slice().reverse();
+
+  const pollingResponse = [];
+  for (const message of messages) {
+    try {
+      const rawMailResponse = await gmail.users.messages.get({
+        userId: 'me',
+        id: message.id!,
+        format: 'raw',
+      });
+
+      const parsedMailResponse = await parseStream(
+        Buffer.from(rawMailResponse.data.raw as string, 'base64').toString(
+          'utf-8'
+        )
+      );
+
+      const { attachments, ...restOfParsedMailResponse } = parsedMailResponse;
+      const parsedAttachments = await convertAttachment(attachments, files);
+
+      for (const attachment of parsedAttachments) {
+        pollingResponse.push({
+          epochMilliSeconds: Number(rawMailResponse.data.internalDate),
+          data: {
+            attachment,
+            message: {
+              id: message.id,
+              ...restOfParsedMailResponse,
+            },
+          },
+        });
+      }
+    } catch (error: any) {
+      const isRateLimit =
+        error.status === 429 ||
+        (error.status === 403 &&
+          /quota|rate.?limit/i.test(error.message ?? ''));
+      if (isRateLimit) {
+        break;
+      }
+      throw error;
+    }
+  }
+
+  return pollingResponse;
+}