@divyacon/piece-gmail 0.0.0-stage → 0.1.1

package/src/lib/common/data.ts

@@ -0,0 +1,268 @@
+import { FilesService } from '@agnocon/pieces-framework';
+import {
+  GmailLabel,
+  GmailMessage,
+  GmailThread,
+  GmailMessageFormat,
+  GmailMessageResponse as GmailMessageList,
+} from './models';
+import {
+  AuthenticationType,
+  httpClient,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { Attachment, ParsedMail, simpleParser } from 'mailparser';
+import { GmailAuthValue, getAccessToken } from '../auth';
+
+interface SearchMailProps {
+  access_token: string;
+  from: string;
+  to: string;
+  subject?: string;
+  label: GmailLabel;
+  category: string;
+  after?: number;
+  before?: number;
+  max_results?: number;
+  page_token?: string;
+}
+
+interface GetMailProps {
+  access_token: string;
+  message_id?: string;
+  thread_id?: string;
+  format: GmailMessageFormat;
+}
+
+export const GmailRequests = {
+  getMail: async ({ access_token, format, message_id }: GetMailProps) => {
+    const response = await httpClient.sendRequest<GmailMessage>({
+      method: HttpMethod.GET,
+      url: `https://gmail.googleapis.com/gmail/v1/users/me/messages/${message_id}`,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: access_token,
+      },
+      queryParams: {
+        format,
+      },
+    });
+    let bodyHtml = '';
+    let bodyPlain = '';
+    const payload = response.body.payload;
+    let bodyParts = payload.parts || [];
+    const headers = payload.headers.reduce(
+      (obj: { [key: string]: string }, header) => {
+        obj[header.name.toLowerCase()] = header.value;
+        return obj;
+      },
+      {}
+    );
+    const alternateBodyPart = bodyParts.find((part) =>
+      part.mimeType.startsWith('multipart/alternative')
+    );
+    if (alternateBodyPart && alternateBodyPart?.parts) {
+      bodyParts = alternateBodyPart.parts;
+    }
+    const subject = headers['subject'] || '';
+    // Determine the content type of the message body
+    const contentType = headers['content-type'] || 'text/plain';
+    const isMultipart = contentType.startsWith('multipart/');
+
+    if (isMultipart) {
+      // If the message is multipart, extract the plain text and HTML parts
+      const textPart = bodyParts.find((part) => part.mimeType === 'text/plain');
+      const htmlPart = bodyParts.find((part) => part.mimeType === 'text/html');
+
+      // If the message is an "alternative" multipart, use the plain text part if it exists
+      const preferredPart = textPart || htmlPart;
+      bodyHtml = htmlPart ? decodeBase64(htmlPart.body.data) : '';
+      bodyPlain = preferredPart ? decodeBase64(preferredPart.body.data) : '';
+    } else {
+      // If the message is not multipart, use the body as-is
+      bodyPlain = decodeBase64(payload.body.data);
+      bodyHtml = '';
+    }
+
+    return {
+      subject: subject,
+      body_html: bodyHtml,
+      body_plain: bodyPlain,
+      ...response.body,
+    };
+  },
+  getThread: async ({ access_token, format, thread_id }: GetMailProps) => {
+    const response = await httpClient.sendRequest<GmailThread>({
+      method: HttpMethod.GET,
+      url: `https://gmail.googleapis.com/gmail/v1/users/me/threads/${thread_id}`,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: access_token,
+      },
+      queryParams: {
+        format,
+      },
+    });
+
+    return response.body;
+  },
+  getLabels: async (authentication: GmailAuthValue) => {
+    return await httpClient.sendRequest<{ labels: GmailLabel[] }>({
+      method: HttpMethod.GET,
+      url: `https://gmail.googleapis.com/gmail/v1/users/me/labels`,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(authentication),
+      },
+    });
+  },
+  searchMail: async ({
+    access_token,
+    max_results = 1,
+    page_token: pageToken,
+    ...mail
+  }: SearchMailProps) => {
+    const query = [];
+
+    if (mail.from) query.push(`from:(${mail.from})`);
+    if (mail.to) query.push(`to:(${mail.to})`);
+    if (mail.subject) query.push(`subject:(${mail.subject})`);
+    if (mail.label) query.push(`label:${mail.label.name}`);
+    if (mail.category) query.push(`category:${mail.category}`);
+    if (mail.after != null && mail.after > 0) query.push(`after:${mail.after}`);
+    if (mail.before != null) query.push(`before:${mail.before}`);
+
+    const response = await httpClient.sendRequest<GmailMessageList>({
+      method: HttpMethod.GET,
+      url: `https://www.googleapis.com/gmail/v1/users/me/messages`,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: access_token,
+      },
+      queryParams: {
+        q: query.join(' '),
+        maxResults: `${max_results}`,
+        ...(pageToken ? { pageToken } : {}),
+      },
+    });
+
+    if (response.body.messages) {
+      const messages = await Promise.all(
+        response.body.messages.map(
+          async (message: { id: string; threadId: string }) => {
+            const mail = await GmailRequests.getMail({
+              access_token,
+              message_id: message.id,
+              format: GmailMessageFormat.FULL,
+            });
+            const thread = await GmailRequests.getThread({
+              access_token,
+              thread_id: message.threadId,
+              format: GmailMessageFormat.FULL,
+            });
+
+            return {
+              message: mail,
+              thread,
+            };
+          }
+        )
+      );
+
+      return {
+        messages,
+        resultSizeEstimate: response.body.resultSizeEstimate,
+        ...(response?.body.nextPageToken
+          ? { nextPageToken: response.body.nextPageToken }
+          : {}),
+      };
+    }
+
+    return response.body;
+  },
+  getRecentMessages: async (
+    authentication: GmailAuthValue,
+    maxResults = 20
+  ) => {
+    return await httpClient.sendRequest<GmailMessageList>({
+      method: HttpMethod.GET,
+      url: 'https://gmail.googleapis.com/gmail/v1/users/me/messages',
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(authentication),
+      },
+      queryParams: {
+        maxResults: maxResults.toString(),
+        q: 'in:inbox OR in:sent', // Get recent messages from inbox and sent
+      },
+    });
+  },
+  getRecentThreads: async (authentication: GmailAuthValue, maxResults = 15) => {
+    return await httpClient.sendRequest<{
+      threads: { id: string; snippet?: string }[];
+    }>({
+      method: HttpMethod.GET,
+      url: 'https://gmail.googleapis.com/gmail/v1/users/me/threads',
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(authentication),
+      },
+      queryParams: {
+        maxResults: maxResults.toString(),
+        q: 'in:inbox OR in:sent', // Get recent threads from inbox and sent
+      },
+    });
+  },
+};
+
+function decodeBase64(data: any) {
+  return Buffer.from(data, 'base64').toString();
+}
+
+export async function parseStream(stream: any) {
+  return new Promise<ParsedMail>((resolve, reject) => {
+    simpleParser(stream, (err, parsed) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(parsed);
+      }
+    });
+  });
+}
+
+export async function convertAttachment(
+  attachments: Attachment[],
+  files: FilesService
+) {
+  const promises = attachments.map(async (attachment) => {
+    try {
+      const fileName = attachment.filename ?? `attachment-${Date.now()}`;
+      return {
+        fileName,
+        mimeType: attachment.contentType,
+        size: attachment.size,
+        data: await files.write({
+          fileName: fileName,
+          data: attachment.content,
+        }),
+      };
+    } catch (error) {
+      console.error(
+        `Failed to process attachment: ${attachment.filename}`,
+        error
+      );
+      return null;
+    }
+  });
+  const results = await Promise.all(promises);
+  return results.filter((result) => result !== null);
+}
+
+export function getFirstFiveOrAll(array: unknown[]) {
+  if (array.length <= 5) {
+    return array;
+  } else {
+    return array.slice(0, 5);
+  }
+}

package/src/lib/common/mime.ts

@@ -0,0 +1,82 @@
+import mime from 'mime-types';
+import MailComposer from 'nodemailer/lib/mail-composer';
+import Mail, { Attachment } from 'nodemailer/lib/mailer';
+import { ApFile } from '@agnocon/pieces-framework';
+
+export interface RawMimeAttachment {
+  filename?: string;
+  content: Buffer;
+  contentType?: string;
+}
+
+interface BuildRawMessageProps {
+  to?: string[];
+  cc?: string[];
+  bcc?: string[];
+  from?: string;
+  subject: string;
+  bodyType: 'plain_text' | 'html';
+  body: string;
+  headers?: { key: string; value: string }[];
+  attachments?: ({ file: ApFile; name?: string } | RawMimeAttachment)[];
+}
+
+function isFileAttachment(
+  attachment: { file: ApFile; name?: string } | RawMimeAttachment
+): attachment is { file: ApFile; name?: string } {
+  return 'file' in attachment;
+}
+
+async function buildRawMessage(props: BuildRawMessageProps): Promise<string> {
+  const subjectBase64 = Buffer.from(props.subject).toString('base64');
+  const mailOptions: Mail.Options = {
+    to: props.to && props.to.length > 0 ? props.to.join(', ') : undefined,
+    cc: props.cc && props.cc.length > 0 ? props.cc.join(', ') : undefined,
+    bcc: props.bcc && props.bcc.length > 0 ? props.bcc.join(', ') : undefined,
+    from: props.from,
+    subject: `=?UTF-8?B?${subjectBase64}?=`,
+    text: props.bodyType === 'plain_text' ? props.body : undefined,
+    html: props.bodyType === 'html' ? props.body : undefined,
+    attachments: [],
+    headers: props.headers,
+  };
+
+  if (props.attachments && props.attachments.length > 0) {
+    const attachmentOption: Attachment[] = props.attachments.map(
+      (attachment) => {
+        if (isFileAttachment(attachment)) {
+          const { file, name } = attachment;
+          const lookupResult = mime.lookup(
+            file.extension ? file.extension : ''
+          );
+          return {
+            filename: name ?? file.filename,
+            content: file?.base64,
+            contentType: lookupResult ? lookupResult : undefined,
+            encoding: 'base64',
+          };
+        }
+        return {
+          filename: attachment.filename,
+          content: attachment.content,
+          contentType: attachment.contentType,
+        };
+      }
+    );
+    mailOptions.attachments = attachmentOption;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const mail: any = new MailComposer(mailOptions).compile();
+  mail.keepBcc = true;
+  const mailBody = await mail.build();
+
+  return Buffer.from(mailBody)
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_');
+}
+
+export const GmailMime = {
+  buildRawMessage,
+};

package/src/lib/common/models.ts

@@ -0,0 +1,91 @@
+export interface GmailLabel {
+  id: string;
+  name: string;
+  messageListVisibility: GmailMessageListVisibility;
+  labelListVisibility: GmailLabelListVisibility;
+  type: GmailLabelType;
+  messagesTotal: number;
+  messagesUnread: number;
+  threadsTotal: number;
+  threadsUnread: number;
+  color: {
+    textColor: string;
+    backgroundColor: string;
+  };
+}
+
+export interface GmailMessage {
+  id: string;
+  threadId: string;
+  labelIds: [string];
+  snippet: string;
+  historyId: string;
+  internalDate: number;
+  payload: {
+    partId: string;
+    mimeType: string;
+    filename: string;
+    headers: {
+      name: string;
+      value: string;
+    }[];
+    body: {
+      data: any;
+      size: number;
+    };
+    parts: {
+      parts: any[];
+      partId: string;
+      mimeType: string;
+      filename: string;
+      headers: {
+        name: string;
+        value: string;
+      }[];
+      body: {
+        size: number;
+        data: string;
+      };
+    }[];
+  };
+  sizeEstimate: number;
+  raw: string;
+}
+
+export interface GmailThread {
+  id: string;
+  snippet: string;
+  historyId: string;
+  messages: GmailMessage[];
+}
+
+export interface GmailMessageResponse {
+  messages: {
+    id: string;
+    threadId: string;
+  }[];
+  nextPageToken?: string;
+  resultSizeEstimate: number;
+}
+
+enum GmailMessageListVisibility {
+  SHOW = 'show',
+  HIDE = 'hide',
+}
+
+enum GmailLabelListVisibility {
+  SHOW = 'show',
+  HIDE = 'hide',
+}
+
+enum GmailLabelType {
+  SYSTEM = 'system',
+  USER = 'user',
+}
+
+export enum GmailMessageFormat {
+  MINIMAL = 'minimal',
+  FULL = 'full',
+  RAW = 'raw',
+  METADATA = 'metadata',
+}

package/src/lib/common/props.ts

@@ -0,0 +1,262 @@
+import { Property } from '@agnocon/pieces-framework';
+import { GmailRequests } from './data';
+import { GmailLabel } from './models';
+import { gmailAuth, createGoogleClient, GmailAuthValue } from '../auth';
+import { gmail as googleGmail } from '@googleapis/gmail';
+
+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: <R extends boolean = false>(overrides: {
+    displayName?: string;
+    description?: string;
+    required: R;
+  }) =>
+    Property.Dropdown<GmailLabel, R, typeof gmailAuth>({
+      auth: gmailAuth,
+      displayName: overrides.displayName ?? 'Label',
+      description:
+        overrides.description ??
+        'Optional filteration, leave unselected to filter based on the email label',
+      required: overrides.required,
+      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 = googleGmail({ 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 = googleGmail({ 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.',
+        };
+      }
+    },
+  }),
+};