@elyx-code/editor-ui 0.0.2

package/src/services/integrations/ExternalIntegrationsService.ts

@@ -0,0 +1,439 @@
+import type { ConnectUI } from '@nangohq/frontend';
+import Nango from '@nangohq/frontend';
+import {
+	editorRuntimeServiceBaseUrl,
+	getCredentials,
+	getProjectCredentials,
+	postConnectSession,
+} from './api';
+import { EditorService } from '../editor';
+import { AxiosResponse } from 'axios';
+import {
+	ApiPublicConnection,
+	ApiPublicConnectionFull,
+	AuthModes,
+	CombinedFilterAction,
+	NangoRecord,
+	UserProvidedProxyConfiguration,
+} from '@nangohq/types';
+import { getAccessToken } from '../../auth';
+import {
+	BaseEntityNames,
+	BUILT_IN_BASE_ENTITY_IDS,
+	checkHasBaseEntity,
+	ExternalIntegrationNames,
+	isObject,
+} from '@elyx-code/project-logic-tree';
+import { Logger } from '@elyx-code/common-ts-utils';
+import { envConfig } from '../../config';
+
+const apiURL =
+	envConfig.EXTERNAL_INTEGRATIONS_URL ?? 'https://integrations.dev.elyx.tech';
+const nango = new Nango({ host: apiURL, publicKey: 'empty' });
+const connectUIBaseUrl =
+	envConfig.EXTERNAL_INTEGRATIONS_CONNECT_URL ??
+	'https://connect.dev.elyx.tech';
+
+export interface Integration {
+	created_at: string;
+	updated_at: string;
+	unique_key: string;
+	provider: string;
+	logo: string;
+	display_name: string;
+	webhook_url?: string | null;
+	credentials?:
+		| {
+				type: AuthModes['OAuth2'] | AuthModes['OAuth1'] | AuthModes['TBA'];
+				client_id: string | null;
+				client_secret: string | null;
+				scopes: string | null;
+		  }
+		| {
+				type: AuthModes['App'];
+				app_id: string | null;
+				private_key: string | null;
+				app_link: string | null;
+		  }
+		| null;
+}
+
+export type GetIntegrations = {
+	integrations: Integration[];
+};
+
+export interface GetConnectionsSuccess {
+	connections: ApiPublicConnection[];
+}
+
+export interface ListRecordsRequestConfig {
+	providerConfigKey: string;
+	connectionId: string;
+	model: string;
+	variant?: string;
+	modifiedAfter?: string;
+	limit?: number;
+	filter?: CombinedFilterAction | CombinedFilterAction;
+	cursor?: string | null;
+	ids?: string[];
+}
+
+export type ProxyConfiguration = Omit<
+	UserProvidedProxyConfiguration,
+	'files' | 'providerConfigKey'
+> & {
+	providerConfigKey?: string;
+	connectionId?: string;
+};
+
+export interface IConnectOptions {
+	onSuccess?: (connection: ApiPublicConnection) => Promise<void> | void;
+}
+
+export class ExternalIntegrationsService {
+	// Service methods and logic go here
+	nango = nango;
+
+	connectUI: ConnectUI | null = null;
+
+	editor: EditorService;
+
+	allIntegrations: Integration[] = [];
+	allConnections: ApiPublicConnection[] = [];
+
+	constructor(editor: EditorService) {
+		this.editor = editor;
+	}
+
+	integration(uniqueKey: string): Integration | null {
+		return (
+			this.allIntegrations.find(
+				(integration) => integration.unique_key === uniqueKey,
+			) || null
+		);
+	}
+
+	// We check the existing connections against the entities in the project
+	// And return the ones that are not tracked by the project
+	getUntrackedConnections(): ApiPublicConnection[] {
+		return this.allConnections.filter((connection) => {
+			const connectionId = connection.connection_id;
+
+			const trackedIds = this.editor.project?.entities
+				.filter((entity) =>
+					checkHasBaseEntity(
+						entity,
+						BaseEntityNames.EXTERNAL_INTEGRATION_CONNECTION,
+					),
+				)
+				.map((entity) => {
+					const builtInConnectionPropertyId =
+						BUILT_IN_BASE_ENTITY_IDS['built-in-base-entity']
+							.BUILT_IN_EXTERNAL_INTEGRATION_CONNECTION_ENTITY.properties
+							.connectionId.id;
+					const connectionIdProperty = entity.properties.find(
+						(property) =>
+							property.implements.find(
+								(impl) => impl.id === builtInConnectionPropertyId,
+							) ||
+							// It could be that this is a specific connection entity, and therefore itself extends the base connection entity
+							property.implements.find(
+								(impl) => impl.extends?.id === builtInConnectionPropertyId,
+							),
+					);
+
+					const connectionIdValue =
+						connectionIdProperty?.getDefaultValue()?.value;
+
+					return connectionIdValue as string;
+				})
+				.filter((id) => !!id);
+
+			return !trackedIds?.includes(connectionId);
+		});
+	}
+
+	connect(
+		integrationOrOptions?: ExternalIntegrationNames | IConnectOptions,
+		options?: IConnectOptions,
+	): void {
+		// if (!integrationUniqueKey) {
+		// 	throw new Error(
+		// 		`To 'connect' you must provide an integration unique key`
+		// 	);
+		// }
+
+		let sanitizedUniqueKey: ExternalIntegrationNames | null = null;
+		let sanitizedOptions: IConnectOptions = options || {};
+
+		if (typeof integrationOrOptions === 'string') {
+			sanitizedUniqueKey = integrationOrOptions;
+		} else if (isObject(integrationOrOptions)) {
+			sanitizedOptions = integrationOrOptions;
+		}
+
+		// sanitizedUniqueKey = getRootExternalIntegrationFromAlias(
+		// 	sanitizedUniqueKey as ExternalIntegrationAliasProviders
+		// ) as ExternalIntegrationNames;
+
+		this.connectUI = nango.openConnectUI({
+			// host: connectUIBaseUrl, // Type error: Property 'host' does not exist on type 'ConnectUIOptions'
+			apiURL,
+			baseURL: connectUIBaseUrl,
+			onEvent: async (event) => {
+				if (event.type === 'close') {
+					// Open alert to notify the user
+					return;
+				} else if (event.type === 'connect') {
+					// The backend will receive a webhook with the connection info
+					// Open alert to notify the user
+					if (sanitizedOptions.onSuccess) {
+						Logger.log('Connection established successfully:', event);
+
+						// Re-fetch the connections list
+						const result =
+							await this.editor.integrationsService.listConnections();
+
+						this.allConnections = result.connections;
+
+						const newConnection = result.connections.find(
+							(connection) =>
+								connection.connection_id === event.payload.connectionId,
+						);
+
+						await sanitizedOptions.onSuccess(
+							newConnection as ApiPublicConnection,
+						);
+					}
+					return;
+				}
+
+				console.warn('Unknown connect external integration event type:', event);
+			},
+		});
+
+		// We defer the token creation so the iframe can open and display a loading screen
+		setTimeout(async () => {
+			Logger.log(
+				'Creating connect session for unique key:',
+				sanitizedUniqueKey,
+			);
+			const res = await postConnectSession(
+				sanitizedUniqueKey as string,
+				this.editor.projectId,
+			);
+			Logger.log('Connect session response:', res);
+			this.connectUI!.setSessionToken(res.connectSession);
+		}, 10);
+	}
+
+	async listIntegrations(): Promise<GetIntegrations> {
+		const res = await fetch(
+			`${editorRuntimeServiceBaseUrl}/v1/external-integrations/integrations`,
+			{
+				headers: {
+					Authorization: `Bearer ${await getAccessToken()}`,
+				},
+			},
+		);
+
+		if (res.status !== 200) {
+			const errorText = await res.text();
+			try {
+				// If the server returned JSON, throw the parsed object
+				// or a custom error with that data attached.
+				const errorJson = JSON.parse(errorText);
+				throw errorJson;
+			} catch (e) {
+				throw new Error(errorText || 'Error listing external integrations');
+			}
+		}
+
+		const json = (await res.json()) as GetIntegrations;
+		return json;
+	}
+
+	async listConnections(): Promise<GetConnectionsSuccess> {
+		const res = await fetch(
+			`${editorRuntimeServiceBaseUrl}/v1/external-integrations/all-connections/${this.editor.projectId}`,
+			{
+				headers: {
+					Authorization: `Bearer ${await getAccessToken()}`,
+				},
+			},
+		);
+
+		if (res.status !== 200) {
+			const errorText = await res.text();
+			try {
+				// If the server returned JSON, throw the parsed object
+				// or a custom error with that data attached.
+				const errorJson = JSON.parse(errorText);
+				throw errorJson;
+			} catch (e) {
+				throw new Error(
+					errorText || 'Error listing external integrations connections',
+				);
+			}
+		}
+
+		const json = (await res.json()) as GetConnectionsSuccess;
+
+		this.allConnections = json.connections;
+
+		return json;
+	}
+
+	// Generic list method which can be used to list any records from any integration
+	async listRecords<T extends Record<string, any> = any>(
+		providerConfigKey: string,
+		connectionId: string,
+		model: string,
+		config: Omit<
+			ListRecordsRequestConfig,
+			'providerConfigKey' | 'connectionId' | 'model'
+		> = {},
+	): Promise<{
+		records: NangoRecord<T>[];
+		next_cursor: string | null;
+	}> {
+		const querySanitisedConfig = {
+			variant: config.variant,
+			modifiedAfter: config.modifiedAfter,
+			limit: config.limit ? String(config.limit) : undefined,
+			filter: config.filter,
+			cursor: config.cursor,
+			ids: config.ids ? config.ids.join(',') : undefined,
+		};
+
+		// Loop over the keys and remove undefined values
+		Object.keys(querySanitisedConfig).forEach((key) => {
+			// @ts-ignore
+			if (querySanitisedConfig[key] === undefined) {
+				// @ts-ignore
+				delete querySanitisedConfig[key];
+			}
+		});
+
+		const queryParams = new URLSearchParams(
+			querySanitisedConfig as Record<string, string>,
+		);
+
+		const url = `${editorRuntimeServiceBaseUrl}/v1/external-integrations/list-records/${providerConfigKey}/${connectionId}/${model}?${queryParams.toString()}`;
+
+		const res = await fetch(url, {
+			method: 'GET',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${await getAccessToken()}`,
+			},
+		});
+
+		if (res.status !== 200) {
+			const errorText = await res.text();
+			try {
+				// If the server returned JSON, throw the parsed object
+				// or a custom error with that data attached.
+				const errorJson = JSON.parse(errorText);
+				throw errorJson;
+			} catch (e) {
+				throw new Error(
+					errorText || 'Error listing records from external integration',
+				);
+			}
+		}
+
+		const json = (await res.json()) as {
+			records: NangoRecord<T>[];
+			next_cursor: string | null;
+		};
+		return json;
+	}
+
+	// Generic method to get a single record
+	async get<T = any>(
+		providerConfigKey: string,
+		connectionId: string,
+		config: ProxyConfiguration,
+	): Promise<AxiosResponse<T>> {
+		const res = await fetch(
+			`${editorRuntimeServiceBaseUrl}/v1/external-integrations/get-item/${providerConfigKey}/${connectionId}`,
+			{
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${await getAccessToken()}`,
+				},
+				body: JSON.stringify(config),
+			},
+		);
+
+		if (res.status !== 200) {
+			const errorText = await res.text();
+			try {
+				// If the server returned JSON, throw the parsed object
+				// or a custom error with that data attached.
+				const errorJson = JSON.parse(errorText);
+				throw errorJson;
+			} catch (e) {
+				throw new Error(
+					errorText || 'Error getting item from external integration',
+				);
+			}
+		}
+
+		const json = (await res.json()) as AxiosResponse<T>;
+		return json;
+	}
+
+	// Generic method to trigger an action
+	async triggerAction<In = unknown, Out = object>(
+		providerConfigKey: string,
+		connectionId: string,
+		action: string,
+		payload: In,
+	): Promise<Out> {
+		const res = await fetch(
+			`${editorRuntimeServiceBaseUrl}/v1/external-integrations/trigger-action/${providerConfigKey}/${connectionId}/${action}`,
+			{
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${await getAccessToken()}`,
+				},
+				body: JSON.stringify({
+					// providerConfigKey,
+					// connectionId,
+					// action,
+					payload,
+				}),
+			},
+		);
+
+		if (res.status !== 200) {
+			const errorText = await res.text();
+			try {
+				// If the server returned JSON, throw the parsed object
+				// or a custom error with that data attached.
+				const errorJson = JSON.parse(errorText);
+				throw errorJson;
+			} catch (e) {
+				throw new Error(
+					errorText || 'Error triggering external integration action',
+				);
+			}
+		}
+		const json = (await res.json()) as Out;
+		return json;
+	}
+
+	getProjectCredentials(
+		connectionIds?: string[],
+	): Promise<{ credentials: ApiPublicConnectionFull[] }> {
+		return getProjectCredentials(this.editor.projectId, connectionIds);
+	}
+
+	getCredentials(integrationId: string, connectionId: string): Promise<any> {
+		return getCredentials(this.editor.projectId, integrationId, connectionId);
+	}
+}

package/src/services/integrations/api.ts

@@ -0,0 +1,175 @@
+import { ApiPublicConnectionFull } from '@nangohq/types';
+import { getAccessToken } from '../../auth';
+import { envConfig } from '../../config';
+
+export const editorRuntimeServiceBaseUrl =
+	`${envConfig.API_BASE_URL}/editor-runtime` ||
+	'http://localhost:3010';
+
+type File = {
+	[key: string]: any;
+};
+
+export async function postConnectSession(
+	integration: string,
+	projectId: string
+): Promise<any> {
+	const res = await fetch(
+		`${editorRuntimeServiceBaseUrl}/v1/external-integrations/connect-session/${projectId}`,
+		{
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${await getAccessToken()}`,
+			},
+			body: JSON.stringify({ integration }),
+		}
+	);
+	if (res.status !== 200) {
+		throw new Error();
+	}
+
+	const json = (await res.json()) as any;
+	return json;
+}
+
+export async function listIntegrations(): Promise<any> {
+	const res = await fetch(`${editorRuntimeServiceBaseUrl}/integrations`, {
+		method: 'GET',
+		headers: {
+			Authorization: `Bearer ${await getAccessToken()}`,
+		},
+	});
+	if (res.status !== 200) {
+		throw new Error();
+	}
+
+	const json = (await res.json()) as any;
+	return json;
+}
+
+export async function listConnections(): Promise<any> {
+	const res = await fetch(`${editorRuntimeServiceBaseUrl}/v1/external-integrations/connections`, {
+		method: 'GET',
+		headers: {
+			Authorization: `Bearer ${await getAccessToken()}`,
+		},
+	});
+	if (res.status !== 200) {
+		throw new Error();
+	}
+
+	const json = (await res.json()) as any;
+	return json;
+}
+
+export async function getNangoCredentials(integrationId: string): Promise<any> {
+	const res = await fetch(
+		`${editorRuntimeServiceBaseUrl}/nango-credentials?integrationId=${integrationId}`
+	);
+	if (res.status !== 200) {
+		throw new Error('Failed to get Nango credentials');
+	}
+	return res.json();
+}
+
+export async function setConnectionMetadata(
+	integrationId: string,
+	metadata: Record<string, any>
+): Promise<void> {
+	const res = await fetch(
+		`${editorRuntimeServiceBaseUrl}/v1/external-integrations/set-connection-metadata`,
+		{
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${await getAccessToken()}`,
+			},
+			body: JSON.stringify({ integrationId, metadata }),
+		}
+	);
+	if (res.status !== 200) {
+		throw new Error('Failed to set connection metadata');
+	}
+}
+
+export async function getFiles(): Promise<File[]> {
+	const res = await fetch(`${editorRuntimeServiceBaseUrl}/get-files`);
+	if (res.status !== 200) {
+		throw new Error('Failed to get files');
+	}
+	const json: { files: File[] } = await res.json();
+	return json.files;
+}
+
+export async function downloadFile(fileId: string): Promise<Blob> {
+	const res = await fetch(`${editorRuntimeServiceBaseUrl}/download/${fileId}`, {
+		method: 'GET',
+	});
+
+	if (!res.ok) {
+		throw new Error('Failed to download file');
+	}
+
+	return res.blob();
+}
+
+export async function deleteConnection(integration: string): Promise<void> {
+	const res = await fetch(
+		`${editorRuntimeServiceBaseUrl}/v1/external-integrations/connections/${integration}`,
+		{
+			headers: {
+				Authorization: `Bearer ${await getAccessToken()}`,
+			},
+			method: 'DELETE',
+		}
+	);
+	if (res.status !== 200) {
+		throw new Error('Failed to delete connection');
+	}
+}
+
+export async function getProjectCredentials(
+	projectId: string,
+	connectionIds?: string[]
+): Promise<{ credentials: ApiPublicConnectionFull[] }> {
+	const res = await fetch(
+		`${editorRuntimeServiceBaseUrl}/v1/external-integrations/credentials/${projectId}${
+			!!connectionIds ? `?connectionIds=${connectionIds.join(',')}` : ''
+		}`,
+		{
+			method: 'GET',
+			headers: {
+				Authorization: `Bearer ${await getAccessToken()}`,
+			},
+		}
+	);
+
+	if (res.status !== 200) {
+		throw new Error('Failed to get credentials');
+	}
+
+	return res.json();
+}
+
+export async function getCredentials(
+	projectId: string,
+	integrationId: string,
+	connectionId: string
+): Promise<{ credentials: ApiPublicConnectionFull[] }> {
+	const res = await fetch(
+		`${editorRuntimeServiceBaseUrl}/v1/external-integrations/credentials/${projectId}/${integrationId}/${connectionId}`,
+		{
+			method: 'GET',
+			headers: {
+				Authorization: `Bearer ${await getAccessToken()}`,
+			},
+		}
+	);
+
+	if (res.status !== 200) {
+		throw new Error('Failed to get credentials');
+	}
+
+	return res.json();
+}

package/src/services/local-relational-database/idb_helper.ts

@@ -0,0 +1,66 @@
+import { Logger } from '@elyx-code/common-ts-utils';
+import { IDataBase, Connection } from 'jsstore';
+import SqlWeb from 'sqlweb';
+
+const getWorkerPath = () => {
+	try {
+		if (process.env.NODE_ENV === 'development') {
+			return require('file-loader?name=scripts/[name].[hash].js!jsstore/dist/jsstore.worker.js');
+		} else {
+			return require('file-loader?name=scripts/[name].[hash].js!jsstore/dist/jsstore.worker.min.js');
+		}
+	} catch (ex) {
+		// Logger.error(ex);
+		return {
+			default: '',
+		};
+	}
+};
+
+// Ensure that we are using only one instance.
+// Otherwise due to multiple instance multiple worker will be created.
+const workerPath = getWorkerPath().default;
+
+export const initLocalDBConnection = async (): Promise<
+	Connection & {
+		$sql: {
+			run: (sql: string) => Promise<any>;
+		};
+	} & {
+		database: IDataBase;
+	}
+> => {
+	try {
+		const idbCon = !!workerPath
+			? new Connection(new Worker(workerPath))
+			: new Connection();
+
+		// Add SqlWeb so we can use raw SQL queries
+		await idbCon.addPlugin(SqlWeb);
+
+		return idbCon as Connection & {
+			$sql: {
+				run: (sql: string) => Promise<any>;
+			};
+		} & {
+			database: IDataBase;
+		};
+	} catch (ex) {
+		Logger.log('Here');
+		Logger.error('HERE :', ex);
+	}
+};
+
+export const initLocalIndexedDatabase = async (
+	connection: Connection,
+	database: IDataBase
+): Promise<boolean> => {
+	try {
+		Logger.log('Initializing database at jsstore level');
+
+		return connection.initDb(database);
+	} catch (ex) {
+		Logger.log('Here');
+		Logger.error('HERE :', ex);
+	}
+};