@remotion/lambda-client 4.0.364 → 4.0.365

package/eslint.config.mjs

@@ -1,5 +0,0 @@
-import {remotionFlatConfig} from '@remotion/eslint-config-internal';
-
-const config = remotionFlatConfig({react: false});
-
-export default [config];

package/src/app-router-webhook.ts

@@ -1,73 +0,0 @@
-import type {
-	WebhookErrorPayload,
-	WebhookPayload,
-	WebhookSuccessPayload,
-	WebhookTimeoutPayload,
-} from '@remotion/serverless-client';
-import {validateWebhookSignature} from './validate-webhook-signature';
-
-export type NextWebhookArgs = {
-	testing?: boolean;
-	extraHeaders?: Record<string, string>;
-	secret: string;
-	onSuccess?: (payload: WebhookSuccessPayload) => void | Promise<void>;
-	onTimeout?: (payload: WebhookTimeoutPayload) => void | Promise<void>;
-	onError?: (payload: WebhookErrorPayload) => void | Promise<void>;
-};
-
-export const appRouterWebhook = (
-	options: NextWebhookArgs,
-): ((req: Request) => Promise<Response>) => {
-	const {testing, extraHeaders, secret, onSuccess, onTimeout, onError} =
-		options;
-	return async function (req: Request): Promise<Response> {
-		let headers = 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',
-			};
-			headers = {...headers, ...testingheaders};
-		}
-
-		if (req.method === 'OPTIONS') {
-			//  do we have any use of the OPTIONS method other than the tester on webhooks page ? if so we can add a condition here to only return this if testing mode enabled
-			return new Response(null, {
-				headers,
-			});
-		}
-
-		// Parse the body properly
-		const body = await req.json();
-
-		try {
-			validateWebhookSignature({
-				secret,
-				body,
-				signatureHeader: req.headers.get('X-Remotion-Signature') as string,
-			});
-
-			const payload = body as WebhookPayload;
-			if (payload.type === 'success' && onSuccess) {
-				await onSuccess(payload);
-			} else if (payload.type === 'timeout' && onTimeout) {
-				await onTimeout(payload);
-			} else if (payload.type === 'error' && onError) {
-				await onError(payload);
-			}
-		} catch (err) {
-			return new Response(
-				JSON.stringify({
-					success: false,
-					error: err instanceof Error ? err.message : String(err),
-				}),
-				{status: 500, headers},
-			);
-		}
-
-		return new Response(JSON.stringify({success: true}), {headers});
-	};
-};

package/src/apply-lifecycle.ts

@@ -1,30 +0,0 @@
-import type {
-	DeleteBucketLifecycleCommandInput,
-	LifecycleRule,
-	PutBucketLifecycleConfigurationCommandInput,
-} from '@aws-sdk/client-s3';
-
-export const deleteLifeCycleInput = ({
-	bucketName,
-}: {
-	bucketName: string;
-}): DeleteBucketLifecycleCommandInput => {
-	return {
-		Bucket: bucketName,
-	};
-};
-
-export const createLifeCycleInput = ({
-	bucketName,
-	lcRules,
-}: {
-	bucketName: string;
-	lcRules: LifecycleRule[];
-}): PutBucketLifecycleConfigurationCommandInput => {
-	return {
-		Bucket: bucketName,
-		LifecycleConfiguration: {
-			Rules: lcRules,
-		},
-	};
-};

package/src/aws-clients.ts

@@ -1,75 +0,0 @@
-import type {CloudWatchLogsClient} from '@aws-sdk/client-cloudwatch-logs';
-import type {IAMClient} from '@aws-sdk/client-iam';
-import type {LambdaClient} from '@aws-sdk/client-lambda';
-import type {ServiceQuotasClient} from '@aws-sdk/client-service-quotas';
-import type {STSClient} from '@aws-sdk/client-sts';
-import {getServiceClient} from './get-service-client';
-import type {AwsRegion} from './regions';
-import type {RequestHandler} from './types';
-
-export const getCloudWatchLogsClient = (
-	region: AwsRegion,
-	requestHandler: RequestHandler | null,
-): CloudWatchLogsClient => {
-	return getServiceClient({
-		region,
-		service: 'cloudwatch',
-		customCredentials: null,
-		forcePathStyle: false,
-		requestHandler,
-	});
-};
-
-export const getLambdaClient = (
-	region: AwsRegion,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	_timeoutInTest: number | undefined,
-	requestHandler: RequestHandler | null,
-): LambdaClient => {
-	return getServiceClient({
-		region,
-		service: 'lambda',
-		customCredentials: null,
-		forcePathStyle: false,
-		requestHandler,
-	});
-};
-
-export const getIamClient = (
-	region: AwsRegion,
-	requestHandler: RequestHandler | null,
-): IAMClient => {
-	return getServiceClient({
-		region,
-		service: 'iam',
-		customCredentials: null,
-		forcePathStyle: false,
-		requestHandler,
-	});
-};
-
-export const getServiceQuotasClient = (
-	region: AwsRegion,
-	requestHandler: RequestHandler | null,
-): ServiceQuotasClient => {
-	return getServiceClient({
-		region,
-		service: 'servicequotas',
-		customCredentials: null,
-		forcePathStyle: false,
-		requestHandler,
-	});
-};
-
-export const getStsClient = (
-	region: AwsRegion,
-	requestHandler: RequestHandler | null,
-): STSClient => {
-	return getServiceClient({
-		region,
-		service: 'sts',
-		customCredentials: null,
-		forcePathStyle: false,
-		requestHandler,
-	});
-};

package/src/aws-provider.ts

@@ -1,139 +0,0 @@
-import type {AwsRegion} from './regions';
-
-export type AwsProvider = {
-	type: 'aws';
-	region: AwsRegion;
-	receivedArtifactType: {
-		s3Key: string;
-		s3Url: string;
-	};
-	creationFunctionOptions: {
-		createCloudWatchLogGroup: boolean;
-		accountId: string;
-		alreadyCreated: boolean;
-		retentionInDays: number;
-		customRoleArn: string;
-		enableLambdaInsights: boolean;
-		vpcSubnetIds: string;
-		vpcSecurityGroupIds: string;
-		runtimePreference: RuntimePreference;
-	};
-	storageClass: StorageClass;
-	requestHandler: RequestHandler | null | undefined;
-};
-
-import type {StorageClass} from '@aws-sdk/client-s3';
-import type {ProviderSpecifics} from '@remotion/serverless-client';
-import {expiryDays} from '@remotion/serverless-client';
-import {EventEmitter} from 'node:events';
-import {bucketExistsInRegionImplementation} from './bucket-exists';
-import {callFunctionAsyncImplementation} from './call-lambda-async';
-import {callFunctionWithStreamingImplementation} from './call-lambda-streaming';
-import {callFunctionSyncImplementation} from './call-lambda-sync';
-import {checkCredentials} from './check-credentials';
-import {MAX_EPHEMERAL_STORAGE_IN_MB, REMOTION_BUCKET_PREFIX} from './constants';
-import {convertToServeUrlImplementation} from './convert-to-serve-url';
-import {createBucket} from './create-bucket';
-import {lambdaDeleteFileImplementation} from './delete-file';
-import {deleteFunction} from './delete-function';
-import {estimatePrice} from './estimate-price';
-import {getAccountIdImplementation} from './get-account-id';
-import {getCloudwatchMethodUrl, getCloudwatchRendererUrl} from './get-aws-urls';
-import {getRemotionBuckets} from './get-buckets';
-import {getFunctions} from './get-functions';
-import {getOutputUrlFromMetadata} from './get-output-url-from-metadata';
-import {lambdaHeadFileImplementation} from './head-file';
-import {isFlakyError} from './is-flaky-error';
-import {applyLifeCyleOperation} from './lifecycle-rules';
-import {lambdaLsImplementation} from './list-objects';
-import {parseFunctionName} from './parse-function-name';
-import {randomHashImplementation} from './random-hash';
-import {lambdaReadFileImplementation} from './read-file';
-import type {RuntimePreference} from './runtime-preference';
-import type {RequestHandler} from './types';
-import {lambdaWriteFileImplementation} from './write-file';
-
-if (
-	/^AWS_Lambda_nodejs(?:18|20)[.]x$/.test(
-		process.env.AWS_EXECUTION_ENV ?? '',
-	) === true
-) {
-	process.env.FONTCONFIG_PATH = '/opt';
-	process.env.FONTCONFIG_FILE = '/opt/fonts.conf';
-
-	process.env.DISABLE_FROM_SURFACE = '1';
-	process.env.NO_COLOR = '1';
-
-	// @ts-expect-error
-	globalThis._dumpUnreleasedBuffers = new EventEmitter();
-
-	// @ts-expect-error
-	(globalThis._dumpUnreleasedBuffers as EventEmitter).setMaxListeners(201);
-}
-
-const validateDeleteAfter = (lifeCycleValue: unknown) => {
-	if (lifeCycleValue === null) {
-		return;
-	}
-
-	if (lifeCycleValue === undefined) {
-		return;
-	}
-
-	if (typeof lifeCycleValue !== 'string') {
-		throw new TypeError(
-			`Expected life cycle value to be a string, got ${JSON.stringify(
-				lifeCycleValue,
-			)}`,
-		);
-	}
-
-	if (!(lifeCycleValue in expiryDays)) {
-		throw new TypeError(
-			`Expected deleteAfter value to be one of ${Object.keys(expiryDays).join(
-				', ',
-			)}, got ${lifeCycleValue}`,
-		);
-	}
-};
-
-export const awsImplementation: ProviderSpecifics<AwsProvider> = {
-	getChromiumPath() {
-		return '/opt/bin/chromium';
-	},
-	getBuckets: getRemotionBuckets,
-	createBucket,
-	applyLifeCycle: applyLifeCyleOperation,
-	listObjects: lambdaLsImplementation,
-	deleteFile: lambdaDeleteFileImplementation,
-	bucketExists: bucketExistsInRegionImplementation,
-	randomHash: randomHashImplementation,
-	readFile: lambdaReadFileImplementation,
-	writeFile: lambdaWriteFileImplementation,
-	headFile: lambdaHeadFileImplementation,
-	convertToServeUrl: convertToServeUrlImplementation,
-	printLoggingHelper: true,
-	validateDeleteAfter,
-	callFunctionAsync: callFunctionAsyncImplementation,
-	callFunctionStreaming: callFunctionWithStreamingImplementation,
-	callFunctionSync: callFunctionSyncImplementation,
-	getEphemeralStorageForPriceCalculation() {
-		// We cannot determine the ephemeral storage size, so we
-		// overestimate the price, but will only have a miniscule effect (~0.2%)
-		return MAX_EPHEMERAL_STORAGE_IN_MB;
-	},
-	estimatePrice,
-	getLoggingUrlForMethod: getCloudwatchMethodUrl,
-	getLoggingUrlForRendererFunction: getCloudwatchRendererUrl,
-	isFlakyError,
-	getOutputUrl: getOutputUrlFromMetadata,
-	serverStorageProductName: () => 'S3',
-	getMaxStillInlinePayloadSize: () => 5_000_000,
-	getMaxNonInlinePayloadSizePerFunction: () => 200_000,
-	getAccountId: getAccountIdImplementation,
-	deleteFunction,
-	getFunctions,
-	parseFunctionName,
-	checkCredentials,
-	getBucketPrefix: () => REMOTION_BUCKET_PREFIX,
-};

package/src/bucket-exists.ts

@@ -1,35 +0,0 @@
-import {GetBucketLocationCommand} from '@aws-sdk/client-s3';
-import type {ProviderSpecifics} from '@remotion/serverless-client';
-import type {AwsProvider} from './aws-provider';
-import {getS3Client} from './get-s3-client';
-
-export const bucketExistsInRegionImplementation: ProviderSpecifics<AwsProvider>['bucketExists'] =
-	async ({
-		bucketName,
-		region,
-		expectedBucketOwner,
-		forcePathStyle,
-		requestHandler,
-	}) => {
-		try {
-			const bucket = await getS3Client({
-				region,
-				customCredentials: null,
-				forcePathStyle,
-				requestHandler,
-			}).send(
-				new GetBucketLocationCommand({
-					Bucket: bucketName,
-					ExpectedBucketOwner: expectedBucketOwner ?? undefined,
-				}),
-			);
-
-			return (bucket.LocationConstraint ?? 'us-east-1') === region;
-		} catch (err) {
-			if ((err as {Code: string}).Code === 'NoSuchBucket') {
-				return false;
-			}
-
-			throw err;
-		}
-	};

package/src/call-lambda-async.ts

@@ -1,43 +0,0 @@
-import {InvokeCommand} from '@aws-sdk/client-lambda';
-import type {
-	CallFunctionOptions,
-	CloudProvider,
-	ServerlessRoutines,
-} from '@remotion/serverless-client';
-import {getLambdaClient} from './aws-clients';
-import type {AwsRegion} from './regions';
-
-export const callFunctionAsyncImplementation = async <
-	T extends ServerlessRoutines,
-	Provider extends CloudProvider,
->({
-	functionName,
-	payload,
-	region,
-	timeoutInTest,
-}: CallFunctionOptions<T, Provider>): Promise<void> => {
-	const stringifiedPayload = JSON.stringify(payload);
-	if (stringifiedPayload.length > 256 * 1024) {
-		throw new Error(
-			`Payload is too big: ${stringifiedPayload.length} bytes. Maximum size is 256 KB. This should not happen, please report this to the Remotion team. Payload: ${stringifiedPayload}`,
-		);
-	}
-
-	const result = await getLambdaClient(
-		region as AwsRegion,
-		timeoutInTest,
-		null,
-	).send(
-		new InvokeCommand({
-			FunctionName: functionName,
-			Payload: stringifiedPayload,
-			InvocationType: 'Event',
-		}),
-	);
-
-	if (result.FunctionError) {
-		throw new Error(
-			`Lambda function returned error: ${result.FunctionError} ${result.LogResult}`,
-		);
-	}
-};

package/src/call-lambda-streaming.ts

@@ -1,226 +0,0 @@
-/* eslint-disable no-console */
-import type {InvokeWithResponseStreamCommandOutput} from '@aws-sdk/client-lambda';
-import {
-	InvokeWithResponseStreamCommand,
-	type InvokeWithResponseStreamResponseEvent,
-} from '@aws-sdk/client-lambda';
-import type {
-	CallFunctionOptions,
-	CloudProvider,
-	MessageTypeId,
-	OnMessage,
-	ServerlessRoutines,
-	StreamingMessage,
-} from '@remotion/serverless-client';
-import {
-	formatMap,
-	makeStreamer,
-	messageTypeIdToMessageType,
-} from '@remotion/serverless-client';
-import {getLambdaClient} from './aws-clients';
-import type {AwsRegion} from './regions';
-
-const STREAM_STALL_TIMEOUT = 30000;
-const LAMBDA_STREAM_STALL = `AWS did not invoke Lambda in ${STREAM_STALL_TIMEOUT}ms`;
-
-export const parseJsonOrThrowSource = (data: Uint8Array, type: string) => {
-	const asString = new TextDecoder('utf-8').decode(data);
-	try {
-		return JSON.parse(asString);
-	} catch {
-		throw new Error(`Invalid JSON (${type}): ${asString}`);
-	}
-};
-
-const invokeStreamOrTimeout = async <Provider extends CloudProvider>({
-	region,
-	timeoutInTest,
-	functionName,
-	type,
-	payload,
-}: {
-	region: Provider['region'];
-	timeoutInTest: number;
-	functionName: string;
-	type: string;
-	payload: Record<string, unknown>;
-}) => {
-	const resProm = getLambdaClient(
-		region as AwsRegion,
-		timeoutInTest,
-		null,
-	).send(
-		new InvokeWithResponseStreamCommand({
-			FunctionName: functionName,
-			Payload: JSON.stringify({type, ...payload}),
-		}),
-	);
-
-	let cleanup = () => undefined;
-
-	const timeout = new Promise<InvokeWithResponseStreamCommandOutput>(
-		(_resolve, reject) => {
-			const int = setTimeout(() => {
-				reject(new Error(LAMBDA_STREAM_STALL));
-			}, STREAM_STALL_TIMEOUT);
-			cleanup = () => {
-				clearTimeout(int);
-			};
-		},
-	);
-
-	const res = await Promise.race([resProm, timeout]);
-
-	cleanup();
-
-	return res;
-};
-
-const INVALID_JSON_MESSAGE = 'Cannot parse Lambda response as JSON';
-
-const callLambdaWithStreamingWithoutRetry = async <
-	T extends ServerlessRoutines,
-	Provider extends CloudProvider,
->({
-	functionName,
-	type,
-	payload,
-	region,
-	timeoutInTest,
-	receivedStreamingPayload,
-}: CallFunctionOptions<T, Provider> & {
-	receivedStreamingPayload: OnMessage<Provider>;
-}): Promise<void> => {
-	const res = await invokeStreamOrTimeout({
-		functionName,
-		payload,
-		region,
-		timeoutInTest,
-		type,
-	});
-
-	const {onData, clear} = makeStreamer((status, messageTypeId, data) => {
-		const messageType = messageTypeIdToMessageType(
-			messageTypeId as MessageTypeId,
-		);
-		const innerPayload =
-			formatMap[messageType] === 'json'
-				? parseJsonOrThrowSource(data, messageType)
-				: data;
-
-		const message: StreamingMessage<Provider> = {
-			successType: status,
-			message: {
-				type: messageType,
-				payload: innerPayload,
-			},
-		};
-
-		receivedStreamingPayload(message);
-	});
-
-	const dumpBuffers = () => {
-		clear();
-	};
-
-	// @ts-expect-error - We are adding a listener to a global variable
-	if (globalThis._dumpUnreleasedBuffers) {
-		// @ts-expect-error - We are adding a listener to a global variable
-		(globalThis._dumpUnreleasedBuffers as EventEmitter).addListener(
-			'dump-unreleased-buffers',
-			dumpBuffers,
-		);
-	}
-
-	const events =
-		res.EventStream as AsyncIterable<InvokeWithResponseStreamResponseEvent>;
-
-	for await (const event of events) {
-		// There are two types of events you can get on a stream.
-
-		// `PayloadChunk`: These contain the actual raw bytes of the chunk
-		// It has a single property: `Payload`
-		if (event.PayloadChunk && event.PayloadChunk.Payload) {
-			onData(event.PayloadChunk.Payload);
-		}
-
-		if (event.InvokeComplete) {
-			if (event.InvokeComplete.ErrorCode) {
-				const logs = `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:logs-insights$3FqueryDetail$3D~(end~0~start~-3600~timeType~'RELATIVE~unit~'seconds~editorString~'fields*20*40timestamp*2c*20*40requestId*2c*20*40message*0a*7c*20filter*20*40requestId*20like*20*${res.$metadata.requestId}*22*0a*7c*20sort*20*40timestamp*20asc~source~(~'*2faws*2flambda*2f${functionName}))`;
-				if (event.InvokeComplete.ErrorCode === 'Unhandled') {
-					throw new Error(
-						`Lambda function ${functionName} failed with an unhandled error: ${
-							event.InvokeComplete.ErrorDetails as string
-						} See ${logs} to see the logs of this invocation.`,
-					);
-				}
-
-				throw new Error(
-					`Lambda function ${functionName} failed with error code ${event.InvokeComplete.ErrorCode}: ${event.InvokeComplete.ErrorDetails}. See ${logs} to see the logs of this invocation.`,
-				);
-			}
-		}
-
-		// Don't put a `break` statement here, as it will cause the socket to not properly exit.
-	}
-
-	// @ts-expect-error - We are adding a listener to a global variable
-	if (globalThis._dumpUnreleasedBuffers) {
-		// @ts-expect-error - We are adding a listener to a global variable
-		(globalThis._dumpUnreleasedBuffers as EventEmitter).removeListener(
-			'dump-unreleased-buffers',
-			dumpBuffers,
-		);
-	}
-
-	clear();
-};
-
-export const callFunctionWithStreamingImplementation = async <
-	Provider extends CloudProvider,
-	T extends ServerlessRoutines,
->(
-	options: CallFunctionOptions<T, Provider> & {
-		receivedStreamingPayload: OnMessage<Provider>;
-		retriesRemaining: number;
-	},
-): Promise<void> => {
-	// As of August 2023, Lambda streaming sometimes misses parts of the JSON response.
-	// Handling this for now by applying a retry mechanism.
-
-	try {
-		// Do not remove this await
-		await callLambdaWithStreamingWithoutRetry<T, Provider>(options);
-	} catch (err) {
-		if (
-			(err as Error).stack?.includes('TooManyRequestsException') ||
-			(err as Error).message?.includes('ConcurrentInvocationLimitExceeded')
-		) {
-			throw new Error(
-				`AWS Concurrency limit reached (Original Error: ${(err as Error).message}). See https://www.remotion.dev/docs/lambda/troubleshooting/rate-limit for tips to fix this.`,
-			);
-		}
-
-		if (
-			!(err as Error).message.includes(INVALID_JSON_MESSAGE) &&
-			!(err as Error).message.includes(LAMBDA_STREAM_STALL) &&
-			// https://discord.com/channels/809501355504959528/1332166561242288220/1332166561242288220
-			!(err as Error).message.includes('Runtime.TruncatedResponse') &&
-			!(err as Error).message.includes('aborted')
-		) {
-			throw err;
-		}
-
-		console.error('Retries remaining:', options.retriesRemaining);
-		if (options.retriesRemaining === 0) {
-			console.error('Throwing error:');
-			throw err;
-		}
-
-		console.error(err);
-		return callFunctionWithStreamingImplementation({
-			...options,
-			retriesRemaining: options.retriesRemaining - 1,
-		});
-	}
-};

package/src/call-lambda-sync.ts

@@ -1,59 +0,0 @@
-import {InvokeCommand} from '@aws-sdk/client-lambda';
-import type {
-	CallFunctionOptions,
-	CloudProvider,
-	OrError,
-	ServerlessReturnValues,
-	ServerlessRoutines,
-} from '@remotion/serverless-client';
-import {getLambdaClient} from './aws-clients';
-import type {AwsRegion} from './regions';
-
-const callLambdaSyncWithoutRetry = async <
-	T extends ServerlessRoutines,
-	Provider extends CloudProvider,
->({
-	functionName,
-	payload,
-	region,
-	timeoutInTest,
-}: CallFunctionOptions<T, Provider>): Promise<
-	OrError<ServerlessReturnValues<Provider>[T]>
-> => {
-	const Payload = JSON.stringify(payload);
-	const res = await getLambdaClient(
-		region as AwsRegion,
-		timeoutInTest,
-		null,
-	).send(
-		new InvokeCommand({
-			FunctionName: functionName,
-			Payload,
-			InvocationType: 'RequestResponse',
-		}),
-	);
-
-	const decoded = new TextDecoder('utf-8').decode(res.Payload);
-
-	try {
-		return JSON.parse(decoded) as OrError<ServerlessReturnValues<Provider>[T]>;
-	} catch {
-		throw new Error(`Invalid JSON: ${JSON.stringify(decoded)}`);
-	}
-};
-
-export const callFunctionSyncImplementation = async <
-	Provider extends CloudProvider,
-	T extends ServerlessRoutines,
->(
-	options: CallFunctionOptions<T, Provider>,
-): Promise<ServerlessReturnValues<Provider>[T]> => {
-	const res = await callLambdaSyncWithoutRetry<T, Provider>(options);
-	if (res.type === 'error') {
-		const err = new Error(res.message);
-		err.stack = res.stack;
-		throw err;
-	}
-
-	return res;
-};