@memberjunction/communication-gmail 3.4.0 → 4.1.0

package/README.md

@@ -1,18 +1,40 @@
 # @memberjunction/communication-gmail
 
-Gmail/Google Suite provider implementation for the MemberJunction Communication framework. This package enables sending and receiving emails through Gmail's API using OAuth2 authentication.
-
-## Overview
-
-The Gmail Communication Provider integrates Gmail's API with MemberJunction's communication infrastructure, providing:
-
-- Email sending capabilities with full HTML and plain text support
-- **Draft message creation** for composing emails to be sent later
-- Email retrieval with flexible query options
-- Reply-to-message functionality maintaining thread context
-- Message forwarding capabilities
-- OAuth2-based authentication using refresh tokens
-- Automatic token refresh for uninterrupted service
+Gmail / Google Workspace provider for the MemberJunction Communication Framework. This provider enables full mailbox operations -- sending, receiving, searching, managing labels, attachments, drafts, and more -- through the Gmail API with OAuth2 authentication.
+
+## Architecture
+
+```mermaid
+graph TD
+    subgraph gmail["@memberjunction/communication-gmail"]
+        GP["GmailProvider"]
+        AUTH["Auth Module\n(OAuth2 Client)"]
+        CFG["Config Module\n(Environment Variables)"]
+        CRED["GmailCredentials"]
+    end
+
+    subgraph google["Google APIs"]
+        OAUTH["Google OAuth2"]
+        GAPI["Gmail API v1\n(/users/me/...)"]
+        MAILBOX["Gmail Mailbox"]
+    end
+
+    subgraph base["@memberjunction/communication-types"]
+        BCP["BaseCommunicationProvider"]
+    end
+
+    BCP --> GP
+    GP --> AUTH
+    GP --> CFG
+    GP --> CRED
+    AUTH --> OAUTH
+    GP --> GAPI
+    GAPI --> MAILBOX
+
+    style gmail fill:#2d6a9f,stroke:#1a4971,color:#fff
+    style google fill:#7c5295,stroke:#563a6b,color:#fff
+    style base fill:#2d8659,stroke:#1a5c3a,color:#fff
+```
 
 ## Installation
 
@@ -22,260 +44,193 @@ npm install @memberjunction/communication-gmail
 
 ## Configuration
 
-The Gmail provider requires OAuth2 credentials and a refresh token. Set the following environment variables:
+Set the following environment variables:
 
 ```env
-# Required: OAuth2 Client Credentials
-GMAIL_CLIENT_ID=your_client_id_here
-GMAIL_CLIENT_SECRET=your_client_secret_here
-GMAIL_REDIRECT_URI=your_redirect_uri_here
-GMAIL_REFRESH_TOKEN=your_refresh_token_here
-
-# Optional: Default sender email
-GMAIL_SERVICE_ACCOUNT_EMAIL=noreply@yourdomain.com
+GMAIL_CLIENT_ID=your-oauth2-client-id
+GMAIL_CLIENT_SECRET=your-oauth2-client-secret
+GMAIL_REDIRECT_URI=your-redirect-uri
+GMAIL_REFRESH_TOKEN=your-refresh-token
+GMAIL_SERVICE_ACCOUNT_EMAIL=noreply@yourdomain.com   # optional default sender
 ```
 
-### Obtaining OAuth2 Credentials
-
-1. Go to the [Google Cloud Console](https://console.cloud.google.com/)
-2. Create a new project or select an existing one
-3. Enable the Gmail API for your project
-4. Create OAuth2 credentials (OAuth 2.0 Client ID)
-5. Set up the OAuth consent screen
-6. Use the OAuth2 flow to obtain a refresh token with the required scopes
-
 ### Required OAuth2 Scopes
 
-The provider requires the following Gmail API scopes:
 - `https://www.googleapis.com/auth/gmail.send`
 - `https://www.googleapis.com/auth/gmail.readonly`
 - `https://www.googleapis.com/auth/gmail.modify`
 - `https://www.googleapis.com/auth/gmail.compose`
 
+### Obtaining OAuth2 Credentials
+
+1. Go to the [Google Cloud Console](https://console.cloud.google.com/)
+2. Create or select a project and enable the Gmail API
+3. Create OAuth 2.0 Client ID credentials
+4. Configure the OAuth consent screen
+5. Use the OAuth2 flow to obtain a refresh token with the required scopes
+
+## Supported Operations
+
+This provider supports all 14 operations defined in `BaseCommunicationProvider`:
+
+| Operation | Gmail Implementation |
+|-----------|---------------------|
+| `SendSingleMessage` | Send via `users.messages.send` |
+| `GetMessages` | List and fetch with Gmail search query support |
+| `GetSingleMessage` | Fetch single message by ID |
+| `ForwardMessage` | Reconstruct and send as RFC 822 attachment |
+| `ReplyToMessage` | Send in same thread via `threadId` |
+| `CreateDraft` | Create via `users.drafts.create` |
+| `DeleteMessage` | Trash or permanently delete |
+| `MoveMessage` | Add/remove labels via `users.messages.modify` |
+| `ListFolders` | List labels with optional message/unread counts |
+| `MarkAsRead` | Add/remove UNREAD label (batch) |
+| `ArchiveMessage` | Remove INBOX label |
+| `SearchMessages` | Gmail query syntax with date filters |
+| `ListAttachments` | Parse message parts recursively for attachments |
+| `DownloadAttachment` | Download via `users.messages.attachments.get` |
+
 ## Usage
 
-### Basic Setup
+### Sending Email
 
 ```typescript
-import { GmailProvider } from '@memberjunction/communication-gmail';
+import { CommunicationEngine } from '@memberjunction/communication-engine';
+import { Message } from '@memberjunction/communication-types';
 
-// The provider is automatically registered with MemberJunction's class factory
-// using the @RegisterClass decorator
-```
-
-### Sending Emails
+const engine = CommunicationEngine.Instance;
+await engine.Config(false, contextUser);
 
-```typescript
-import { ProcessedMessage, MessageResult } from '@memberjunction/communication-types';
-import { GmailProvider } from '@memberjunction/communication-gmail';
+const message = new Message();
+message.From = 'sender@gmail.com';
+message.To = 'recipient@example.com';
+message.Subject = 'Hello from Gmail';
+message.HTMLBody = '<h1>Hello</h1>';
+message.CCRecipients = ['cc@example.com'];
 
-const provider = new GmailProvider();
+const result = await engine.SendSingleMessage('Gmail', 'Email', message);
+```
 
-const message: ProcessedMessage = {
-  To: 'recipient@example.com',
-  From: 'sender@example.com', // Optional, uses authenticated account if not specified
-  FromName: 'Sender Name',
-  ProcessedSubject: 'Test Email',
-  ProcessedBody: 'This is a plain text email body',
-  ProcessedHTMLBody: '<html><body><h1>This is an HTML email</h1></body></html>',
-  CCRecipients: ['cc@example.com'],
-  BCCRecipients: ['bcc@example.com']
-};
+### Per-Request Credentials
 
-const result: MessageResult = await provider.SendSingleMessage(message);
+Override credentials for multi-user scenarios:
 
-if (result.Success) {
-  console.log('Email sent successfully');
-} else {
-  console.error('Failed to send email:', result.Error);
-}
+```typescript
+import { GmailCredentials } from '@memberjunction/communication-gmail';
+
+const result = await provider.SendSingleMessage(processedMessage, {
+    clientId: 'other-client-id',
+    clientSecret: 'other-secret',
+    redirectUri: 'other-redirect',
+    refreshToken: 'user-specific-refresh-token'
+} as GmailCredentials);
 ```
 
 ### Retrieving Messages
 
 ```typescript
-import { GetMessagesParams, GetMessagesResult } from '@memberjunction/communication-types';
-
-const params: GetMessagesParams = {
-  NumMessages: 10,
-  UnreadOnly: true,
-  ContextData: {
-    query: 'from:important@example.com', // Gmail search query
-    MarkAsRead: true // Mark retrieved messages as read
-  }
-};
-
-const result: GetMessagesResult = await provider.GetMessages(params);
-
-if (result.Success) {
-  result.Messages.forEach(message => {
-    console.log(`From: ${message.From}`);
-    console.log(`Subject: ${message.Subject}`);
-    console.log(`Body: ${message.Body}`);
-  });
-} else {
-  console.error('Failed to get messages:', result.ErrorMessage);
-}
+const provider = engine.GetProvider('Gmail');
+
+const result = await provider.GetMessages({
+    NumMessages: 10,
+    UnreadOnly: true,
+    ContextData: {
+        query: 'from:important@example.com',  // Gmail search syntax
+        MarkAsRead: true
+    }
+});
+
+result.Messages.forEach(msg => {
+    console.log(`${msg.From}: ${msg.Subject}`);
+    console.log(`Thread: ${msg.ThreadID}`);
+});
 ```
 
-### Creating Draft Messages
+### Creating Drafts
 
 ```typescript
-import { CreateDraftParams, CreateDraftResult } from '@memberjunction/communication-types';
-
-const draftMessage: ProcessedMessage = {
-  To: 'recipient@example.com',
-  From: 'sender@example.com',
-  ProcessedSubject: 'Draft Email Subject',
-  ProcessedBody: 'This is a draft email that can be edited later',
-  ProcessedHTMLBody: '<p>This is a draft email that can be edited later</p>',
-  CCRecipients: ['cc@example.com']
-};
-
-const params: CreateDraftParams = {
-  Message: draftMessage
-};
-
-const result: CreateDraftResult = await provider.CreateDraft(params);
-
+const result = await provider.CreateDraft({ Message: processedMessage });
 if (result.Success) {
-  console.log(`Draft created with ID: ${result.DraftID}`);
-  // The draft can now be edited or sent through Gmail's interface
-} else {
-  console.error('Failed to create draft:', result.ErrorMessage);
+    console.log(`Draft ID: ${result.DraftID}`);
+    // Draft appears in Gmail drafts folder
 }
 ```
 
-**Note**: Drafts created through this provider will appear in the authenticated user's Gmail drafts folder and can be edited or sent through Gmail's web interface or mobile app.
-
-### Replying to Messages
+### Searching with Gmail Query Syntax
 
 ```typescript
-import { ReplyToMessageParams, ProcessedMessage } from '@memberjunction/communication-types';
-
-const replyMessage: ProcessedMessage = {
-  To: 'original-sender@example.com',
-  ProcessedSubject: 'Re: Original Subject',
-  ProcessedBody: 'This is my reply'
-};
-
-const params: ReplyToMessageParams = {
-  MessageID: 'original-message-id', // Gmail message ID
-  Message: replyMessage
-};
-
-const result = await provider.ReplyToMessage(params);
-
-if (result.Success) {
-  console.log('Reply sent successfully');
-}
+const result = await provider.SearchMessages({
+    Query: 'has:attachment',
+    FromDate: new Date('2025-01-01'),
+    ToDate: new Date('2025-06-01'),
+    FolderID: 'INBOX',    // Gmail label ID
+    MaxResults: 50
+});
 ```
 
-### Forwarding Messages
+### Managing Labels (Folders)
 
 ```typescript
-import { ForwardMessageParams } from '@memberjunction/communication-types';
-
-const params: ForwardMessageParams = {
-  MessageID: 'message-to-forward-id',
-  ToRecipients: ['forward-to@example.com'],
-  CCRecipients: ['cc@example.com'],
-  BCCRecipients: ['bcc@example.com'],
-  Message: 'FYI - forwarding this message' // Optional forward comment
-};
+const folders = await provider.ListFolders({ IncludeCounts: true });
+folders.Folders.forEach(f => {
+    console.log(`${f.Name} (${f.ID}): ${f.MessageCount} messages`);
+    console.log(`  System: ${f.IsSystemFolder}, Type: ${f.SystemFolderType}`);
+});
+```
 
-const result = await provider.ForwardMessage(params);
+### Downloading Attachments
 
-if (result.Success) {
-  console.log('Message forwarded successfully');
+```typescript
+const attachments = await provider.ListAttachments({ MessageID: 'msg-id' });
+for (const att of attachments.Attachments) {
+    const download = await provider.DownloadAttachment({
+        MessageID: 'msg-id',
+        AttachmentID: att.ID
+    });
+    // download.Content is a Buffer
+    // download.ContentBase64 is base64 string
+    // download.Filename, download.ContentType available
 }
 ```
 
-## API Reference
-
-### GmailProvider Class
-
-The main provider class that extends `BaseCommunicationProvider` from `@memberjunction/communication-types`.
-
-#### Methods
-
-##### `SendSingleMessage(message: ProcessedMessage): Promise<MessageResult>`
-Sends a single email message through Gmail.
-
-##### `GetMessages(params: GetMessagesParams): Promise<GetMessagesResult>`
-Retrieves messages from Gmail based on the provided parameters.
-
-##### `ReplyToMessage(params: ReplyToMessageParams): Promise<ReplyToMessageResult>`
-Replies to an existing Gmail message, maintaining the thread context.
-
-##### `ForwardMessage(params: ForwardMessageParams): Promise<ForwardMessageResult>`
-Forwards an existing Gmail message to new recipients.
+## Gmail Label Mapping
 
-### Configuration Module
+Gmail uses labels instead of traditional folders. The provider maps system labels to standard folder types:
 
-#### Environment Variables
-- `GMAIL_CLIENT_ID` (required): OAuth2 client ID
-- `GMAIL_CLIENT_SECRET` (required): OAuth2 client secret
-- `GMAIL_REDIRECT_URI` (required): OAuth2 redirect URI
-- `GMAIL_REFRESH_TOKEN` (required): OAuth2 refresh token
-- `GMAIL_SERVICE_ACCOUNT_EMAIL` (optional): Default sender email address
+| Gmail Label | SystemFolderType |
+|-------------|-----------------|
+| `INBOX` | `inbox` |
+| `SENT` | `sent` |
+| `DRAFT` | `drafts` |
+| `TRASH` | `trash` |
+| `SPAM` | `spam` |
+| User labels | `undefined` |
 
-### Authentication Module
+## Client Caching
 
-The `auth.ts` module exports:
-- `GmailClient`: Pre-configured Gmail API client
-- `getAuthenticatedUser()`: Helper function to verify authentication
+The provider caches Gmail API client instances for performance. Environment credential clients are shared across all calls; per-request credential clients are cached by a key derived from `clientId` and `refreshToken`.
 
-## Integration with MemberJunction
-
-This provider integrates seamlessly with MemberJunction's communication framework:
+## Security Considerations
 
-1. **Automatic Registration**: The provider is automatically registered using the `@RegisterClass` decorator
-2. **Type Safety**: Full TypeScript support with types from `@memberjunction/communication-types`
-3. **Logging**: Integrated with MemberJunction's logging system via `@memberjunction/core`
-4. **Global Registry**: Utilizes `@memberjunction/global` for class registration
+1. Store refresh tokens securely and never commit them to version control
+2. Request only the minimum required OAuth2 scopes
+3. Use secure methods to manage environment variables in production
+4. Regularly rotate client secrets and monitor API usage
 
 ## Dependencies
 
-- `@memberjunction/communication-types`: Communication framework interfaces and types
-- `@memberjunction/core`: Core MemberJunction utilities and logging
-- `@memberjunction/global`: Global class registry system
-- `googleapis`: Google APIs Node.js client library
-- `dotenv`: Environment variable management
-- `env-var`: Environment variable validation
-
-## Error Handling
-
-The provider includes comprehensive error handling:
-- OAuth2 authentication failures
-- API rate limiting
-- Network errors
-- Invalid message formats
-- Missing required fields
-
-All errors are logged using MemberJunction's logging system and returned with descriptive error messages.
-
-## Security Considerations
-
-1. **Refresh Token Security**: Store refresh tokens securely and never commit them to version control
-2. **Scope Limitations**: Request only the minimum required OAuth2 scopes
-3. **Environment Variables**: Use secure methods to manage environment variables in production
-4. **API Credentials**: Regularly rotate client secrets and monitor API usage
+| Package | Purpose |
+|---------|---------|
+| `@memberjunction/communication-types` | Base provider class and type definitions |
+| `@memberjunction/core` | Logging utilities |
+| `@memberjunction/global` | RegisterClass decorator |
+| `googleapis` | Google APIs Node.js client |
+| `dotenv` | Environment variable loading |
+| `env-var` | Environment variable validation |
 
 ## Development
 
-### Building
-
 ```bash
-npm run build
+npm run build    # Compile TypeScript
+npm run clean    # Remove dist directory
 ```
-
-### Cleaning
-
-```bash
-npm run clean
-```
-
-## License
-
-This package is part of the MemberJunction ecosystem. See the root repository for license information.

package/dist/GmailProvider.d.ts

@@ -0,0 +1,175 @@
+import { BaseCommunicationProvider, CreateDraftParams, CreateDraftResult, ForwardMessageParams, ForwardMessageResult, GetMessagesParams, GetMessagesResult, MessageResult, ProcessedMessage, ProviderCredentialsBase, ReplyToMessageParams, ReplyToMessageResult, ProviderOperation, GetSingleMessageParams, GetSingleMessageResult, DeleteMessageParams, DeleteMessageResult, MoveMessageParams, MoveMessageResult, ListFoldersParams, ListFoldersResult, MarkAsReadParams, MarkAsReadResult, ArchiveMessageParams, ArchiveMessageResult, SearchMessagesParams, SearchMessagesResult, ListAttachmentsParams, ListAttachmentsResult, DownloadAttachmentParams, DownloadAttachmentResult } from "@memberjunction/communication-types";
+/**
+ * Credentials for Gmail provider using OAuth2.
+ * Extend ProviderCredentialsBase to support per-request credential override.
+ *
+ * @remarks
+ * **TEMPORARY INTERFACE**: This interface is part of the interim credential solution for 2.x patch release.
+ * In MemberJunction 3.0, this will be integrated with the comprehensive credential management system.
+ */
+export interface GmailCredentials extends ProviderCredentialsBase {
+    /** Google OAuth2 Client ID */
+    clientId?: string;
+    /** Google OAuth2 Client Secret */
+    clientSecret?: string;
+    /** OAuth2 Redirect URI */
+    redirectUri?: string;
+    /** OAuth2 Refresh Token */
+    refreshToken?: string;
+    /** Service account email (optional) */
+    serviceAccountEmail?: string;
+}
+/**
+ * Implementation of the Gmail provider for sending and receiving messages
+ */
+export declare class GmailProvider extends BaseCommunicationProvider {
+    /** Cached Gmail client for environment credentials */
+    private envGmailClient;
+    /** Cache of Gmail clients for per-request credentials */
+    private clientCache;
+    /**
+     * Resolves credentials by merging request credentials with environment fallback
+     */
+    private resolveCredentials;
+    /**
+     * Creates a Gmail client with the given credentials
+     */
+    private createGmailClient;
+    /**
+     * Gets a Gmail client for the given credentials, using caching for efficiency
+     */
+    private getGmailClient;
+    /**
+     * Gets the authenticated user's email address for a given cached client
+     */
+    private getUserEmail;
+    /**
+     * Encode and format email content for Gmail API
+     */
+    private createEmailContent;
+    /**
+     * Sends a single message using the Gmail API
+     * @param message - The message to send
+     * @param credentials - Optional credentials override for this request.
+     *                      If not provided, uses environment variables.
+     *                      Set `credentials.disableEnvironmentFallback = true` to require explicit credentials.
+     */
+    SendSingleMessage(message: ProcessedMessage, credentials?: GmailCredentials): Promise<MessageResult>;
+    /**
+     * Gets messages from Gmail
+     * @param params - Parameters for fetching messages
+     * @param credentials - Optional credentials override for this request.
+     *                      If not provided, uses environment variables.
+     *                      Set `credentials.disableEnvironmentFallback = true` to require explicit credentials.
+     */
+    GetMessages(params: GetMessagesParams, credentials?: GmailCredentials): Promise<GetMessagesResult>;
+    /**
+     * Reply to a message using Gmail API
+     * @param params - Parameters for replying to a message
+     * @param credentials - Optional credentials override for this request.
+     *                      If not provided, uses environment variables.
+     *                      Set `credentials.disableEnvironmentFallback = true` to require explicit credentials.
+     */
+    ReplyToMessage(params: ReplyToMessageParams, credentials?: GmailCredentials): Promise<ReplyToMessageResult>;
+    /**
+     * Forward a message using Gmail API
+     * @param params - Parameters for forwarding a message
+     * @param credentials - Optional credentials override for this request.
+     *                      If not provided, uses environment variables.
+     *                      Set `credentials.disableEnvironmentFallback = true` to require explicit credentials.
+     */
+    ForwardMessage(params: ForwardMessageParams, credentials?: GmailCredentials): Promise<ForwardMessageResult>;
+    /**
+     * Helper to mark a message as read
+     */
+    private markMessageAsRead;
+    /**
+     * Creates a draft message in Gmail
+     * @param params - Parameters for creating a draft
+     * @param credentials - Optional credentials override for this request.
+     *                      If not provided, uses environment variables.
+     *                      Set `credentials.disableEnvironmentFallback = true` to require explicit credentials.
+     */
+    CreateDraft(params: CreateDraftParams, credentials?: GmailCredentials): Promise<CreateDraftResult>;
+    /**
+     * Returns the list of operations supported by the Gmail provider.
+     * Gmail supports all operations through its label-based system.
+     */
+    getSupportedOperations(): ProviderOperation[];
+    /**
+     * Gets a single message by ID
+     * @param params - Parameters for retrieving the message
+     * @param credentials - Optional credentials override for this request
+     */
+    GetSingleMessage(params: GetSingleMessageParams, credentials?: GmailCredentials): Promise<GetSingleMessageResult>;
+    /**
+     * Deletes a message from Gmail
+     * @param params - Parameters for deleting the message
+     * @param credentials - Optional credentials override for this request
+     */
+    DeleteMessage(params: DeleteMessageParams, credentials?: GmailCredentials): Promise<DeleteMessageResult>;
+    /**
+     * Moves a message to a different label (Gmail's equivalent of folders)
+     * In Gmail, moving is done by adding/removing labels
+     * @param params - Parameters for moving the message
+     * @param credentials - Optional credentials override for this request
+     */
+    MoveMessage(params: MoveMessageParams, credentials?: GmailCredentials): Promise<MoveMessageResult>;
+    /**
+     * Lists Gmail labels (Gmail's equivalent of folders)
+     * @param params - Parameters for listing labels
+     * @param credentials - Optional credentials override for this request
+     */
+    ListFolders(params: ListFoldersParams, credentials?: GmailCredentials): Promise<ListFoldersResult>;
+    /**
+     * Marks messages as read or unread
+     * @param params - Parameters for marking messages
+     * @param credentials - Optional credentials override for this request
+     */
+    MarkAsRead(params: MarkAsReadParams, credentials?: GmailCredentials): Promise<MarkAsReadResult>;
+    /**
+     * Archives a message (removes INBOX label in Gmail)
+     * @param params - Parameters for archiving the message
+     * @param credentials - Optional credentials override for this request
+     */
+    ArchiveMessage(params: ArchiveMessageParams, credentials?: GmailCredentials): Promise<ArchiveMessageResult>;
+    /**
+     * Searches messages using Gmail's search syntax
+     * @param params - Parameters for searching messages
+     * @param credentials - Optional credentials override for this request
+     */
+    SearchMessages(params: SearchMessagesParams, credentials?: GmailCredentials): Promise<SearchMessagesResult>;
+    /**
+     * Lists attachments on a message
+     * @param params - Parameters for listing attachments
+     * @param credentials - Optional credentials override for this request
+     */
+    ListAttachments(params: ListAttachmentsParams, credentials?: GmailCredentials): Promise<ListAttachmentsResult>;
+    /**
+     * Downloads an attachment from a message
+     * @param params - Parameters for downloading the attachment
+     * @param credentials - Optional credentials override for this request
+     */
+    DownloadAttachment(params: DownloadAttachmentParams, credentials?: GmailCredentials): Promise<DownloadAttachmentResult>;
+    /**
+     * Parses a Gmail message into the standard GetMessageMessage format
+     */
+    private parseGmailMessage;
+    /**
+     * Maps Gmail label IDs to system folder types
+     */
+    private mapGmailLabelToSystemFolder;
+    /**
+     * Formats a date for Gmail search query (YYYY/MM/DD)
+     */
+    private formatDateForGmail;
+    /**
+     * Recursively extracts attachment information from message parts
+     */
+    private extractAttachments;
+    /**
+     * Finds attachment info (filename, content type) by attachment ID
+     */
+    private findAttachmentInfo;
+}
+//# sourceMappingURL=GmailProvider.d.ts.map

package/dist/GmailProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GmailProvider.d.ts","sourceRoot":"","sources":["../src/GmailProvider.ts"],"names":[],"mappings":"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"}