@remotion/lambda-client 4.0.363 → 4.0.365

package/src/lifecycle-rules.ts

@@ -1,119 +0,0 @@
-import {
-	DeleteBucketLifecycleCommand,
-	PutBucketLifecycleConfigurationCommand,
-} from '@aws-sdk/client-s3';
-import type {CustomCredentials} from '@remotion/serverless-client';
-import {createLifeCycleInput, deleteLifeCycleInput} from './apply-lifecycle';
-import type {AwsProvider} from './aws-provider';
-import {getS3Client} from './get-s3-client';
-import {getLifeCycleRules} from './lifecycle';
-import type {AwsRegion} from './regions';
-import type {RequestHandler} from './types';
-
-const createLCRules = async ({
-	bucketName,
-	region,
-	customCredentials,
-	forcePathStyle,
-	requestHandler,
-}: {
-	bucketName: string;
-	region: AwsRegion;
-	customCredentials: CustomCredentials<AwsProvider> | null;
-	forcePathStyle: boolean;
-	requestHandler: RequestHandler | null;
-}) => {
-	const lcRules = getLifeCycleRules();
-	// create the lifecyle rules
-	const createCommandInput = createLifeCycleInput({
-		bucketName,
-		lcRules,
-	});
-	const createCommand = new PutBucketLifecycleConfigurationCommand(
-		createCommandInput,
-	);
-	try {
-		await getS3Client({
-			region,
-			customCredentials,
-			forcePathStyle,
-			requestHandler,
-		}).send(createCommand);
-	} catch (err) {
-		if ((err as Error).stack?.includes('AccessDenied')) {
-			throw new Error(
-				`You don't have the required permissions to create lifecycle rules on the bucket "${bucketName}", but the "enableFolderExpiry" was set to true. Ensure that your user has the "s3:PutLifecycleConfiguration" permission.`,
-			);
-		}
-	}
-};
-
-const deleteLCRules = async ({
-	bucketName,
-	region,
-	customCredentials,
-	forcePathStyle,
-	requestHandler,
-}: {
-	bucketName: string;
-	region: AwsRegion;
-	customCredentials: CustomCredentials<AwsProvider> | null;
-	forcePathStyle: boolean;
-	requestHandler: RequestHandler | null;
-}) => {
-	const deleteCommandInput = deleteLifeCycleInput({
-		bucketName,
-	});
-	try {
-		await getS3Client({
-			region,
-			customCredentials,
-			forcePathStyle,
-			requestHandler,
-		}).send(new DeleteBucketLifecycleCommand(deleteCommandInput));
-	} catch (err) {
-		if ((err as Error).stack?.includes('AccessDenied')) {
-			throw new Error(
-				`You don't have the required permissions to delete lifecycle rules on the bucket "${bucketName}", but the "enableFolderExpiry" option was set to "false". Ensure that your user has the "s3:PutLifecycleConfiguration" permission. Set "enableFolderExpiry" to "null" to not overwrite any existing lifecycle rules.`,
-			);
-		}
-	}
-};
-
-export const applyLifeCyleOperation = async ({
-	enableFolderExpiry,
-	bucketName,
-	region,
-	customCredentials,
-	forcePathStyle,
-	requestHandler,
-}: {
-	enableFolderExpiry: boolean | null;
-	bucketName: string;
-	region: AwsRegion;
-	customCredentials: CustomCredentials<AwsProvider> | null;
-	forcePathStyle: boolean;
-	requestHandler: RequestHandler | null;
-}) => {
-	if (enableFolderExpiry === null) {
-		return;
-	}
-
-	if (enableFolderExpiry === true) {
-		await createLCRules({
-			bucketName,
-			region,
-			customCredentials,
-			forcePathStyle,
-			requestHandler,
-		});
-	} else {
-		await deleteLCRules({
-			bucketName,
-			region,
-			customCredentials,
-			forcePathStyle,
-			requestHandler,
-		});
-	}
-};

package/src/lifecycle.ts

@@ -1,44 +0,0 @@
-import type {LifecycleRule} from '@aws-sdk/client-s3';
-import type {
-	CloudProvider,
-	DeleteAfter,
-	ProviderSpecifics,
-} from '@remotion/serverless-client';
-import {expiryDays, truthy} from '@remotion/serverless-client';
-
-const getEnabledLifeCycleRule = ({
-	key,
-	value,
-}: {
-	key: string;
-	value: number;
-}): LifecycleRule => {
-	return {
-		Expiration: {
-			Days: value,
-		},
-		Filter: {
-			Prefix: `renders/${key}`,
-		},
-		ID: `delete-after-${key}`,
-		Status: 'Enabled',
-	};
-};
-
-export const getLifeCycleRules = (): LifecycleRule[] => {
-	return Object.entries(expiryDays).map(([key, value]) =>
-		getEnabledLifeCycleRule({key, value}),
-	);
-};
-
-export const generateRandomHashWithLifeCycleRule = <
-	Provider extends CloudProvider,
->({
-	deleteAfter,
-	randomHashFn,
-}: {
-	deleteAfter: DeleteAfter | null;
-	randomHashFn: ProviderSpecifics<Provider>['randomHash'];
-}) => {
-	return [deleteAfter, randomHashFn()].filter(truthy).join('-');
-};

package/src/list-objects.ts

@@ -1,87 +0,0 @@
-import {ListObjectsV2Command} 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 lambdaLsImplementation: ProviderSpecifics<AwsProvider>['listObjects'] =
-	async ({
-		bucketName,
-		prefix,
-		region,
-		expectedBucketOwner,
-		continuationToken,
-		forcePathStyle,
-		requestHandler,
-	}) => {
-		try {
-			const list = await getS3Client({
-				region,
-				customCredentials: null,
-				forcePathStyle,
-				requestHandler,
-			}).send(
-				new ListObjectsV2Command({
-					Bucket: bucketName,
-					Prefix: prefix,
-					ExpectedBucketOwner: expectedBucketOwner ?? undefined,
-					ContinuationToken: continuationToken,
-				}),
-			);
-			if (list.NextContinuationToken) {
-				return [
-					...(list.Contents ?? []).map((o) => {
-						return {
-							Key: o.Key as string,
-							LastModified: o.LastModified as Date,
-							ETag: o.ETag as string,
-							Size: o.Size as number,
-						};
-					}),
-					...(await lambdaLsImplementation({
-						bucketName,
-						prefix,
-						expectedBucketOwner,
-						region,
-						continuationToken: list.NextContinuationToken,
-						forcePathStyle,
-						requestHandler,
-					})),
-				];
-			}
-
-			return (
-				(list.Contents || [])?.map((o) => {
-					return {
-						Key: o.Key as string,
-						LastModified: o.LastModified as Date,
-						ETag: o.ETag as string,
-						Size: o.Size as number,
-					};
-				}) ?? []
-			);
-		} catch (err) {
-			if (!expectedBucketOwner) {
-				throw err;
-			}
-
-			// Prevent from accessing a foreign bucket, retry without ExpectedBucketOwner and see if it works. If it works then it's an owner mismatch.
-			if ((err as Error).stack?.includes('AccessDenied')) {
-				await getS3Client({
-					region,
-					customCredentials: null,
-					forcePathStyle,
-					requestHandler,
-				}).send(
-					new ListObjectsV2Command({
-						Bucket: bucketName,
-						Prefix: prefix,
-					}),
-				);
-				throw new Error(
-					`Bucket owner mismatch: Expected the bucket ${bucketName} to be owned by you (AWS Account ID: ${expectedBucketOwner}) but it's not the case. Did you accidentially specify the wrong bucket?`,
-				);
-			}
-
-			throw err;
-		}
-	};

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;
-};