@guayaba/workflow-piece-gmail 0.12.3

package/src/lib/actions/request-approval-in-email.ts

@@ -0,0 +1,194 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+  gmailAuth,
+  createGoogleClient,
+  getAccessToken,
+  getUserEmail,
+} from '../auth';
+import { google } from 'googleapis';
+import MailComposer from 'nodemailer/lib/mail-composer';
+import Mail from 'nodemailer/lib/mailer';
+import { assertNotNullOrUndefined, ExecutionType } from '@guayaba/workflows-shared';
+
+export const requestApprovalInEmail = createAction({
+  auth: gmailAuth,
+  name: 'request_approval_in_mail',
+  displayName: 'Request Approval in Email',
+  description:
+    'Send approval request email and then wait until the email is approved or disapproved',
+  props: {
+    receiver: Property.ShortText({
+      displayName: 'Receiver Email (To)',
+      description:
+        'The email address of the recipient who will receive the approval request.',
+      required: true,
+    }),
+
+    cc: Property.Array({
+      displayName: 'CC Email',
+      description:
+        'The email addresses of the recipients who will receive a carbon copy of the approval request.',
+      required: false,
+    }),
+    bcc: Property.Array({
+      displayName: 'BCC Email',
+      description:
+        'The email addresses of the recipients who will receive a blind carbon copy of the approval request.',
+      required: false,
+    }),
+    subject: Property.ShortText({
+      displayName: 'Subject',
+      description: 'The subject of the approval request email.',
+      required: true,
+    }),
+    body: Property.ShortText({
+      displayName: 'Body',
+      description: 'Body for the email you want to send',
+      required: true,
+    }),
+    reply_to: Property.Array({
+      displayName: 'Reply-To Email',
+      description: 'Email address to set as the "Reply-To" header',
+      required: false,
+    }),
+    sender_name: Property.ShortText({
+      displayName: 'Sender Name',
+      required: false,
+    }),
+    from: Property.ShortText({
+      displayName: 'Sender Email',
+      description:
+        "The address must be listed in your GMail account's settings",
+      required: false,
+    }),
+    in_reply_to: Property.ShortText({
+      displayName: 'In reply to',
+      description: 'Reply to this Message-ID',
+      required: false,
+    }),
+  },
+  async run(context) {
+    if (context.executionType === ExecutionType.BEGIN) {
+      try {
+        const token = await getAccessToken(context.auth);
+
+        const { subject, body } = context.propsValue;
+
+        assertNotNullOrUndefined(token, 'token');
+        assertNotNullOrUndefined(context.propsValue.receiver, 'receiver');
+        assertNotNullOrUndefined(subject, 'subject');
+        assertNotNullOrUndefined(body, 'body');
+
+        const waitpoint = await context.run.createWaitpoint({
+          type: 'WEBHOOK',
+        });
+
+        const approvalLink = waitpoint.buildResumeUrl({
+          queryParams: { action: 'approve' },
+        });
+        const disapprovalLink = waitpoint.buildResumeUrl({
+          queryParams: { action: 'disapprove' },
+        });
+
+        const htmlBody = `
+        <div>
+          <p>${body}</p>
+          <br />
+          <p>
+            <a href="${approvalLink}" style="display: inline-block; padding: 10px 20px; margin-right: 10px; background-color: #2acc50; color: white; text-decoration: none; border-radius: 4px;">Approve</a>
+            <a href="${disapprovalLink}" style="display: inline-block; padding: 10px 20px; background-color: #e4172b; color: white; text-decoration: none; border-radius: 4px;">Disapprove</a>
+          </p>
+        </div>
+      `;
+
+        const authClient = await createGoogleClient(context.auth);
+
+        const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+        const subjectBase64 = Buffer.from(
+          context.propsValue['subject']
+        ).toString('base64');
+
+        const replyTo = context.propsValue['reply_to']?.filter(
+          (email) => email !== ''
+        );
+        const receiverEmail = context.propsValue.receiver;
+        const cc = context.propsValue['cc']?.filter((email) => email !== '');
+        const bcc = context.propsValue['bcc']?.filter((email) => email !== '');
+        const mailOptions: Mail.Options = {
+          to: receiverEmail,
+          cc: cc ? cc.join(', ') : undefined,
+          bcc: bcc ? bcc.join(', ') : undefined,
+          subject: `=?UTF-8?B?${subjectBase64}?=`,
+          replyTo: replyTo ? replyTo.join(', ') : '',
+          // text:
+          //   context.propsValue.body_type === 'plain_text'
+          //     ? context.propsValue['body']
+          //     : undefined,
+          html: htmlBody,
+          attachments: [],
+        };
+
+        const senderEmail =
+          context.propsValue.from ||
+          (await getUserEmail(context.auth, authClient));
+        if (senderEmail) {
+          mailOptions.from = context.propsValue.sender_name
+            ? `${context.propsValue['sender_name']} <${senderEmail}>`
+            : senderEmail;
+        }
+        let threadId = undefined;
+        if (context.propsValue.in_reply_to) {
+          mailOptions.headers = [
+            {
+              key: 'References',
+              value: context.propsValue.in_reply_to,
+            },
+            {
+              key: 'In-Reply-To',
+              value: context.propsValue.in_reply_to,
+            },
+          ];
+          const messages = await gmail.users.messages.list({
+            userId: 'me',
+            q: `Rfc822msgid:${context.propsValue.in_reply_to}`,
+          });
+          threadId = messages.data.messages?.[0].threadId;
+        }
+        const mail: any = new MailComposer(mailOptions).compile();
+        mail.keepBcc = true;
+        const mailBody = await mail.build();
+
+        const encodedPayload = Buffer.from(mailBody)
+          .toString('base64')
+          .replace(/\+/g, '-')
+          .replace(/\//g, '_');
+        await gmail.users.messages.send({
+          userId: 'me',
+          requestBody: {
+            threadId,
+            raw: encodedPayload,
+          },
+        });
+        context.run.waitForWaitpoint(waitpoint.id);
+
+        return {
+          approved: false, // default approval is false
+        };
+      } catch (error) {
+        console.error(
+          '[RequestApprovalEmail] Error during BEGIN execution:',
+          error
+        );
+        throw error;
+      }
+    } else {
+      const action = context.resumePayload.queryParams['action'];
+      const approved = action === 'approve';
+
+      return {
+        approved,
+      };
+    }
+  },
+});

package/src/lib/actions/search-email-action.ts

@@ -0,0 +1,211 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { gmailAuth, createGoogleClient } from '../auth';
+import { google } from 'googleapis';
+import { convertAttachment, parseStream } from '../common/data';
+import { GmailProps } from '../common/props';
+import { GmailLabel } from '../common/models';
+
+export const gmailSearchMailAction = createAction({
+  auth: gmailAuth,
+  name: 'gmail_search_mail',
+  displayName: 'Find Email',
+  description:
+    'Find emails using advanced search criteria. If no filters are provided, the latest emails are returned.',
+  props: {
+    from: GmailProps.from,
+    to: GmailProps.to,
+    subject: GmailProps.subject,
+    content: Property.ShortText({
+      displayName: 'Email Content',
+      description: 'Search for specific text within email body',
+      required: false,
+    }),
+    has_attachment: Property.Checkbox({
+      displayName: 'Has Attachment',
+      description: 'Only find emails with attachments',
+      required: false,
+      defaultValue: false,
+    }),
+    attachment_name: Property.ShortText({
+      displayName: 'Attachment Name',
+      description: 'Search for emails with specific attachment filename',
+      required: false,
+    }),
+    label: GmailProps.label,
+    category: GmailProps.category,
+    after_date: Property.DateTime({
+      displayName: 'After Date',
+      description: 'Find emails sent after this date',
+      required: false,
+    }),
+    before_date: Property.DateTime({
+      displayName: 'Before Date',
+      description: 'Find emails sent before this date',
+      required: false,
+    }),
+
+    include_spam_trash: Property.Checkbox({
+      displayName: 'Include Spam & Trash',
+      description:
+        'Include emails from Spam and Trash folders in search results',
+      required: false,
+      defaultValue: false,
+    }),
+    max_results: Property.Number({
+      displayName: 'Max Results',
+      description: 'Maximum number of emails to return (1-500)',
+      required: false,
+      defaultValue: 10,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const queryParts: string[] = [];
+
+    if (context.propsValue.from?.trim()) {
+      queryParts.push(`from:(${context.propsValue.from.trim()})`);
+    }
+    if (context.propsValue.to?.trim()) {
+      queryParts.push(`to:(${context.propsValue.to.trim()})`);
+    }
+    if (context.propsValue.subject?.trim()) {
+      queryParts.push(`subject:(${context.propsValue.subject.trim()})`);
+    }
+    if (context.propsValue.content?.trim()) {
+      queryParts.push(`"${context.propsValue.content.trim()}"`);
+    }
+
+    if (context.propsValue.has_attachment) {
+      queryParts.push('has:attachment');
+    }
+    if (context.propsValue.attachment_name?.trim()) {
+      queryParts.push(
+        `filename:(${context.propsValue.attachment_name.trim()})`
+      );
+    }
+
+    if (context.propsValue.label) {
+      const label = context.propsValue.label as GmailLabel;
+      queryParts.push(`label:${label.name}`);
+    }
+    if (context.propsValue.category?.trim()) {
+      queryParts.push(`category:${context.propsValue.category.trim()}`);
+    }
+
+    if (context.propsValue.after_date) {
+      const afterDate = new Date(context.propsValue.after_date);
+      const afterDateStr = afterDate
+        .toISOString()
+        .split('T')[0]
+        .replace(/-/g, '/');
+      queryParts.push(`after:${afterDateStr}`);
+    }
+    if (context.propsValue.before_date) {
+      const beforeDate = new Date(context.propsValue.before_date);
+      const beforeDateStr = beforeDate
+        .toISOString()
+        .split('T')[0]
+        .replace(/-/g, '/');
+      queryParts.push(`before:${beforeDateStr}`);
+    }
+
+    const searchQuery = queryParts.join(' ');
+
+    const maxResults = Math.min(
+      Math.max(context.propsValue.max_results || 10, 1),
+      500
+    );
+
+    try {
+      const searchResponse = await gmail.users.messages.list({
+        userId: 'me',
+        ...(searchQuery.trim() ? { q: searchQuery } : {}),
+        maxResults: maxResults,
+        includeSpamTrash: context.propsValue.include_spam_trash,
+      });
+
+      const messages = searchResponse.data.messages || [];
+
+      if (messages.length === 0) {
+        return {
+          found: false,
+          results: {
+            messages: [],
+            count: 0,
+          },
+        };
+      }
+
+      const detailedMessages = await Promise.all(
+        messages.map(async (message) => {
+          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')
+            );
+
+            return {
+              id: message.id,
+              ...parsedMailResponse,
+              attachments: await convertAttachment(
+                parsedMailResponse.attachments,
+                context.files
+              ),
+            };
+          } catch (error) {
+            console.error(
+              `Failed to get details for message ${message.id}:`,
+              error
+            );
+            return {
+              id: message.id,
+              threadId: message.threadId,
+              error: 'Failed to retrieve message details',
+            };
+          }
+        })
+      );
+
+      return {
+        found: true,
+        results: {
+          messages: detailedMessages,
+          count: detailedMessages.length,
+        },
+      };
+    } catch (error: any) {
+      // Enhanced error handling
+      if (error.code === 400) {
+        if (error.message?.includes('Invalid query')) {
+          throw new Error(
+            `Invalid search query: "${searchQuery}". Please check your search syntax.`
+          );
+        }
+        throw new Error(`Invalid search request: ${error.message}`);
+      } else if (error.code === 403) {
+        throw new Error(
+          'Insufficient permissions to search emails. Ensure the gmail.readonly scope is granted.'
+        );
+      } else if (error.code === 429) {
+        throw new Error(
+          'Gmail API rate limit exceeded. Please try again later.'
+        );
+      } else if (error.code === 500) {
+        throw new Error('Gmail API server error. Please try again later.');
+      }
+
+      throw new Error(`Failed to search emails: ${error.message}`);
+    }
+  },
+});

package/src/lib/actions/send-email-action.ts

@@ -0,0 +1,205 @@
+import { ApFile, createAction, Property } from '@guayaba/workflows-framework';
+import mime from 'mime-types';
+import MailComposer from 'nodemailer/lib/mail-composer';
+import Mail, { Attachment } from 'nodemailer/lib/mailer';
+import { gmailAuth, createGoogleClient, getUserEmail } from '../auth';
+import { google } from 'googleapis';
+
+export const gmailSendEmailAction = createAction({
+  auth: gmailAuth,
+  name: 'send_email',
+  description: 'Send an email through a Gmail account',
+  displayName: 'Send Email',
+  props: {
+    receiver: Property.Array({
+      displayName: 'Receiver Email (To)',
+      description: undefined,
+      required: true,
+    }),
+    cc: Property.Array({
+      displayName: 'CC Email',
+      description: undefined,
+      required: false,
+    }),
+    bcc: Property.Array({
+      displayName: 'BCC Email',
+      description: undefined,
+      required: false,
+    }),
+    subject: Property.ShortText({
+      displayName: 'Subject',
+      description: undefined,
+      required: true,
+    }),
+    body_type: Property.StaticDropdown({
+      displayName: 'Body Type',
+      required: true,
+      defaultValue: 'plain_text',
+      options: {
+        disabled: false,
+        options: [
+          {
+            label: 'plain text',
+            value: 'plain_text',
+          },
+          {
+            label: 'html',
+            value: 'html',
+          },
+        ],
+      },
+    }),
+    body: Property.ShortText({
+      displayName: 'Body',
+      description: 'Body for the email you want to send',
+      required: true,
+    }),
+    reply_to: Property.Array({
+      displayName: 'Reply-To Email',
+      description: 'Email address to set as the "Reply-To" header',
+      required: false,
+    }),
+    sender_name: Property.ShortText({
+      displayName: 'Sender Name',
+      required: false,
+    }),
+    from: Property.ShortText({
+      displayName: 'Sender Email',
+      description:
+        "The address must be listed in your GMail account's settings",
+      required: false,
+    }),
+    attachments: Property.Array({
+      displayName: 'Attachments',
+      required: false,
+      properties: {
+        file: Property.File({
+          displayName: 'File',
+          description: 'File to attach to the email you want to send.',
+          required: true,
+        }),
+        name: Property.ShortText({
+          displayName: 'Attachment Name',
+          description: 'In case you want to change the name of the attachment.',
+          required: false,
+        }),
+      },
+    }),
+    in_reply_to: Property.ShortText({
+      displayName: 'In reply to',
+      description: 'Reply to this Message-ID',
+      required: false,
+    }),
+    draft: Property.Checkbox({
+      displayName: 'Create draft',
+      description: 'Create draft without sending the actual email',
+      required: true,
+      defaultValue: false,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const gmail = google.gmail({ version: 'v1', auth: authClient });
+
+    const subjectBase64 = Buffer.from(context.propsValue['subject']).toString(
+      'base64'
+    );
+    const attachments = context.propsValue.attachments as {
+      file: ApFile;
+      name: string | undefined;
+    }[];
+    const replyTo = context.propsValue['reply_to']?.filter(
+      (email) => email !== ''
+    );
+    const receiver = context.propsValue['receiver']?.filter(
+      (email) => email !== ''
+    );
+    const cc = context.propsValue['cc']?.filter((email) => email !== '');
+    const bcc = context.propsValue['bcc']?.filter((email) => email !== '');
+    const mailOptions: Mail.Options = {
+      to: receiver.join(', '), // Join all email addresses with a comma
+      cc: cc ? cc.join(', ') : undefined,
+      bcc: bcc ? bcc.join(', ') : undefined,
+      subject: `=?UTF-8?B?${subjectBase64}?=`,
+      replyTo: replyTo ? replyTo.join(', ') : '',
+      text:
+        context.propsValue.body_type === 'plain_text'
+          ? context.propsValue['body']
+          : undefined,
+      html:
+        context.propsValue.body_type === 'html'
+          ? context.propsValue['body']
+          : undefined,
+      attachments: [],
+    };
+    let threadId = undefined;
+    if (context.propsValue.in_reply_to) {
+      mailOptions.headers = [
+        {
+          key: 'References',
+          value: context.propsValue.in_reply_to,
+        },
+        {
+          key: 'In-Reply-To',
+          value: context.propsValue.in_reply_to,
+        },
+      ];
+      const messages = await gmail.users.messages.list({
+        userId: 'me',
+        q: `Rfc822msgid:${context.propsValue.in_reply_to}`,
+      });
+      threadId = messages.data.messages?.[0].threadId;
+    }
+
+    const senderEmail =
+      context.propsValue.from || (await getUserEmail(context.auth, authClient));
+    if (senderEmail) {
+      mailOptions.from = context.propsValue.sender_name
+        ? `${context.propsValue['sender_name']} <${senderEmail}>`
+        : senderEmail;
+    }
+
+    if (attachments && attachments.length > 0) {
+      const attachmentOption: Attachment[] = attachments.map(
+        ({ file, name }) => {
+          const lookupResult = mime.lookup(
+            file.extension ? file.extension : ''
+          );
+          return {
+            filename: name ?? file.filename,
+            content: file?.base64,
+            contentType: lookupResult ? lookupResult : undefined,
+            encoding: 'base64',
+          };
+        }
+      );
+
+      mailOptions.attachments = attachmentOption;
+    }
+
+    const mail: any = new MailComposer(mailOptions).compile();
+    mail.keepBcc = true;
+    const mailBody = await mail.build();
+
+    const encodedPayload = Buffer.from(mailBody)
+      .toString('base64')
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_');
+
+    if (context.propsValue.draft) {
+      return await gmail.users.drafts.create({
+        userId: 'me',
+        requestBody: { message: { threadId, raw: encodedPayload } },
+      });
+    } else {
+      return await gmail.users.messages.send({
+        userId: 'me',
+        requestBody: {
+          threadId,
+          raw: encodedPayload,
+        },
+      });
+    }
+  },
+});