@nocobase/app-plugin-mail 0.0.0-stage → 1.0.0-beta.9

package/dist/server/adapters/gmail/adapter.js

@@ -0,0 +1,800 @@
+import { randomUUID } from 'node:crypto';
+import { incompleteMessage } from '../incomplete-message.js';
+import { GMAIL_CAPABILITIES } from './constants.js';
+import { parseGmailBatchResponse } from './batch.js';
+import { waitForGmailQuota } from './quota.js';
+import { apiBase, fetchWithTimeout, gmailRequest, readJson, responseError, submissionResponse, } from './http.js';
+import { contentPreparationError, errorResult, failure, unknownError, ProviderRequestError, } from './errors.js';
+import { decodeBase64Url, gmailFolderType, normalizeMessage, } from './normalize.js';
+import { buildMime, forwardedHtml, forwardedText, normalizedDraft, } from './mime.js';
+import { gmailCursor, parseGmailCursor } from './sync.js';
+import { expiry, exchangeToken, required, splitScopes } from './auth.js';
+export class GmailMailProviderAdapter {
+    context;
+    config;
+    account;
+    identity;
+    capabilities = GMAIL_CAPABILITIES;
+    pushNotificationsConfigured;
+    static batchGetSize = 10;
+    constructor(context, config, account) {
+        this.context = context;
+        this.config = config;
+        this.account = account;
+        this.identity = account.provider;
+        this.pushNotificationsConfigured = Boolean(config.pushTopicName);
+    }
+    async upsertPushSubscription(input) {
+        if (!this.config.pushTopicName) {
+            return failure('GMAIL_PUSH_TOPIC_REQUIRED', 'Gmail push notifications require pushTopicName.', 'configuration', false);
+        }
+        const result = await this.request('/users/me/watch', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                topicName: this.config.pushTopicName,
+                ...(this.config.pushLabelIds?.length
+                    ? {
+                        labelIds: this.config.pushLabelIds,
+                        labelFilterBehavior: 'include',
+                    }
+                    : {}),
+            }),
+            signal: input.signal,
+        });
+        if (!result.ok)
+            return result;
+        const expiration = Number(result.value.expiration);
+        if (!Number.isFinite(expiration)) {
+            return failure('GMAIL_PUSH_EXPIRATION_MISSING', 'Gmail did not return a push watch expiration.', 'provider', false);
+        }
+        const expiresAt = new Date(expiration).toISOString();
+        return {
+            ok: true,
+            value: {
+                providerSubscriptionId: this.account.address,
+                renewAfter: new Date(Math.min(Date.now() + 86_400_000, expiration - 3_600_000)).toISOString(),
+                expiresAt,
+            },
+        };
+    }
+    deletePushSubscription(_providerSubscriptionId, signal) {
+        return this.emptyRequest('/users/me/stop', { method: 'POST', signal });
+    }
+    async getCurrentSyncCursor(signal) {
+        const profile = await this.request('/users/me/profile', {
+            signal,
+        });
+        if (!profile.ok)
+            return profile;
+        return profile.value.historyId
+            ? {
+                ok: true,
+                value: gmailCursor(profile.value.historyId, undefined, new Date().toISOString()),
+            }
+            : failure('GMAIL_HISTORY_ID_MISSING', 'Gmail did not provide a history ID for the initial sync baseline.', 'provider', false);
+    }
+    async listFolders(input) {
+        const result = await this.request('/users/me/labels', {
+            signal: input.signal,
+        });
+        if (!result.ok)
+            return result;
+        const folders = (result.value.labels ?? []).flatMap((label) => label.id
+            ? [
+                {
+                    providerFolderId: label.id,
+                    type: gmailFolderType(label.id),
+                    name: label.name ?? label.id,
+                    unreadCount: label.messagesUnread,
+                    kind: 'label',
+                },
+            ]
+            : []);
+        const completeFolders = [
+            ...folders,
+            {
+                providerFolderId: '__archive__',
+                type: 'archive',
+                name: 'Archive',
+                kind: 'label',
+            },
+        ];
+        return {
+            ok: true,
+            value: {
+                folders: completeFolders,
+                completeProviderFolderIds: completeFolders.map((folder) => folder.providerFolderId),
+            },
+        };
+    }
+    async createLabel(name, signal) {
+        const result = await this.request('/users/me/labels', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                name,
+                labelListVisibility: 'labelShow',
+                messageListVisibility: 'show',
+            }),
+            signal,
+        });
+        if (!result.ok)
+            return result;
+        const id = result.value.id;
+        if (!id) {
+            return failure('GMAIL_LABEL_ID_MISSING', 'Gmail did not return an ID for the created label.', 'provider', false);
+        }
+        return {
+            ok: true,
+            value: {
+                providerFolderId: id,
+                type: 'custom',
+                name: result.value.name ?? name,
+                unreadCount: result.value.messagesUnread,
+                kind: 'label',
+            },
+        };
+    }
+    updateLabels(providerMessageId, input) {
+        return this.modifyLabels(providerMessageId, input.addLabelIds, input.removeLabelIds, input.signal);
+    }
+    async listMessages(input) {
+        if (!input.receivedAfter ||
+            !Number.isFinite(Date.parse(input.receivedAfter))) {
+            return failure('GMAIL_SYNC_START_DATE_REQUIRED', 'Gmail initial synchronization requires a valid start date.', 'configuration', false);
+        }
+        const query = new URLSearchParams();
+        query.set('maxResults', String(Math.min(input.limit ?? 100, 500)));
+        query.set('includeSpamTrash', 'true');
+        if (input.cursor)
+            query.set('pageToken', input.cursor);
+        const seconds = Math.floor(new Date(input.receivedAfter).getTime() / 1000);
+        query.set('q', `after:${seconds - 1}`);
+        const page = await this.request(`/users/me/messages?${query.toString()}`, { signal: input.signal });
+        if (!page.ok)
+            return input.cursor &&
+                page.error.code === 'GMAIL_HTTP_400' &&
+                /token/i.test(page.error.message)
+                ? failure('GMAIL_SYNC_CURSOR_INVALID', 'Gmail history pagination expired.', 'provider', false)
+                : page;
+        const messages = await this.getSyncMessages((page.value.messages ?? []).flatMap((item) => (item.id ? [item.id] : [])), input.signal);
+        const failed = messages.find((result) => !result.ok && result.error.code !== 'GMAIL_HTTP_404');
+        if (failed && !failed.ok)
+            return failed;
+        return {
+            ok: true,
+            value: {
+                messages: messages.flatMap((result) => result.ok &&
+                    (!input.receivedAfter ||
+                        !result.value.receivedAt ||
+                        Date.parse(result.value.receivedAt) >=
+                            Date.parse(input.receivedAfter))
+                    ? [result.value]
+                    : []),
+                nextCursor: page.value.nextPageToken,
+            },
+        };
+    }
+    async listChanges(input) {
+        const cursor = parseGmailCursor(input.cursor);
+        if (!cursor)
+            return failure('GMAIL_SYNC_CURSOR_INVALID', 'Gmail sync cursor is invalid.', 'provider', false);
+        if (cursor.recoveryAfter) {
+            return failure('GMAIL_SYNC_CURSOR_INVALID', 'Gmail requires a complete policy-scoped rescan.', 'provider', false);
+        }
+        const query = new URLSearchParams({
+            startHistoryId: cursor.historyId,
+            maxResults: String(Math.min(input.limit, 500)),
+        });
+        if (cursor.pageToken)
+            query.set('pageToken', cursor.pageToken);
+        const history = await this.request(`/users/me/history?${query.toString()}`, { signal: input.signal });
+        if (!history.ok) {
+            return history.error.code === 'GMAIL_HTTP_404'
+                ? failure('GMAIL_SYNC_CURSOR_INVALID', 'Gmail history expired; rescan is required.', 'provider', false)
+                : history;
+        }
+        const deleted = new Set();
+        const changed = new Set();
+        for (const record of history.value.history ?? []) {
+            for (const item of record.messages ?? [])
+                if (item.id)
+                    changed.add(item.id);
+            for (const item of record.messagesAdded ?? [])
+                if (item.message?.id)
+                    changed.add(item.message.id);
+            for (const item of record.labelsAdded ?? [])
+                if (item.message?.id)
+                    changed.add(item.message.id);
+            for (const item of record.labelsRemoved ?? [])
+                if (item.message?.id)
+                    changed.add(item.message.id);
+            for (const item of record.messagesDeleted ?? []) {
+                if (item.message?.id) {
+                    deleted.add(item.message.id);
+                    changed.delete(item.message.id);
+                }
+            }
+        }
+        const results = await this.getSyncMessages([...changed], input.signal);
+        const failed = results.find((result) => !result.ok && result.error.code !== 'GMAIL_HTTP_404');
+        if (failed && !failed.ok)
+            return failed;
+        const historyId = history.value.nextPageToken
+            ? cursor.historyId
+            : (history.value.historyId ?? cursor.historyId);
+        const capturedAt = history.value.nextPageToken
+            ? cursor.capturedAt
+            : new Date().toISOString();
+        return {
+            ok: true,
+            value: {
+                messages: results.flatMap((result) => result.ok ? [result.value] : []),
+                deletedProviderMessageIds: [...deleted],
+                nextCursor: gmailCursor(historyId, history.value.nextPageToken, capturedAt),
+                hasMore: Boolean(history.value.nextPageToken),
+            },
+        };
+    }
+    async getSyncMessages(ids, signal) {
+        const results = [];
+        for (let offset = 0; offset < ids.length; offset += GmailMailProviderAdapter.batchGetSize) {
+            signal?.throwIfAborted();
+            const batchIds = ids.slice(offset, offset + GmailMailProviderAdapter.batchGetSize);
+            const batch = await this.getMessagesBatch(batchIds, signal);
+            if (!batch.ok) {
+                results.push(...batchIds.map(() => batch));
+                continue;
+            }
+            for (const item of batch.value) {
+                results.push(await this.normalizeSyncMessage(item.id, item.result, signal));
+            }
+        }
+        return results;
+    }
+    async getMessagesBatch(ids, signal) {
+        try {
+            const accessToken = await this.accessToken(signal);
+            const boundary = `mail_${randomUUID().replaceAll('-', '')}`;
+            const body = ids
+                .map((id, index) => `--${boundary}\r\nContent-Type: application/http\r\nContent-ID: <item-${index}:${boundary}@mail.nocobase>\r\n\r\nGET /gmail/v1/users/me/messages/${encodeURIComponent(id)}?format=full HTTP/1.1\r\naccept: application/json\r\n\r\n`)
+                .join('') + `--${boundary}--\r\n`;
+            await waitForGmailQuota(this.config, this.account.address, 20 * ids.length, signal);
+            const response = await fetchWithTimeout(gmailBatchUrl(this.config), {
+                method: 'POST',
+                headers: {
+                    authorization: `Bearer ${accessToken}`,
+                    accept: 'application/json',
+                    'content-type': `multipart/mixed; boundary=${boundary}`,
+                },
+                body,
+                signal,
+            });
+            const result = await parseGmailBatchResponse(response, ids);
+            if (!result.ok &&
+                result.error.code === 'GMAIL_BATCH_RESPONSE_TOO_LARGE' &&
+                ids.length > 1) {
+                const midpoint = Math.ceil(ids.length / 2);
+                const first = await this.getMessagesBatch(ids.slice(0, midpoint), signal);
+                if (!first.ok)
+                    return first;
+                const second = await this.getMessagesBatch(ids.slice(midpoint), signal);
+                if (!second.ok)
+                    return second;
+                return { ok: true, value: [...first.value, ...second.value] };
+            }
+            return result;
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: errorResult(error, 'GMAIL_BATCH_REQUEST_FAILED'),
+            };
+        }
+    }
+    async normalizeSyncMessage(id, result, signal) {
+        if (!result.ok)
+            return result;
+        let messageResult;
+        try {
+            messageResult = normalizeMessage(result.value);
+        }
+        catch {
+            messageResult = failure('MAIL_CONTENT_INVALID', 'Mail content could not be decoded.', 'content', false);
+        }
+        if (messageResult.ok || messageResult.error.category !== 'content')
+            return messageResult;
+        const metadata = await this.request(`/users/me/messages/${encodeURIComponent(id)}?format=metadata`, { signal });
+        if (!metadata.ok)
+            return metadata;
+        try {
+            const normalized = normalizeMessage(metadata.value);
+            if (normalized.ok)
+                return {
+                    ok: true,
+                    value: incompleteMessage(id, messageResult.error.code, normalized.value),
+                };
+        }
+        catch {
+            /* Keep the provider identity even when its headers are malformed. */
+        }
+        const receivedAt = new Date(Number(metadata.value.internalDate));
+        return {
+            ok: true,
+            value: incompleteMessage(id, messageResult.error.code, {
+                providerFolderIds: metadata.value.labelIds ?? [],
+                receivedAt: metadata.value.internalDate && Number.isFinite(receivedAt.getTime())
+                    ? receivedAt.toISOString()
+                    : undefined,
+            }),
+        };
+    }
+    async getMessage(providerMessageId, signal) {
+        const message = await this.request(`/users/me/messages/${encodeURIComponent(providerMessageId)}?format=full`, { signal });
+        if (!message.ok)
+            return message;
+        try {
+            return normalizeMessage(message.value);
+        }
+        catch {
+            return failure('MAIL_CONTENT_INVALID', 'Mail content could not be decoded.', 'content', false);
+        }
+    }
+    async getAttachment(providerMessageId, providerAttachmentId, signal) {
+        const result = await this.request(`/users/me/messages/${encodeURIComponent(providerMessageId)}/attachments/${encodeURIComponent(providerAttachmentId)}`, { signal });
+        if (!result.ok)
+            return result;
+        const bytes = decodeBase64Url(result.value.data ?? '');
+        return {
+            ok: true,
+            value: {
+                fileName: providerAttachmentId,
+                contentType: 'application/octet-stream',
+                size: result.value.size ?? bytes.byteLength,
+                stream: new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(bytes);
+                        controller.close();
+                    },
+                }),
+            },
+        };
+    }
+    async sendMessage(input) {
+        let submissionStarted = false;
+        let accessToken;
+        try {
+            accessToken = await this.accessToken(input.signal);
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                error: errorResult(error, 'GMAIL_AUTHORIZATION_FAILED'),
+            };
+        }
+        try {
+            const prepared = input.message.draftProviderMessageId
+                ? { ok: true, value: input }
+                : await this.prepareForward(input);
+            if (!prepared.ok) {
+                return { status: 'failed', error: prepared.error };
+            }
+            input = prepared.value;
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                error: contentPreparationError(error, 'GMAIL_MESSAGE_PREPARATION_FAILED'),
+            };
+        }
+        try {
+            if (input.message.draftProviderMessageId) {
+                let resolvedDraftId;
+                try {
+                    resolvedDraftId = await this.resolveDraftId(input.message.draftProviderMessageId, input.message.draftProviderDraftId, input.signal);
+                    if (!resolvedDraftId.ok) {
+                        return { status: 'failed', error: resolvedDraftId.error };
+                    }
+                    const updated = await this.updateDraft(resolvedDraftId.value, input);
+                    if (!updated.ok)
+                        return { status: 'failed', error: updated.error };
+                }
+                catch (error) {
+                    return {
+                        status: 'failed',
+                        error: contentPreparationError(error, 'GMAIL_MESSAGE_PREPARATION_FAILED'),
+                    };
+                }
+                await waitForGmailQuota(this.config, this.account.address, 100, input.signal);
+                input.signal?.throwIfAborted();
+                submissionStarted = true;
+                const response = await fetchWithTimeout(`${apiBase(this.config)}/users/me/drafts/send`, {
+                    method: 'POST',
+                    headers: {
+                        authorization: `Bearer ${accessToken}`,
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify({ id: resolvedDraftId.value }),
+                    signal: input.signal,
+                });
+                if (!response.ok) {
+                    return submissionResponse(response);
+                }
+                const value = await readJson(response);
+                return { status: 'accepted', providerMessageId: value.id };
+            }
+            let raw;
+            try {
+                raw = await buildMime(input);
+            }
+            catch (error) {
+                return {
+                    status: 'failed',
+                    error: contentPreparationError(error, 'GMAIL_MESSAGE_PREPARATION_FAILED'),
+                };
+            }
+            await waitForGmailQuota(this.config, this.account.address, 100, input.signal);
+            input.signal?.throwIfAborted();
+            submissionStarted = true;
+            const response = await fetchWithTimeout(`${apiBase(this.config)}/users/me/messages/send`, {
+                method: 'POST',
+                headers: {
+                    authorization: `Bearer ${accessToken}`,
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    raw,
+                    ...(input.message.providerConversationId
+                        ? { threadId: input.message.providerConversationId }
+                        : {}),
+                }),
+                signal: input.signal,
+            });
+            if (!response.ok)
+                return submissionResponse(response);
+            const value = await readJson(response);
+            return { status: 'accepted', providerMessageId: value.id };
+        }
+        catch (error) {
+            return {
+                status: submissionStarted ? 'submission_unknown' : 'failed',
+                error: unknownError(error, submissionStarted
+                    ? 'GMAIL_SEND_RESULT_UNKNOWN'
+                    : 'GMAIL_SEND_NOT_SUBMITTED'),
+            };
+        }
+    }
+    async saveDraft(input) {
+        let accessToken;
+        try {
+            accessToken = await this.accessToken(input.signal);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: errorResult(error, 'GMAIL_AUTHORIZATION_FAILED'),
+            };
+        }
+        try {
+            const prepared = await this.prepareForward(input);
+            if (!prepared.ok)
+                return prepared;
+            input = prepared.value;
+            await waitForGmailQuota(this.config, this.account.address, 10, input.signal);
+            const response = await fetchWithTimeout(`${apiBase(this.config)}/users/me/drafts`, {
+                method: 'POST',
+                headers: {
+                    authorization: `Bearer ${accessToken}`,
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    message: {
+                        raw: await buildMime(input),
+                        ...(input.message.providerConversationId
+                            ? { threadId: input.message.providerConversationId }
+                            : {}),
+                    },
+                }),
+                signal: input.signal,
+            });
+            if (!response.ok) {
+                return { ok: false, error: await responseError('GMAIL', response) };
+            }
+            const value = await readJson(response);
+            const providerMessageId = required(value.message?.id, 'Gmail draft message ID');
+            const saved = input.message.attachments.length
+                ? await this.getMessage(providerMessageId, input.signal)
+                : undefined;
+            if (saved && !saved.ok)
+                return saved;
+            return {
+                ok: true,
+                value: {
+                    ...(saved?.ok
+                        ? saved.value
+                        : normalizedDraft(input, providerMessageId)),
+                    providerDraftId: required(value.id, 'Gmail draft ID'),
+                    providerConversationId: value.message?.threadId ?? input.message.providerConversationId,
+                    providerFolderIds: ['DRAFT'],
+                    read: true,
+                    draft: true,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: unknownError(error, 'GMAIL_DRAFT_SAVE_FAILED'),
+            };
+        }
+    }
+    async updateDraft(providerDraftId, input) {
+        const resolvedDraftId = await this.resolveDraftId(input.message.draftProviderMessageId ?? providerDraftId, input.message.draftProviderDraftId, input.signal);
+        if (!resolvedDraftId.ok)
+            return resolvedDraftId;
+        providerDraftId = resolvedDraftId.value;
+        const existing = input.message.draftProviderMessageId
+            ? await this.getMessage(input.message.draftProviderMessageId, input.signal)
+            : undefined;
+        if (existing && !existing.ok)
+            return existing;
+        const retained = new Set(input.message.retainedProviderAttachmentIds ?? []);
+        const preservedAttachments = existing?.ok
+            ? existing.value.attachments
+                .filter((attachment) => retained.has(attachment.providerAttachmentId))
+                .map((attachment) => ({
+                fileName: attachment.fileName,
+                contentType: attachment.contentType,
+                size: attachment.size,
+                contentId: attachment.contentId,
+                inline: attachment.inline,
+                open: async () => {
+                    const content = await this.getAttachment(existing.value.providerMessageId, attachment.providerAttachmentId, input.signal);
+                    if (!content.ok)
+                        throw new ProviderRequestError(content.error);
+                    return content.value.stream;
+                },
+            }))
+            : [];
+        const message = {
+            ...input.message,
+            attachments: [...preservedAttachments, ...input.message.attachments],
+        };
+        const result = await this.request(`/users/me/drafts/${encodeURIComponent(providerDraftId)}`, {
+            method: 'PUT',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                id: providerDraftId,
+                message: {
+                    raw: await buildMime({ ...input, message }),
+                    ...(input.message.providerConversationId
+                        ? { threadId: input.message.providerConversationId }
+                        : {}),
+                },
+            }),
+            signal: input.signal,
+        });
+        if (!result.ok)
+            return result;
+        const providerMessageId = required(result.value.message?.id, 'Gmail draft message ID');
+        const saved = input.message.attachments.length || input.message.draftProviderMessageId
+            ? await this.getMessage(providerMessageId, input.signal)
+            : undefined;
+        if (saved && !saved.ok)
+            return saved;
+        return {
+            ok: true,
+            value: {
+                ...(saved?.ok
+                    ? saved.value
+                    : normalizedDraft(input, providerMessageId)),
+                providerDraftId,
+                providerConversationId: result.value.message?.threadId ??
+                    input.message.providerConversationId,
+                providerFolderIds: ['DRAFT'],
+                read: true,
+                draft: true,
+            },
+        };
+    }
+    async prepareForward(input) {
+        const sourceId = input.message.forwardOfProviderMessageId;
+        if (!sourceId)
+            return { ok: true, value: input };
+        const source = await this.getMessage(sourceId, input.signal);
+        if (!source.ok)
+            return source;
+        const forwardedAttachments = source.value.attachments.map((attachment) => ({
+            fileName: attachment.fileName,
+            contentType: attachment.contentType,
+            size: attachment.size,
+            contentId: attachment.contentId,
+            inline: attachment.inline,
+            open: async () => {
+                const content = await this.getAttachment(source.value.providerMessageId, attachment.providerAttachmentId, input.signal);
+                if (!content.ok)
+                    throw new ProviderRequestError(content.error);
+                return content.value.stream;
+            },
+        }));
+        const attachmentSize = [
+            ...forwardedAttachments,
+            ...input.message.attachments,
+        ].reduce((total, attachment) => total + attachment.size, 0);
+        if (attachmentSize > 25 * 1024 * 1024) {
+            return failure('GMAIL_FORWARD_ATTACHMENTS_TOO_LARGE', 'Forwarded attachments exceed the 25 MB message limit.', 'content', false);
+        }
+        const text = input.message.forwardBodyIncluded
+            ? input.message.text
+            : forwardedText(input.message.text, source.value);
+        const html = input.message.forwardBodyIncluded
+            ? input.message.html
+            : forwardedHtml(input.message.html, input.message.text, source.value);
+        return {
+            ok: true,
+            value: {
+                ...input,
+                message: {
+                    ...input.message,
+                    text,
+                    html,
+                    attachments: [...input.message.attachments, ...forwardedAttachments],
+                    forwardOfProviderMessageId: undefined,
+                },
+            },
+        };
+    }
+    async resolveDraftId(providerMessageId, providerDraftId, signal) {
+        if (providerDraftId)
+            return { ok: true, value: providerDraftId };
+        let pageToken;
+        const seenPageTokens = new Set();
+        do {
+            if (pageToken) {
+                if (seenPageTokens.has(pageToken)) {
+                    return failure('GMAIL_PAGING_STALLED', 'Gmail returned the same draft page token repeatedly.', 'provider', false);
+                }
+                seenPageTokens.add(pageToken);
+            }
+            const query = new URLSearchParams({ maxResults: '500' });
+            if (pageToken)
+                query.set('pageToken', pageToken);
+            const page = await this.request(`/users/me/drafts?${query.toString()}`, { signal });
+            if (!page.ok)
+                return page;
+            const match = page.value.drafts?.find((draft) => draft.message?.id === providerMessageId);
+            if (match?.id)
+                return { ok: true, value: match.id };
+            pageToken = page.value.nextPageToken;
+        } while (pageToken);
+        return failure('GMAIL_DRAFT_NOT_FOUND', 'Gmail draft was not found.', 'provider', false);
+    }
+    setRead(providerMessageId, read, signal) {
+        return this.modifyLabels(providerMessageId, read ? [] : ['UNREAD'], read ? ['UNREAD'] : [], signal);
+    }
+    setStarred(providerMessageId, starred, signal) {
+        return this.modifyLabels(providerMessageId, starred ? ['STARRED'] : [], starred ? [] : ['STARRED'], signal);
+    }
+    async moveMessage(providerMessageId, providerFolderId, signal) {
+        const archive = providerFolderId === '__archive__';
+        const result = await this.modifyLabels(providerMessageId, archive ? [] : [providerFolderId], ['INBOX', 'TRASH', 'SPAM'].filter((label) => label !== providerFolderId), signal);
+        return result.ok ? { ok: true, value: { providerMessageId } } : result;
+    }
+    deleteMessage(providerMessageId, permanently, signal) {
+        return permanently
+            ? this.emptyRequest(`/users/me/messages/${encodeURIComponent(providerMessageId)}`, { method: 'DELETE', signal })
+            : this.emptyRequest(`/users/me/messages/${encodeURIComponent(providerMessageId)}/trash`, { method: 'POST', signal });
+    }
+    async modifyLabels(providerMessageId, addLabelIds, removeLabelIds, signal) {
+        return this.emptyRequest(`/users/me/messages/${encodeURIComponent(providerMessageId)}/modify`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ addLabelIds, removeLabelIds }),
+            signal,
+        });
+    }
+    async emptyRequest(path, init) {
+        try {
+            const accessToken = await this.accessToken(init.signal ?? undefined);
+            await waitForGmailQuota(this.config, this.account.address, gmailQuotaUnits(path, init.method), init.signal ?? undefined);
+            const response = await fetchWithTimeout(`${apiBase(this.config)}${path}`, {
+                ...init,
+                headers: {
+                    authorization: `Bearer ${accessToken}`,
+                    ...init.headers,
+                },
+            });
+            return response.ok
+                ? { ok: true, value: undefined }
+                : { ok: false, error: await responseError('GMAIL', response) };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: errorResult(error, 'GMAIL_MESSAGE_MUTATION_FAILED'),
+            };
+        }
+    }
+    async request(path, init) {
+        try {
+            const accessToken = await this.accessToken(init.signal ?? undefined);
+            await waitForGmailQuota(this.config, this.account.address, gmailQuotaUnits(path, init.method), init.signal ?? undefined);
+            return await gmailRequest(this.config, accessToken, path, init);
+        }
+        catch (error) {
+            return { ok: false, error: errorResult(error, 'GMAIL_REQUEST_FAILED') };
+        }
+    }
+    async accessToken(signal) {
+        const credential = await this.context.credentials.getOrRefresh(this.account.credentialReference, (value) => Date.parse(value.expiresAt) > Date.now() + 60_000, async (value, refreshSignal) => {
+            const refreshed = await exchangeToken(this.config, {
+                client_id: this.config.clientId,
+                client_secret: this.config.clientSecret,
+                refresh_token: value.refreshToken,
+                grant_type: 'refresh_token',
+            }, refreshSignal ?? signal);
+            if (!refreshed.ok)
+                throw new ProviderRequestError(refreshed.error);
+            return {
+                ...value,
+                accessToken: required(refreshed.value.access_token, 'Gmail access token'),
+                refreshToken: refreshed.value.refresh_token ?? value.refreshToken,
+                expiresAt: expiry(refreshed.value.expires_in),
+                scopes: splitScopes(refreshed.value.scope, value.scopes),
+                tokenType: refreshed.value.token_type ?? value.tokenType,
+            };
+        }, signal);
+        return credential.accessToken;
+    }
+}
+function gmailBatchUrl(config) {
+    const base = apiBase(config);
+    const apiSuffix = '/gmail/v1';
+    const root = base.endsWith(apiSuffix)
+        ? base.slice(0, -apiSuffix.length)
+        : base;
+    return `${root}/batch/gmail/v1`;
+}
+function gmailQuotaUnits(path, method = 'GET') {
+    const normalizedMethod = method.toUpperCase();
+    if (/\/watch(?:\?|$)/.test(path))
+        return 100;
+    if (/\/stop(?:\?|$)/.test(path))
+        return 50;
+    if (/\/messages\/send(?:\?|$)/.test(path) ||
+        /\/drafts\/send(?:\?|$)/.test(path))
+        return 100;
+    if (/\/messages\/batch(?:Delete|Modify)(?:\?|$)/i.test(path))
+        return 50;
+    if (/\/history(?:\?|$)/.test(path))
+        return 2;
+    if (/\/profile(?:\?|$)/.test(path))
+        return 1;
+    if (/\/messages\/[^/]+\/attachments\//.test(path))
+        return 20;
+    if (/\/messages\/[^/]+\/trash(?:\?|$)/.test(path))
+        return 20;
+    if (/\/messages\/[^/]+\/untrash(?:\?|$)/.test(path))
+        return 5;
+    if (/\/messages\/[^/?]+(?:\?|$)/.test(path) && normalizedMethod === 'DELETE')
+        return 10;
+    if (/\/messages\/[^/?]+(?:\?|$)/.test(path))
+        return 20;
+    if (/\/messages(?:\?|$)/.test(path))
+        return 5;
+    if (/\/drafts\/[^/?]+/.test(path))
+        return normalizedMethod === 'GET'
+            ? 20
+            : normalizedMethod === 'DELETE'
+                ? 10
+                : 15;
+    if (/\/drafts(?:\?|$)/.test(path))
+        return normalizedMethod === 'GET' ? 5 : 10;
+    if (/\/labels\/[^/?]+/.test(path))
+        return normalizedMethod === 'GET' ? 1 : 5;
+    if (/\/labels(?:\?|$)/.test(path))
+        return normalizedMethod === 'GET' ? 1 : 5;
+    return 5;
+}
+//# sourceMappingURL=adapter.js.map