@elyx-code/editor-ui 0.0.2

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

@@ -0,0 +1,535 @@
+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, { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { editorRuntimeServiceBaseUrl } from '../../../../../integrations/api';
+import { getAccessToken } from '../../../../../../auth';
+import { Logger } from '@elyx-code/common-ts-utils';
+
+/* ----------------------------- Constants ----------------------------- */
+
+const FIELDS = 'id,name,mimeType,size,webViewLink,parents,modifiedTime';
+const MAX_SIMPLE_UPLOAD_BYTES = 5 * 1024 * 1024; // internal guard only
+const PROXY_CFG_HEADER = 'X-Elyx-Proxy-Config';
+
+/* --------------------------- Byte helpers --------------------------- */
+
+function stripLeadingSlash(p: string) {
+	return p.startsWith('/') ? p.slice(1) : p;
+}
+
+async function toBytesAndMime(
+	content: string | ArrayBuffer | Uint8Array | Blob
+): Promise<{ bytes: Uint8Array; inferredMime?: string; isBinary: boolean }> {
+	// data URL (base64)
+	if (typeof content === 'string' && /^data:[^;]+;base64,/.test(content)) {
+		const [, mime, b64] = content.match(/^data:([^;]+);base64,(.*)$/) || [];
+		const bin = atob(b64);
+		const out = new Uint8Array(bin.length);
+		for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+		return { bytes: out, inferredMime: mime, isBinary: true };
+	}
+
+	if (typeof content === 'string') {
+		const enc = new TextEncoder();
+		return {
+			bytes: enc.encode(content),
+			inferredMime: undefined,
+			isBinary: false,
+		};
+	}
+	if (content instanceof Blob) {
+		const ab = await content.arrayBuffer();
+		return {
+			bytes: new Uint8Array(ab),
+			inferredMime: content.type || undefined,
+			isBinary: true,
+		};
+	}
+	if (content instanceof ArrayBuffer) {
+		return {
+			bytes: new Uint8Array(content),
+			inferredMime: undefined,
+			isBinary: true,
+		};
+	}
+	// Uint8Array
+	return {
+		bytes: content as Uint8Array,
+		inferredMime: undefined,
+		isBinary: true,
+	};
+}
+
+async function contentToString(
+	content: string | ArrayBuffer | Uint8Array | Blob
+): Promise<string> {
+	if (typeof content === 'string') {
+		if (/^data:[^;]+;base64,/.test(content)) {
+			const [, , b64] = content.match(/^data:([^;]+);base64,(.*)$/) || [];
+			return new TextDecoder('utf-8').decode(
+				Uint8Array.from(atob(b64), (c) => c.charCodeAt(0))
+			);
+		}
+		return content;
+	}
+	if (content instanceof Blob) {
+		return new TextDecoder('utf-8').decode(
+			new Uint8Array(await content.arrayBuffer())
+		);
+	}
+	const ab =
+		content instanceof ArrayBuffer ? content : (content as Uint8Array).buffer;
+	return new TextDecoder('utf-8').decode(new Uint8Array(ab));
+}
+
+/* --------- CSV helpers: unescape \n/\t when needed, normalize CRLF ---------- */
+function coerceCsvText(s: string) {
+	let out = s;
+	if (!out.includes('\n') && /\\n/.test(out)) {
+		out = out.replace(/\\r\\n/g, '\n').replace(/\\n/g, '\n');
+	}
+	if (!out.includes('\t') && /\\t/.test(out)) {
+		out = out.replace(/\\t/g, '\t');
+	}
+	// Normalize to CRLF
+	out = out.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+	out = out.replace(/\n/g, '\r\n');
+	return out;
+}
+
+/* ------------------------------ The extension ------------------------------ */
+
+export class OperationsImplementationsUploadGoogleDriveFileModule
+	extends BaseRegisteredExtension
+	implements IRegisteredExtension<OperationsImplementation>
+{
+	manifest: ExtensionManifest = {
+		id:
+			BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX +
+			ExternalIntegrationOperations.GoogleDriveUploadFile,
+		version: '2.0.0',
+		description:
+			'Upload a file to Google Drive (media / import+copy) with auto content detection and simplified inputs.',
+		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.GoogleDriveUploadFile
+				) as ActionDescriptorState;
+
+				if (operation) {
+					operation.implementation = this.module.main;
+				}
+			}
+		},
+
+		main: async (
+			entity: OperationState,
+			_inputs: IDynamicValue[]
+		): Promise<IPrimitiveExecutionResult> => {
+			try {
+				const inputs = _inputs.map(
+					(input) => input.value?.valueAsType ?? input.value?.value,
+				);
+
+				const connectionEntity = inputs[0] as DefinitionEntityState;
+				if (!(connectionEntity instanceof DefinitionEntityState)) {
+					return bail(entity, 'Invalid or missing connection entity');
+				}
+
+				const content = inputs[1] as
+					| string
+					| ArrayBuffer
+					| Uint8Array
+					| Blob
+					| null
+					| undefined;
+				const name = (inputs[2] as string)?.trim();
+				const mimeType = (inputs[3] as string) || 'application/octet-stream';
+				const folderId = (inputs[4] as string) || undefined;
+				const description = (inputs[5] as string) || undefined;
+				const importMimeType = (inputs[6] as string) || 'text/plain';
+
+				if (!name) return bail(entity, 'Missing required input: name');
+
+				const editor = this.extensionsRegistry.requestContexts(this, [
+					ExtensionContextType.Editor,
+				])[0] as EditorService;
+				const connectionId =
+					getConnectionIdFromDefinitionEntity(connectionEntity);
+
+				const accessToken = await getAccessToken();
+				const authHeaders = { Authorization: `Bearer ${accessToken}` };
+
+				const proxyBaseV2 = `${editorRuntimeServiceBaseUrl}/v2/external-integrations/proxy/${editor.projectId}/${ExternalIntegrationNames['google-drive']}/${connectionId}`;
+
+				type Method = 'POST' | 'PATCH' | 'DELETE' | 'GET';
+
+				const callV2 = async <T = any>(
+					method: Method,
+					endpoint: string,
+					{
+						params,
+						body,
+						contentType,
+						providerHeaders,
+						responseType,
+					}: {
+						params?: Record<string, string | number | boolean>;
+						body?: any;
+						contentType?: string;
+						providerHeaders?: Record<string, string>;
+						responseType?: AxiosRequestConfig['responseType']; // rarely needed (binary responses)
+					} = {},
+				): Promise<AxiosResponse<T>> => {
+					const url = `${proxyBaseV2}/${stripLeadingSlash(endpoint)}`;
+					const headers: Record<string, string> = {
+						...authHeaders,
+					};
+					if (contentType) headers['Content-Type'] = contentType;
+
+					// Optional override header if we ever need to tweak provider headers/responseType
+					if (providerHeaders || responseType) {
+						headers[PROXY_CFG_HEADER] = JSON.stringify({
+							...(providerHeaders ? { headers: providerHeaders } : {}),
+							...(responseType ? { responseType } : {}),
+						});
+					}
+
+					return axios.request<T>({
+						method,
+						url,
+						params,
+						data: body,
+						responseType: responseType || 'json',
+						headers,
+					});
+				};
+
+				const isGoogleNative =
+					typeof mimeType === 'string' &&
+					mimeType.startsWith('application/vnd.google-apps.');
+
+				/* ----------------------------------------------------------------
+				   A) Google-native with no content → metadata-only create
+				------------------------------------------------------------------ */
+				if (isGoogleNative && (content == null || content === '')) {
+					const metadata: Record<string, any> = { name, mimeType };
+					if (folderId) metadata.parents = [folderId];
+					if (typeof description === 'string')
+						metadata.description = description;
+
+					const res = await callV2<Record<string, any>>(
+						'POST',
+						'/drive/v3/files',
+						{
+							params: { supportsAllDrives: 'true', fields: FIELDS },
+							body: JSON.stringify(metadata),
+							contentType: 'application/json',
+						},
+					);
+
+					if (res.status !== 200 && res.status !== 201) {
+						return bail(entity, `Drive create failed (status=${res.status})`);
+					}
+					return success({ file: res.data });
+				}
+
+				/* ----------------------------------------------------------------
+				   B) Google-native with content → upload import data, then copy-convert
+				------------------------------------------------------------------ */
+				if (isGoogleNative && content != null) {
+					let textContent = await contentToString(content);
+
+					// Pick the right media type for the source we’re uploading.
+					const pickMediaType = (target: string, provided?: string) => {
+						if (provided) return provided;
+						if (target === 'application/vnd.google-apps.spreadsheet')
+							return 'text/csv';
+						if (
+							target === 'application/vnd.google-apps.document' ||
+							target === 'application/vnd.google-apps.presentation'
+						)
+							return 'text/html';
+						return 'text/plain';
+					};
+					const mediaType = pickMediaType(mimeType, importMimeType);
+					const mediaTypeHeader =
+						mediaType.startsWith('text/') && !/charset=/i.test(mediaType)
+							? `${mediaType}; charset=UTF-8`
+							: mediaType;
+
+					// For CSV imports, fix literal "\n"/"\t" and normalize to CRLF.
+					if (mediaType.startsWith('text/csv')) {
+						textContent = coerceCsvText(textContent);
+					}
+
+					// Upload exact text bytes (no base64; body is bytes)
+					const textBytes = new TextEncoder().encode(textContent);
+					if (textBytes.byteLength > MAX_SIMPLE_UPLOAD_BYTES) {
+						return bail(
+							entity,
+							`Text body exceeds simple upload limit (${textBytes.byteLength} bytes).`,
+						);
+					}
+
+					let sourceId: string | undefined;
+
+					try {
+						const uploadRes = await callV2<Record<string, any>>(
+							'POST',
+							'/upload/drive/v3/files',
+							{
+								params: {
+									uploadType: 'media',
+									supportsAllDrives: 'true',
+									fields: FIELDS,
+								},
+								body: textBytes,
+								contentType: mediaTypeHeader,
+							},
+						);
+
+						if (uploadRes.status !== 200 && uploadRes.status !== 201) {
+							return bail(
+								entity,
+								`Drive media upload failed (status=${uploadRes.status})`,
+							);
+						}
+
+						sourceId = uploadRes.data?.id as string | undefined;
+						if (!sourceId)
+							return bail(entity, 'Drive media upload did not return an id');
+
+						// Copy + convert into the requested native Google type (can set name/parents/description here)
+						const copyBody: Record<string, any> = { name, mimeType };
+						if (folderId) copyBody.parents = [folderId];
+						if (typeof description === 'string')
+							copyBody.description = description;
+
+						const copyRes = await callV2<Record<string, any>>(
+							'POST',
+							`/drive/v3/files/${encodeURIComponent(sourceId)}/copy`,
+							{
+								params: { supportsAllDrives: 'true', fields: FIELDS },
+								body: JSON.stringify(copyBody),
+								contentType: 'application/json',
+							},
+						);
+
+						if (copyRes.status !== 200 && copyRes.status !== 201) {
+							return bail(
+								entity,
+								`Drive copy-convert failed (status=${copyRes.status})`,
+							);
+						}
+
+						return success({ file: copyRes.data });
+					} finally {
+						// Best-effort cleanup of the temporary source
+						if (sourceId) {
+							try {
+								await callV2(
+									'DELETE',
+									`/drive/v3/files/${encodeURIComponent(sourceId)}`,
+									{ params: { supportsAllDrives: 'true' } },
+								);
+							} catch {
+								/* ignore cleanup errors */
+							}
+						}
+					}
+				}
+
+				/* ----------------------------------------------------------------
+				   C) Non-native (PDF/PNG/ZIP/etc.)
+				   Auto-detect whether content is binary or textual, send raw bytes.
+				------------------------------------------------------------------ */
+
+				if (content == null) {
+					return bail(entity, 'Missing content for non-native upload');
+				}
+
+				const { bytes, inferredMime, isBinary } = await toBytesAndMime(content);
+
+				const approxBytes = bytes.byteLength;
+				if (approxBytes > MAX_SIMPLE_UPLOAD_BYTES) {
+					return bail(
+						entity,
+						`File too large for simple upload (${approxBytes} bytes).`,
+					);
+				}
+
+				const contentTypeHeader =
+					mimeType ||
+					inferredMime ||
+					(isBinary ? 'application/octet-stream' : 'text/plain; charset=UTF-8');
+
+				const uploadRes = await callV2<Record<string, any>>(
+					'POST',
+					'/upload/drive/v3/files',
+					{
+						params: {
+							uploadType: 'media',
+							supportsAllDrives: 'true',
+							fields: FIELDS,
+						},
+						body: bytes,
+						contentType: contentTypeHeader,
+					},
+				);
+
+				if (uploadRes.status !== 200 && uploadRes.status !== 201) {
+					return bail(
+						entity,
+						`Drive media upload failed (status=${uploadRes.status})`,
+					);
+				}
+
+				let final = uploadRes.data;
+				const fileId = uploadRes.data?.id as string | undefined;
+
+				if (fileId && (folderId || name || description)) {
+					final = await patchMetadataWithParentTolerant(
+						callV2,
+						fileId,
+						name,
+						description,
+						folderId,
+					);
+				}
+
+				return success({ file: final });
+			} catch (e: any) {
+				// Extract the juicy details from Axios if they exist
+				const errorData = e.response?.data || e.message || e;
+
+				Logger.error('[Google Drive] Upload document 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,
+				};
+			}
+		},
+	};
+}
+
+/* --------------------------------- Helpers -------------------------------- */
+
+function success(result: any): IPrimitiveExecutionResult {
+	return { value: ExecutionTerminationType.Success, error: null, result };
+}
+
+function bail(
+	entity: OperationState,
+	message: string
+): IPrimitiveExecutionResult {
+	Logger.log('[Google Drive] Upload error:', message);
+	return {
+		value:
+			entity.catchesError || entity.errorCalls.length
+				? ExecutionTerminationType.CaughtError
+				: ExecutionTerminationType.UnhandledError,
+		error: message,
+		result: null,
+	};
+}
+
+/** Try to PATCH metadata & move into folder, best-effort removing from root if applicable. */
+async function patchMetadataWithParentTolerant(
+	callV2: <T = any>(
+		method: 'POST' | 'PATCH' | 'DELETE' | 'GET',
+		endpoint: string,
+		opts?: {
+			params?: Record<string, string | number | boolean>;
+			body?: any;
+			contentType?: string;
+			providerHeaders?: Record<string, string>;
+			responseType?: AxiosRequestConfig['responseType'];
+		}
+	) => Promise<AxiosResponse<T>>,
+	fileId: string,
+	name?: string,
+	description?: string,
+	folderId?: string
+) {
+	const metadata: Record<string, any> = {};
+	if (name) metadata.name = name;
+	if (typeof description === 'string') metadata.description = description;
+
+	const baseParams: Record<string, string> = {
+		supportsAllDrives: 'true',
+		fields: FIELDS,
+	};
+
+	// First attempt: addParents + removeParents=root
+	const tryParams: Record<string, string> = { ...baseParams };
+	if (folderId) {
+		tryParams.addParents = folderId;
+		tryParams.removeParents = 'root';
+	}
+
+	let patchRes = await callV2<Record<string, any>>(
+		'PATCH',
+		`/drive/v3/files/${encodeURIComponent(fileId)}`,
+		{
+			params: tryParams,
+			body: JSON.stringify(metadata),
+			contentType: 'application/json',
+		}
+	);
+
+	// If removeParents fails (e.g., Shared Drive), retry without it.
+	if (patchRes.status >= 400 && folderId) {
+		patchRes = await callV2<Record<string, any>>(
+			'PATCH',
+			`/drive/v3/files/${encodeURIComponent(fileId)}`,
+			{
+				params: { ...baseParams, addParents: folderId },
+				body: JSON.stringify(metadata),
+				contentType: 'application/json',
+			}
+		);
+	}
+
+	if (patchRes.status !== 200) {
+		throw new Error(`Drive metadata update failed (status=${patchRes.status})`);
+	}
+
+	return patchRes.data;
+}