@remotion/lambda-client 4.0.364 → 4.0.366

package/src/make-lambda-payload.ts

@@ -1,328 +0,0 @@
-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,
-} from '@remotion/serverless-client';
-import type {AwsProvider} from './aws-provider';
-import {awsImplementation} from './aws-provider';
-
-import type {StorageClass} from '@aws-sdk/client-s3';
-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 type {RequestHandler} from './types';
-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;
-	concurrency: 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;
-	storageClass: StorageClass | null;
-	requestHandler: RequestHandler | null;
-} & ToOptions<typeof BrowserSafeApis.optionsMap.renderMediaOnLambda>;
-
-export const makeLambdaRenderMediaPayload = async ({
-	rendererFunctionName,
-	frameRange,
-	framesPerLambda,
-	concurrency,
-	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,
-	mediaCacheSizeInBytes,
-	deleteAfter,
-	colorSpace,
-	preferLossless,
-	forcePathStyle,
-	metadata,
-	apiKey,
-	offthreadVideoThreads,
-	storageClass,
-	requestHandler,
-}: InnerRenderMediaOnLambdaInput): Promise<
-	ServerlessStartPayload<AwsProvider>
-> => {
-	const actualCodec = validateLambdaCodec(codec);
-	validateServeUrl(serveUrl);
-	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',
-		requestHandler: requestHandler ?? null,
-	});
-	return {
-		rendererFunctionName,
-		framesPerLambda,
-		concurrency,
-		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,
-		offthreadVideoThreads: offthreadVideoThreads ?? null,
-		mediaCacheSizeInBytes: mediaCacheSizeInBytes ?? null,
-		storageClass: storageClass ?? 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,
-	jpegQuality,
-	region,
-	maxRetries,
-	composition,
-	privacy,
-	frame,
-	logLevel,
-	outName,
-	timeoutInMilliseconds,
-	chromiumOptions,
-	scale,
-	downloadBehavior,
-	forceHeight,
-	forceWidth,
-	forceBucketName,
-	offthreadVideoCacheSizeInBytes,
-	deleteAfter,
-	forcePathStyle,
-	apiKey,
-	storageClass,
-	requestHandler,
-	offthreadVideoThreads,
-	mediaCacheSizeInBytes,
-}: RenderStillOnLambdaNonNullInput): Promise<
-	ServerlessPayloads<AwsProvider>[ServerlessRoutines.still]
-> => {
-	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',
-		requestHandler,
-	});
-
-	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,
-		offthreadVideoThreads: offthreadVideoThreads ?? null,
-		mediaCacheSizeInBytes: mediaCacheSizeInBytes ?? null,
-		storageClass: storageClass ?? null,
-	};
-};

package/src/make-s3-url.ts

@@ -1,13 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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 async function (
-		req: NextApiRequest,
-		res: NextApiResponse,
-	): Promise<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;
-		}
-
-		try {
-			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) {
-				await onSuccess(payload);
-			} else if (payload.type === 'timeout' && onTimeout) {
-				await onTimeout(payload);
-			} else if (payload.type === 'error' && onError) {
-				await onError(payload);
-			}
-
-			res.status(200).json({
-				success: true,
-			});
-		} catch (err) {
-			res.status(500).json({
-				success: false,
-				error: err instanceof Error ? err.message : String(err),
-			});
-		}
-	};
-};

package/src/parse-function-name.ts

@@ -1,24 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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 type {RequestHandler} from './types';
-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>> & {
-			requestHandler?: RequestHandler;
-		};
-type PresignUrlInputInternal<CheckIfObjectExists extends boolean> =
-	MandatoryParameters &
-		OptionalParameters<CheckIfObjectExists> & {
-			requestHandler?: RequestHandler;
-		};
-
-const internalPresignUrl = async <CheckIfObjectExists extends boolean = false>({
-	region,
-	bucketName,
-	objectKey,
-	checkIfObjectExists,
-	expiresInSeconds,
-	forcePathStyle,
-	requestHandler,
-}: 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,
-		requestHandler: requestHandler ?? null,
-	});
-
-	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,
-	requestHandler,
-}: PresignUrlInput<CheckIfObjectExists>): Promise<
-	CheckIfObjectExists extends true ? string | null : string
-> => {
-	return internalPresignUrl({
-		region,
-		bucketName,
-		objectKey,
-		checkIfObjectExists: checkIfObjectExists ?? false,
-		expiresInSeconds,
-		forcePathStyle: forcePathStyle ?? false,
-		requestHandler,
-	});
-};