@elyx-code/editor-ui 0.0.2

package/src/services/editor/modules/operations-implementations/external-integrations/google-drive/smart-fetch-document.ts

@@ -0,0 +1,702 @@
+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';
+
+type SmartMode = 'auto' | 'native' | 'binary' | 'plain-text';
+
+type ProxyConfig = {
+	method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+	endpoint: string;
+	baseUrlOverride?: string;
+	params?: Record<string, string>;
+	data?: any;
+	headers?: Record<string, string>;
+	retries?: number;
+	responseType?: 'json' | 'text' | 'arraybuffer';
+};
+
+export enum GoogleDriveMimeType {
+	Audio = 'application/vnd.google-apps.audio',
+	Document = 'application/vnd.google-apps.document',
+	DriveSdk = 'application/vnd.google-apps.drive-sdk',
+	Drawing = 'application/vnd.google-apps.drawing',
+	File = 'application/vnd.google-apps.file',
+	Folder = 'application/vnd.google-apps.folder',
+	Form = 'application/vnd.google-apps.form',
+	FusionTable = 'application/vnd.google-apps.fusiontable',
+	Jam = 'application/vnd.google-apps.jam',
+	MailLayout = 'application/vnd.google-apps.mail-layout',
+	Map = 'application/vnd.google-apps.map',
+	Photo = 'application/vnd.google-apps.photo',
+	Presentation = 'application/vnd.google-apps.presentation',
+	Script = 'application/vnd.google-apps.script',
+	Shortcut = 'application/vnd.google-apps.shortcut',
+	Site = 'application/vnd.google-apps.site',
+	Spreadsheet = 'application/vnd.google-apps.spreadsheet',
+	Unknown = 'application/vnd.google-apps.unknown',
+	Vid = 'application/vnd.google-apps.vid',
+	Video = 'application/vnd.google-apps.video',
+}
+
+type FileMetadata = {
+	id: string;
+	mimeType: string;
+	name?: string;
+	size?: string;
+};
+
+/** Body shape when Lambda returns inline */
+type ProxyWrapped<T = any> = {
+	status: number;
+	data: T;
+	headers?: Record<string, string>;
+};
+
+/** Body shape when Lambda stores payload in S3 */
+type ProxyStoredEnvelope = {
+	encoding?: 'utf8' | 'base64' | 'raw';
+	headers?: Record<string, string>;
+	bytes: number;
+	contentEncoding?: 'gzip';
+	contentType?: string; // e.g. application/json
+	key: string;
+	note?: string;
+	presignedUrl: string;
+	// upstream status might be absent; treat as success if present payload
+	status?: number;
+};
+
+type ProxyBody<T = any> = ProxyWrapped<T> | ProxyStoredEnvelope;
+
+function isStoredEnvelopeBody(x: any): x is ProxyStoredEnvelope {
+	return !!x && typeof x === 'object' && typeof x.presignedUrl === 'string';
+}
+
+export class OperationsImplementationsGoogleDriveSmartFetchDocumentModule
+	extends BaseRegisteredExtension
+	implements IRegisteredExtension<OperationsImplementation>
+{
+	manifest: ExtensionManifest = {
+		id:
+			BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX +
+			ExternalIntegrationOperations.GoogleDriveSmartFetchDocument,
+		version: '1.0.2',
+		description:
+			'Google Drive: smart fetch document (Docs/Sheets JSON, text, or binary)',
+		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.GoogleDriveSmartFetchDocument
+				) as ActionDescriptorState;
+				if (operation) operation.implementation = this.module.main;
+			}
+		},
+
+		/**
+		 * INPUTS (index):
+		 * 0 = connection (DefinitionEntityState)
+		 * 1 = fileId (string)
+		 * 2 = mode (SmartMode) — optional, defaults to 'auto'
+		 *
+		 * OUTPUTS (array order):
+		 * 0 = kind: 'docs' | 'sheets' | 'text' | 'binary'
+		 * 1 = mime: string
+		 * 2 = isBinary: boolean
+		 * 3 = title: string | null
+		 * 4 = sizeBytes: number | null
+		 * 5 = text: string | null
+		 * 6 = base64: string | null
+		 * 7 = json: string | null
+		 * 8 = raw_json: string
+		 */
+		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;
+				const fileId = (inputs[1] as string)?.trim();
+				const mode = (inputs[2] as SmartMode) || 'auto';
+
+				if (
+					!connectionEntity ||
+					!(connectionEntity instanceof DefinitionEntityState)
+				) {
+					return bail(entity, 'Invalid or missing connection entity');
+				}
+				if (!fileId) {
+					return bail(entity, 'Missing required input: fileId');
+				}
+				if (!['auto', 'native', 'binary', 'plain-text'].includes(mode)) {
+					return bail(entity, `Invalid mode: ${mode}`);
+				}
+
+				const editor = this.extensionsRegistry.requestContexts(this, [
+					ExtensionContextType.Editor,
+				])[0] as EditorService;
+
+				const connectionId =
+					getConnectionIdFromDefinitionEntity(connectionEntity);
+				const accessToken = await getAccessToken();
+				const authHeaders = { Authorization: `Bearer ${accessToken}` };
+
+				// generic proxy base (POST)
+				const genericBaseUrl = `${editorRuntimeServiceBaseUrl}/v1/external-integrations/generic-proxy/${editor.projectId}/${ExternalIntegrationNames['google-drive']}/${connectionId}`;
+
+				// ---------- helpers ----------
+				const proxy = async <T = any>(
+					cfg: ProxyConfig
+				): Promise<AxiosResponse<ProxyBody<T>>> => {
+					return axios.post<ProxyBody<T>>(genericBaseUrl, cfg, {
+						headers: authHeaders,
+					});
+				};
+
+				// Fetch S3 envelope and return as wrapped object for downstream
+				const fetchStored = async (
+					env: ProxyStoredEnvelope,
+					desired: 'json' | 'text' | 'arraybuffer'
+				): Promise<any> => {
+					const isBinary = desired === 'arraybuffer';
+					const r = await axios.get(env.presignedUrl, {
+						responseType: isBinary ? 'arraybuffer' : 'text',
+					});
+
+					const contentType =
+						env.contentType ||
+						(r.headers?.['content-type'] as string) ||
+						(r.headers?.['Content-Type'] as string) ||
+						'';
+
+					let data: any;
+					if (desired === 'json') {
+						const txt =
+							typeof r.data === 'string'
+								? r.data
+								: new TextDecoder().decode(r.data);
+						data = JSON.parse(txt);
+					} else {
+						data = r.data;
+					}
+
+					return {
+						status: 200, // stored path indicates success; upstream status not preserved
+						headers: r.headers as any,
+						data,
+					};
+				};
+
+				// Unified unwrap: either returns wrapped body directly, or resolves the S3 envelope
+				const unwrap = async <T = any>(
+					res: AxiosResponse<ProxyBody<T>>,
+					desired: 'json' | 'text' | 'arraybuffer' = 'json'
+				): Promise<ProxyWrapped<T>> => {
+					const body = res.data;
+
+					if (isStoredEnvelopeBody(body)) {
+						return (await fetchStored(body, desired)) as ProxyWrapped<T>;
+					}
+
+					return body as ProxyWrapped<T>;
+				};
+
+				const toArrayBufferFromProxyData = (payload: any): ArrayBuffer => {
+					if (payload instanceof ArrayBuffer) return payload;
+					if (payload?.buffer instanceof ArrayBuffer) return payload.buffer;
+					if (typeof payload === 'string') {
+						// assume base64
+						const binary = atob(payload);
+						const len = binary.length;
+						const bytes = new Uint8Array(len);
+						for (let i = 0; i < len; i++) bytes[i] = binary.charCodeAt(i);
+						return bytes.buffer;
+					}
+					if (payload?.type === 'Buffer' && Array.isArray(payload?.data)) {
+						return new Uint8Array(payload.data).buffer;
+					}
+					throw new Error('Unexpected binary payload shape from proxy');
+				};
+
+				const toBase64 = (ab: ArrayBuffer): string => {
+					const bytes = new Uint8Array(ab);
+					const chunk = 0x8000;
+					let binary = '';
+					for (let i = 0; i < bytes.length; i += chunk) {
+						binary += String.fromCharCode.apply(
+							null,
+							Array.from(bytes.subarray(i, i + chunk)) as unknown as number[]
+						);
+					}
+					return btoa(binary);
+				};
+
+				const uint8ToUtf8 = (ab: ArrayBuffer): string => {
+					return new TextDecoder('utf-8', { fatal: false }).decode(
+						new Uint8Array(ab)
+					);
+				};
+
+				const headerGet = (h: Record<string, any> | undefined, key: string) => {
+					if (!h) return '';
+					const found =
+						h[key] ??
+						h[String(key).toLowerCase()] ??
+						Object.entries(h).find(
+							([k]) => k.toLowerCase() === key.toLowerCase()
+						)?.[1];
+					return (found as string) || '';
+				};
+
+				const isTextual = (ct?: string) => {
+					if (!ct) return false;
+					const lower = ct.toLowerCase();
+					return (
+						lower.startsWith('text/') ||
+						lower.includes('json') ||
+						lower.includes('xml') ||
+						lower.includes('javascript') ||
+						lower.includes('csv')
+					);
+				};
+
+				// 1) Metadata (Drive via www.googleapis.com)
+				const metaWrapped = await unwrap<FileMetadata>(
+					await proxy<FileMetadata>({
+						method: 'GET',
+						endpoint: `/drive/v3/files/${encodeURIComponent(fileId)}`,
+						params: {
+							fields: 'id,name,mimeType,size',
+							supportsAllDrives: 'true',
+						},
+						retries: 3,
+					}),
+					'json'
+				);
+
+				if (!metaWrapped?.data?.id || !metaWrapped?.data?.mimeType) {
+					return bail(
+						entity,
+						`Failed to retrieve file metadata (status=${
+							metaWrapped?.status ?? 'n/a'
+						})`
+					);
+				}
+
+				const file = metaWrapped.data;
+				const mimeType: string = file.mimeType;
+				const title: string | null = file.name ?? null;
+				const sizeBytes: number | null = file.size ? Number(file.size) : null;
+
+				const isDocs =
+					mimeType === GoogleDriveMimeType.Document ||
+					mimeType === 'application/vnd.google-apps.document';
+				const isSheets =
+					mimeType === GoogleDriveMimeType.Spreadsheet ||
+					mimeType === 'application/vnd.google-apps.spreadsheet';
+				const isGoogleNative = mimeType?.startsWith(
+					'application/vnd.google-apps.'
+				);
+
+				// Prepare outputs
+				let outKind: 'docs' | 'sheets' | 'text' | 'binary';
+				let outMime = '';
+				let outIsBinary = false;
+				let outText: string | null = null;
+				let outBase64: string | null = null;
+				let outJson: string | null = null;
+
+				const raw: any = {
+					metadata: file,
+					modeRequested: mode,
+					modeResolved: null as null | string,
+					source: null as null | 'drive' | 'docs' | 'sheets',
+					exportMimeType: null as null | string,
+					note: null as null | string,
+				};
+
+				// 2) Mode routing
+				if (mode === 'auto') {
+					if (isDocs) {
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								baseUrlOverride: 'https://docs.googleapis.com',
+								endpoint: `/v1/documents/${encodeURIComponent(fileId)}`,
+								params: { includeTabsContent: 'true' },
+								retries: 3,
+							}),
+							'json'
+						);
+						if (wrapped.status !== 200) {
+							return bail(entity, `Docs API failed (status=${wrapped.status})`);
+						}
+						outKind = 'docs';
+						outMime = 'application/json';
+						outIsBinary = false;
+						outJson = JSON.stringify(wrapped.data);
+						raw.modeResolved = 'native';
+						raw.source = 'docs';
+					} else if (isSheets) {
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								baseUrlOverride: 'https://sheets.googleapis.com',
+								endpoint: `/v4/spreadsheets/${encodeURIComponent(fileId)}`,
+								params: { includeGridData: 'true' },
+								retries: 3,
+							}),
+							'json'
+						);
+
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Sheets API failed (status=${wrapped.status})`
+							);
+						}
+						outKind = 'sheets';
+						outMime = 'application/json';
+						outIsBinary = false;
+
+						outJson = JSON.stringify(wrapped.data);
+
+						raw.modeResolved = 'native';
+						raw.source = 'sheets';
+					} else {
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								endpoint: `/drive/v3/files/${encodeURIComponent(fileId)}`,
+								params: { alt: 'media' },
+								responseType: 'arraybuffer',
+								retries: 3,
+							}),
+							'arraybuffer'
+						);
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Drive media fetch failed (status=${wrapped.status})`
+							);
+						}
+						const ct = headerGet(wrapped.headers, 'content-type');
+						const buf = toArrayBufferFromProxyData(wrapped.data);
+						if (isTextual(ct)) {
+							outKind = 'text';
+							outMime = ct || 'text/plain';
+							outIsBinary = false;
+							outText = uint8ToUtf8(buf);
+							raw.modeResolved = 'plain-text';
+							raw.source = 'drive';
+						} else {
+							outKind = 'binary';
+							outMime = ct || 'application/octet-stream';
+							outIsBinary = true;
+							outBase64 = toBase64(buf);
+							raw.modeResolved = 'binary';
+							raw.source = 'drive';
+						}
+					}
+				} else if (mode === 'native') {
+					if (isDocs) {
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								baseUrlOverride: 'https://docs.googleapis.com',
+								endpoint: `/v1/documents/${encodeURIComponent(fileId)}`,
+								params: { includeTabsContent: 'true' },
+								retries: 3,
+							}),
+							'json'
+						);
+						if (wrapped.status !== 200) {
+							return bail(entity, `Docs API failed (status=${wrapped.status})`);
+						}
+						outKind = 'docs';
+						outMime = 'application/json';
+						outIsBinary = false;
+						outJson = JSON.stringify(wrapped.data);
+						raw.modeResolved = 'native';
+						raw.source = 'docs';
+					} else if (isSheets) {
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								baseUrlOverride: 'https://sheets.googleapis.com',
+								endpoint: `/v4/spreadsheets/${encodeURIComponent(fileId)}`,
+								params: { includeGridData: 'true' },
+								retries: 3,
+							}),
+							'json'
+						);
+
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Sheets API failed (status=${wrapped.status})`
+							);
+						}
+						outKind = 'sheets';
+						outMime = 'application/json';
+						outIsBinary = false;
+
+						outJson = JSON.stringify(wrapped.data);
+
+						raw.modeResolved = 'native';
+						raw.source = 'sheets';
+					} else {
+						return bail(
+							entity,
+							`mode=native is not supported for mimeType=${mimeType}. Try 'binary' or 'plain-text'.`
+						);
+					}
+				} else if (mode === 'plain-text') {
+					if (isDocs) {
+						const wrapped = await unwrap<string>(
+							await proxy<string>({
+								method: 'GET',
+								endpoint: `/drive/v3/files/${encodeURIComponent(
+									fileId
+								)}/export`,
+								params: { mimeType: 'text/plain' },
+								responseType: 'text',
+								retries: 3,
+							}),
+							'text'
+						);
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Drive export (text) failed (status=${wrapped.status})`
+							);
+						}
+						outKind = 'text';
+						outMime = 'text/plain';
+						outIsBinary = false;
+						outText = wrapped.data ?? '';
+						raw.modeResolved = 'plain-text';
+						raw.source = 'drive';
+					} else if (isSheets) {
+						const wrapped = await unwrap<string>(
+							await proxy<string>({
+								method: 'GET',
+								endpoint: `/drive/v3/files/${encodeURIComponent(
+									fileId
+								)}/export`,
+								params: { mimeType: 'text/csv' },
+								responseType: 'text',
+								retries: 3,
+							}),
+							'text'
+						);
+
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Drive export (csv) failed (status=${wrapped.status})`
+							);
+						}
+						outKind = 'text';
+						outMime = 'text/csv';
+						outIsBinary = false;
+
+						outText = wrapped.data ?? '';
+
+						raw.modeResolved = 'plain-text';
+						raw.source = 'drive';
+						raw.note = 'Sheets CSV export returns only the first sheet.';
+					} else {
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								endpoint: `/drive/v3/files/${encodeURIComponent(fileId)}`,
+								params: { alt: 'media' },
+								responseType: 'arraybuffer',
+								retries: 3,
+							}),
+							'arraybuffer'
+						);
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Drive media fetch failed (status=${wrapped.status})`
+							);
+						}
+						const ct = headerGet(wrapped.headers, 'content-type');
+						if (!isTextual(ct)) {
+							return bail(
+								entity,
+								`mode=plain-text not supported for mimeType=${mimeType} (content-type=${ct}).`
+							);
+						}
+						const buf = toArrayBufferFromProxyData(wrapped.data);
+						outKind = 'text';
+						outMime = ct || 'text/plain';
+						outIsBinary = false;
+						outText = uint8ToUtf8(buf);
+						raw.modeResolved = 'plain-text';
+						raw.source = 'drive';
+					}
+				} else if (mode === 'binary') {
+					if (isGoogleNative) {
+						const exportMime = 'application/pdf';
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								endpoint: `/drive/v3/files/${encodeURIComponent(
+									fileId
+								)}/export`,
+								params: { mimeType: exportMime },
+								responseType: 'arraybuffer',
+								retries: 3,
+							}),
+							'arraybuffer'
+						);
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Drive export (pdf) failed (status=${wrapped.status})`
+							);
+						}
+						const buf = toArrayBufferFromProxyData(wrapped.data);
+						outKind = 'binary';
+						outMime = exportMime;
+						outIsBinary = true;
+						outBase64 = toBase64(buf);
+						raw.modeResolved = 'binary';
+						raw.source = 'drive';
+						raw.exportMimeType = exportMime;
+					} else {
+						const wrapped = await unwrap<any>(
+							await proxy<any>({
+								method: 'GET',
+								endpoint: `/drive/v3/files/${encodeURIComponent(fileId)}`,
+								params: { alt: 'media' },
+								responseType: 'arraybuffer',
+								retries: 3,
+							}),
+							'arraybuffer'
+						);
+						if (wrapped.status !== 200) {
+							return bail(
+								entity,
+								`Drive media fetch failed (status=${wrapped.status})`
+							);
+						}
+						const ct =
+							headerGet(wrapped.headers, 'content-type') ||
+							'application/octet-stream';
+						const buf = toArrayBufferFromProxyData(wrapped.data);
+						outKind = 'binary';
+						outMime = ct;
+						outIsBinary = true;
+						outBase64 = toBase64(buf);
+						raw.modeResolved = 'binary';
+						raw.source = 'drive';
+					}
+				} else {
+					throw new Error(`Unsupported mode: ${mode}`);
+				}
+
+				if (!outMime)
+					outMime =
+						isDocs || isSheets
+							? 'application/json'
+							: 'application/octet-stream';
+
+				const raw_json = JSON.stringify(raw);
+
+				if (!!outJson && typeof outJson === 'string') {
+					const parsed = JSON.parse(outJson);
+					outJson = parsed;
+				}
+
+				return {
+					value: ExecutionTerminationType.Success,
+					error: null,
+					result: {
+						kind: outKind,
+						mime: outMime,
+						isBinary: outIsBinary,
+						title,
+						sizeBytes,
+						text: outText,
+						base64: outBase64,
+						json: outJson,
+						raw_json,
+					},
+				};
+			} catch (e: any) {
+				const msg = String(e?.message || e);
+				const hint =
+					msg.toLowerCase().includes('insufficient') ||
+					msg.toLowerCase().includes('forbidden')
+						? ' (Hint: mode=native requires Docs/Sheets read scopes in addition to Drive, and access to the file.)'
+						: '';
+				Logger.error('[Google Drive] Smart fetch error:', e);
+
+				return {
+					value:
+						entity.catchesError || entity.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					error: msg + hint,
+					result: null,
+				};
+			}
+		},
+	};
+}
+
+/** small helper for uniform error returns */
+function bail(
+	entity: OperationState,
+	message: string
+): IPrimitiveExecutionResult {
+	Logger.log('[Google Drive] Smart fetch error:', message);
+	return {
+		value:
+			entity.catchesError || entity.errorCalls.length
+				? ExecutionTerminationType.CaughtError
+				: ExecutionTerminationType.UnhandledError,
+		error: message,
+		result: null,
+	};
+}