Skip to content

🎥 Make videos programmatically with React

4.5 KB
Raw Blame
import type {IncomingMessage, ServerResponse} from 'node:http';
import {StudioProtocolInternals} from '@remotion/studio-protocol';
import {normalizeHttpUrl} from '@remotion/studio-shared';
import {consumeStudioProtocolTarget} from '../element-install-state';
import type {LiveEventsServer} from '../live-events';
import {parseRequestBody, RequestBodyTooLargeError} from '../parse-body';
import {
	getAllowedStudioProtocolOrigin,
	setStudioProtocolCorsHeaders,
} from './origin-policy';
import {writeStudioProtocolError} from './protocol-response';

type FocusStudioTab = (studioUrl: string) => void;

const MAX_STUDIO_PROTOCOL_ELEMENT_LIBRARY_BODY_SIZE = 16 * 1024;

export const handleStudioProtocolElementLibrary = async ({
	configFile,
	focusStudioTab,
	liveEventsServer,
	request,
	response,
}: {
	readonly configFile: string | null;
	readonly focusStudioTab: FocusStudioTab;
	readonly liveEventsServer: LiveEventsServer;
	readonly request: IncomingMessage;
	readonly response: ServerResponse;
}): Promise<void> => {
	setStudioProtocolCorsHeaders({request, response});
	const requestOrigin = getAllowedStudioProtocolOrigin(request);
	if (requestOrigin === null) {
		writeStudioProtocolError({
			code: 'unsupported-origin',
			message: 'Origin not allowed',
			response,
			status: 403,
		});
		return;
	}

	if (request.method !== 'POST') {
		writeStudioProtocolError({
			code: 'method-not-allowed',
			message: 'Use POST to add an Element Library.',
			response,
			status: 405,
		});
		return;
	}

	let body: unknown;
	try {
		body = await parseRequestBody(request, {
			maxBytes: MAX_STUDIO_PROTOCOL_ELEMENT_LIBRARY_BODY_SIZE,
		});
	} catch (error) {
		if (error instanceof RequestBodyTooLargeError) {
			writeStudioProtocolError({
				code: 'request-too-large',
				message: 'The request body is too large.',
				response,
				status: 413,
			});
			return;
		}

		writeStudioProtocolError({
			code: 'invalid-request',
			message: 'The request body is not valid JSON.',
			response,
			status: 400,
		});
		return;
	}

	const parsedRequest =
		StudioProtocolInternals.parseStudioProtocolAddElementLibraryRequest(body);
	if (parsedRequest === null) {
		writeStudioProtocolError({
			code: 'unsupported-protocol',
			message: 'Invalid Remotion Studio Protocol request.',
			response,
			status: 400,
		});
		return;
	}

	let normalizedUrl: string;
	try {
		const parsedUrl = new URL(parsedRequest.url);
		if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
			throw new Error('Unsupported protocol');
		}

		normalizedUrl = parsedUrl.href;
	} catch {
		writeStudioProtocolError({
			code: 'invalid-url',
			message: 'The Element Library URL must be an absolute HTTP or HTTPS URL.',
			response,
			status: 400,
		});
		return;
	}

	const captionStylesUrl =
		parsedRequest.captionStylesUrl === null
			? null
			: normalizeHttpUrl(parsedRequest.captionStylesUrl);
	if (parsedRequest.captionStylesUrl !== null && captionStylesUrl === null) {
		writeStudioProtocolError({
			code: 'invalid-url',
			message: 'The caption styles URL must be an absolute HTTP or HTTPS URL.',
			response,
			status: 400,
		});
		return;
	}

	const displayName = parsedRequest.displayName?.trim() ?? null;
	if (displayName === '') {
		writeStudioProtocolError({
			code: 'invalid-display-name',
			message: 'The Element Library display name must not be empty.',
			response,
			status: 400,
		});
		return;
	}

	const target = consumeStudioProtocolTarget({
		now: Date.now(),
		origin: requestOrigin,
		purpose: 'add-element-library',
		targetId: parsedRequest.targetId,
	});
	if (target === null) {
		writeStudioProtocolError({
			code: 'target-expired',
			message: 'The selected Studio target is no longer available.',
			response,
			status: 409,
		});
		return;
	}

	if (configFile === null) {
		writeStudioProtocolError({
			code: 'no-config-file',
			message: 'The selected Studio did not load a Remotion config file.',
			response,
			status: 409,
		});
		return;
	}

	const delivered = liveEventsServer.sendEventToClientId(target.clientId, {
		type: 'element-library-add-request',
		captionStylesUrl,
		url: normalizedUrl,
		displayName,
		origin: requestOrigin,
	});
	if (!delivered) {
		writeStudioProtocolError({
			code: 'target-expired',
			message: 'The selected Remotion Studio tab is no longer connected.',
			response,
			status: 409,
		});
		return;
	}

	focusStudioTab(target.studioUrl);

	response.writeHead(200, {'Content-Type': 'application/json'});
	response.end(
		JSON.stringify({
			protocol: 'remotion-studio-protocol',
			protocolVersion: 1,
			status: 'awaiting-confirmation',
		}),
	);
};