@guayaba/workflow-piece-gmail 0.12.3

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

@@ -0,0 +1,413 @@
+import {
+  createTrigger,
+  TriggerStrategy,
+  FilesService,
+  Property,
+} from '@guayaba/workflows-framework';
+import { GmailProps } from '../common/props';
+import { gmailAuth, createGoogleClient } from '../auth';
+import { google } from 'googleapis';
+import { parseStream, convertAttachment } from '../common/data';
+
+async function enrichNewConversation({
+  gmail,
+  threadId,
+  files,
+  conversationInfo,
+}: {
+  gmail: any;
+  threadId: string;
+  files: FilesService;
+  conversationInfo: {
+    createdAt: number;
+    historyId: string;
+  };
+}) {
+  const threadResponse = await gmail.users.threads.get({
+    userId: 'me',
+    id: threadId,
+    format: 'full',
+  });
+
+  const thread = threadResponse.data;
+  const messages = thread.messages || [];
+
+  const firstMessage = messages[0];
+  if (!firstMessage?.id) {
+    throw new Error('No messages found in thread');
+  }
+
+  const rawMessageResponse = await gmail.users.messages.get({
+    userId: 'me',
+    id: firstMessage.id,
+    format: 'raw',
+  });
+
+  const parsedFirstMessage = await parseStream(
+    Buffer.from(rawMessageResponse.data.raw as string, 'base64').toString(
+      'utf-8'
+    )
+  );
+
+  const headers = firstMessage.payload?.headers || [];
+  const headerMap = headers.reduce(
+    (acc: { [key: string]: string }, header: any) => {
+      if (header.name && header.value) {
+        acc[header.name.toLowerCase()] = header.value;
+      }
+      return acc;
+    },
+    {}
+  );
+
+  return {
+    conversation: {
+      threadId: threadId,
+      messageCount: messages.length,
+      snippet: thread.snippet || '',
+      historyId: thread.historyId,
+      participants: extractParticipants(messages),
+      subject: headerMap['subject'] || '',
+      starter: {
+        from: headerMap['from'] || '',
+        to: headerMap['to'] || '',
+        cc: headerMap['cc'] || '',
+        bcc: headerMap['bcc'] || '',
+        date: headerMap['date'] || '',
+        messageId: firstMessage.id,
+      },
+    },
+    firstMessage: {
+      ...parsedFirstMessage,
+      messageId: firstMessage.id,
+      attachments: await convertAttachment(
+        parsedFirstMessage.attachments,
+        files
+      ),
+    },
+    conversationInfo: {
+      ...conversationInfo,
+      triggeredAt: Date.now(),
+    },
+  };
+}
+
+function extractParticipants(messages: any[]): {
+  from: Set<string>;
+  to: Set<string>;
+  cc: Set<string>;
+} {
+  const participants = {
+    from: new Set<string>(),
+    to: new Set<string>(),
+    cc: new Set<string>(),
+  };
+
+  messages.forEach((message) => {
+    const headers = message.payload?.headers || [];
+    headers.forEach((header: any) => {
+      if (header.name && header.value) {
+        const name = header.name.toLowerCase();
+        const value = header.value;
+
+        if (name === 'from') {
+          participants.from.add(value);
+        } else if (name === 'to') {
+          value
+            .split(',')
+            .forEach((email: string) => participants.to.add(email.trim()));
+        } else if (name === 'cc') {
+          value
+            .split(',')
+            .forEach((email: string) => participants.cc.add(email.trim()));
+        }
+      }
+    });
+  });
+
+  return {
+    from: participants.from,
+    to: participants.to,
+    cc: participants.cc,
+  };
+}
+
+export const gmailNewConversationTrigger = createTrigger({
+  auth: gmailAuth,
+  name: 'new_conversation',
+  displayName: 'New Conversation',
+  description: 'Triggers when a new email conversation (thread) begins',
+  props: {
+    from: {
+      ...GmailProps.from,
+      description: 'Filter by sender email (optional)',
+      displayName: 'From',
+      required: false,
+    },
+    subject: Property.ShortText({
+      displayName: 'Subject Contains',
+      description:
+        'Only trigger for conversations containing this text in the subject (optional)',
+      required: false,
+    }),
+    maxAgeHours: Property.Number({
+      displayName: 'Maximum Age (Hours)',
+      description:
+        'Only trigger for conversations started within this many hours',
+      required: false,
+      defaultValue: 24,
+    }),
+  },
+  sampleData: {},
+  type: TriggerStrategy.POLLING,
+  onEnable: async (context) => {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const profile = await gmail.users.getProfile({ userId: 'me' });
+    await context.store.put('lastHistoryId', profile.data.historyId);
+    await context.store.put('processedThreads', []);
+  },
+  onDisable: async (context) => {
+    await context.store.delete('lastHistoryId');
+    await context.store.delete('processedThreads');
+  },
+  run: async (context) => {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const lastHistoryId = await context.store.get('lastHistoryId');
+    const processedThreads =
+      (await context.store.get<string[]>('processedThreads')) || [];
+    const maxAge = (context.propsValue.maxAgeHours || 24) * 60 * 60 * 1000;
+    const cutoffTime = Date.now() - maxAge;
+
+    try {
+      const historyResponse = await gmail.users.history.list({
+        userId: 'me',
+        startHistoryId: lastHistoryId as string,
+        historyTypes: ['messageAdded'],
+        maxResults: 100,
+      });
+
+      const newConversations: string[] = [];
+
+      if (historyResponse.data.history) {
+        for (const history of historyResponse.data.history) {
+          if (history.messagesAdded) {
+            for (const added of history.messagesAdded) {
+              const threadId = added.message?.threadId;
+              if (threadId && !processedThreads.includes(threadId)) {
+                const threadResponse = await gmail.users.threads.get({
+                  userId: 'me',
+                  id: threadId,
+                  format: 'minimal',
+                });
+
+                if (threadResponse.data.messages?.length === 1) {
+                  newConversations.push(threadId);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      const results: any[] = [];
+      for (const threadId of newConversations) {
+        const threadResponse = await gmail.users.threads.get({
+          userId: 'me',
+          id: threadId,
+          format: 'full',
+        });
+
+        const thread = threadResponse.data;
+        const firstMessage = thread.messages?.[0];
+        if (!firstMessage) continue;
+
+        const messageDate = parseInt(firstMessage.internalDate || '0');
+        if (messageDate < cutoffTime) continue;
+
+        const headers = firstMessage.payload?.headers || [];
+        const headerMap: { [key: string]: string } = {};
+        headers.forEach((h: any) => {
+          if (h.name && h.value) {
+            headerMap[h.name.toLowerCase()] = h.value;
+          }
+        });
+
+        if (context.propsValue.from) {
+          const from = headerMap['from'] || '';
+          if (
+            !from.toLowerCase().includes(context.propsValue.from.toLowerCase())
+          ) {
+            continue;
+          }
+        }
+
+        if (context.propsValue.subject) {
+          const subject = headerMap['subject'] || '';
+          if (
+            !subject
+              .toLowerCase()
+              .includes(context.propsValue.subject.toLowerCase())
+          ) {
+            continue;
+          }
+        }
+
+        const rawResponse = await gmail.users.messages.get({
+          userId: 'me',
+          id: firstMessage.id!,
+          format: 'raw',
+        });
+
+        const parsedMessage = await parseStream(
+          Buffer.from(rawResponse.data.raw as string, 'base64').toString(
+            'utf-8'
+          )
+        );
+
+        results.push({
+          id: `conversation_${threadId}`,
+          data: {
+            thread: {
+              id: threadId,
+              snippet: thread.snippet,
+              messageCount: 1,
+            },
+            message: {
+              ...parsedMessage,
+              id: firstMessage.id,
+              threadId: threadId,
+              date: new Date(messageDate).toISOString(),
+              attachments: await convertAttachment(
+                parsedMessage.attachments,
+                context.files
+              ),
+            },
+            conversation: {
+              starter: {
+                from: headerMap['from'],
+                to: headerMap['to'],
+                subject: headerMap['subject'],
+                date: headerMap['date'],
+              },
+            },
+          },
+        });
+
+        processedThreads.push(threadId);
+      }
+
+      if (historyResponse.data.historyId) {
+        await context.store.put(
+          'lastHistoryId',
+          historyResponse.data.historyId
+        );
+      }
+
+      const recentThreads = processedThreads.slice(-1000);
+      await context.store.put('processedThreads', recentThreads);
+
+      return results;
+    } catch (error: any) {
+      if (error.code === 404) {
+        const profile = await gmail.users.getProfile({ userId: 'me' });
+        await context.store.put('lastHistoryId', profile.data.historyId);
+        return [];
+      }
+      throw error;
+    }
+  },
+  test: async (context) => {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const maxAge = (context.propsValue.maxAgeHours || 24) * 60 * 60 * 1000;
+    const cutoffSeconds = Math.floor((Date.now() - maxAge) / 1000);
+
+    let query = `after:${cutoffSeconds}`;
+    if (context.propsValue.from) {
+      query += ` from:(${context.propsValue.from})`;
+    }
+    if (context.propsValue.subject) {
+      query += ` subject:(${context.propsValue.subject})`;
+    }
+
+    const threadsResponse = await gmail.users.threads.list({
+      userId: 'me',
+      q: query,
+      maxResults: 5,
+    });
+
+    const results: any[] = [];
+    if (threadsResponse.data.threads) {
+      for (const thread of threadsResponse.data.threads) {
+        const threadId = thread.id!;
+
+        const fullThread = await gmail.users.threads.get({
+          userId: 'me',
+          id: threadId,
+          format: 'full',
+        });
+
+        if (fullThread.data.messages?.length === 1) {
+          const firstMessage = fullThread.data.messages[0];
+          const headers = firstMessage.payload?.headers || [];
+          const headerMap: { [key: string]: string } = {};
+          headers.forEach((h: any) => {
+            if (h.name && h.value) {
+              headerMap[h.name.toLowerCase()] = h.value;
+            }
+          });
+
+          const rawResponse = await gmail.users.messages.get({
+            userId: 'me',
+            id: firstMessage.id!,
+            format: 'raw',
+          });
+
+          const parsedMessage = await parseStream(
+            Buffer.from(rawResponse.data.raw as string, 'base64').toString(
+              'utf-8'
+            )
+          );
+
+          results.push({
+            id: `test_conversation_${threadId}`,
+            data: {
+              thread: {
+                id: threadId,
+                snippet: fullThread.data.snippet,
+                messageCount: 1,
+              },
+              message: {
+                ...parsedMessage,
+                id: firstMessage.id,
+                threadId: threadId,
+                date: new Date(
+                  parseInt(firstMessage.internalDate || '0')
+                ).toISOString(),
+                attachments: await convertAttachment(
+                  parsedMessage.attachments,
+                  context.files
+                ),
+              },
+              conversation: {
+                starter: {
+                  from: headerMap['from'],
+                  to: headerMap['to'],
+                  subject: headerMap['subject'],
+                  date: headerMap['date'],
+                },
+              },
+            },
+          });
+        }
+      }
+    }
+
+    return results;
+  },
+});

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

@@ -0,0 +1,167 @@
+import {
+  createTrigger,
+  TriggerStrategy,
+  FilesService,
+} from '@guayaba/workflows-framework';
+import { GmailLabel } from '../common/models';
+import { GmailProps } from '../common/props';
+import { gmailAuth, createGoogleClient, GmailAuthValue } from '../auth';
+import {
+  parseStream,
+  convertAttachment,
+  getFirstFiveOrAll,
+} from '../common/data';
+import { google } from 'googleapis';
+
+export const gmailNewEmailTrigger = createTrigger({
+  auth: gmailAuth,
+  name: 'gmail_new_email_received',
+  displayName: 'New Email',
+  description: 'Triggers when new mail is found in your Gmail inbox',
+  props: {
+    subject: GmailProps.subject,
+    from: GmailProps.from,
+    to: GmailProps.to,
+    label: GmailProps.label,
+    category: GmailProps.category,
+  },
+  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));
+  },
+});
+
+interface PropsValue {
+  from: string | undefined;
+  to: string | undefined;
+  subject: string | undefined;
+  label: GmailLabel | undefined;
+  category: string | undefined;
+}
+
+async function pollRecentMessages({
+  auth,
+  props,
+  files,
+  lastFetchEpochMS,
+}: {
+  auth: GmailAuthValue;
+  props: PropsValue;
+  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 = [];
+  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 (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 threadResponse = await gmail.users.threads.get({
+        userId: 'me',
+        id: message.threadId!,
+      });
+
+      const parsedMailResponse = await parseStream(
+        Buffer.from(rawMailResponse.data.raw as string, 'base64').toString(
+          'utf-8'
+        )
+      );
+
+      pollingResponse.push({
+        epochMilliSeconds: Number(rawMailResponse.data.internalDate),
+        data: {
+          message: {
+            ...parsedMailResponse,
+            attachments: await convertAttachment(
+              parsedMailResponse.attachments,
+              files
+            ),
+          },
+          thread: {
+            ...threadResponse,
+          },
+        },
+      });
+    } 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;
+}

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

@@ -0,0 +1,77 @@
+import { createTrigger, TriggerStrategy } from '@guayaba/workflows-framework';
+import { gmailAuth, createGoogleClient } from '../auth';
+import { google } from 'googleapis';
+import { getFirstFiveOrAll } from '../common/data';
+import { isNil } from '@guayaba/workflows-shared';
+
+const TRIGGER_KEY = 'labels';
+
+export const gmailNewLabelTrigger = createTrigger({
+  auth: gmailAuth,
+  name: 'new_label',
+  displayName: 'New Label',
+  description: 'Triggers when a new label is created.',
+  props: {},
+  sampleData: {},
+  type: TriggerStrategy.POLLING,
+  async onEnable(context) {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const response = await gmail.users.labels.list({
+      userId: 'me',
+    });
+
+    const labels = response.data.labels || [];
+
+    const existingLabelIds = labels.map((label) => label.id);
+    await context.store.put(TRIGGER_KEY, JSON.stringify(existingLabelIds));
+  },
+  async onDisable(context) {
+    await context.store.delete(TRIGGER_KEY);
+  },
+  async test(context) {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const response = await gmail.users.labels.list({
+      userId: 'me',
+    });
+
+    const labels = response.data.labels || [];
+
+    return getFirstFiveOrAll(labels);
+  },
+  async run(context) {
+    const existingIds = (await context.store.get<string>(TRIGGER_KEY)) ?? '[]';
+    const parsedExistingIds = JSON.parse(existingIds) as string[];
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const response = await gmail.users.labels.list({
+      userId: 'me',
+    });
+
+    if (isNil(response.data.labels) || response.data.labels.length === 0) {
+      await context.store.put(TRIGGER_KEY, '[]');
+      return [];
+    }
+
+    const allCurrentIds = response.data.labels.map((label) => label.id);
+
+    const newLables = response.data.labels.filter((label) => {
+      const labelId = label.id ?? undefined;
+      return labelId !== undefined && !parsedExistingIds.includes(labelId);
+    });
+
+    await context.store.put(TRIGGER_KEY, JSON.stringify(allCurrentIds));
+
+    if (newLables.length === 0) {
+      return [];
+    }
+
+    return newLables;
+  },
+});