@divyacon/piece-gmail 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,173 @@
+import {
+  createTrigger,
+  TriggerStrategy,
+  FilesService,
+} from '@agnocon/pieces-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 { gmail as googleGmail } from '@googleapis/gmail';
+import { gmailNewEmailReceivedTriggerOutputSchema } from '../output-schemas';
+
+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',
+  aiMetadata: {
+    description:
+      'Fires when a new email arrives in the connected Gmail account, optionally narrowed by sender, recipient, subject, label, or category filters. Each event represents one newly received message with its parsed contents and thread.',
+  },
+  props: {
+    subject: GmailProps.subject,
+    from: GmailProps.from,
+    to: GmailProps.to,
+    label: GmailProps.label({ required: false }),
+    category: GmailProps.category,
+  },
+  outputSchema: gmailNewEmailReceivedTriggerOutputSchema,
+  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 = googleGmail({ 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,83 @@
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { gmailAuth, createGoogleClient } from '../auth';
+import { gmail as googleGmail } from '@googleapis/gmail';
+import { getFirstFiveOrAll } from '../common/data';
+import { isNil } from '@agnocon/pieces-framework';
+import { newLabelTriggerOutputSchema } from '../output-schemas';
+
+const TRIGGER_KEY = 'labels';
+
+export const gmailNewLabelTrigger = createTrigger({
+  auth: gmailAuth,
+  name: 'new_label',
+  displayName: 'New Label',
+  description: 'Triggers when a new label is created.',
+  aiMetadata: {
+    description:
+      'Fires when a new label is created in the connected Gmail account. Each event represents one newly added label not seen on a prior poll.',
+  },
+  props: {},
+  outputSchema: newLabelTriggerOutputSchema,
+  sampleData: {},
+  type: TriggerStrategy.POLLING,
+  async onEnable(context) {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = googleGmail({ 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 = googleGmail({ 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 = googleGmail({ 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;
+  },
+});

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

@@ -0,0 +1,197 @@
+import {
+  createTrigger,
+  TriggerStrategy,
+  FilesService,
+} from '@agnocon/pieces-framework';
+import { GmailProps } from '../common/props';
+import { gmailAuth, createGoogleClient } from '../auth';
+import { gmail as googleGmail } from '@googleapis/gmail';
+import { parseStream, convertAttachment } from '../common/data';
+import { newLabeledEmailTriggerOutputSchema } from '../output-schemas';
+
+async function enrichGmailMessage({
+  gmail,
+  messageId,
+  files,
+  labelInfo,
+}: {
+  gmail: any;
+  messageId: string;
+  files: FilesService;
+  labelInfo: {
+    labelId: string;
+    labelName: string;
+  };
+}) {
+  const rawMailResponse = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'raw',
+  });
+
+  const threadResponse = await gmail.users.threads.get({
+    userId: 'me',
+    id: rawMailResponse.data.threadId!,
+  });
+
+  const parsedMailResponse = await parseStream(
+    Buffer.from(rawMailResponse.data.raw as string, 'base64').toString('utf-8')
+  );
+
+  return {
+    message: {
+      ...parsedMailResponse,
+      attachments: await convertAttachment(
+        parsedMailResponse.attachments,
+        files
+      ),
+    },
+    thread: threadResponse.data,
+    labelInfo: {
+      ...labelInfo,
+      addedAt: Date.now(),
+    },
+  };
+}
+
+export const gmailNewLabeledEmailTrigger = createTrigger({
+  auth: gmailAuth,
+  name: 'new_labeled_email',
+  displayName: 'New Labeled Email',
+  description: 'Triggers when a label is added to an email',
+  aiMetadata: {
+    description:
+      'Fires when the specified label is applied to an email (either newly received with the label or labeled afterward). Each event represents one message that just gained that label, with its parsed contents and label info.',
+  },
+  props: {
+    label: GmailProps.label({
+      required: true,
+    }),
+  },
+  outputSchema: newLabeledEmailTriggerOutputSchema,
+  sampleData: {},
+  type: TriggerStrategy.POLLING,
+  onEnable: async (context) => {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = googleGmail({ version: 'v1', auth: authClient });
+
+    const profile = await gmail.users.getProfile({
+      userId: 'me',
+    });
+
+    await context.store.put('lastHistoryId', profile.data.historyId);
+  },
+  onDisable: async (context) => {
+    await context.store.delete('lastHistoryId');
+  },
+  run: async (context) => {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = googleGmail({ version: 'v1', auth: authClient });
+
+    const lastHistoryId = await context.store.get('lastHistoryId');
+
+    const historyResponse = await gmail.users.history.list({
+      userId: 'me',
+      startHistoryId: lastHistoryId as string,
+      labelId: context.propsValue.label.id,
+      historyTypes: ['labelAdded', 'messageAdded'],
+    });
+
+    const labeledMessages = new Map<string, string>();
+    const results = [];
+
+    if (historyResponse.data.history) {
+      for (const history of historyResponse.data.history) {
+        if (history.labelsAdded) {
+          for (const labelAdded of history.labelsAdded) {
+            if (
+              labelAdded.labelIds?.includes(context.propsValue.label.id) &&
+              labelAdded.message?.id
+            ) {
+              labeledMessages.set(
+                labelAdded.message.id,
+                history.id?.toString() || ''
+              );
+            }
+          }
+        } else if (history.messagesAdded) {
+          for (const messageAdded of history.messagesAdded) {
+            if (
+              messageAdded.message?.id &&
+              messageAdded.message.labelIds?.includes(
+                context.propsValue.label.id
+              )
+            ) {
+              labeledMessages.set(
+                messageAdded.message.id,
+                history.id?.toString() || ''
+              );
+            }
+          }
+        }
+      }
+    }
+
+    for (const [messageId, historyId] of labeledMessages) {
+      const enrichedMessage = await enrichGmailMessage({
+        gmail,
+        messageId,
+        files: context.files,
+        labelInfo: {
+          labelId: context.propsValue.label.id,
+          labelName: context.propsValue.label.name,
+        },
+      });
+
+      if (lastHistoryId !== historyId) {
+        results.push({
+          id: historyId,
+          data: enrichedMessage,
+        });
+      }
+    }
+
+    if (historyResponse.data.historyId) {
+      await context.store.put('lastHistoryId', historyResponse.data.historyId);
+    }
+
+    return results;
+  },
+  test: async (context) => {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = googleGmail({ version: 'v1', auth: authClient });
+
+    const messagesResponse = await gmail.users.messages.list({
+      userId: 'me',
+      labelIds: [context.propsValue.label.id],
+      maxResults: 5,
+    });
+
+    const results = [];
+
+    if (messagesResponse.data.messages) {
+      for (const message of messagesResponse.data.messages) {
+        const messageId = message.id;
+        if (!messageId) {
+          continue;
+        }
+        const enrichedMessage = await enrichGmailMessage({
+          gmail,
+          messageId: messageId,
+          files: context.files,
+          labelInfo: {
+            labelId: context.propsValue.label.id,
+            labelName: context.propsValue.label.name,
+          },
+        });
+
+        results.push({
+          id: messageId,
+          data: enrichedMessage,
+        });
+      }
+    }
+
+    return results;
+  },
+});