@remotion/lambda-client 4.0.261

package/src/random-hash.ts

@@ -0,0 +1,10 @@
+const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
+
+export const randomHashImplementation = (): string => {
+	return new Array(10)
+		.fill(1)
+		.map(() => {
+			return alphabet[Math.floor(Math.random() * alphabet.length)];
+		})
+		.join('');
+};

package/src/read-file.ts

@@ -0,0 +1,31 @@
+import {GetObjectCommand} from '@aws-sdk/client-s3';
+import type {Readable} from 'stream';
+import {getS3Client} from './get-s3-client';
+import type {AwsRegion} from './regions';
+
+export const lambdaReadFileImplementation = async ({
+	bucketName,
+	key,
+	region,
+	expectedBucketOwner,
+	forcePathStyle,
+}: {
+	bucketName: string;
+	key: string;
+	region: AwsRegion;
+	expectedBucketOwner: string | null;
+	forcePathStyle: boolean;
+}): Promise<Readable> => {
+	const {Body} = await getS3Client({
+		region,
+		customCredentials: null,
+		forcePathStyle,
+	}).send(
+		new GetObjectCommand({
+			Bucket: bucketName,
+			Key: key,
+			ExpectedBucketOwner: expectedBucketOwner ?? undefined,
+		}),
+	);
+	return Body as Readable;
+};

package/src/regions.ts

@@ -0,0 +1,48 @@
+export const DEFAULT_AWS_REGIONS = [
+	'eu-central-1',
+	'eu-west-1',
+	'eu-west-2',
+	'eu-west-3',
+	'eu-north-1',
+	'us-east-1', // N. Virginia
+	'us-east-2', // Ohio;
+	'us-west-1',
+	'us-west-2', // Oregon
+	'ap-south-1',
+	'ap-southeast-1',
+	'ap-southeast-2',
+	'ap-northeast-1',
+	'ap-northeast-2',
+	'ap-northeast-3',
+	'ca-central-1',
+	'sa-east-1',
+] as const;
+
+export const AWS_REGIONS = [
+	'eu-central-1',
+	'eu-central-2',
+	'eu-west-1',
+	'eu-west-2',
+	'eu-west-3',
+	'eu-south-1',
+	'eu-north-1',
+	'us-east-1', // N. Virginia
+	'us-east-2', // Ohio;
+	'us-west-1',
+	'us-west-2', // Oregon
+	'af-south-1',
+	'ap-south-1',
+	'ap-east-1',
+	'ap-southeast-1',
+	'ap-southeast-2',
+	'ap-northeast-1',
+	'ap-northeast-2',
+	'ap-northeast-3',
+	'ap-southeast-4',
+	'ap-southeast-5',
+	'ca-central-1',
+	'me-south-1',
+	'sa-east-1',
+] as const;
+
+export type AwsRegion = (typeof AWS_REGIONS)[number];

package/src/render-media-on-lambda.ts

@@ -0,0 +1,216 @@
+import type {
+	AudioCodec,
+	BrowserSafeApis,
+	ChromiumOptions,
+	DownloadBehavior,
+	FrameRange,
+	OutNameInput,
+	PixelFormat,
+	Privacy,
+	ProResProfile,
+	ServerlessCodec,
+	ToOptions,
+	VideoImageFormat,
+	WebhookOption,
+} from '@remotion/serverless-client';
+import {
+	ServerlessRoutines,
+	wrapWithErrorHandling,
+} from '@remotion/serverless-client';
+import {awsImplementation, type AwsProvider} from './aws-provider';
+import {
+	getCloudwatchMethodUrl,
+	getCloudwatchRendererUrl,
+	getLambdaInsightsUrl,
+	getProgressJsonUrl,
+	getS3RenderUrl,
+} from './get-aws-urls';
+import type {InnerRenderMediaOnLambdaInput} from './make-lambda-payload';
+import {makeLambdaRenderMediaPayload} from './make-lambda-payload';
+import type {AwsRegion} from './regions';
+
+export type RenderMediaOnLambdaInput = {
+	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;
+	proResProfile?: ProResProfile;
+	privacy?: Privacy;
+	/**
+	 * @deprecated Renamed to `jpegQuality`
+	 */
+	quality?: never;
+	jpegQuality?: number;
+	maxRetries?: number;
+	framesPerLambda?: number;
+	frameRange?: FrameRange;
+	outName?: OutNameInput<AwsProvider>;
+	chromiumOptions?: Omit<ChromiumOptions, 'enableMultiProcessOnLinux'>;
+	scale?: number;
+	everyNthFrame?: number;
+	concurrencyPerLambda?: number;
+	downloadBehavior?: DownloadBehavior | null;
+	overwrite?: boolean;
+	webhook?: WebhookOption | null;
+	forceWidth?: number | null;
+	forceHeight?: number | null;
+	rendererFunctionName?: string | null;
+	forceBucketName?: string;
+	audioCodec?: AudioCodec | null;
+	/**
+	 * @deprecated in favor of `logLevel`: true
+	 */
+	dumpBrowserLogs?: boolean;
+	forcePathStyle?: boolean;
+	metadata?: Record<string, string> | null;
+} & Partial<ToOptions<typeof BrowserSafeApis.optionsMap.renderMediaOnLambda>>;
+
+export type RenderMediaOnLambdaOutput = {
+	renderId: string;
+	bucketName: string;
+	cloudWatchLogs: string;
+	cloudWatchMainLogs: string;
+	lambdaInsightsLogs: string;
+	folderInS3Console: string;
+	progressJsonInConsole: string;
+};
+
+export const internalRenderMediaOnLambdaRaw = async (
+	input: InnerRenderMediaOnLambdaInput,
+): Promise<RenderMediaOnLambdaOutput> => {
+	const {functionName, region, rendererFunctionName} = input;
+
+	try {
+		const res = await awsImplementation.callFunctionSync({
+			functionName,
+			type: ServerlessRoutines.start,
+			payload: await makeLambdaRenderMediaPayload(input),
+			region,
+			timeoutInTest: 120000,
+		});
+
+		return {
+			renderId: res.renderId,
+			bucketName: res.bucketName,
+			cloudWatchLogs: getCloudwatchRendererUrl({
+				functionName,
+				region,
+				renderId: res.renderId,
+				rendererFunctionName: rendererFunctionName ?? null,
+				chunk: null,
+			}),
+			cloudWatchMainLogs: getCloudwatchMethodUrl({
+				renderId: res.renderId,
+				functionName,
+				method: ServerlessRoutines.launch,
+				region,
+				rendererFunctionName: rendererFunctionName ?? null,
+			}),
+			folderInS3Console: getS3RenderUrl({
+				bucketName: res.bucketName,
+				renderId: res.renderId,
+				region,
+			}),
+			lambdaInsightsLogs: getLambdaInsightsUrl({
+				functionName,
+				region,
+			}),
+			progressJsonInConsole: getProgressJsonUrl({
+				bucketName: res.bucketName,
+				renderId: res.renderId,
+				region,
+			}),
+		};
+	} catch (err) {
+		if ((err as Error).stack?.includes('UnrecognizedClientException')) {
+			throw new Error(
+				'UnrecognizedClientException: The AWS credentials provided were probably mixed up. Learn how to fix this issue here: https://remotion.dev/docs/lambda/troubleshooting/unrecognizedclientexception',
+			);
+		}
+
+		throw err;
+	}
+};
+
+export const renderMediaOnLambdaOptionalToRequired = (
+	options: RenderMediaOnLambdaInput,
+): InnerRenderMediaOnLambdaInput => {
+	return {
+		audioBitrate: options.audioBitrate ?? null,
+		audioCodec: options.audioCodec ?? null,
+		chromiumOptions: options.chromiumOptions ?? {},
+		codec: options.codec,
+		colorSpace: options.colorSpace ?? null,
+		composition: options.composition,
+		concurrencyPerLambda: options.concurrencyPerLambda ?? 1,
+		crf: options.crf,
+		downloadBehavior: options.downloadBehavior ?? {type: 'play-in-browser'},
+		envVariables: options.envVariables ?? {},
+		everyNthFrame: options.everyNthFrame ?? 1,
+		forceBucketName: options.forceBucketName ?? null,
+		forceHeight: options.forceHeight ?? null,
+		forceWidth: options.forceWidth ?? null,
+		frameRange: options.frameRange ?? null,
+		framesPerLambda: options.framesPerLambda ?? null,
+		functionName: options.functionName,
+		imageFormat: options.imageFormat ?? 'jpeg',
+		inputProps: options.inputProps ?? {},
+		jpegQuality: options.jpegQuality ?? 80,
+		logLevel: options.logLevel ?? 'info',
+		maxRetries: options.maxRetries ?? 1,
+		muted: options.muted ?? false,
+		numberOfGifLoops: options.numberOfGifLoops ?? null,
+		offthreadVideoCacheSizeInBytes:
+			options.offthreadVideoCacheSizeInBytes ?? null,
+		outName: options.outName ?? null,
+		overwrite: options.overwrite ?? false,
+		pixelFormat: options.pixelFormat ?? undefined,
+		privacy: options.privacy ?? 'public',
+		proResProfile: options.proResProfile ?? undefined,
+		region: options.region,
+		rendererFunctionName: options.rendererFunctionName ?? null,
+		scale: options.scale ?? 1,
+		serveUrl: options.serveUrl,
+		timeoutInMilliseconds: options.timeoutInMilliseconds ?? 30000,
+		videoBitrate: options.videoBitrate ?? null,
+		encodingMaxRate: options.encodingMaxRate ?? null,
+		encodingBufferSize: options.encodingBufferSize ?? null,
+		webhook: options.webhook ?? null,
+		x264Preset: options.x264Preset ?? null,
+		deleteAfter: options.deleteAfter ?? null,
+		preferLossless: options.preferLossless ?? false,
+		forcePathStyle: options.forcePathStyle ?? false,
+		indent: false,
+		metadata: options.metadata ?? null,
+		apiKey: options.apiKey ?? null,
+	};
+};
+
+const wrapped = wrapWithErrorHandling(internalRenderMediaOnLambdaRaw);
+
+/*
+ * @description Kicks off a render process on Remotion Lambda. The progress can be tracked using getRenderProgress().
+ * @see [Documentation](https://remotion.dev/docs/lambda/rendermediaonlambda)
+ */
+export const renderMediaOnLambda = (
+	options: RenderMediaOnLambdaInput,
+): Promise<RenderMediaOnLambdaOutput> => {
+	if (options.quality) {
+		throw new Error(
+			'quality has been renamed to jpegQuality. Please rename the option.',
+		);
+	}
+
+	return wrapped(renderMediaOnLambdaOptionalToRequired(options));
+};
+
+/**
+ * @deprecated Renamed to renderMediaOnLambda()
+ */
+export const renderVideoOnLambda = renderMediaOnLambda;

package/src/render-still-on-lambda.ts

@@ -0,0 +1,195 @@
+import type {
+	BrowserSafeApis,
+	ChromiumOptions,
+	DownloadBehavior,
+	StillImageFormat,
+	ToOptions,
+} from '@remotion/serverless-client';
+import {ServerlessRoutines} from '@remotion/serverless-client';
+
+import type {
+	CostsInfo,
+	OutNameInput,
+	Privacy,
+	ReceivedArtifact,
+	RenderStillFunctionResponsePayload,
+} from '@remotion/serverless-client';
+import {wrapWithErrorHandling} from '@remotion/serverless-client';
+import {awsImplementation, type AwsProvider} from './aws-provider';
+import {DEFAULT_MAX_RETRIES} from './constants';
+import {getCloudwatchMethodUrl, getLambdaInsightsUrl} from './get-aws-urls';
+import {makeLambdaRenderStillPayload} from './make-lambda-payload';
+import type {AwsRegion} from './regions';
+
+type MandatoryParameters = {
+	region: AwsRegion;
+	functionName: string;
+	serveUrl: string;
+	composition: string;
+	inputProps: Record<string, unknown>;
+	imageFormat: StillImageFormat;
+	privacy: Privacy;
+};
+
+type OptionalParameters = {
+	maxRetries: number;
+	envVariables: Record<string, string>;
+	/**
+	 * @deprecated Renamed to `jpegQuality`
+	 */
+	quality?: never;
+	frame: number;
+	outName: OutNameInput<AwsProvider> | null;
+	chromiumOptions: ChromiumOptions;
+	downloadBehavior: DownloadBehavior;
+	forceWidth: number | null;
+	forceHeight: number | null;
+	forceBucketName: string | null;
+	/**
+	 * @deprecated Renamed to `logLevel`
+	 */
+	dumpBrowserLogs: boolean;
+	onInit: (data: {
+		renderId: string;
+		cloudWatchLogs: string;
+		lambdaInsightsUrl: string;
+	}) => void;
+	indent: boolean;
+	forcePathStyle: boolean;
+} & ToOptions<typeof BrowserSafeApis.optionsMap.renderStillOnLambda>;
+
+export type RenderStillOnLambdaNonNullInput = MandatoryParameters &
+	OptionalParameters;
+
+export type RenderStillOnLambdaInput = MandatoryParameters &
+	Partial<OptionalParameters>;
+
+export type RenderStillOnLambdaOutput = {
+	estimatedPrice: CostsInfo;
+	url: string;
+	outKey: string;
+	sizeInBytes: number;
+	bucketName: string;
+	renderId: string;
+	cloudWatchLogs: string;
+	artifacts: ReceivedArtifact<AwsProvider>[];
+};
+
+const internalRenderStillOnLambda = async (
+	input: RenderStillOnLambdaNonNullInput,
+): Promise<RenderStillOnLambdaOutput> => {
+	const {functionName, region, onInit} = input;
+	try {
+		const payload = await makeLambdaRenderStillPayload(input);
+		const res = await new Promise<
+			RenderStillFunctionResponsePayload<AwsProvider>
+		>((resolve, reject) => {
+			awsImplementation
+				.callFunctionStreaming<ServerlessRoutines.still>({
+					functionName,
+					type: ServerlessRoutines.still,
+					payload,
+					region,
+					receivedStreamingPayload: ({message}) => {
+						if (message.type === 'render-id-determined') {
+							onInit?.({
+								renderId: message.payload.renderId,
+								cloudWatchLogs: getCloudwatchMethodUrl({
+									functionName,
+									method: ServerlessRoutines.still,
+									region,
+									rendererFunctionName: null,
+									renderId: message.payload.renderId,
+								}),
+								lambdaInsightsUrl: getLambdaInsightsUrl({
+									functionName,
+									region,
+								}),
+							});
+						}
+
+						if (message.type === 'error-occurred') {
+							reject(new Error(message.payload.error));
+						}
+
+						if (message.type === 'still-rendered') {
+							resolve(message.payload);
+						}
+					},
+					timeoutInTest: 120000,
+					retriesRemaining: input.maxRetries,
+				})
+				.then(() => {
+					reject(new Error('Expected response to be streamed'));
+				})
+				.catch((err) => {
+					reject(err);
+				});
+		});
+
+		return {
+			estimatedPrice: res.estimatedPrice,
+			url: res.output,
+			outKey: res.outKey,
+			sizeInBytes: res.size,
+			bucketName: res.bucketName,
+			renderId: res.renderId,
+			cloudWatchLogs: getCloudwatchMethodUrl({
+				functionName,
+				method: ServerlessRoutines.still,
+				region,
+				renderId: res.renderId,
+				rendererFunctionName: null,
+			}),
+			artifacts: res.receivedArtifacts,
+		};
+	} catch (err) {
+		if ((err as Error).stack?.includes('UnrecognizedClientException')) {
+			throw new Error(
+				'UnrecognizedClientException: The AWS credentials provided were probably mixed up. Learn how to fix this issue here: https://remotion.dev/docs/lambda/troubleshooting/unrecognizedclientexception',
+			);
+		}
+
+		throw err;
+	}
+};
+
+const errorHandled = wrapWithErrorHandling(internalRenderStillOnLambda);
+
+/*
+ * @description Renders a still image inside a lambda function and writes it to the specified output location.
+ * @see [Documentation](https://remotion.dev/docs/lambda/renderstillonlambda)
+ */
+export const renderStillOnLambda = (input: RenderStillOnLambdaInput) => {
+	return errorHandled({
+		chromiumOptions: input.chromiumOptions ?? {},
+		composition: input.composition,
+		deleteAfter: input.deleteAfter ?? null,
+		downloadBehavior: input.downloadBehavior ?? {type: 'play-in-browser'},
+		envVariables: input.envVariables ?? {},
+		forceBucketName: input.forceBucketName ?? null,
+		forceHeight: input.forceHeight ?? null,
+		forceWidth: input.forceWidth ?? null,
+		frame: input.frame ?? 0,
+		functionName: input.functionName,
+		imageFormat: input.imageFormat,
+		indent: false,
+		inputProps: input.inputProps,
+		maxRetries: input.maxRetries ?? DEFAULT_MAX_RETRIES,
+		onInit: input.onInit ?? (() => undefined),
+		outName: input.outName ?? null,
+		privacy: input.privacy,
+		quality: undefined,
+		region: input.region,
+		serveUrl: input.serveUrl,
+		jpegQuality: input.jpegQuality ?? 80,
+		logLevel: input.dumpBrowserLogs ? 'verbose' : (input.logLevel ?? 'info'),
+		offthreadVideoCacheSizeInBytes:
+			input.offthreadVideoCacheSizeInBytes ?? null,
+		scale: input.scale ?? 1,
+		timeoutInMilliseconds: input.timeoutInMilliseconds ?? 30000,
+		dumpBrowserLogs: false,
+		forcePathStyle: input.forcePathStyle ?? false,
+		apiKey: input.apiKey ?? null,
+	});
+};

package/src/runtime-preference.ts

@@ -0,0 +1,7 @@
+export const runtimePreferenceOptions = [
+	'default',
+	'apple-emojis',
+	'cjk',
+] as const;
+
+export type RuntimePreference = (typeof runtimePreferenceOptions)[number];

package/src/speculate-function-name.ts

@@ -0,0 +1,27 @@
+import {RENDER_FN_PREFIX} from './constants';
+import {LAMBDA_VERSION_STRING} from './lambda-version-string';
+
+export type SpeculateFunctionNameInput = {
+	memorySizeInMb: string | number;
+	diskSizeInMb: string | number;
+	timeoutInSeconds: string | number;
+};
+
+/*
+ * @description Speculate the name of the Lambda function that will be created by `deployFunction()` or its CLI equivalent, based on the function configuration.
+ * @see [Documentation](https://remotion.dev/docs/lambda/speculatefunctionname)
+ */
+export const speculateFunctionName = ({
+	memorySizeInMb,
+	diskSizeInMb,
+	timeoutInSeconds,
+}: SpeculateFunctionNameInput) => {
+	// find-function-name.ts uses this for templating
+	// consider this before adding any validation here
+	return [
+		`${RENDER_FN_PREFIX}${LAMBDA_VERSION_STRING}`,
+		`mem${memorySizeInMb}mb`,
+		`disk${diskSizeInMb}mb`,
+		`${timeoutInSeconds}sec`,
+	].join('-');
+};

package/src/test/encode-aws-url.test.ts

@@ -0,0 +1,7 @@
+import {expect, test} from 'bun:test';
+import {encodeAwsUrlParams} from '../encode-aws-url-params';
+
+test('Encode AWS URL test', () => {
+	const params = encodeAwsUrlParams('"method=test"');
+	expect(params).toBe('$2522method$253Dtest$2522');
+});

package/src/test/price-calculation.test.ts

@@ -0,0 +1,61 @@
+import {estimatePriceFromMetadata} from '@remotion/serverless-client';
+import {expect, test} from 'bun:test';
+import {awsImplementation} from '../aws-provider';
+
+test('Should not throw while calculating prices when time shifts occur', () => {
+	const aDate = Date.now();
+	process.env.AWS_REGION = 'us-east-1';
+
+	const price = estimatePriceFromMetadata({
+		memorySizeInMb: 1024,
+		renderMetadata: {
+			audioBitrate: null,
+			codec: 'h264',
+			compositionId: 'react-svg',
+			estimatedRenderLambdaInvokations: 10,
+			estimatedTotalLambdaInvokations: 10,
+			framesPerLambda: 10,
+			imageFormat: 'jpeg',
+			inputProps: {
+				type: 'payload',
+				payload: '{}',
+			},
+			lambdaVersion: '2021-11-29',
+			memorySizeInMb: 1024,
+			region: 'eu-central-1',
+			renderId: '123',
+			deleteAfter: null,
+			siteId: 'my-site',
+			startedDate: aDate + 1000,
+			totalChunks: 20,
+			type: 'video',
+			outName: 'out.mp4',
+			privacy: 'public',
+			everyNthFrame: 1,
+			frameRange: [0, 99],
+			audioCodec: null,
+			downloadBehavior: {type: 'play-in-browser'},
+			numberOfGifLoops: null,
+			muted: false,
+			metadata: {Author: 'Lunar'},
+			functionName: 'remotion-render-la8ffw',
+			rendererFunctionName: 'remotion-render-la8ffw',
+			dimensions: {
+				height: 1080,
+				width: 1920,
+			},
+		},
+		diskSizeInMb: 512,
+		functionsInvoked: 1,
+		timings: [
+			{
+				chunk: 1,
+				rendered: aDate - 2000,
+				start: aDate,
+			},
+		],
+		region: 'eu-central-1',
+		providerSpecifics: awsImplementation,
+	});
+	expect(price?.accruedSoFar).toBeGreaterThanOrEqual(0);
+});

package/src/test/pricing.test.ts

@@ -0,0 +1,32 @@
+import {expect, test} from 'bun:test';
+import {estimatePrice} from '../estimate-price';
+
+test('Should calculate costs accurately', () => {
+	expect(
+		estimatePrice({
+			region: 'us-east-1',
+			durationInMiliseconds: 20000000,
+			memorySizeInMb: 2048,
+			diskSizeInMb: 512,
+			lambdasInvoked: 1,
+		}),
+	).toEqual(0.53334);
+	expect(
+		estimatePrice({
+			region: 'us-east-1',
+			durationInMilliseconds: 20000000,
+			memorySizeInMb: 2048,
+			diskSizeInMb: 10240,
+			lambdasInvoked: 1,
+		}),
+	).toEqual(0.53921);
+	expect(
+		estimatePrice({
+			region: 'us-east-1',
+			durationInMiliseconds: 20000000,
+			memorySizeInMb: 2048,
+			diskSizeInMb: 10240,
+			lambdasInvoked: 1,
+		}),
+	).toEqual(0.53921);
+});

package/src/test/validate-disk-size-in-mb.test.ts

@@ -0,0 +1,15 @@
+import {expect, test} from 'bun:test';
+import {validateDiskSizeInMb} from '../validate-disk-size-in-mb';
+
+test('Disk size tests', () => {
+	expect(() => validateDiskSizeInMb(512)).not.toThrow();
+	expect(() => validateDiskSizeInMb(10240)).not.toThrow();
+	expect(() => {
+		validateDiskSizeInMb(0);
+	}).toThrow(
+		/parameter 'diskSizeInMb' must be between 512 and 10240, but got 0/,
+	);
+	expect(() => {
+		validateDiskSizeInMb({});
+	}).toThrow(/parameter 'diskSizeInMb' must be a number, got a object/);
+});

package/src/validate-aws-region.ts

@@ -0,0 +1,14 @@
+import type {AwsRegion} from './regions';
+import {AWS_REGIONS} from './regions';
+
+export function validateAwsRegion(
+	region: unknown,
+): asserts region is AwsRegion {
+	if (!AWS_REGIONS.includes(region as AwsRegion)) {
+		throw new TypeError(
+			`${region} is not a supported AWS region. Must be one of: ${AWS_REGIONS.join(
+				', ',
+			)}`,
+		);
+	}
+}

package/src/validate-bucketname.ts

@@ -0,0 +1,24 @@
+import {REMOTION_BUCKET_PREFIX} from './constants';
+import type {AwsRegion} from './regions';
+import {AWS_REGIONS} from './regions';
+
+export const parseBucketName = (
+	name: string,
+): {
+	region: AwsRegion | null;
+} => {
+	const parsed = name.match(
+		new RegExp(`^${REMOTION_BUCKET_PREFIX}(.*)-([a-z0-9A-Z]+)$`),
+	);
+	const region = parsed?.[1] as AwsRegion;
+
+	if (!region) {
+		return {region: null};
+	}
+
+	const realRegionFound = AWS_REGIONS.find(
+		(r) => r.replace(/-/g, '') === region,
+	);
+
+	return {region: realRegionFound ?? null};
+};