@remotion/lambda-client 4.0.313 → 4.0.315

package/src/presign-url.ts

@@ -4,6 +4,7 @@ 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 = {
@@ -19,9 +20,15 @@ type OptionalParameters<CheckIfObjectExists extends boolean> = {
 };
 
 export type PresignUrlInput<CheckIfObjectExists extends boolean = boolean> =
-	MandatoryParameters & Partial<OptionalParameters<CheckIfObjectExists>>;
+	MandatoryParameters &
+		Partial<OptionalParameters<CheckIfObjectExists>> & {
+			requestHandler?: RequestHandler;
+		};
 type PresignUrlInputInternal<CheckIfObjectExists extends boolean> =
-	MandatoryParameters & OptionalParameters<CheckIfObjectExists>;
+	MandatoryParameters &
+		OptionalParameters<CheckIfObjectExists> & {
+			requestHandler?: RequestHandler;
+		};
 
 const internalPresignUrl = async <CheckIfObjectExists extends boolean = false>({
 	region,
@@ -30,6 +37,7 @@ const internalPresignUrl = async <CheckIfObjectExists extends boolean = false>({
 	checkIfObjectExists,
 	expiresInSeconds,
 	forcePathStyle,
+	requestHandler,
 }: PresignUrlInputInternal<CheckIfObjectExists>): Promise<
 	CheckIfObjectExists extends true ? string | null : string
 > => {
@@ -44,6 +52,7 @@ const internalPresignUrl = async <CheckIfObjectExists extends boolean = false>({
 		region,
 		customCredentials: null,
 		forcePathStyle,
+		requestHandler: requestHandler ?? null,
 	});
 
 	if (checkIfObjectExists === true) {
@@ -96,6 +105,7 @@ export const presignUrl = <CheckIfObjectExists extends boolean = false>({
 	checkIfObjectExists,
 	expiresInSeconds,
 	forcePathStyle,
+	requestHandler,
 }: PresignUrlInput<CheckIfObjectExists>): Promise<
 	CheckIfObjectExists extends true ? string | null : string
 > => {
@@ -106,5 +116,6 @@ export const presignUrl = <CheckIfObjectExists extends boolean = false>({
 		checkIfObjectExists: checkIfObjectExists ?? false,
 		expiresInSeconds,
 		forcePathStyle: forcePathStyle ?? false,
+		requestHandler,
 	});
 };

package/src/read-file.ts

@@ -2,6 +2,7 @@ import {GetObjectCommand} from '@aws-sdk/client-s3';
 import type {Readable} from 'stream';
 import {getS3Client} from './get-s3-client';
 import type {AwsRegion} from './regions';
+import type {RequestHandler} from './types';
 
 export const lambdaReadFileImplementation = async ({
 	bucketName,
@@ -9,17 +10,20 @@ export const lambdaReadFileImplementation = async ({
 	region,
 	expectedBucketOwner,
 	forcePathStyle,
+	requestHandler,
 }: {
 	bucketName: string;
 	key: string;
 	region: AwsRegion;
 	expectedBucketOwner: string | null;
 	forcePathStyle: boolean;
+	requestHandler: RequestHandler | null;
 }): Promise<Readable> => {
 	const {Body} = await getS3Client({
 		region,
 		customCredentials: null,
 		forcePathStyle,
+		requestHandler,
 	}).send(
 		new GetObjectCommand({
 			Bucket: bucketName,

package/src/render-media-on-lambda.ts

@@ -29,6 +29,7 @@ import {
 import type {InnerRenderMediaOnLambdaInput} from './make-lambda-payload';
 import {makeLambdaRenderMediaPayload} from './make-lambda-payload';
 import type {AwsRegion} from './regions';
+import type {RequestHandler} from './types';
 
 export type RenderMediaOnLambdaInput = {
 	region: AwsRegion;
@@ -71,6 +72,7 @@ export type RenderMediaOnLambdaInput = {
 	forcePathStyle?: boolean;
 	metadata?: Record<string, string> | null;
 	storageClass?: StorageClass | null;
+	requestHandler?: RequestHandler;
 } & Partial<ToOptions<typeof BrowserSafeApis.optionsMap.renderMediaOnLambda>>;
 
 export type RenderMediaOnLambdaOutput = {
@@ -95,6 +97,7 @@ export const internalRenderMediaOnLambdaRaw = async (
 			payload: await makeLambdaRenderMediaPayload(input),
 			region,
 			timeoutInTest: 120000,
+			requestHandler: input.requestHandler,
 		});
 
 		return {
@@ -193,6 +196,7 @@ export const renderMediaOnLambdaOptionalToRequired = (
 		metadata: options.metadata ?? null,
 		apiKey: options.apiKey ?? null,
 		storageClass: options.storageClass ?? null,
+		requestHandler: options.requestHandler ?? null,
 	};
 };
 

package/src/render-still-on-lambda.ts

@@ -21,6 +21,7 @@ import {DEFAULT_MAX_RETRIES} from './constants';
 import {getCloudwatchMethodUrl, getLambdaInsightsUrl} from './get-aws-urls';
 import {makeLambdaRenderStillPayload} from './make-lambda-payload';
 import type {AwsRegion} from './regions';
+import type {RequestHandler} from './types';
 
 type MandatoryParameters = {
 	region: AwsRegion;
@@ -50,13 +51,16 @@ type OptionalParameters = {
 	indent: boolean;
 	forcePathStyle: boolean;
 	storageClass: StorageClass | null;
+	requestHandler: RequestHandler | null | undefined;
 } & ToOptions<typeof BrowserSafeApis.optionsMap.renderStillOnLambda>;
 
 export type RenderStillOnLambdaNonNullInput = MandatoryParameters &
 	OptionalParameters;
 
 export type RenderStillOnLambdaInput = MandatoryParameters &
-	Partial<OptionalParameters>;
+	Partial<OptionalParameters> & {
+		requestHandler?: RequestHandler;
+	};
 
 export type RenderStillOnLambdaOutput = {
 	estimatedPrice: CostsInfo;
@@ -112,6 +116,7 @@ const innerRenderStillOnLambda = async (
 					},
 					timeoutInTest: 120000,
 					retriesRemaining: input.maxRetries,
+					requestHandler: input.requestHandler,
 				})
 				.then(() => {
 					reject(new Error('Expected response to be streamed'));
@@ -198,5 +203,6 @@ export const renderStillOnLambda = (
 		apiKey: input.apiKey ?? null,
 		offthreadVideoThreads: input.offthreadVideoThreads ?? null,
 		storageClass: input.storageClass ?? null,
+		requestHandler: input.requestHandler ?? null,
 	});
 };

package/src/test/request-handler.test.ts

@@ -0,0 +1,42 @@
+import {expect, test} from 'bun:test';
+import type {GetAwsClientInput} from '../get-aws-client';
+import type {GetFunctionsInput} from '../get-functions';
+import type {RequestHandler} from '../types';
+
+test('RequestHandler type should be properly exported and defined', () => {
+	// Just verify the type can be imported
+	const requestHandler: RequestHandler = {
+		httpsAgent: {
+			maxSockets: 100,
+		},
+	};
+
+	expect(requestHandler).toBeDefined();
+	expect(typeof requestHandler).toBe('object');
+});
+
+test('API input types should accept requestHandler option', () => {
+	// Test that the type checking works for various API inputs
+	const getAwsClientInput: GetAwsClientInput<'lambda'> = {
+		region: 'us-east-1',
+		service: 'lambda',
+		requestHandler: {
+			httpsAgent: {
+				maxSockets: 50,
+			},
+		},
+	};
+
+	const getFunctionsInput: GetFunctionsInput = {
+		region: 'us-east-1',
+		compatibleOnly: false,
+		requestHandler: {
+			httpsAgent: {
+				maxSockets: 25,
+			},
+		},
+	};
+
+	expect(getAwsClientInput.requestHandler).toBeDefined();
+	expect(getFunctionsInput.requestHandler).toBeDefined();
+});

package/src/types.ts

@@ -0,0 +1,7 @@
+import type {LambdaClient} from '@aws-sdk/client-lambda';
+
+// Extract RequestHandler type from AWS SDK LambdaClient constructor
+type LambdaClientConfig = NonNullable<
+	ConstructorParameters<typeof LambdaClient>[0]
+>;
+export type RequestHandler = LambdaClientConfig['requestHandler'];

package/src/write-file.ts

@@ -25,11 +25,13 @@ const tryLambdaWriteFile = async ({
 	customCredentials,
 	forcePathStyle,
 	storageClass,
+	requestHandler,
 }: WriteFileInput<AwsProvider>): Promise<void> => {
 	const client = getS3Client({
 		region,
 		customCredentials: customCredentials as CustomCredentials<AwsProvider>,
 		forcePathStyle,
+		requestHandler,
 	});
 
 	const params: PutObjectCommandInput = {