@elyx-code/editor-ui 0.0.2

package/src/services/editor/modules/operations-implementations/external-integrations/google-mail/get-emails.ts

@@ -0,0 +1,586 @@
+import {
+	ActionDescriptorState,
+	OperationState,
+	IPrimitiveExecutionResult,
+	ExecutionTerminationType,
+	DefinitionEntityState,
+	IDynamicValue,
+	BaseRegisteredExtension,
+	ExtensionContextType,
+	ExtensionManifest,
+	ExtensionPermissions,
+	ExtentionPriority,
+	IRegisteredExtension,
+	DefaultEditorContext,
+	DefaultProjectLogicContext,
+	getConnectionIdFromDefinitionEntity,
+	OperationsImplementation,
+	BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX,
+	ExternalIntegrationOperations,
+	ExternalIntegrationNames,
+} from '@elyx-code/project-logic-tree';
+import { EditorService } from '../../../../EditorService';
+import axios, { AxiosResponse } from 'axios';
+import { editorRuntimeServiceBaseUrl } from '../../../../../integrations/api';
+import { getAccessToken } from '../../../../../../auth';
+import { Logger } from '@elyx-code/common-ts-utils';
+
+// ---------- types & helpers ----------
+
+type ProxyConfig = {
+	method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+	endpoint: string;
+	baseUrlOverride?: string;
+	params?: Record<string, any>;
+	data?: any;
+	headers?: Record<string, string>;
+	retries?: number;
+	responseType?: 'json' | 'text' | 'arraybuffer';
+};
+
+type ProxyWrapped<T = any> = {
+	status: number;
+	data: T;
+	headers?: Record<string, string>;
+};
+
+type ProxyStoredEnvelope = {
+	presignedUrl: string;
+	key: string;
+	bytes: number;
+	contentType: string;
+	contentEncoding: string; // gzip
+	note?: string;
+	status?: number;
+	headers?: Record<string, string>;
+};
+
+function isStoredEnvelope(x: any): x is ProxyStoredEnvelope {
+	return !!x && typeof x === 'object' && typeof x.presignedUrl === 'string';
+}
+
+type IncludeBody = 'none' | 'text' | 'html' | 'both' | 'auto';
+type AttachmentsMode = 'none' | 'metadata' | 'download';
+
+type GmailListResp = {
+	messages?: { id: string; threadId?: string }[];
+	nextPageToken?: string;
+	resultSizeEstimate?: number;
+};
+
+type GmailMessage = {
+	id: string;
+	threadId: string;
+	labelIds?: string[];
+	snippet?: string;
+	internalDate?: string; // ms as string
+	payload?: {
+		mimeType?: string;
+		filename?: string;
+		headers?: { name: string; value: string }[];
+		body?: { size?: number; data?: string; attachmentId?: string };
+		parts?: GmailPart[];
+	};
+};
+
+type GmailPart = {
+	mimeType?: string;
+	filename?: string;
+	headers?: { name: string; value: string }[];
+	body?: { size?: number; data?: string; attachmentId?: string };
+	parts?: GmailPart[];
+};
+
+type GmailAttachmentOut = {
+	attachmentId: string;
+	filename: string;
+	mimeType: string;
+	size?: number | null;
+};
+
+type GmailEmailOut = {
+	id: string;
+	threadId: string;
+	labelIds?: string[] | null;
+	internalDateMs: number;
+	dateIso: string;
+	from?: string | null;
+	to?: string | null;
+	cc?: string | null;
+	bcc?: string | null;
+	replyTo?: string | null;
+	subject?: string | null;
+	messageId?: string | null;
+	snippet?: string | null;
+	bodyText?: string | null;
+	bodyHtml?: string | null;
+	attachments?: GmailAttachmentOut[] | null;
+	raw_json: string;
+};
+
+const DEFAULT_HEADERS = [
+	'From',
+	'To',
+	'Cc',
+	'Bcc',
+	'Reply-To',
+	'Subject',
+	'Date',
+	'Message-ID',
+];
+
+function toUnixSeconds(input?: string | number): number | undefined {
+	if (input == null) return undefined;
+	if (typeof input === 'number') return Math.floor(input);
+	const ms = Date.parse(input);
+	if (Number.isNaN(ms)) return undefined;
+	return Math.floor(ms / 1000);
+}
+
+function composeQuery(
+	q: string | undefined,
+	after?: string | number,
+	before?: string | number
+): string | undefined {
+	if (q && q.trim()) return q.trim();
+	const parts: string[] = [];
+	const a = toUnixSeconds(after);
+	const b = toUnixSeconds(before);
+	if (a) parts.push(`after:${a}`);
+	if (b) parts.push(`before:${b}`);
+	return parts.length ? parts.join(' ') : undefined;
+}
+
+function headersArrayToMap(
+	arr?: { name: string; value: string }[],
+	lowerCaseKeys = true
+): Record<string, string> {
+	const out: Record<string, string> = {};
+	if (!arr) return out;
+	for (const h of arr) {
+		const key = lowerCaseKeys ? h.name.toLowerCase() : h.name;
+		out[key] = h.value;
+	}
+	return out;
+}
+
+function b64urlToUtf8(input: string): string {
+	// Gmail uses base64url for parts
+	let s = input.replace(/-/g, '+').replace(/_/g, '/');
+	const pad = s.length % 4;
+	if (pad) s += '='.repeat(4 - pad);
+	const binary = atob(s);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder('utf-8').decode(bytes);
+}
+
+function extractBodyAndAttachments(
+	msg: GmailMessage,
+	includeBody: IncludeBody,
+	attachmentsMode: AttachmentsMode
+): {
+	text?: string | null;
+	html?: string | null;
+	attachments?: GmailAttachmentOut[];
+} {
+	let text: string | null = null;
+	let html: string | null = null;
+	const attachments: GmailAttachmentOut[] = [];
+
+	const considerPart = (p?: GmailPart) => {
+		if (!p) return;
+		// body data on this part
+		const mt = p.mimeType || '';
+		const hasData = p.body?.data && typeof p.body.data === 'string';
+		if (hasData) {
+			if (
+				mt === 'text/plain' &&
+				(includeBody === 'text' ||
+					includeBody === 'both' ||
+					includeBody === 'auto') &&
+				!text
+			) {
+				text = b64urlToUtf8(p.body!.data!);
+			} else if (
+				mt === 'text/html' &&
+				(includeBody === 'html' ||
+					includeBody === 'both' ||
+					includeBody === 'auto') &&
+				!html
+			) {
+				html = b64urlToUtf8(p.body!.data!);
+			}
+		}
+		// attachment metadata
+		if (attachmentsMode !== 'none' && p.filename && p.body?.attachmentId) {
+			attachments.push({
+				attachmentId: p.body.attachmentId,
+				filename: p.filename,
+				mimeType: p.mimeType || 'application/octet-stream',
+				size: typeof p.body.size === 'number' ? p.body.size : null,
+			});
+		}
+		// recurse
+		if (p.parts?.length) {
+			for (const sub of p.parts) considerPart(sub);
+		}
+	};
+
+	// Sometimes payload has body directly (no parts)
+	if (msg.payload) {
+		considerPart(msg.payload as unknown as GmailPart);
+		if (msg.payload.parts?.length) {
+			for (const p of msg.payload.parts) considerPart(p);
+		}
+	}
+
+	// auto preference: if auto & no text but html exists, keep html; if no html but text exists, keep text.
+	if (includeBody === 'auto') {
+		// nothing special to do—above logic already fills whichever appears first
+	}
+
+	return { text, html, attachments };
+}
+
+// simple concurrency limit
+async function mapWithLimit<T, R>(
+	items: T[],
+	limit: number,
+	mapper: (item: T, idx: number) => Promise<R>
+): Promise<R[]> {
+	const results: R[] = new Array(items.length);
+	let next = 0;
+	let active = 0;
+	return new Promise((resolve, reject) => {
+		const pump = () => {
+			if (next >= items.length && active === 0) return resolve(results);
+			while (active < limit && next < items.length) {
+				const i = next++;
+				active++;
+				mapper(items[i], i)
+					.then((r) => {
+						results[i] = r;
+						active--;
+						pump();
+					})
+					.catch(reject);
+			}
+		};
+		pump();
+	});
+}
+
+// ---------- Implementation module ----------
+
+export class OperationsImplementationsGmailMessagesModule
+	extends BaseRegisteredExtension
+	implements IRegisteredExtension<OperationsImplementation>
+{
+	manifest: ExtensionManifest = {
+		id:
+			BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX +
+			ExternalIntegrationOperations.GoogleMailEmails, // ensure this enum/key exists in your defs
+		version: '1.0.0',
+		description: 'Gmail: list & fetch messages with optional body/attachments',
+		initPriority: ExtentionPriority.High,
+		permissions: [ExtensionPermissions.All],
+		contexts: [ExtensionContextType.Editor, ExtensionContextType.Logic],
+	};
+
+	module = {
+		init: (contexts: (DefaultEditorContext | DefaultProjectLogicContext)[]) => {
+			const projectState = contexts.find(
+				(c) => c.contextType === ExtensionContextType.Logic
+			) as DefaultProjectLogicContext;
+
+			if (projectState) {
+				const operation = projectState.get(
+					ExternalIntegrationOperations.GoogleMailEmails
+				) as ActionDescriptorState;
+				if (operation) operation.implementation = this.module.main;
+			}
+		},
+
+		/**
+		 * INPUTS (index):
+		 * 0 = connection (DefinitionEntityState, required)
+		 * 1 = q (string)
+		 * 2 = after (string | number)
+		 * 3 = before (string | number)
+		 * 4 = labelIds (string[])
+		 * 5 = pageSize (number; 1–500; default 100)
+		 * 6 = pageToken (string)
+		 * 7 = autoPaginate (boolean; default false)
+		 * 8 = includeBody ('none'|'text'|'html'|'both'|'auto'; default 'auto')
+		 * 9 = attachmentsMode ('none'|'metadata'|'download'; default 'metadata')  // 'download' not implemented yet
+		 * 10 = includeHeaders (string[]; default common set)
+		 * 11 = includeSpamTrash (boolean; default false)
+		 * 12 = maxPages (number; default 10 when autoPaginate)
+		 * 13 = maxMessages (number; optional)
+		 *
+		 * OUTPUTS:
+		 * 0 = emails: GmailEmailOut[]
+		 * 1 = nextPageToken: string | null
+		 */
+		main: async (
+			entity: OperationState,
+			_inputs: IDynamicValue[]
+		): Promise<IPrimitiveExecutionResult> => {
+			try {
+				const inputs = _inputs.map(
+					(i) => i.value?.valueAsType || i.value?.value,
+				);
+
+				const connectionEntity = inputs[0] as DefinitionEntityState;
+				if (!(connectionEntity instanceof DefinitionEntityState)) {
+					return bail(entity, 'Invalid or missing connection entity');
+				}
+
+				const q = (inputs[1] as string | undefined)?.trim();
+				const after = inputs[2] as string | number | undefined;
+				const before = inputs[3] as string | number | undefined;
+				const labelIds = (inputs[4] as string[] | undefined) || [];
+				const pageSizeRaw = (inputs[5] as number | undefined) ?? 100;
+				const pageToken = (inputs[6] as string | undefined) || undefined;
+				const autoPaginate = (inputs[7] as boolean | undefined) ?? false;
+				const includeBody = (inputs[8] as IncludeBody | undefined) ?? 'auto';
+				const attachmentsMode =
+					(inputs[9] as AttachmentsMode | undefined) ?? 'metadata';
+				const includeHeaders =
+					(inputs[10] as string[] | undefined)?.filter(Boolean) ||
+					DEFAULT_HEADERS;
+				const includeSpamTrash = (inputs[11] as boolean | undefined) ?? false;
+				const maxPages = (inputs[12] as number | undefined) ?? 10;
+				const maxMessages = inputs[13] as number | undefined;
+
+				const pageSize = Math.max(1, Math.min(500, Math.floor(pageSizeRaw)));
+				const connectionId =
+					getConnectionIdFromDefinitionEntity(connectionEntity);
+
+				if (!connectionId) {
+					return bail(
+						entity,
+						'Connection entity is missing the Connection ID value',
+					);
+				}
+
+				const editor = this.extensionsRegistry.requestContexts(this, [
+					ExtensionContextType.Editor,
+				])[0] as EditorService;
+
+				const accessToken = await getAccessToken();
+				const authHeaders = { Authorization: `Bearer ${accessToken}` };
+				const genericBaseUrl = `${editorRuntimeServiceBaseUrl}/v1/external-integrations/generic-proxy/${editor.projectId}/${ExternalIntegrationNames['google-mail']}/${connectionId}`;
+
+				const proxy = async <T = any>(
+					cfg: ProxyConfig,
+				): Promise<AxiosResponse<ProxyWrapped<T> | ProxyStoredEnvelope>> => {
+					return axios.post(genericBaseUrl, cfg, { headers: authHeaders });
+				};
+
+				const unwrapProxy = async <T = any>(
+					res: AxiosResponse<ProxyWrapped<T> | ProxyStoredEnvelope>,
+				): Promise<ProxyWrapped<T>> => {
+					const payload = res.data as any;
+					if (isStoredEnvelope(payload)) {
+						// fetch stored JSON (browser auto-decompresses gzip)
+						const r = await axios.get(payload.presignedUrl, {
+							responseType: 'text',
+						});
+						const txt =
+							typeof r.data === 'string'
+								? r.data
+								: new TextDecoder().decode(r.data);
+						const parsed = JSON.parse(txt);
+						return {
+							status: payload.status ?? 200,
+							headers: payload.headers,
+							data: parsed as T,
+						};
+					} else {
+						return payload as ProxyWrapped<T>;
+					}
+				};
+
+				const finalQ = composeQuery(q, after, before);
+
+				// helper to list a page
+				const listPage = async (token?: string) => {
+					const params: Record<string, any> = {
+						maxResults: String(pageSize),
+					};
+					if (finalQ) params.q = finalQ;
+					if (token) params.pageToken = token;
+					if (includeSpamTrash) params.includeSpamTrash = 'true';
+					if (labelIds && labelIds.length) params.labelIds = labelIds;
+
+					const res = await proxy<GmailListResp>({
+						method: 'GET',
+						endpoint: '/gmail/v1/users/me/messages',
+						params,
+						retries: 5,
+					});
+					const unwrapped = await unwrapProxy<GmailListResp>(res);
+					if (unwrapped.status !== 200)
+						throw new Error(`Gmail list failed (status=${unwrapped.status})`);
+					return {
+						messages: Array.isArray(unwrapped.data?.messages)
+							? unwrapped.data.messages
+							: [],
+						nextPageToken: unwrapped.data?.nextPageToken || '',
+					};
+				};
+
+				const needsFull = includeBody !== 'none' || attachmentsMode !== 'none';
+
+				const fetchMessage = async (id: string): Promise<GmailEmailOut> => {
+					const params: Record<string, any> = needsFull
+						? { format: 'full' }
+						: { format: 'metadata', metadataHeaders: includeHeaders };
+
+					const res = await proxy<GmailMessage>({
+						method: 'GET',
+						endpoint: `/gmail/v1/users/me/messages/${encodeURIComponent(id)}`,
+						params,
+						retries: 5,
+					});
+					const unwrapped = await unwrapProxy<GmailMessage>(res);
+					if (unwrapped.status !== 200)
+						throw new Error(
+							`Gmail message fetch failed (status=${unwrapped.status})`,
+						);
+
+					const m = unwrapped.data;
+					const payloadHeaders = headersArrayToMap(m.payload?.headers);
+					const getHdr = (name: string) =>
+						payloadHeaders[name.toLowerCase()] || null;
+
+					const internalMs = m.internalDate ? Number(m.internalDate) : NaN;
+					const internalDateMs = Number.isFinite(internalMs)
+						? internalMs
+						: Date.now();
+
+					let bodyText: string | null = null;
+					let bodyHtml: string | null = null;
+					let attachments: GmailAttachmentOut[] | null = null;
+
+					if (needsFull) {
+						const {
+							text,
+							html,
+							attachments: att,
+						} = extractBodyAndAttachments(m, includeBody, attachmentsMode);
+						bodyText = text ?? null;
+						bodyHtml = html ?? null;
+						attachments = att && att.length ? att : null;
+
+						// NOTE: attachmentsMode === 'download' not implemented here. If needed, add a follow-up
+						// call to `/gmail/v1/users/me/messages/{id}/attachments/{attachmentId}` via proxy.
+					}
+
+					return {
+						id: m.id,
+						threadId: m.threadId,
+						labelIds: m.labelIds || null,
+						internalDateMs,
+						dateIso: new Date(internalDateMs).toISOString(),
+						from: getHdr('From'),
+						to: getHdr('To'),
+						cc: getHdr('Cc'),
+						bcc: getHdr('Bcc'),
+						replyTo: getHdr('Reply-To'),
+						subject: getHdr('Subject'),
+						messageId: getHdr('Message-ID'),
+						snippet: m.snippet ?? null,
+						bodyText,
+						bodyHtml,
+						attachments,
+						raw_json: JSON.stringify(m),
+					};
+				};
+
+				// pagination + detail fetch
+				const emails: GmailEmailOut[] = [];
+				let token = pageToken || '';
+				let pagesFetched = 0;
+
+				const addMessages = async (
+					msgRefs: { id: string; threadId?: string }[],
+				) => {
+					const ids = msgRefs.map((m) => m.id);
+					const limit = 5; // concurrency
+					const details = await mapWithLimit(ids, limit, (id) =>
+						fetchMessage(id),
+					);
+					emails.push(...details);
+				};
+
+				if (autoPaginate) {
+					do {
+						const { messages, nextPageToken } = await listPage(
+							token || undefined,
+						);
+						if (messages.length) await addMessages(messages);
+						token = nextPageToken;
+						pagesFetched += 1;
+						if (maxPages && pagesFetched >= maxPages) break;
+						if (
+							typeof maxMessages === 'number' &&
+							emails.length >= maxMessages
+						) {
+							emails.splice(maxMessages); // hard cap
+							token = ''; // stop
+							break;
+						}
+					} while (token);
+				} else {
+					const { messages, nextPageToken } = await listPage(
+						token || undefined,
+					);
+					if (messages.length) await addMessages(messages);
+					token = nextPageToken;
+				}
+
+				const outNextToken = autoPaginate ? null : token || null;
+
+				return {
+					value: ExecutionTerminationType.Success,
+					error: null,
+					result: { records: emails, nextPageToken: outNextToken },
+				};
+			} catch (e: any) {
+				// Extract the juicy details from Axios if they exist
+				const errorData = e.response?.data || e.message || e;
+
+				Logger.error('[Gmail] Get emails failed:', errorData);
+
+				return {
+					value:
+						entity.catchesError || entity.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					// Pass the extracted error downstream instead of the raw Axios object
+					error: errorData,
+					result: null,
+				};
+			}
+		},
+	};
+}
+
+/** uniform error helper */
+function bail(
+	entity: OperationState,
+	message: string
+): IPrimitiveExecutionResult {
+	Logger.log('[Gmail] error:', message);
+	return {
+		value:
+			entity.catchesError || entity.errorCalls.length
+				? ExecutionTerminationType.CaughtError
+				: ExecutionTerminationType.UnhandledError,
+		error: message,
+		result: null,
+	};
+}