@remotion/lambda-client 4.0.261

package/src/get-env-variable.ts

@@ -0,0 +1,15 @@
+export const getEnvVariable = (name: string) => {
+	if (
+		typeof process !== 'undefined' &&
+		typeof process.env !== 'undefined' &&
+		process.env[name]
+	) {
+		return process.env[name];
+	}
+
+	if (typeof Deno !== 'undefined' && Deno.env.has(name)) {
+		return Deno.env.get(name);
+	}
+
+	return undefined;
+};

package/src/get-function-name.ts

@@ -0,0 +1,24 @@
+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/get-function-version.ts

@@ -0,0 +1,43 @@
+import type {LogLevel} from '@remotion/serverless-client';
+import {
+	COMMAND_NOT_FOUND,
+	ServerlessRoutines,
+} from '@remotion/serverless-client';
+import {awsImplementation} from './aws-provider';
+import type {AwsRegion} from './regions';
+
+export const getFunctionVersion = async ({
+	functionName,
+	region,
+	logLevel,
+}: {
+	functionName: string;
+	region: AwsRegion;
+	logLevel: LogLevel;
+}): Promise<string> => {
+	try {
+		const result = await awsImplementation.callFunctionSync({
+			functionName,
+			payload: {
+				logLevel,
+				type: ServerlessRoutines.info,
+			},
+			region,
+			type: ServerlessRoutines.info,
+			timeoutInTest: 120000,
+		});
+		return result.version;
+	} catch (err) {
+		// Prerelease versions had no info command
+		if ((err as Error).message.includes(COMMAND_NOT_FOUND)) {
+			return 'n/a';
+		}
+
+		// Bug in certain version of AWS S3 kit
+		if ((err as Error).message.includes('AWS CRT binary not present ')) {
+			return 'n/a';
+		}
+
+		throw err;
+	}
+};

package/src/get-functions.ts

@@ -0,0 +1,103 @@
+import type {FunctionConfiguration} from '@aws-sdk/client-lambda';
+import {ListFunctionsCommand} from '@aws-sdk/client-lambda';
+import type {FunctionInfo, LogLevel} from '@remotion/serverless-client';
+import {VERSION} from '@remotion/serverless-client';
+import {getLambdaClient} from './aws-clients';
+import {DEFAULT_EPHEMERAL_STORAGE_IN_MB, RENDER_FN_PREFIX} from './constants';
+import {getFunctionVersion} from './get-function-version';
+import type {AwsRegion} from './regions';
+
+export type GetFunctionsInput = {
+	region: AwsRegion;
+	compatibleOnly: boolean;
+	logLevel?: LogLevel;
+};
+
+const getAllFunctions = async ({
+	existing,
+	nextMarker,
+	region,
+}: {
+	existing: FunctionConfiguration[];
+	nextMarker: string | null;
+	region: AwsRegion;
+}): Promise<FunctionConfiguration[]> => {
+	const allLambdas: FunctionConfiguration[] = [...existing];
+	const lambdas = await getLambdaClient(region).send(
+		new ListFunctionsCommand({
+			Marker: nextMarker ?? undefined,
+		}),
+	);
+	if (!lambdas.Functions) {
+		return allLambdas;
+	}
+
+	for (const lambda of lambdas.Functions) {
+		allLambdas.push(lambda);
+	}
+
+	if (lambdas.NextMarker) {
+		return getAllFunctions({
+			existing: allLambdas,
+			nextMarker: lambdas.NextMarker,
+			region,
+		});
+	}
+
+	return allLambdas;
+};
+
+/*
+ * @description Retrieves a list of functions that Remotion deployed to AWS Lambda in a certain region.
+ * @see [Documentation](https://remotion.dev/docs/lambda/getfunctions)
+ */
+export const getFunctions = async (
+	params: GetFunctionsInput,
+): Promise<FunctionInfo[]> => {
+	const lambdas = await getAllFunctions({
+		existing: [],
+		nextMarker: null,
+		region: params.region,
+	});
+
+	const remotionLambdas = lambdas.filter((f) => {
+		return f.FunctionName?.startsWith(RENDER_FN_PREFIX);
+	});
+
+	const configs = await Promise.all(
+		remotionLambdas.map(async (fn) => {
+			try {
+				const version = await getFunctionVersion({
+					functionName: fn.FunctionName as string,
+					region: params.region,
+					logLevel: params.logLevel ?? 'info',
+				});
+				return version;
+			} catch {
+				return null;
+			}
+		}),
+	);
+
+	const list = remotionLambdas.map((lambda, i): FunctionInfo => {
+		return {
+			functionName: lambda.FunctionName as string,
+			version: configs[i],
+			memorySizeInMb: lambda.MemorySize as number,
+			timeoutInSeconds: lambda.Timeout as number,
+			diskSizeInMb:
+				lambda.EphemeralStorage?.Size ?? DEFAULT_EPHEMERAL_STORAGE_IN_MB,
+		};
+	});
+	if (!params.compatibleOnly) {
+		return list;
+	}
+
+	return list.filter((l) => {
+		if (!params.compatibleOnly) {
+			return true;
+		}
+
+		return l.version === VERSION;
+	});
+};

package/src/get-output-url-from-metadata.ts

@@ -0,0 +1,23 @@
+import type {GetOutputUrl} from '@remotion/serverless-client';
+import {getExpectedOutName} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {REMOTION_BUCKET_PREFIX} from './constants';
+
+export const getOutputUrlFromMetadata: GetOutputUrl<AwsProvider> = ({
+	renderMetadata,
+	bucketName,
+	customCredentials,
+	currentRegion,
+}) => {
+	const {key, renderBucketName} = getExpectedOutName({
+		renderMetadata,
+		bucketName,
+		customCredentials,
+		bucketNamePrefix: REMOTION_BUCKET_PREFIX,
+	});
+
+	return {
+		url: `https://s3.${currentRegion}.amazonaws.com/${renderBucketName}/${key}`,
+		key,
+	};
+};

package/src/get-render-progress.ts

@@ -0,0 +1,62 @@
+import type {CustomCredentials, LogLevel} from '@remotion/serverless-client';
+import {getProgress, ServerlessRoutines} from '@remotion/serverless-client';
+import {awsImplementation, type AwsProvider} from './aws-provider';
+import type {RenderProgress} from './constants';
+import {getRenderProgressPayload} from './make-lambda-payload';
+import {parseFunctionName} from './parse-function-name';
+import type {AwsRegion} from './regions';
+
+export type GetRenderProgressInput = {
+	functionName: string;
+	bucketName: string;
+	renderId: string;
+	region: AwsRegion;
+	logLevel?: LogLevel;
+	s3OutputProvider?: CustomCredentials<AwsProvider>;
+	forcePathStyle?: boolean;
+	skipLambdaInvocation?: boolean;
+};
+
+/*
+ * @description Gets the current status of a render originally triggered via renderMediaOnLambda().
+ * @see [Documentation](https://remotion.dev/docs/lambda/getrenderprogress)
+ */
+export const getRenderProgress = async (
+	input: GetRenderProgressInput,
+): Promise<RenderProgress> => {
+	if (input.skipLambdaInvocation) {
+		const parsed = parseFunctionName(input.functionName);
+		if (!parsed) {
+			throw new Error(
+				[
+					`The function name ${input.functionName} does not adhere to the function name convention (https://www.remotion.dev/docs/lambda/naming-convention).`,
+					'Cannot determine memory and disk size from the function name.',
+					'You must call getRenderProgress with `skipLambdaInvocation` set to false.',
+				].join('\n'),
+			);
+		}
+
+		return getProgress<AwsProvider>({
+			bucketName: input.bucketName,
+			renderId: input.renderId,
+			region: input.region,
+			forcePathStyle: input.forcePathStyle ?? false,
+			customCredentials: input.s3OutputProvider ?? null,
+			expectedBucketOwner: null,
+			providerSpecifics: awsImplementation,
+			memorySizeInMb: parsed.memorySizeInMb,
+			timeoutInMilliseconds: parsed.timeoutInSeconds * 1000,
+			functionName: input.functionName,
+		});
+	}
+
+	const result =
+		await awsImplementation.callFunctionSync<ServerlessRoutines.status>({
+			functionName: input.functionName,
+			type: ServerlessRoutines.status,
+			payload: getRenderProgressPayload(input),
+			region: input.region,
+			timeoutInTest: 120000,
+		});
+	return result;
+};

package/src/get-s3-client.ts

@@ -0,0 +1,22 @@
+import type {S3Client} from '@aws-sdk/client-s3';
+import type {CustomCredentials} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {getServiceClient} from './get-service-client';
+import type {AwsRegion} from './regions';
+
+export const getS3Client = ({
+	region,
+	customCredentials,
+	forcePathStyle,
+}: {
+	region: AwsRegion;
+	customCredentials: CustomCredentials<AwsProvider> | null;
+	forcePathStyle: boolean;
+}): S3Client => {
+	return getServiceClient({
+		region: customCredentials?.region ?? region,
+		service: 's3',
+		customCredentials,
+		forcePathStyle,
+	});
+};

package/src/get-service-client.ts

@@ -0,0 +1,178 @@
+import {CloudWatchLogsClient} from '@aws-sdk/client-cloudwatch-logs';
+import {IAMClient} from '@aws-sdk/client-iam';
+import {LambdaClient} from '@aws-sdk/client-lambda';
+import {S3Client} from '@aws-sdk/client-s3';
+import {ServiceQuotasClient} from '@aws-sdk/client-service-quotas';
+import {STSClient} from '@aws-sdk/client-sts';
+import type {CustomCredentials} from '@remotion/serverless-client';
+import {MAX_FUNCTIONS_PER_RENDER, random} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {checkCredentials} from './check-credentials';
+import {getCredentials} from './get-credentials';
+import {getEnvVariable} from './get-env-variable';
+import type {AwsRegion} from './regions';
+
+export type ServiceMapping = {
+	s3: S3Client;
+	cloudwatch: CloudWatchLogsClient;
+	iam: IAMClient;
+	lambda: LambdaClient;
+	servicequotas: ServiceQuotasClient;
+	sts: STSClient;
+};
+
+const getCredentialsHash = ({
+	customCredentials,
+	region,
+	service,
+	forcePathStyle,
+}: {
+	region: AwsRegion;
+	customCredentials: CustomCredentials<AwsProvider> | null;
+	service: keyof ServiceMapping;
+	forcePathStyle: boolean;
+}): string => {
+	const hashComponents: {[key: string]: unknown} = {};
+
+	if (getEnvVariable('REMOTION_SKIP_AWS_CREDENTIALS_CHECK')) {
+		hashComponents.credentials = {
+			credentialsSkipped: true,
+		};
+	} else if (getEnvVariable('REMOTION_AWS_PROFILE')) {
+		hashComponents.credentials = {
+			awsProfile: getEnvVariable('REMOTION_AWS_PROFILE'),
+		};
+	} else if (
+		getEnvVariable('REMOTION_AWS_ACCESS_KEY_ID') &&
+		getEnvVariable('REMOTION_AWS_SECRET_ACCESS_KEY')
+	) {
+		hashComponents.credentials = {
+			accessKeyId: getEnvVariable('REMOTION_AWS_ACCESS_KEY_ID'),
+			secretAccessKey: getEnvVariable('REMOTION_AWS_SECRET_ACCESS_KEY'),
+		};
+	} else if (getEnvVariable('AWS_PROFILE')) {
+		hashComponents.credentials = {
+			awsProfile: getEnvVariable('AWS_PROFILE'),
+		};
+	} else if (
+		getEnvVariable('AWS_ACCESS_KEY_ID') &&
+		getEnvVariable('AWS_SECRET_ACCESS_KEY')
+	) {
+		hashComponents.credentials = {
+			accessKeyId: getEnvVariable('AWS_ACCESS_KEY_ID') as string,
+			secretAccessKey: getEnvVariable('AWS_SECRET_ACCESS_KEY') as string,
+		};
+	}
+
+	hashComponents.customCredentials = customCredentials;
+	hashComponents.region = region;
+	hashComponents.service = service;
+	hashComponents.forcePathStyle = forcePathStyle;
+
+	return random(JSON.stringify(hashComponents)).toString().replace('0.', '');
+};
+
+const _clients: Partial<
+	Record<
+		string,
+		| CloudWatchLogsClient
+		| LambdaClient
+		| S3Client
+		| IAMClient
+		| ServiceQuotasClient
+		| STSClient
+	>
+> = {};
+
+export const getServiceClient = <T extends keyof ServiceMapping>({
+	region,
+	service,
+	customCredentials,
+	forcePathStyle,
+}: {
+	region: AwsRegion;
+	service: T;
+	customCredentials: CustomCredentials<AwsProvider> | null;
+	forcePathStyle: boolean;
+}): ServiceMapping[T] => {
+	const Client = (() => {
+		if (service === 'cloudwatch') {
+			return CloudWatchLogsClient;
+		}
+
+		if (service === 'lambda') {
+			return LambdaClient;
+		}
+
+		if (service === 's3') {
+			return S3Client;
+		}
+
+		if (service === 'iam') {
+			return IAMClient;
+		}
+
+		if (service === 'servicequotas') {
+			return ServiceQuotasClient;
+		}
+
+		if (service === 'sts') {
+			return STSClient;
+		}
+
+		throw new TypeError('unknown client ' + service);
+	})();
+
+	const key = getCredentialsHash({
+		region,
+		customCredentials,
+		service,
+		forcePathStyle,
+	});
+
+	if (!_clients[key]) {
+		checkCredentials();
+
+		const lambdaOptions =
+			service === 'lambda'
+				? {
+						httpsAgent: {
+							maxSockets: MAX_FUNCTIONS_PER_RENDER * 2,
+						},
+					}
+				: undefined;
+
+		const client = customCredentials
+			? new Client({
+					region: customCredentials.region ?? 'us-east-1',
+					credentials:
+						customCredentials.accessKeyId && customCredentials.secretAccessKey
+							? {
+									accessKeyId: customCredentials.accessKeyId,
+									secretAccessKey: customCredentials.secretAccessKey,
+								}
+							: undefined,
+					endpoint: customCredentials.endpoint,
+					requestHandler: lambdaOptions,
+					forcePathStyle: customCredentials.forcePathStyle,
+				})
+			: getEnvVariable('REMOTION_SKIP_AWS_CREDENTIALS_CHECK')
+				? new Client({
+						region,
+						requestHandler: lambdaOptions,
+					})
+				: new Client({
+						region,
+						credentials: getCredentials(),
+						requestHandler: lambdaOptions,
+					});
+
+		if (getEnvVariable('REMOTION_DISABLE_AWS_CLIENT_CACHE')) {
+			return client as ServiceMapping[T];
+		}
+
+		_clients[key] = client;
+	}
+
+	return _clients[key] as ServiceMapping[T];
+};

package/src/get-sites.ts

@@ -0,0 +1,128 @@
+import type {ProviderSpecifics} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {awsImplementation} from './aws-provider';
+import {getSitesKey} from './constants';
+import type {BucketWithLocation} from './get-buckets';
+import {makeS3ServeUrl} from './make-s3-url';
+import type {AwsRegion} from './regions';
+
+type Site = {
+	sizeInBytes: number;
+	lastModified: number | null;
+	bucketName: string;
+	id: string;
+	serveUrl: string;
+};
+
+type MandatoryParameters = {
+	region: AwsRegion;
+};
+
+type OptionalParameters = {
+	forceBucketName: string | null;
+	forcePathStyle: boolean;
+};
+
+type GetSitesInternalInput = MandatoryParameters & OptionalParameters;
+export type GetSitesInput = MandatoryParameters & Partial<OptionalParameters>;
+
+export type GetSitesOutput = {
+	sites: Site[];
+	buckets: BucketWithLocation[];
+};
+
+export const internalGetSites = async ({
+	region,
+	forceBucketName,
+	providerSpecifics,
+	forcePathStyle,
+}: GetSitesInternalInput & {
+	providerSpecifics: ProviderSpecifics<AwsProvider>;
+}): Promise<GetSitesOutput> => {
+	const remotionBuckets = forceBucketName
+		? await providerSpecifics.getBuckets({
+				region,
+				forceBucketName,
+				forcePathStyle,
+			})
+		: await providerSpecifics.getBuckets({
+				region,
+				forceBucketName: null,
+				forcePathStyle,
+			});
+	const accountId = await providerSpecifics.getAccountId({region});
+
+	const sites: {[key: string]: Site} = {};
+
+	for (const bucket of remotionBuckets) {
+		const ls = await providerSpecifics.listObjects({
+			bucketName: bucket.name,
+			prefix: getSitesKey(''),
+			region,
+			expectedBucketOwner: accountId,
+			forcePathStyle,
+		});
+
+		for (const file of ls) {
+			const siteKeyMatch = file.Key?.match(
+				/sites\/([0-9a-zA-Z-!_.*'()]+)\/(.*)$/,
+			);
+			if (!siteKeyMatch) {
+				throw new Error(
+					`A file was found in the bucket "${bucket.name}" with the key ${file.Key} which is an unexpected folder structure. Delete this file.`,
+				);
+			}
+
+			const [, siteId] = siteKeyMatch;
+			if (!sites[siteId]) {
+				sites[siteId] = {
+					sizeInBytes: 0,
+					bucketName: bucket.name,
+					lastModified: null,
+					id: siteId,
+					serveUrl: makeS3ServeUrl({
+						bucketName: bucket.name,
+						region,
+						subFolder: getSitesKey(siteId),
+					}),
+				};
+			}
+
+			if (file.LastModified) {
+				const currentLastModified = sites[siteId].lastModified;
+				if (
+					currentLastModified === null ||
+					file.LastModified.getTime() > currentLastModified
+				) {
+					sites[siteId].lastModified = file.LastModified.getTime();
+				}
+			}
+
+			if (file.Size) {
+				sites[siteId].sizeInBytes += file.Size;
+			}
+		}
+	}
+
+	const sitesArray: Site[] = Object.keys(sites).map((siteId) => {
+		return sites[siteId];
+	});
+	return {sites: sitesArray, buckets: remotionBuckets};
+};
+
+/*
+ * @description Gets an array of Remotion projects in Cloud Storage, in your GCP project.
+ * @see [Documentation](https://remotion.dev/docs/cloudrun/getsites)
+ */
+export const getSites = ({
+	region,
+	forceBucketName,
+	forcePathStyle,
+}: GetSitesInput): Promise<GetSitesOutput> => {
+	return internalGetSites({
+		region,
+		forceBucketName: forceBucketName ?? null,
+		forcePathStyle: forcePathStyle ?? false,
+		providerSpecifics: awsImplementation,
+	});
+};

package/src/head-file.ts

@@ -0,0 +1,28 @@
+import {HeadObjectCommand} 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 lambdaHeadFileImplementation: ProviderSpecifics<AwsProvider>['headFile'] =
+	async ({
+		bucketName,
+		key,
+		region,
+		customCredentials,
+		forcePathStyle,
+	}): Promise<{
+		LastModified?: Date | undefined;
+		ContentLength?: number | undefined;
+	}> => {
+		const head = await getS3Client({
+			region,
+			customCredentials,
+			forcePathStyle,
+		}).send(
+			new HeadObjectCommand({
+				Bucket: bucketName,
+				Key: key,
+			}),
+		);
+		return head;
+	};