@remotion/lambda-client 4.0.261

package/src/delete-render.ts

@@ -0,0 +1,107 @@
+import type {ProviderSpecifics} from '@remotion/serverless-client';
+import {
+	getExpectedOutName,
+	getOverallProgressFromStorage,
+	rendersPrefix,
+	type CustomCredentials,
+} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {awsImplementation} from './aws-provider';
+import {cleanItems} from './clean-items';
+import {REMOTION_BUCKET_PREFIX} from './constants';
+import type {AwsRegion} from './regions';
+
+export type DeleteRenderInput = {
+	region: AwsRegion;
+	bucketName: string;
+	renderId: string;
+	customCredentials?: CustomCredentials<AwsProvider>;
+	forcePathStyle?: boolean;
+};
+
+export const internalDeleteRender = async (
+	input: DeleteRenderInput & {
+		providerSpecifics: ProviderSpecifics<AwsProvider>;
+		forcePathStyle: boolean;
+	},
+) => {
+	const expectedBucketOwner = await input.providerSpecifics.getAccountId({
+		region: input.region,
+	});
+	const progress = await getOverallProgressFromStorage({
+		bucketName: input.bucketName,
+		expectedBucketOwner,
+		region: input.region,
+		renderId: input.renderId,
+		providerSpecifics: input.providerSpecifics,
+		forcePathStyle: input.forcePathStyle,
+	});
+
+	// Render did not start yet
+	if (progress.renderMetadata === null) {
+		return {freedBytes: 0};
+	}
+
+	const {key, renderBucketName, customCredentials} = getExpectedOutName({
+		renderMetadata: progress.renderMetadata,
+		bucketName: input.bucketName,
+		customCredentials: input.customCredentials ?? null,
+		bucketNamePrefix: REMOTION_BUCKET_PREFIX,
+	});
+
+	await input.providerSpecifics.deleteFile({
+		bucketName: renderBucketName,
+		customCredentials,
+		key,
+		region: input.region,
+		forcePathStyle: input.forcePathStyle,
+	});
+
+	let files = await input.providerSpecifics.listObjects({
+		bucketName: input.bucketName,
+		prefix: rendersPrefix(input.renderId),
+		region: input.region,
+		expectedBucketOwner,
+		forcePathStyle: input.forcePathStyle,
+	});
+
+	let totalSize = 0;
+
+	while (files.length > 0) {
+		totalSize += files.reduce((a, b) => {
+			return a + (b.Size ?? 0);
+		}, 0);
+		await cleanItems({
+			list: files.map((f) => f.Key as string),
+			bucket: input.bucketName,
+			onAfterItemDeleted: () => undefined,
+			onBeforeItemDeleted: () => undefined,
+			region: input.region,
+			providerSpecifics: input.providerSpecifics,
+			forcePathStyle: input.forcePathStyle,
+		});
+		files = await input.providerSpecifics.listObjects({
+			bucketName: input.bucketName,
+			prefix: rendersPrefix(input.renderId),
+			region: input.region,
+			expectedBucketOwner,
+			forcePathStyle: input.forcePathStyle,
+		});
+	}
+
+	return {
+		freedBytes: totalSize,
+	};
+};
+
+/*
+ * @description Deletes a rendered video, audio or still and its associated metadata.
+ * @see [Documentation](https://remotion.dev/docs/lambda/deleterender)
+ */
+export const deleteRender = (input: DeleteRenderInput) => {
+	return internalDeleteRender({
+		...input,
+		providerSpecifics: awsImplementation,
+		forcePathStyle: false,
+	});
+};

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

@@ -0,0 +1,3 @@
+export const encodeAwsUrlParams = (input: string) => {
+	return encodeURIComponent(input).replace(/%/g, '$25');
+};

package/src/estimate-price.ts

@@ -0,0 +1,95 @@
+import {MIN_EPHEMERAL_STORAGE_IN_MB} from './constants';
+import {pricing} from './price-per-1s';
+import type {AwsRegion} from './regions';
+import {validateAwsRegion} from './validate-aws-region';
+import {validateDiskSizeInMb} from './validate-disk-size-in-mb';
+import {validateMemorySize} from './validate-memory-size';
+
+type Miliseconds =
+	| {
+			/**
+			 * @deprecated Typo in property name. Use `durationInMilliseconds` instead.
+			 */
+			durationInMiliseconds: number;
+	  }
+	| {
+			durationInMilliseconds: number;
+	  };
+
+export type EstimatePriceInput = {
+	region: AwsRegion;
+	memorySizeInMb: number;
+	diskSizeInMb: number;
+	lambdasInvoked: number;
+} & Miliseconds;
+
+/*
+ * @description Calculates the AWS costs incurred for AWS Lambda given the region, execution duration and memory size.
+ * @see [Documentation](https://remotion.dev/docs/lambda/estimateprice)
+ */
+export const estimatePrice = ({
+	region,
+	memorySizeInMb,
+	diskSizeInMb,
+	lambdasInvoked,
+	...other
+}: EstimatePriceInput): number => {
+	validateMemorySize(memorySizeInMb);
+	validateAwsRegion(region);
+	validateDiskSizeInMb(diskSizeInMb);
+
+	const durationInMilliseconds =
+		'durationInMiliseconds' in other
+			? other.durationInMiliseconds
+			: other.durationInMilliseconds;
+
+	if (typeof durationInMilliseconds !== 'number') {
+		throw new TypeError(
+			`Parameter 'durationInMilliseconds' must be a number but got ${typeof durationInMilliseconds}`,
+		);
+	}
+
+	if (Number.isNaN(durationInMilliseconds)) {
+		throw new TypeError(
+			`Parameter 'durationInMilliseconds' must not be NaN but it is.`,
+		);
+	}
+
+	if (!Number.isFinite(durationInMilliseconds)) {
+		throw new TypeError(
+			`Parameter 'durationInMilliseconds' must be finite but it is ${durationInMilliseconds}`,
+		);
+	}
+
+	if (durationInMilliseconds < 0) {
+		throw new TypeError(
+			`Parameter 'durationInMilliseconds' must be over 0 but it is ${durationInMilliseconds}.`,
+		);
+	}
+
+	const durationPrice = pricing[region]['Lambda Duration-ARM'].price;
+
+	// In GB-second
+	const timeCostDollars =
+		Number(durationPrice) *
+		((memorySizeInMb * durationInMilliseconds) / 1000 / 1024);
+
+	const diskSizePrice = pricing[region]['Lambda Storage-Duration-ARM'].price;
+
+	const chargedDiskSize = Math.max(
+		0,
+		diskSizeInMb - MIN_EPHEMERAL_STORAGE_IN_MB,
+	);
+	// In GB-second
+	const diskSizeDollars =
+		chargedDiskSize *
+		Number(diskSizePrice) *
+		(durationInMilliseconds / 1000 / 1024);
+
+	const invocationCost =
+		Number(pricing[region]['Lambda Requests'].price) * lambdasInvoked;
+
+	return Number(
+		(timeCostDollars + diskSizeDollars + invocationCost).toFixed(5),
+	);
+};

package/src/express-webhook.ts

@@ -0,0 +1,50 @@
+import type {Request, Response} from 'express';
+import type {NextWebhookArgs} from './app-router-webhook';
+import {addHeaders} from './pages-router-webhook';
+import {validateWebhookSignature} from './validate-webhook-signature';
+
+export const expressWebhook = (options: NextWebhookArgs) => {
+	const {testing, extraHeaders, secret, onSuccess, onTimeout, onError} =
+		options;
+	return (req: Request, res: Response) => {
+		//  add headers to enable  testing
+		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);
+		}
+
+		//  add extra headers
+		addHeaders(res, extraHeaders || {});
+
+		// dont go forward if just testing
+		if (req.method === 'OPTIONS') {
+			res.status(200).end();
+			return;
+		}
+
+		// validate the webhook signature
+		validateWebhookSignature({
+			signatureHeader: req.header('X-Remotion-Signature') as string,
+			body: req.body,
+			secret,
+		});
+
+		//  custom logic
+		const payload = req.body;
+		if (payload.type === 'success' && onSuccess) {
+			onSuccess(payload);
+		} else if (payload.type === 'error' && onError) {
+			onError(payload);
+		} else if (payload.type === 'timeout' && onTimeout) {
+			onTimeout(payload);
+		}
+
+		// send response
+		res.status(200).json({success: true});
+	};
+};

package/src/get-account-id.ts

@@ -0,0 +1,22 @@
+import {GetCallerIdentityCommand} from '@aws-sdk/client-sts';
+import type {GetAccountId} from '@remotion/serverless-client';
+import {getStsClient} from './aws-clients';
+import type {AwsProvider} from './aws-provider';
+import type {AwsRegion} from './regions';
+import {validateAwsRegion} from './validate-aws-region';
+
+export const getAccountIdImplementation: GetAccountId<
+	AwsProvider
+> = async (options: {region: AwsRegion}) => {
+	validateAwsRegion(options.region);
+
+	const callerIdentity = await getStsClient(options.region).send(
+		new GetCallerIdentityCommand({}),
+	);
+
+	if (!callerIdentity.Account) {
+		throw new Error('Cannot get account ID');
+	}
+
+	return callerIdentity.Account;
+};

package/src/get-aws-client.ts

@@ -0,0 +1,59 @@
+import * as CloudWatchSDK from '@aws-sdk/client-cloudwatch-logs';
+import * as IamSdk from '@aws-sdk/client-iam';
+import * as LambdaSDK from '@aws-sdk/client-lambda';
+import * as S3SDK from '@aws-sdk/client-s3';
+import * as ServiceQuotasSDK from '@aws-sdk/client-service-quotas';
+import * as StsSdk from '@aws-sdk/client-sts';
+import type {CustomCredentials} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {getServiceClient, type ServiceMapping} from './get-service-client';
+import type {AwsRegion} from './regions';
+
+export type GetAwsClientInput<T extends keyof ServiceMapping> = {
+	region: AwsRegion;
+	service: T;
+	customCredentials?: CustomCredentials<AwsProvider> | null;
+	forcePathStyle?: boolean;
+};
+
+type SdkMapping = {
+	s3: typeof S3SDK;
+	cloudwatch: typeof CloudWatchSDK;
+	iam: typeof IamSdk;
+	lambda: typeof LambdaSDK;
+	servicequotas: typeof ServiceQuotasSDK;
+	sts: typeof StsSdk;
+};
+
+export type GetAwsClientOutput<T extends keyof ServiceMapping> = {
+	client: ServiceMapping[T];
+	sdk: SdkMapping[T];
+};
+
+/*
+ * @description Exposes full access to the AWS SDK used by Remotion, allowing interaction with AWS infrastructure beyond provided functionalities.
+ * @see [Documentation](https://remotion.dev/docs/lambda/getawsclient)
+ */
+export const getAwsClient = <T extends keyof ServiceMapping>({
+	region,
+	service,
+	customCredentials,
+	forcePathStyle,
+}: GetAwsClientInput<T>): GetAwsClientOutput<T> => {
+	return {
+		client: getServiceClient({
+			region,
+			service,
+			customCredentials: customCredentials ?? null,
+			forcePathStyle: forcePathStyle ?? false,
+		}),
+		sdk: {
+			lambda: LambdaSDK,
+			cloudwatch: CloudWatchSDK,
+			iam: IamSdk,
+			s3: S3SDK,
+			servicequotas: ServiceQuotasSDK,
+			sts: StsSdk,
+		}[service],
+	};
+};

package/src/get-aws-urls.ts

@@ -0,0 +1,85 @@
+import type {
+	GetLoggingUrlForRendererFunction,
+	ServerlessRoutines,
+} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {encodeAwsUrlParams} from './encode-aws-url-params';
+import type {AwsRegion} from './regions';
+
+const cloudWatchUrlWithQuery = ({
+	region,
+	functionNameToUse,
+	query,
+}: {
+	region: AwsRegion;
+	functionNameToUse: string;
+	query: string;
+}) => {
+	return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/$252Faws$252Flambda$252F${functionNameToUse}/log-events$3FfilterPattern$3D${encodeAwsUrlParams(
+		query,
+	)}`;
+};
+
+export const getCloudwatchMethodUrl = ({
+	region,
+	functionName,
+	renderId,
+	rendererFunctionName,
+	method,
+}: {
+	region: AwsRegion;
+	functionName: string;
+	method: ServerlessRoutines;
+	rendererFunctionName: string | null;
+	renderId: string;
+}) => {
+	const functionNameToUse = rendererFunctionName ?? functionName;
+	const query = `"method=${method},renderId=${renderId}"`;
+
+	return cloudWatchUrlWithQuery({region, functionNameToUse, query});
+};
+
+export const getLambdaInsightsUrl = ({
+	region,
+	functionName,
+}: {
+	region: AwsRegion;
+	functionName: string;
+}) => {
+	return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#lambda-insights:functions/${functionName}`;
+};
+
+export const getCloudwatchRendererUrl: GetLoggingUrlForRendererFunction<
+	AwsProvider
+> = ({region, functionName, renderId, rendererFunctionName, chunk}) => {
+	const functionNameToUse = rendererFunctionName ?? functionName;
+	const query = `"method=renderer,renderId=${renderId}${
+		chunk === null ? '' : `,chunk=${chunk},`
+	}"`;
+
+	return cloudWatchUrlWithQuery({region, functionNameToUse, query});
+};
+
+export const getS3RenderUrl = ({
+	renderId,
+	region,
+	bucketName,
+}: {
+	renderId: string;
+	region: AwsRegion;
+	bucketName: string;
+}) => {
+	return `https://s3.console.aws.amazon.com/s3/buckets/${bucketName}?region=${region}&prefix=renders/${renderId}/`;
+};
+
+export const getProgressJsonUrl = ({
+	region,
+	bucketName,
+	renderId,
+}: {
+	region: AwsRegion;
+	bucketName: string;
+	renderId: string;
+}) => {
+	return `https://${region}.console.aws.amazon.com/s3/object/${bucketName}?region=${region}&bucketType=general&prefix=renders/${renderId}/progress.json`;
+};

package/src/get-buckets.ts

@@ -0,0 +1,81 @@
+import {GetBucketLocationCommand, ListBucketsCommand} from '@aws-sdk/client-s3';
+import type {ProviderSpecifics} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {REMOTION_BUCKET_PREFIX} from './constants';
+import {getS3Client} from './get-s3-client';
+import type {AwsRegion} from './regions';
+import {parseBucketName} from './validate-bucketname';
+
+export type BucketWithLocation = {
+	name: string;
+	creationDate: number;
+	region: AwsRegion;
+};
+
+export const getRemotionBuckets: ProviderSpecifics<AwsProvider>['getBuckets'] =
+	async ({
+		region,
+		forceBucketName,
+		forcePathStyle,
+	}): Promise<BucketWithLocation[]> => {
+		const {Buckets} = await getS3Client({
+			region,
+			customCredentials: null,
+			forcePathStyle,
+		}).send(new ListBucketsCommand({}));
+		if (!Buckets) {
+			return [];
+		}
+
+		const remotionBuckets = Buckets.filter((b) => {
+			if (forceBucketName) {
+				return b.Name === forceBucketName;
+			}
+
+			return b.Name?.startsWith(REMOTION_BUCKET_PREFIX);
+		});
+
+		const locations = await Promise.all(
+			remotionBuckets.map(async (bucket) => {
+				const {region: parsedRegion} = parseBucketName(bucket.Name as string);
+				if (parsedRegion) {
+					return parsedRegion;
+				}
+
+				try {
+					const result = await getS3Client({
+						region,
+						customCredentials: null,
+						forcePathStyle,
+					}).send(
+						new GetBucketLocationCommand({
+							Bucket: bucket.Name as string,
+						}),
+					);
+					// AWS docs: Buckets in Region us-east-1 have a LocationConstraint of null!!
+					return result.LocationConstraint ?? ('us-east-1' as AwsRegion);
+				} catch (err) {
+					// Sometimes the API returns a bucket even if it was deleted before
+					if ((err as Error).stack?.includes('NoSuchBucket')) {
+						return null;
+					}
+
+					throw err;
+				}
+			}),
+		);
+
+		const bucketsWithLocation = remotionBuckets
+			.map((bucket, i): BucketWithLocation => {
+				return {
+					creationDate: (bucket.CreationDate as Date).getTime(),
+					name: bucket.Name as string,
+					region: locations[i] as AwsRegion,
+				};
+			})
+			.filter((b) => b.region);
+
+		return bucketsWithLocation.filter((bucket) => {
+			return bucket.region === region;
+		});
+	};

package/src/get-compositions-on-lambda.ts

@@ -0,0 +1,104 @@
+import type {
+	BrowserSafeApis,
+	ChromiumOptions,
+	ToOptions,
+	VideoConfig,
+} from '@remotion/serverless-client';
+import {
+	ServerlessRoutines,
+	VERSION,
+	compressInputProps,
+	getNeedsToUpload,
+	serializeOrThrow,
+} from '@remotion/serverless-client';
+import {awsImplementation} from './aws-provider';
+import type {AwsRegion} from './regions';
+
+export type GetCompositionsOnLambdaInput = {
+	chromiumOptions?: ChromiumOptions;
+	region: AwsRegion;
+	inputProps: Record<string, unknown>;
+	functionName: string;
+	serveUrl: string;
+	envVariables?: Record<string, string>;
+	forceBucketName?: string;
+	/**
+	 * @deprecated in favor of `logLevel`: true
+	 */
+	dumpBrowserLogs?: boolean;
+	forcePathStyle?: boolean;
+} & Partial<
+	ToOptions<typeof BrowserSafeApis.optionsMap.getCompositionsOnLambda>
+>;
+
+export type GetCompositionsOnLambdaOutput = VideoConfig[];
+
+/*
+ * @description Gets the compositions inside a Lambda function.
+ * @see [Documentation](https://remotion.dev/docs/lambda/getcompositionsonlambda)
+ */
+export const getCompositionsOnLambda = async ({
+	chromiumOptions,
+	serveUrl,
+	region,
+	inputProps,
+	functionName,
+	envVariables,
+	logLevel,
+	timeoutInMilliseconds,
+	forceBucketName: bucketName,
+	dumpBrowserLogs,
+	offthreadVideoCacheSizeInBytes,
+	forcePathStyle,
+}: GetCompositionsOnLambdaInput): Promise<GetCompositionsOnLambdaOutput> => {
+	const stringifiedInputProps = serializeOrThrow(inputProps, 'input-props');
+
+	const serializedInputProps = await compressInputProps({
+		stringifiedInputProps,
+		region,
+		userSpecifiedBucketName: bucketName ?? null,
+		propsType: 'input-props',
+		needsToUpload: getNeedsToUpload({
+			type: 'video-or-audio',
+			sizes: [
+				stringifiedInputProps.length,
+				JSON.stringify(envVariables).length,
+			],
+			providerSpecifics: awsImplementation,
+		}),
+		providerSpecifics: awsImplementation,
+		forcePathStyle: forcePathStyle ?? false,
+		skipPutAcl: false,
+	});
+
+	try {
+		const res = await awsImplementation.callFunctionSync({
+			functionName,
+			type: ServerlessRoutines.compositions,
+			payload: {
+				type: ServerlessRoutines.compositions,
+				chromiumOptions: chromiumOptions ?? {},
+				serveUrl,
+				envVariables,
+				inputProps: serializedInputProps,
+				logLevel: dumpBrowserLogs ? 'verbose' : (logLevel ?? 'info'),
+				timeoutInMilliseconds: timeoutInMilliseconds ?? 30000,
+				version: VERSION,
+				bucketName: bucketName ?? null,
+				offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes ?? null,
+				forcePathStyle: forcePathStyle ?? false,
+			},
+			region,
+			timeoutInTest: 120000,
+		});
+		return res.compositions;
+	} 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;
+	}
+};

package/src/get-credentials.ts

@@ -0,0 +1,81 @@
+import {fromIni} from '@aws-sdk/credential-providers';
+import {getEnvVariable} from './get-env-variable';
+import {isInsideLambda} from './is-in-lambda';
+
+type CredentialPair = {
+	accessKeyId: string;
+	secretAccessKey: string;
+	sessionToken?: string;
+};
+type AwsCredentialIdentityProvider = ReturnType<typeof fromIni>;
+
+export const getCredentials = ():
+	| CredentialPair
+	| AwsCredentialIdentityProvider
+	| undefined => {
+	if (isInsideLambda()) {
+		return undefined;
+	}
+
+	if (getEnvVariable('REMOTION_AWS_PROFILE')) {
+		return fromIni({
+			profile: getEnvVariable('REMOTION_AWS_PROFILE'),
+		});
+	}
+
+	if (
+		getEnvVariable('REMOTION_AWS_ACCESS_KEY_ID') &&
+		getEnvVariable('REMOTION_AWS_SECRET_ACCESS_KEY') &&
+		getEnvVariable('REMOTION_AWS_SESSION_TOKEN')
+	) {
+		return {
+			accessKeyId: getEnvVariable('REMOTION_AWS_ACCESS_KEY_ID') as string,
+			secretAccessKey: getEnvVariable(
+				'REMOTION_AWS_SECRET_ACCESS_KEY',
+			) as string,
+			sessionToken: getEnvVariable('REMOTION_AWS_SESSION_TOKEN') as string,
+		};
+	}
+
+	if (
+		getEnvVariable('REMOTION_AWS_ACCESS_KEY_ID') &&
+		getEnvVariable('REMOTION_AWS_SECRET_ACCESS_KEY')
+	) {
+		return {
+			accessKeyId: getEnvVariable('REMOTION_AWS_ACCESS_KEY_ID') as string,
+			secretAccessKey: getEnvVariable(
+				'REMOTION_AWS_SECRET_ACCESS_KEY',
+			) as string,
+		};
+	}
+
+	if (getEnvVariable('AWS_PROFILE')) {
+		return fromIni({
+			profile: getEnvVariable('AWS_PROFILE'),
+		});
+	}
+
+	if (
+		getEnvVariable('AWS_ACCESS_KEY_ID') &&
+		getEnvVariable('AWS_SECRET_ACCESS_KEY') &&
+		getEnvVariable('AWS_SESSION_TOKEN')
+	) {
+		return {
+			accessKeyId: getEnvVariable('AWS_ACCESS_KEY_ID') as string,
+			secretAccessKey: getEnvVariable('AWS_SECRET_ACCESS_KEY') as string,
+			sessionToken: getEnvVariable('AWS_SESSION_TOKEN') as string,
+		};
+	}
+
+	if (
+		getEnvVariable('AWS_ACCESS_KEY_ID') &&
+		getEnvVariable('AWS_SECRET_ACCESS_KEY')
+	) {
+		return {
+			accessKeyId: getEnvVariable('AWS_ACCESS_KEY_ID') as string,
+			secretAccessKey: getEnvVariable('AWS_SECRET_ACCESS_KEY') as string,
+		};
+	}
+
+	return undefined;
+};