feat: Pexip Integration

apps/meteor/app/api/server/api.ts

@@ -43,6 +43,7 @@ export const API: {
 	api: Router<'/api', any, APIActionHandler>;
 	v1: APIClass<'/v1'>;
 	default: APIClass;
+	pexip: APIClass;
 	ApiClass: typeof APIClass;
 	channels?: {
 		create: {
@@ -74,6 +75,9 @@ export const API: {
 		useDefaultAuth: true,
 	}),
 	default: createApi({}),
+	pexip: createApi({
+		version: 'pexip',
+	}),
 };
 
 settings.watch<string>('Accounts_CustomFields', (value) => {
@@ -118,6 +122,7 @@ export const startRestAPI = () => {
 			.use(cors(settings))
 			.use(loggerMiddleware(logger))
 			.use(API.v1.router)
+			.use(API.pexip.router)
 			.use(API.default.router).router,
 	);
 };

apps/meteor/app/api/server/index.ts

@@ -45,6 +45,7 @@ import './v1/mailer';
 import './v1/teams';
 import './v1/moderation';
 import './v1/uploads';
+import './pexip';
 
 // This has to come last so all endpoints are registered before generating the OpenAPI documentation
 import './default/openApi';

apps/meteor/app/api/server/pexip/eventSink.ts

@@ -0,0 +1,47 @@
+import { isEventSinkRequestProps, Pexip } from '@rocket.chat/pexip';
+import { ajv, validateNotFoundErrorResponse, validateUnauthorizedErrorResponse } from '@rocket.chat/rest-typings';
+
+import { getPexipSettings } from '../../../../server/settings/pexip';
+import { API } from '../api';
+
+const successResponseSchema = ajv.compile<void>({
+	type: 'object',
+	properties: { success: { type: 'boolean', enum: [true] } },
+	required: ['success'],
+	additionalProperties: false,
+});
+
+API.pexip.post(
+	'events',
+	{
+		response: {
+			200: successResponseSchema,
+			401: validateUnauthorizedErrorResponse,
+			404: validateNotFoundErrorResponse,
+		},
+		body: isEventSinkRequestProps,
+		authRequired: false,
+		rateLimiterOptions: false,
+	},
+	async function action() {
+		const {
+			bodyParams: event,
+			request: { headers },
+		} = this;
+
+		const settings = getPexipSettings();
+		const pexip = new Pexip(settings);
+
+		try {
+			const authHeader = headers.get('authorization');
+
+			pexip.validateRequestCredentials(authHeader);
+		} catch (err) {
+			return API.pexip.unauthorized();
+		}
+
+		void pexip.processEvent(event).catch(() => true);
+
+		return API.pexip.success();
+	},
+);

apps/meteor/app/api/server/pexip/index.ts

@@ -0,0 +1,2 @@
+import './eventSink';
+import './policyServer';

apps/meteor/app/api/server/pexip/policyServer.ts

@@ -0,0 +1,50 @@
+import { isServiceConfigurationRequestProps, isPolicyServerResponse, Pexip } from '@rocket.chat/pexip';
+import { validateNotFoundErrorResponse, validateUnauthorizedErrorResponse } from '@rocket.chat/rest-typings';
+
+import { getPexipSettings } from '../../../../server/settings/pexip';
+import { API } from '../api';
+
+API.pexip.get(
+	'policy/v1/service/configuration',
+	{
+		response: {
+			200: isPolicyServerResponse,
+			401: validateUnauthorizedErrorResponse,
+			404: validateNotFoundErrorResponse,
+		},
+		query: isServiceConfigurationRequestProps,
+		authRequired: false,
+		rateLimiterOptions: false,
+	},
+	async function action() {
+		const {
+			queryParams: serviceRequest,
+			request: { headers },
+		} = this;
+
+		const settings = getPexipSettings();
+		const pexip = new Pexip(settings);
+
+		try {
+			const authHeader = headers.get('authorization');
+
+			pexip.validateRequestCredentials(authHeader);
+		} catch (err) {
+			return API.pexip.unauthorized();
+		}
+
+		const result = await pexip.getServiceConfiguration(serviceRequest);
+		if (!result) {
+			return API.pexip.notFound();
+		}
+
+		const status = 'success' as const;
+		const action = 'continue' as const;
+
+		return API.pexip.success({
+			status,
+			action,
+			result,
+		});
+	},
+);

apps/meteor/package.json

@@ -141,6 +141,7 @@
 		"@rocket.chat/password-policies": "workspace:^",
 		"@rocket.chat/patch-injection": "workspace:^",
 		"@rocket.chat/pdf-worker": "workspace:^",
+		"@rocket.chat/pexip": "workspace:^",
 		"@rocket.chat/poplib": "workspace:^",
 		"@rocket.chat/presence": "workspace:^",
 		"@rocket.chat/random": "workspace:^",

apps/meteor/server/lib/videoConfProviders.ts

@@ -1,9 +1,13 @@
 import type { VideoConferenceCapabilities } from '@rocket.chat/core-typings';
+import { Pexip, PexipVideoConfProvider } from '@rocket.chat/pexip';
 
 import { settings } from '../../app/settings/server';
+import { getPexipSettings } from '../settings/pexip';
 
 const providers = new Map<string, { capabilities: VideoConferenceCapabilities; label: string; appId: string }>();
 
+type Provider = { key: string; label: string };
+
 export const videoConfProviders = {
 	registerProvider(providerName: string, capabilities: VideoConferenceCapabilities, appId: string): void {
 		providers.set(providerName.toLowerCase(), { capabilities, label: providerName, appId });
@@ -24,32 +28,74 @@ export const videoConfProviders = {
 		const defaultProvider = settings.get<string>('VideoConf_Default_Provider');
 
 		if (defaultProvider) {
-			if (providers.has(defaultProvider)) {
+			if (this.isProviderAvailable(defaultProvider)) {
 				return defaultProvider;
 			}
 
 			return;
 		}
 
+		if (this.isProviderAvailable('core.pexip')) {
+			return 'core.pexip';
+		}
+
 		if (providers.size === 1) {
 			const [[name]] = [...providers];
 			return name;
 		}
 	},
 
 	hasAnyProvider(): boolean {
-		return providers.size > 0;
+		return providers.size > 0 || settings.get<boolean>('Pexip_Integration_Enabled');
 	},
 
-	getProviderList(): { key: string; label: string }[] {
+	getRegisteredProviders(): Provider[] {
 		return [...providers.keys()].map((key) => ({ key, label: providers.get(key)?.label || key }));
 	},
 
+	getInternalProviders(): Provider[] {
+		const pexip = this.getPexipProvider();
+
+		if (pexip) {
+			return [pexip];
+		}
+
+		return [];
+	},
+
+	getPexipProvider(): Provider | null {
+		if (!settings.get<boolean>('Pexip_Integration_Enabled')) {
+			return null;
+		}
+
+		return { key: 'core.pexip', label: 'Pexip_Integration' };
+	},
+
+	getAllProviders(): Provider[] {
+		const registeredProviders = [...providers.keys()].map((key) => ({ key, label: providers.get(key)?.label || key }));
+		const internalProviders = this.getInternalProviders();
+
+		return [...registeredProviders, ...internalProviders];
+	},
+
 	isProviderAvailable(name: string): boolean {
+		if (name === 'core.pexip') {
+			return settings.get<boolean>('Pexip_Integration_Enabled');
+		}
+
 		return providers.has(name);
 	},
 
 	getProviderCapabilities(name: string): VideoConferenceCapabilities | undefined {
+		if (name === 'core.pexip') {
+			return {
+				mic: false,
+				cam: false,
+				title: true,
+				persistentChat: true,
+			};
+		}
+
 		const key = name.toLowerCase();
 		if (!providers.has(key)) {
 			return;
@@ -60,11 +106,29 @@ export const videoConfProviders = {
 
 	getProviderAppId(name: string): string | undefined {
 		const key = name.toLowerCase();
+		if (key === 'core.pexip') {
+			return undefined;
+		}
 
 		if (!providers.has(key)) {
 			return;
 		}
 
 		return providers.get(key)?.appId;
 	},
+
+	getVideoConfProviderHandler(providerName: string): PexipVideoConfProvider | null {
+		if (providerName === 'core.pexip') {
+			return this.getPexipHandler();
+		}
+
+		return null;
+	},
+
+	getPexipHandler() {
+		const pexipSettings = getPexipSettings();
+
+		const pexip = new Pexip(pexipSettings);
+		return new PexipVideoConfProvider(pexip);
+	},
 };