@remotion/lambda-client 4.0.261

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

@@ -0,0 +1,37 @@
+import {
+	MAX_EPHEMERAL_STORAGE_IN_MB,
+	MIN_EPHEMERAL_STORAGE_IN_MB,
+} from './constants';
+
+export const validateDiskSizeInMb = (diskSizeInMb: unknown) => {
+	if (typeof diskSizeInMb !== 'number') {
+		throw new TypeError(
+			`parameter 'diskSizeInMb' must be a number, got a ${typeof diskSizeInMb}`,
+		);
+	}
+
+	if (Number.isNaN(diskSizeInMb)) {
+		throw new TypeError(`parameter 'diskSizeInMb' must not be NaN, but is`);
+	}
+
+	if (!Number.isFinite(diskSizeInMb)) {
+		throw new TypeError(
+			`parameter 'diskSizeInMb' must be finite, but is ${diskSizeInMb}`,
+		);
+	}
+
+	if (
+		diskSizeInMb < MIN_EPHEMERAL_STORAGE_IN_MB ||
+		diskSizeInMb > MAX_EPHEMERAL_STORAGE_IN_MB
+	) {
+		throw new TypeError(
+			`parameter 'diskSizeInMb' must be between ${MIN_EPHEMERAL_STORAGE_IN_MB} and ${MAX_EPHEMERAL_STORAGE_IN_MB}, but got ${diskSizeInMb}`,
+		);
+	}
+
+	if (diskSizeInMb % 1 !== 0) {
+		throw new TypeError(
+			`parameter 'diskSizeInMb' must be an integer but got ${diskSizeInMb}`,
+		);
+	}
+};

package/src/validate-lambda-codec.ts

@@ -0,0 +1,28 @@
+/* eslint-disable no-console */
+import type {ServerlessCodec} from '@remotion/serverless-client';
+import {serverlessCodecs} from '@remotion/serverless-client';
+
+export const validateLambdaCodec = (codec: unknown): ServerlessCodec => {
+	if (typeof codec !== 'string') {
+		throw new TypeError('"codec" must be a string ');
+	}
+
+	if (!(serverlessCodecs as readonly string[]).includes(codec)) {
+		throw new TypeError(
+			"'" +
+				codec +
+				"' is not a valid codec for Lambda. The following values are supported: " +
+				serverlessCodecs.join(', '),
+		);
+	}
+
+	if ((codec as string) === 'h264-mkv') {
+		console.warn(
+			'The "h264-mkv" codec for renderMediaOnLambda() is deprecated - it\'s now just "h264".',
+		);
+
+		return 'h264';
+	}
+
+	return codec as ServerlessCodec;
+};

package/src/validate-memory-size.ts

@@ -0,0 +1,31 @@
+import {MAX_MEMORY, MIN_MEMORY} from './constants';
+
+export const validateMemorySize = (memorySizeInMb: unknown) => {
+	if (typeof memorySizeInMb !== 'number') {
+		throw new TypeError(
+			`parameter 'memorySizeInMb' must be a number, got a ${typeof memorySizeInMb}`,
+		);
+	}
+
+	if (Number.isNaN(memorySizeInMb)) {
+		throw new TypeError(`parameter 'memorySizeInMb' must not be NaN, but is`);
+	}
+
+	if (!Number.isFinite(memorySizeInMb)) {
+		throw new TypeError(
+			`parameter 'memorySizeInMb' must be finite, but is ${memorySizeInMb}`,
+		);
+	}
+
+	if (memorySizeInMb < MIN_MEMORY || memorySizeInMb > MAX_MEMORY) {
+		throw new TypeError(
+			`parameter 'memorySizeInMb' must be between ${MIN_MEMORY} and ${MAX_MEMORY}, but got ${memorySizeInMb}`,
+		);
+	}
+
+	if (memorySizeInMb % 1 !== 0) {
+		throw new TypeError(
+			`parameter 'memorySizeInMb' must be an integer but got ${memorySizeInMb}`,
+		);
+	}
+};

package/src/validate-presign-expiration.ts

@@ -0,0 +1,46 @@
+const MAX_PRESIGN_EXPIRATION = 604800;
+const MIN_PRESIGN_EXPIRATION = 1;
+
+export const validatePresignExpiration = (presignExpiration: unknown) => {
+	if (typeof presignExpiration === 'undefined' || presignExpiration === null) {
+		return;
+	}
+
+	if (typeof presignExpiration !== 'number') {
+		throw new TypeError(
+			`'expiresIn' should be a number, but is ${JSON.stringify(
+				presignExpiration,
+			)}`,
+		);
+	}
+
+	if (Number.isNaN(presignExpiration)) {
+		throw new TypeError(`'expiresIn' should not be NaN, but is NaN`);
+	}
+
+	if (!Number.isFinite(presignExpiration)) {
+		throw new TypeError(
+			`'expiresIn' should be finite but is ${presignExpiration}`,
+		);
+	}
+
+	if (presignExpiration % 1 !== 0) {
+		throw new TypeError(
+			`'expiresIn' should be an integer but is ${JSON.stringify(
+				presignExpiration,
+			)}`,
+		);
+	}
+
+	if (presignExpiration > MAX_PRESIGN_EXPIRATION) {
+		throw new TypeError(
+			`The 'expiresIn' parameter must be less or equal than ${MAX_PRESIGN_EXPIRATION} (7 days) as enforced by AWS`,
+		);
+	}
+
+	if (presignExpiration < MIN_PRESIGN_EXPIRATION) {
+		throw new TypeError(
+			`The 'expiresIn' parameter must be greater or equal than ${MIN_PRESIGN_EXPIRATION}`,
+		);
+	}
+};

package/src/validate-serveurl.ts

@@ -0,0 +1,9 @@
+export const validateServeUrl = (serveUrl: unknown) => {
+	if (typeof serveUrl !== 'string') {
+		throw new TypeError(
+			`"serveURL" parameter must be a string, but is ${JSON.stringify(
+				serveUrl,
+			)}`,
+		);
+	}
+};

package/src/validate-webhook-signature.ts

@@ -0,0 +1,42 @@
+/*
+ * @description Validates that the signature received by a webhook endpoint is authentic. If validation fails, an error is thrown.
+ * @see [Documentation](https://remotion.dev/docs/lambda/validatewebhooksignature)
+ */
+export const validateWebhookSignature = ({
+	secret,
+	body,
+	signatureHeader,
+}: {
+	secret: string;
+	body: unknown;
+	signatureHeader: string;
+}) => {
+	if (!secret) {
+		throw new TypeError(
+			"No 'secret' was provided to validateWebhookSignature().",
+		);
+	}
+
+	if (!body) {
+		throw new TypeError(
+			"No 'body' was provided to validateWebhookSignature().",
+		);
+	}
+
+	if (typeof require === 'undefined') {
+		throw new Error('validateWebhookSignature can only be called from Node.JS');
+	}
+
+	const Crypto = require('crypto');
+
+	const hmac = Crypto.createHmac('sha512', secret);
+	const signature = `sha512=${hmac.update(JSON.stringify(body)).digest('hex')}`;
+
+	if (!signatureHeader || signatureHeader === 'NO_SECRET_PROVIDED') {
+		throw new Error('No webhook signature was provided');
+	}
+
+	if (signatureHeader !== signature) {
+		throw new Error('Signatures do not match');
+	}
+};

package/src/write-file.ts

@@ -0,0 +1,74 @@
+/* eslint-disable no-console */
+import {PutObjectCommand} from '@aws-sdk/client-s3';
+import type {
+	CustomCredentials,
+	WriteFileInput,
+} from '@remotion/serverless-client';
+import mimeTypes from 'mime-types';
+import type {AwsProvider} from './aws-provider';
+import {getContentDispositionHeader} from './content-disposition-header';
+import {getS3Client} from './get-s3-client';
+
+const tryLambdaWriteFile = async ({
+	bucketName,
+	key,
+	body,
+	region,
+	privacy,
+	expectedBucketOwner,
+	downloadBehavior,
+	customCredentials,
+	forcePathStyle,
+}: WriteFileInput<AwsProvider>): Promise<void> => {
+	await getS3Client({
+		region,
+		customCredentials: customCredentials as CustomCredentials<AwsProvider>,
+		forcePathStyle,
+	}).send(
+		new PutObjectCommand({
+			Bucket: bucketName,
+			Key: key,
+			Body: body,
+			ACL:
+				privacy === 'no-acl'
+					? undefined
+					: privacy === 'private'
+						? 'private'
+						: 'public-read',
+			ExpectedBucketOwner: customCredentials
+				? undefined
+				: (expectedBucketOwner ?? undefined),
+			ContentType: mimeTypes.lookup(key) || 'application/octet-stream',
+			ContentDisposition: getContentDispositionHeader(downloadBehavior),
+		}),
+	);
+};
+
+export const lambdaWriteFileImplementation = async (
+	params: WriteFileInput<AwsProvider> & {
+		retries?: number;
+	},
+): Promise<void> => {
+	const remainingRetries = params.retries ?? 2;
+	try {
+		await tryLambdaWriteFile(params);
+	} catch (err) {
+		if (remainingRetries === 0) {
+			throw err;
+		}
+
+		const backoff = 2 ** (2 - remainingRetries) * 2000;
+		await new Promise((resolve) => {
+			setTimeout(resolve, backoff);
+		});
+
+		console.warn('Failed to write file to storage:');
+		console.warn(err);
+		console.warn(`Retrying (${remainingRetries} retries remaining)...`);
+
+		return lambdaWriteFileImplementation({
+			...params,
+			retries: remainingRetries - 1,
+		});
+	}
+};

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"rootDir": "src",
+		"outDir": "dist"
+	},
+	"include": ["src"],
+	"references": [{"path": "../serverless-client"}]
+}