@remotion/lambda-client 4.0.261

package/src/make-lambda-payload.ts

@@ -0,0 +1,317 @@
+import type {
+	AudioCodec,
+	BrowserSafeApis,
+	ChromiumOptions,
+	ColorSpace,
+	DeleteAfter,
+	DownloadBehavior,
+	FrameRange,
+	LogLevel,
+	OutNameInput,
+	PixelFormat,
+	Privacy,
+	ProResProfile,
+	ServerlessCodec,
+	ServerlessPayloads,
+	ServerlessStartPayload,
+	ServerlessStatusPayload,
+	ToOptions,
+	VideoImageFormat,
+	WebhookOption,
+	X264Preset,
+} from '@remotion/serverless-client';
+import {
+	ENABLE_V5_BREAKING_CHANGES,
+	ServerlessRoutines,
+	VERSION,
+	compressInputProps,
+	getNeedsToUpload,
+	serializeOrThrow,
+	validateDownloadBehavior,
+	validateFramesPerFunction,
+} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {awsImplementation} from './aws-provider';
+
+import {validateWebhook} from '@remotion/serverless-client';
+import type {GetRenderProgressInput} from './get-render-progress';
+import type {AwsRegion} from './regions';
+import type {RenderStillOnLambdaNonNullInput} from './render-still-on-lambda';
+import {validateLambdaCodec} from './validate-lambda-codec';
+import {validateServeUrl} from './validate-serveurl';
+
+export type InnerRenderMediaOnLambdaInput = {
+	region: AwsRegion;
+	functionName: string;
+	serveUrl: string;
+	composition: string;
+	inputProps: Record<string, unknown>;
+	codec: ServerlessCodec;
+	imageFormat: VideoImageFormat;
+	crf: number | undefined;
+	envVariables: Record<string, string>;
+	pixelFormat: PixelFormat | undefined;
+	proResProfile: ProResProfile | undefined;
+	x264Preset: X264Preset | null;
+	privacy: Privacy;
+	jpegQuality: number;
+	maxRetries: number;
+	framesPerLambda: number | null;
+	logLevel: LogLevel;
+	frameRange: FrameRange | null;
+	outName: OutNameInput<AwsProvider> | null;
+	timeoutInMilliseconds: number;
+	chromiumOptions: ChromiumOptions;
+	scale: number;
+	everyNthFrame: number;
+	numberOfGifLoops: number | null;
+	concurrencyPerLambda: number;
+	downloadBehavior: DownloadBehavior;
+	muted: boolean;
+	overwrite: boolean;
+	audioBitrate: string | null;
+	videoBitrate: string | null;
+	encodingMaxRate: string | null;
+	encodingBufferSize: string | null;
+	webhook: WebhookOption | null;
+	forceWidth: number | null;
+	forceHeight: number | null;
+	rendererFunctionName: string | null;
+	forceBucketName: string | null;
+	audioCodec: AudioCodec | null;
+	colorSpace: ColorSpace | null;
+	deleteAfter: DeleteAfter | null;
+	indent: boolean;
+	forcePathStyle: boolean;
+	metadata: Record<string, string> | null;
+} & ToOptions<typeof BrowserSafeApis.optionsMap.renderMediaOnLambda>;
+
+export const makeLambdaRenderMediaPayload = async ({
+	rendererFunctionName,
+	frameRange,
+	framesPerLambda,
+	forceBucketName: bucketName,
+	codec,
+	composition,
+	serveUrl,
+	imageFormat,
+	inputProps,
+	region,
+	crf,
+	envVariables,
+	pixelFormat,
+	proResProfile,
+	x264Preset,
+	maxRetries,
+	privacy,
+	logLevel,
+	outName,
+	timeoutInMilliseconds,
+	chromiumOptions,
+	scale,
+	everyNthFrame,
+	numberOfGifLoops,
+	audioBitrate,
+	concurrencyPerLambda,
+	audioCodec,
+	forceHeight,
+	forceWidth,
+	webhook,
+	videoBitrate,
+	encodingMaxRate,
+	encodingBufferSize,
+	downloadBehavior,
+	muted,
+	overwrite,
+	jpegQuality,
+	offthreadVideoCacheSizeInBytes,
+	deleteAfter,
+	colorSpace,
+	preferLossless,
+	forcePathStyle,
+	metadata,
+	apiKey,
+}: InnerRenderMediaOnLambdaInput): Promise<
+	ServerlessStartPayload<AwsProvider>
+> => {
+	const actualCodec = validateLambdaCodec(codec);
+	validateServeUrl(serveUrl);
+	validateFramesPerFunction({
+		framesPerFunction: framesPerLambda ?? null,
+		durationInFrames: 1,
+	});
+	validateDownloadBehavior(downloadBehavior);
+	validateWebhook(webhook);
+
+	const stringifiedInputProps = serializeOrThrow(
+		inputProps ?? {},
+		'input-props',
+	);
+
+	const serialized = await compressInputProps({
+		stringifiedInputProps,
+		region,
+		needsToUpload: getNeedsToUpload({
+			type: 'video-or-audio',
+			sizes: [
+				stringifiedInputProps.length,
+				JSON.stringify(envVariables).length,
+			],
+			providerSpecifics: awsImplementation,
+		}),
+		userSpecifiedBucketName: bucketName ?? null,
+		propsType: 'input-props',
+		providerSpecifics: awsImplementation,
+		forcePathStyle: forcePathStyle ?? false,
+		skipPutAcl: privacy === 'no-acl',
+	});
+	return {
+		rendererFunctionName,
+		framesPerLambda,
+		composition,
+		serveUrl,
+		inputProps: serialized,
+		codec: actualCodec,
+		imageFormat,
+		crf: crf ?? null,
+		envVariables,
+		pixelFormat: pixelFormat ?? null,
+		proResProfile: proResProfile ?? null,
+		x264Preset,
+		jpegQuality,
+		maxRetries,
+		privacy,
+		logLevel,
+		frameRange,
+		outName,
+		timeoutInMilliseconds,
+		chromiumOptions,
+		scale,
+		everyNthFrame,
+		numberOfGifLoops,
+		concurrencyPerLambda,
+		downloadBehavior,
+		muted,
+		version: VERSION,
+		overwrite: overwrite ?? ENABLE_V5_BREAKING_CHANGES,
+		audioBitrate: audioBitrate ?? null,
+		videoBitrate: videoBitrate ?? null,
+		encodingBufferSize: encodingBufferSize ?? null,
+		encodingMaxRate: encodingMaxRate ?? null,
+		webhook: webhook ?? null,
+		forceHeight: forceHeight ?? null,
+		forceWidth: forceWidth ?? null,
+		bucketName: bucketName ?? null,
+		audioCodec: audioCodec ?? null,
+		type: ServerlessRoutines.start,
+		offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes ?? null,
+		deleteAfter: deleteAfter ?? null,
+		colorSpace: colorSpace ?? null,
+		preferLossless: preferLossless ?? false,
+		forcePathStyle: forcePathStyle ?? false,
+		metadata: metadata ?? null,
+		apiKey: apiKey ?? null,
+	};
+};
+
+export const getRenderProgressPayload = ({
+	bucketName,
+	renderId,
+	s3OutputProvider,
+	logLevel,
+	forcePathStyle,
+}: GetRenderProgressInput): ServerlessStatusPayload<AwsProvider> => {
+	return {
+		type: ServerlessRoutines.status,
+		bucketName,
+		renderId,
+		version: VERSION,
+		s3OutputProvider: s3OutputProvider ?? null,
+		logLevel: logLevel ?? 'info',
+		forcePathStyle: forcePathStyle ?? false,
+	};
+};
+
+export const makeLambdaRenderStillPayload = async ({
+	serveUrl,
+	inputProps,
+	imageFormat,
+	envVariables,
+	quality,
+	jpegQuality,
+	region,
+	maxRetries,
+	composition,
+	privacy,
+	frame,
+	logLevel,
+	outName,
+	timeoutInMilliseconds,
+	chromiumOptions,
+	scale,
+	downloadBehavior,
+	forceHeight,
+	forceWidth,
+	forceBucketName,
+	offthreadVideoCacheSizeInBytes,
+	deleteAfter,
+	forcePathStyle,
+	apiKey,
+}: RenderStillOnLambdaNonNullInput): Promise<
+	ServerlessPayloads<AwsProvider>[ServerlessRoutines.still]
+> => {
+	if (quality) {
+		throw new Error(
+			'The `quality` option is deprecated. Use `jpegQuality` instead.',
+		);
+	}
+
+	const stringifiedInputProps = serializeOrThrow(inputProps, 'input-props');
+
+	const serializedInputProps = await compressInputProps({
+		stringifiedInputProps,
+		region,
+		needsToUpload: getNeedsToUpload({
+			type: 'still',
+			sizes: [
+				stringifiedInputProps.length,
+				JSON.stringify(envVariables).length,
+			],
+			providerSpecifics: awsImplementation,
+		}),
+		userSpecifiedBucketName: forceBucketName ?? null,
+		propsType: 'input-props',
+		providerSpecifics: awsImplementation,
+		forcePathStyle,
+		skipPutAcl: privacy === 'no-acl',
+	});
+
+	return {
+		composition,
+		serveUrl,
+		inputProps: serializedInputProps,
+		imageFormat,
+		envVariables,
+		jpegQuality,
+		maxRetries,
+		frame,
+		privacy,
+		attempt: 1,
+		logLevel,
+		outName,
+		timeoutInMilliseconds,
+		chromiumOptions,
+		scale,
+		downloadBehavior,
+		version: VERSION,
+		forceHeight,
+		forceWidth,
+		bucketName: forceBucketName,
+		offthreadVideoCacheSizeInBytes,
+		deleteAfter,
+		type: ServerlessRoutines.still,
+		streamed: true,
+		forcePathStyle,
+		apiKey: apiKey ?? null,
+	};
+};

package/src/make-s3-url.ts

@@ -0,0 +1,13 @@
+import type {AwsRegion} from './regions';
+
+export const makeS3ServeUrl = ({
+	bucketName,
+	subFolder,
+	region,
+}: {
+	bucketName: string;
+	subFolder: string;
+	region: AwsRegion;
+}): string => {
+	return `https://${bucketName}.s3.${region}.amazonaws.com/${subFolder}/index.html`;
+};

package/src/p-limit.ts

@@ -0,0 +1,75 @@
+export const pLimit = (concurrency: number) => {
+	const queue: Function[] = [];
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.length > 0) {
+			queue.shift()?.();
+		}
+	};
+
+	const run = async <Arguments extends unknown[], ReturnType>(
+		fn: (..._arguments: Arguments) => PromiseLike<ReturnType> | ReturnType,
+		resolve: (res: Promise<ReturnType>) => void,
+		...args: Arguments
+	) => {
+		activeCount++;
+
+		// eslint-disable-next-line require-await
+		const result = (async () => fn(...args))();
+
+		resolve(result);
+
+		try {
+			await result;
+		} catch {}
+
+		next();
+	};
+
+	const enqueue = <Arguments extends unknown[], ReturnType>(
+		fn: (..._arguments: Arguments) => PromiseLike<ReturnType> | ReturnType,
+		resolve: (res: Promise<ReturnType>) => void,
+		...args: Arguments
+	) => {
+		queue.push(() => run(fn, resolve, ...args));
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.length > 0) {
+				queue.shift()?.();
+			}
+		})();
+	};
+
+	const generator = <Arguments extends unknown[], ReturnType>(
+		fn: (..._arguments: Arguments) => PromiseLike<ReturnType> | ReturnType,
+		...args: Arguments
+	) =>
+		new Promise<ReturnType>((resolve) => {
+			enqueue(fn, resolve, ...args);
+		});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount,
+		},
+		pendingCount: {
+			get: () => queue.length,
+		},
+		clearQueue: {
+			value: () => {
+				queue.length = 0;
+			},
+		},
+	});
+
+	return generator;
+};

package/src/pages-router-webhook.ts

@@ -0,0 +1,58 @@
+import type {WebhookPayload} from '@remotion/serverless-client';
+import type {Response} from 'express';
+import type {NextApiRequest, NextApiResponse} from 'next';
+import type {NextWebhookArgs} from './app-router-webhook';
+import {validateWebhookSignature} from './validate-webhook-signature';
+
+export const addHeaders = (
+	res: NextApiResponse | Response,
+	headers: Record<string, string>,
+) => {
+	Object.entries(headers).forEach(([key, value]) => {
+		res.setHeader(key, value);
+	});
+};
+
+export const pagesRouterWebhook = (options: NextWebhookArgs) => {
+	const {testing, extraHeaders, secret, onSuccess, onTimeout, onError} =
+		options;
+	return function (req: NextApiRequest, res: NextApiResponse): void {
+		addHeaders(res, extraHeaders || {});
+
+		if (testing) {
+			const testingheaders = {
+				'Access-Control-Allow-Origin': 'https://www.remotion.dev',
+				'Access-Control-Allow-Headers':
+					'X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version, X-Remotion-Status, X-Remotion-Signature, X-Remotion-Mode',
+				'Access-Control-Allow-Methods': 'OPTIONS,POST',
+			};
+
+			addHeaders(res, testingheaders);
+		}
+
+		if (req.method === 'OPTIONS') {
+			res.status(200).end();
+			return;
+		}
+
+		validateWebhookSignature({
+			secret,
+			body: req.body,
+			signatureHeader: req.headers['x-remotion-signature'] as string,
+		});
+
+		// If code reaches this path, the webhook is authentic.
+		const payload = req.body as WebhookPayload;
+		if (payload.type === 'success' && onSuccess) {
+			onSuccess(payload);
+		} else if (payload.type === 'timeout' && onTimeout) {
+			onTimeout(payload);
+		} else if (payload.type === 'error' && onError) {
+			onError(payload);
+		}
+
+		res.status(200).json({
+			success: true,
+		});
+	};
+};

package/src/parse-function-name.ts

@@ -0,0 +1,24 @@
+import {RENDER_FN_PREFIX} from './constants';
+
+type ReturnType = {
+	version: string;
+	memorySizeInMb: number;
+	diskSizeInMb: number;
+	timeoutInSeconds: number;
+};
+
+export const parseFunctionName = (functionName: string): ReturnType | null => {
+	const match = functionName.match(
+		new RegExp(RENDER_FN_PREFIX + '(.*)-mem(\\d+)mb-disk(\\d+)mb-(\\d+)sec$'),
+	);
+	if (!match) {
+		return null;
+	}
+
+	return {
+		version: match[1],
+		memorySizeInMb: parseInt(match[2], 10),
+		diskSizeInMb: parseInt(match[3], 10),
+		timeoutInSeconds: parseInt(match[4], 10),
+	};
+};

package/src/presign-url.ts

@@ -0,0 +1,110 @@
+import {GetObjectCommand, HeadObjectCommand} from '@aws-sdk/client-s3';
+import {getSignedUrl} from '@aws-sdk/s3-request-presigner';
+import {validateBucketName} from '@remotion/serverless-client';
+import {REMOTION_BUCKET_PREFIX} from './constants';
+import {getS3Client} from './get-s3-client';
+import type {AwsRegion} from './regions';
+import {validatePresignExpiration} from './validate-presign-expiration';
+
+type MandatoryParameters = {
+	region: AwsRegion;
+	bucketName: string;
+	objectKey: string;
+	expiresInSeconds: number;
+};
+
+type OptionalParameters<CheckIfObjectExists extends boolean> = {
+	checkIfObjectExists: CheckIfObjectExists;
+	forcePathStyle: boolean;
+};
+
+export type PresignUrlInput<CheckIfObjectExists extends boolean = boolean> =
+	MandatoryParameters & Partial<OptionalParameters<CheckIfObjectExists>>;
+type PresignUrlInputInternal<CheckIfObjectExists extends boolean> =
+	MandatoryParameters & OptionalParameters<CheckIfObjectExists>;
+
+const internalPresignUrl = async <CheckIfObjectExists extends boolean = false>({
+	region,
+	bucketName,
+	objectKey,
+	checkIfObjectExists,
+	expiresInSeconds,
+	forcePathStyle,
+}: PresignUrlInputInternal<CheckIfObjectExists>): Promise<
+	CheckIfObjectExists extends true ? string | null : string
+> => {
+	validateBucketName({
+		bucketName,
+		bucketNamePrefix: REMOTION_BUCKET_PREFIX,
+		options: {mustStartWithRemotion: false},
+	});
+	validatePresignExpiration(expiresInSeconds);
+
+	const s3Client = getS3Client({
+		region,
+		customCredentials: null,
+		forcePathStyle,
+	});
+
+	if (checkIfObjectExists === true) {
+		try {
+			await s3Client.send(
+				new HeadObjectCommand({
+					Bucket: bucketName,
+					Key: objectKey,
+				}),
+			);
+		} catch (err) {
+			if ((err as {name: string}).name === 'NotFound') {
+				return null as unknown as string;
+			}
+
+			if (
+				(err as Error).message === 'UnknownError' ||
+				(err as {$metadata: {httpStatusCode: number}}).$metadata
+					.httpStatusCode === 403
+			) {
+				throw new Error(
+					`Unable to access item "${objectKey}" from bucket "${bucketName}". You must have permission for both "s3:GetObject" and "s3:ListBucket" actions.`,
+				);
+			}
+
+			throw err;
+		}
+	}
+
+	const objCommand = new GetObjectCommand({
+		Bucket: bucketName,
+		Key: objectKey,
+	});
+
+	const publicUrl = await getSignedUrl(s3Client, objCommand, {
+		expiresIn: expiresInSeconds,
+	});
+
+	return publicUrl;
+};
+
+/*
+ * @description Takes a private S3 object and turns it into a public URL by signing it with your AWS credentials.
+ * @see [Documentation](https://remotion.dev/docs/lambda/presignurl)
+ */
+export const presignUrl = <CheckIfObjectExists extends boolean = false>({
+	region,
+	bucketName,
+	objectKey,
+	checkIfObjectExists,
+	expiresInSeconds,
+	forcePathStyle,
+}: PresignUrlInput<CheckIfObjectExists>): Promise<
+	CheckIfObjectExists extends true ? string | null : string
+> => {
+	return internalPresignUrl({
+		region,
+		bucketName,
+		objectKey,
+		checkIfObjectExists: checkIfObjectExists ?? false,
+		expiresInSeconds,
+		forcePathStyle: forcePathStyle ?? false,
+	});
+};