Skip to content

🎥 Make videos programmatically with React

7.6 KB
Raw Blame
import * as z from 'zod/mini';

export type StudioProtocolTarget = {
	readonly id: string;
	readonly expiresAt: number;
	readonly lastFocusedAt: number;
};

export type StudioProtocolInstallTarget = Omit<
	StudioProtocolTarget,
	'lastFocusedAt'
> & {
	readonly lastFocusedAt: number | null;
	/**
	 * @deprecated The installation destination is chosen in Studio. Use the opaque target id to request installation instead.
	 */
	readonly compositionId: string | null;
};

export type StudioProtocolInstallCapability = {
	readonly type: 'install-element';
	readonly payloadType: 'remotion-element';
	readonly payloadVersions: readonly number[];
	readonly target: StudioProtocolInstallTarget | null;
};

export type StudioProtocolSetLicenseKeyCapability = {
	readonly type: 'set-license-key';
	readonly target: StudioProtocolTarget | null;
};

export type StudioProtocolAddElementLibraryCapability = {
	readonly type: 'add-element-library';
	readonly target: StudioProtocolTarget | null;
};

export type StudioProtocolCapability =
	| StudioProtocolInstallCapability
	| StudioProtocolSetLicenseKeyCapability
	| StudioProtocolAddElementLibraryCapability;

export type StudioProtocolDescriptor = {
	readonly protocol: 'remotion-studio-protocol';
	readonly protocolVersion: 1;
	readonly studioVersion: string;
	readonly projectName: string | null;
	readonly capabilities: readonly StudioProtocolCapability[];
};

export type StudioProtocolFetcher = (
	input: string | URL | Request,
	options?: RequestInit,
) => Promise<Response>;

export type StudioProtocolDiscoveryDependencies = {
	readonly fetchFn: StudioProtocolFetcher;
	readonly now: () => number;
	readonly ports: readonly number[];
};

export const studioProtocolProbePorts = [
	3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009,
];

const requestTimeout = 2_000;

const targetSchema = z.looseObject({
	id: z.string().check(z.minLength(1)),
	expiresAt: z.number(),
	lastFocusedAt: z.number(),
});

const installTargetSchema = z.looseObject({
	id: z.string().check(z.minLength(1)),
	expiresAt: z.number(),
	lastFocusedAt: z.nullable(z.number()),
	compositionId: z.nullable(z.string().check(z.minLength(1))),
});

const installCapabilitySchema = z.looseObject({
	type: z.literal('install-element'),
	payloadType: z.literal('remotion-element'),
	payloadVersions: z.array(z.number()),
	target: z.nullable(installTargetSchema),
});

const setLicenseKeyCapabilitySchema = z.looseObject({
	type: z.literal('set-license-key'),
	target: z.nullable(targetSchema),
});

const addElementLibraryCapabilitySchema = z.looseObject({
	type: z.literal('add-element-library'),
	target: z.nullable(targetSchema),
});

const capabilitySchema = z.union([
	installCapabilitySchema,
	setLicenseKeyCapabilitySchema,
	addElementLibraryCapabilitySchema,
]);

const descriptorEnvelopeSchema = z.looseObject({
	protocol: z.literal('remotion-studio-protocol'),
	protocolVersion: z.literal(1),
	studioVersion: z.string(),
	projectName: z.nullable(z.string()),
	capabilities: z.array(z.unknown()),
});

const descriptorSchema = z
	.looseObject({
		protocol: z.literal('remotion-studio-protocol'),
		protocolVersion: z.literal(1),
		studioVersion: z.string(),
		projectName: z.nullable(z.string()),
		capabilities: z.array(capabilitySchema),
	})
	.check(
		z.refine((descriptor) => {
			const capabilityTypes = descriptor.capabilities.map(
				(capability) => capability.type,
			);

			return new Set(capabilityTypes).size === capabilityTypes.length;
		}),
	);

const protocolEnvelopeSchema = z.looseObject({
	protocol: z.literal('remotion-studio-protocol'),
});

const protocolVersionEnvelopeSchema = z.looseObject({
	protocol: z.literal('remotion-studio-protocol'),
	protocolVersion: z.unknown(),
});

export const fetchWithTimeout = async ({
	fetchFn,
	options,
	url,
}: {
	readonly fetchFn: StudioProtocolFetcher;
	readonly options: RequestInit | null;
	readonly url: string;
}) => {
	const controller = new AbortController();
	const timeout = setTimeout(() => controller.abort(), requestTimeout);

	try {
		return await fetchFn(url, {
			...(options ?? {}),
			signal: controller.signal,
		});
	} finally {
		clearTimeout(timeout);
	}
};

export const isStudioProtocolDescriptor = (
	value: unknown,
): value is StudioProtocolDescriptor =>
	z.safeParse(descriptorSchema, value).success;

export const parseStudioProtocolDescriptor = (
	value: unknown,
): StudioProtocolDescriptor | null => {
	const envelope = z.safeParse(descriptorEnvelopeSchema, value);

	if (!envelope.success) {
		return null;
	}

	const capabilities: StudioProtocolCapability[] = [];

	for (const capability of envelope.data.capabilities) {
		const parsedCapability = z.safeParse(capabilitySchema, capability);

		if (parsedCapability.success) {
			capabilities.push(parsedCapability.data);
		}
	}

	const descriptor = z.safeParse(descriptorSchema, {
		...envelope.data,
		capabilities,
	});

	return descriptor.success ? descriptor.data : null;
};

export const getInstallCapability = (
	descriptor: StudioProtocolDescriptor,
): StudioProtocolInstallCapability | null =>
	descriptor.capabilities.find(
		(capability): capability is StudioProtocolInstallCapability =>
			capability.type === 'install-element',
	) ?? null;

export const getSetLicenseKeyCapability = (
	descriptor: StudioProtocolDescriptor,
): StudioProtocolSetLicenseKeyCapability | null =>
	descriptor.capabilities.find(
		(capability): capability is StudioProtocolSetLicenseKeyCapability =>
			capability.type === 'set-license-key',
	) ?? null;

export const getAddElementLibraryCapability = (
	descriptor: StudioProtocolDescriptor,
): StudioProtocolAddElementLibraryCapability | null =>
	descriptor.capabilities.find(
		(capability): capability is StudioProtocolAddElementLibraryCapability =>
			capability.type === 'add-element-library',
	) ?? null;

export type DiscoveredStudio = {
	readonly descriptor: StudioProtocolDescriptor;
	readonly discoveredAt: number;
	readonly origin: string;
};

export const discoverStudios = async (
	dependencies: StudioProtocolDiscoveryDependencies,
): Promise<{
	readonly studios: DiscoveredStudio[];
	readonly foundUnsupportedProtocol: boolean;
	readonly foundInvalidResponse: boolean;
}> => {
	let foundUnsupportedProtocol = false;
	let foundInvalidResponse = false;
	const {fetchFn} = dependencies;

	const studios = await Promise.all(
		dependencies.ports.map(async (port): Promise<DiscoveredStudio | null> => {
			const origin = `http://localhost:${port}`;
			let response: Response;

			try {
				response = await fetchFn(`${origin}/api/studio-protocol`, {
					cache: 'no-store',
				});
			} catch {
				return null;
			}

			if (!response.ok) {
				return null;
			}

			let value: unknown;

			try {
				value = await response.json();
			} catch {
				return null;
			}

			const protocolEnvelope = z.safeParse(protocolEnvelopeSchema, value);

			if (!protocolEnvelope.success) {
				return null;
			}

			const protocolVersionEnvelope = z.safeParse(
				protocolVersionEnvelopeSchema,
				value,
			);

			if (!protocolVersionEnvelope.success) {
				foundInvalidResponse = true;

				return null;
			}

			if (protocolVersionEnvelope.data.protocolVersion !== 1) {
				foundUnsupportedProtocol = true;

				return null;
			}

			const descriptor = parseStudioProtocolDescriptor(value);

			if (descriptor === null) {
				foundInvalidResponse = true;

				return null;
			}

			return {
				descriptor,
				discoveredAt: dependencies.now(),
				origin,
			};
		}),
	);

	return {
		studios: studios.filter(
			(studio): studio is DiscoveredStudio => studio !== null,
		),
		foundUnsupportedProtocol,
		foundInvalidResponse,
	};
};

export const isAbortError = (cause: unknown): boolean =>
	cause instanceof Error && cause.name === 'AbortError';