@remotion/serverless-client 4.0.363 → 4.0.365

package/src/test/dont-contain-forbidden.test.ts

@@ -1,14 +0,0 @@
-import {expect, test} from 'bun:test';
-import path from 'path';
-
-test('Should not contain forbidden imports', async () => {
-	const output = await Bun.build({
-		external: ['@remotion/renderer', 'react/jsx-runtime'],
-		entrypoints: [path.join(__filename, '..', '..', 'index.ts')],
-	});
-	expect(output.outputs.length).toBe(1);
-	const text = await output.outputs[0].text();
-	expect(text).not.toContain('jsx-runtime');
-	expect(text).not.toContain('"@remotion/renderer"');
-	expect(text).not.toContain("'@remotion/renderer'");
-});

package/src/test/expected-out-name.test.ts

@@ -1,200 +0,0 @@
-import {expect, test} from 'bun:test';
-import {getExpectedOutName} from '../expected-out-name';
-import type {RenderMetadata} from '../render-metadata';
-
-const bucketName = 'remotionlambda-98fsduf';
-
-type MockProvider = {
-	type: 'aws';
-	region: 'eu-central';
-	receivedArtifactType: {
-		s3Key: string;
-		s3Url: string;
-	};
-	creationFunctionOptions: {};
-	storageClass: string;
-	requestHandler: null;
-};
-
-const testRenderMetadata: RenderMetadata<MockProvider> = {
-	compositionId: 'react-svg',
-	estimatedRenderLambdaInvokations: 100,
-	estimatedTotalLambdaInvokations: 100,
-	framesPerLambda: 20,
-	imageFormat: 'png',
-	type: 'video',
-	inputProps: {
-		type: 'payload',
-		payload: '{}',
-	},
-	lambdaVersion: '2022-02-14',
-	memorySizeInMb: 2048,
-	functionName: 'remotion-render-4-0-187-mem3000mb-disk10000mb-120sec',
-	rendererFunctionName: 'remotion-render-4-0-187-mem3000mb-disk10000mb-120sec',
-	outName: undefined,
-	region: 'eu-central',
-	renderId: '9n8dsfafs',
-	siteId: 'my-site',
-	startedDate: Date.now(),
-	totalChunks: 20,
-	privacy: 'public',
-	everyNthFrame: 1,
-	frameRange: [0, 199],
-	audioCodec: null,
-	deleteAfter: null,
-	numberOfGifLoops: null,
-	downloadBehavior: {type: 'play-in-browser'},
-	audioBitrate: null,
-	muted: false,
-	metadata: null,
-	codec: 'h264',
-	dimensions: {
-		width: 1920,
-		height: 1080,
-	},
-	scale: 1,
-};
-
-test('Should get a custom outname', () => {
-	expect(
-		getExpectedOutName({
-			renderMetadata: testRenderMetadata,
-			bucketName,
-			customCredentials: null,
-			bucketNamePrefix: 'remotionlambda-',
-		}),
-	).toEqual({
-		customCredentials: null,
-		renderBucketName: 'remotionlambda-98fsduf',
-		key: 'renders/9n8dsfafs/out.mp4',
-	});
-});
-
-test('Should save to a different outname', () => {
-	const newRenderMetadata: RenderMetadata<MockProvider> = {
-		...testRenderMetadata,
-		outName: {
-			bucketName: 'my-bucket',
-			key: 'my-key',
-		},
-	};
-	expect(
-		getExpectedOutName({
-			renderMetadata: newRenderMetadata,
-			bucketName,
-			customCredentials: null,
-			bucketNamePrefix: 'remotionlambda-',
-		}),
-	).toEqual({
-		customCredentials: null,
-		renderBucketName: 'my-bucket',
-		key: 'my-key',
-	});
-});
-
-test('For stills', () => {
-	const newRenderMetadata: RenderMetadata<MockProvider> = {
-		...testRenderMetadata,
-		codec: null,
-		type: 'still',
-		imageFormat: 'png',
-	};
-	expect(
-		getExpectedOutName({
-			renderMetadata: newRenderMetadata,
-			bucketName,
-			customCredentials: null,
-			bucketNamePrefix: 'remotionlambda-',
-		}),
-	).toEqual({
-		customCredentials: null,
-		renderBucketName: 'remotionlambda-98fsduf',
-		key: 'renders/9n8dsfafs/out.png',
-	});
-});
-
-test('Just a custom name', () => {
-	const newRenderMetadata: RenderMetadata<MockProvider> = {
-		...testRenderMetadata,
-		type: 'still',
-		imageFormat: 'jpeg',
-		codec: null,
-		outName: 'justaname.jpeg',
-	};
-	expect(
-		getExpectedOutName({
-			renderMetadata: newRenderMetadata,
-			bucketName,
-			customCredentials: null,
-			bucketNamePrefix: 'remotionlambda-',
-		}),
-	).toEqual({
-		customCredentials: null,
-		renderBucketName: 'remotionlambda-98fsduf',
-		key: 'renders/9n8dsfafs/justaname.jpeg',
-	});
-});
-
-test('Should throw on invalid names', () => {
-	const newRenderMetadata: RenderMetadata<MockProvider> = {
-		...testRenderMetadata,
-		type: 'still',
-		imageFormat: 'png',
-		codec: null,
-		outName: '👺.jpeg',
-	};
-	expect(() => {
-		getExpectedOutName({
-			renderMetadata: newRenderMetadata,
-			bucketName,
-			customCredentials: null,
-			bucketNamePrefix: 'remotionlambda-',
-		});
-	}).toThrow(/The S3 Key must match the RegExp/);
-});
-
-test('Should allow outName an outname with a slash', () => {
-	const newRenderMetadata: RenderMetadata<MockProvider> = {
-		...testRenderMetadata,
-		codec: null,
-		audioCodec: null,
-		type: 'still',
-		imageFormat: 'jpeg',
-		outName: 'justa/name.jpeg',
-	};
-	expect(
-		getExpectedOutName({
-			renderMetadata: newRenderMetadata,
-			bucketName,
-			customCredentials: null,
-			bucketNamePrefix: 'remotionlambda-',
-		}),
-	).toEqual({
-		customCredentials: null,
-		key: 'renders/9n8dsfafs/justa/name.jpeg',
-		renderBucketName: 'remotionlambda-98fsduf',
-	});
-});
-
-test('Should allow outName an outname with colon', () => {
-	const newRenderMetadata: RenderMetadata<MockProvider> = {
-		...testRenderMetadata,
-		codec: null,
-		audioCodec: null,
-		type: 'still' as const,
-		imageFormat: 'jpeg',
-		outName: 'ap-east-1:xxxxxx/video/XXXXX-0b9ba84XXXX.mp4',
-	};
-	expect(
-		getExpectedOutName({
-			renderMetadata: newRenderMetadata,
-			bucketName,
-			customCredentials: null,
-			bucketNamePrefix: 'remotionlambda-',
-		}),
-	).toEqual({
-		customCredentials: null,
-		key: 'renders/9n8dsfafs/ap-east-1:xxxxxx/video/XXXXX-0b9ba84XXXX.mp4',
-		renderBucketName: 'remotionlambda-98fsduf',
-	});
-});

package/src/test/min-max.test.ts

@@ -1,25 +0,0 @@
-import {describe, expect, test} from 'bun:test';
-import {max, min} from '../min-max';
-describe('min() and max()', () => {
-	test('Implemented min() functions correctly', () => {
-		expect(min([0, -30, 90, -120, 0])).toBe(-120);
-	});
-	test('Implemented max() functions correctly', () => {
-		expect(max([0, -30, 90, -120, 0])).toBe(90);
-	});
-
-	test('min() should throw on empty arr', () => {
-		expect(() => min([])).toThrow(/Array of 0 length/);
-	});
-	test('max() should throw on empty arr', () => {
-		expect(() => min([])).toThrow(/Array of 0 length/);
-	});
-
-	const bigArray = new Array(300000).fill(true).map((_, i) => {
-		return i;
-	});
-
-	test('Custom max() should not throw', () => {
-		expect(max(bigArray)).toBe(299999);
-	});
-});

package/src/test/most-expensive-chunks.test.ts

@@ -1,167 +0,0 @@
-import {expect, test} from 'bun:test';
-import {getMostExpensiveChunks} from '../most-expensive-chunks';
-
-test('Should calculate most expensive chunks', () => {
-	const most = getMostExpensiveChunks({
-		parsedTimings: [
-			{
-				chunk: 0,
-				rendered: 1000,
-				start: 0,
-			},
-			{
-				chunk: 1,
-				rendered: 4000,
-				start: 2000,
-			},
-			{
-				chunk: 2,
-				rendered: 5000,
-				start: 2000,
-			},
-			{
-				chunk: 3,
-				rendered: 3000,
-				start: 2000,
-			},
-			{
-				chunk: 4,
-				rendered: 100000,
-				start: 2000,
-			},
-			{
-				chunk: 5,
-				rendered: 2001,
-				start: 2000,
-			},
-			{
-				chunk: 6,
-				rendered: 2500,
-				start: 2000,
-			},
-		],
-		framesPerFunction: 10,
-		firstFrame: 0,
-		lastFrame: 99,
-	});
-
-	expect(most).toEqual([
-		{timeInMilliseconds: 98000, chunk: 4, frameRange: [40, 49]},
-		{timeInMilliseconds: 3000, chunk: 2, frameRange: [20, 29]},
-		{timeInMilliseconds: 2000, chunk: 1, frameRange: [10, 19]},
-		{timeInMilliseconds: 1000, chunk: 0, frameRange: [0, 9]},
-		{timeInMilliseconds: 1000, chunk: 3, frameRange: [30, 39]},
-	]);
-});
-
-test('Render starting from frame 10 should have correct offset', () => {
-	const framesPerFunction = 10;
-	const firstFrame = 10;
-	const lastFrame = 99;
-	const most = getMostExpensiveChunks({
-		parsedTimings: [
-			{
-				chunk: 0,
-				rendered: 1000,
-				start: 0,
-			},
-			{
-				chunk: 1,
-				rendered: 4000,
-				start: 2000,
-			},
-			{
-				chunk: 2,
-				rendered: 5000,
-				start: 2000,
-			},
-			{
-				chunk: 3,
-				rendered: 3000,
-				start: 2000,
-			},
-			{
-				chunk: 4,
-				rendered: 100000,
-				start: 2000,
-			},
-			{
-				chunk: 5,
-				rendered: 2001,
-				start: 2000,
-			},
-			{
-				chunk: 6,
-				rendered: 2500,
-				start: 2000,
-			},
-		],
-		framesPerFunction,
-		firstFrame,
-		lastFrame,
-	});
-
-	expect(most).toEqual([
-		{timeInMilliseconds: 98000, chunk: 4, frameRange: [50, 59]},
-		{timeInMilliseconds: 3000, chunk: 2, frameRange: [30, 39]},
-		{timeInMilliseconds: 2000, chunk: 1, frameRange: [20, 29]},
-		{timeInMilliseconds: 1000, chunk: 0, frameRange: [10, 19]},
-		{timeInMilliseconds: 1000, chunk: 3, frameRange: [40, 49]},
-	]);
-});
-
-test('Render starting from frame 10 and last chunk in most expensive should be corret', () => {
-	const framesPerFunction = 10;
-	const firstFrame = 10;
-	const lastFrame = 79;
-	const most = getMostExpensiveChunks({
-		parsedTimings: [
-			{
-				chunk: 0,
-				rendered: 1000,
-				start: 0,
-			},
-			{
-				chunk: 1,
-				rendered: 4000,
-				start: 2000,
-			},
-			{
-				chunk: 2,
-				rendered: 5000,
-				start: 2000,
-			},
-			{
-				chunk: 3,
-				rendered: 3000,
-				start: 2000,
-			},
-			{
-				chunk: 4,
-				rendered: 100000,
-				start: 2000,
-			},
-			{
-				chunk: 5,
-				rendered: 2001,
-				start: 2000,
-			},
-			{
-				chunk: 6,
-				rendered: 125000,
-				start: 2000,
-			},
-		],
-		framesPerFunction,
-		firstFrame,
-		lastFrame,
-	});
-
-	expect(most).toEqual([
-		{timeInMilliseconds: 123000, chunk: 6, frameRange: [70, 79]},
-		{timeInMilliseconds: 98000, chunk: 4, frameRange: [50, 59]},
-		{timeInMilliseconds: 3000, chunk: 2, frameRange: [30, 39]},
-		{timeInMilliseconds: 2000, chunk: 1, frameRange: [20, 29]},
-		{timeInMilliseconds: 1000, chunk: 0, frameRange: [10, 19]},
-	]);
-});

package/src/truthy.ts

@@ -1,5 +0,0 @@
-type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T; // from lodash
-
-export function truthy<T>(value: T): value is Truthy<T> {
-	return Boolean(value);
-}

package/src/types.ts

@@ -1,82 +0,0 @@
-import type {ServerlessPayloads, ServerlessRoutines} from './constants';
-
-export interface CloudProvider<
-	Region extends string = string,
-	ReceivedArtifactType extends Record<string, unknown> = Record<
-		string,
-		unknown
-	>,
-	CreateFunctionSpecifics extends Record<string, unknown> = Record<
-		string,
-		unknown
-	>,
-	StorageClass extends string = string,
-	RequestHandler extends object = object,
-> {
-	type: string;
-	region: Region;
-	receivedArtifactType: ReceivedArtifactType;
-	creationFunctionOptions: CreateFunctionSpecifics;
-	storageClass: StorageClass;
-	requestHandler: RequestHandler | null | undefined;
-}
-
-export type ReceivedArtifact<Provider extends CloudProvider> = {
-	filename: string;
-	sizeInBytes: number;
-	s3Url: string;
-	s3Key: string;
-} & Provider['receivedArtifactType'];
-
-export type CostsInfo = {
-	accruedSoFar: number;
-	displayCost: string;
-	currency: string;
-	disclaimer: string;
-};
-
-export type RenderStillFunctionResponsePayload<Provider extends CloudProvider> =
-	{
-		type: 'success';
-		output: string;
-		outKey: string;
-		size: number;
-		bucketName: string;
-		sizeInBytes: number;
-		estimatedPrice: CostsInfo;
-		renderId: string;
-		receivedArtifacts: ReceivedArtifact<Provider>[];
-	};
-
-export type ChunkRetry = {
-	chunk: number;
-	attempt: number;
-	time: number;
-};
-
-export type ParsedTiming = {
-	chunk: number;
-	start: number;
-	rendered: number;
-};
-
-export type CallFunctionOptions<
-	T extends ServerlessRoutines,
-	Provider extends CloudProvider,
-> = {
-	functionName: string;
-	type: T;
-	payload: ServerlessPayloads<Provider>[T];
-	region: Provider['region'];
-	timeoutInTest: number;
-	requestHandler: Provider['requestHandler'] | null;
-};
-
-export type ObjectChunkTimingData = {
-	chunk: number;
-	frameRange: [number, number];
-	startDate: number;
-	timings: {
-		[key: number]: number;
-	};
-};

package/src/validate-bucket-name.ts

@@ -1,34 +0,0 @@
-export const validateBucketName = ({
-	bucketName,
-	bucketNamePrefix,
-	options,
-}: {
-	bucketName: unknown;
-	bucketNamePrefix: string;
-	options: {
-		mustStartWithRemotion: boolean;
-	};
-}) => {
-	if (typeof bucketName !== 'string') {
-		throw new TypeError(
-			`'bucketName' must be a string, but is ${JSON.stringify(bucketName)}`,
-		);
-	}
-
-	if (
-		options.mustStartWithRemotion &&
-		!bucketName.startsWith(bucketNamePrefix)
-	) {
-		throw new Error(
-			`The bucketName parameter must start with ${bucketNamePrefix}.`,
-		);
-	}
-
-	if (
-		!bucketName.match(
-			/^(?=^.{3,63}$)(?!^(\d+\.)+\d+$)(^(([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])\.)*([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])$)/,
-		)
-	) {
-		throw new Error(`The bucket ${bucketName} `);
-	}
-};

package/src/validate-download-behavior.ts

@@ -1,26 +0,0 @@
-import type {DownloadBehavior} from 'remotion/no-react';
-
-export const validateDownloadBehavior = (downloadBehavior: unknown) => {
-	if (downloadBehavior === null || downloadBehavior === undefined) {
-		return null;
-	}
-
-	if (typeof downloadBehavior !== 'object') {
-		throw new Error('downloadBehavior must be null or an object');
-	}
-
-	const behavior = downloadBehavior as DownloadBehavior;
-	if (behavior.type !== 'download' && behavior.type !== 'play-in-browser') {
-		throw new Error(
-			'Download behavior must be either "download" or "play-in-browser"',
-		);
-	}
-
-	if (behavior.type === 'download') {
-		if (typeof behavior.fileName !== 'string' && behavior.fileName !== null) {
-			throw new Error(
-				'If "downloadBehavior.type" is "download", then fileName must be "null" or a string',
-			);
-		}
-	}
-};

package/src/validate-frames-per-function.ts

@@ -1,125 +0,0 @@
-import {bestFramesPerFunctionParam} from './best-frames-per-function-param';
-import {
-	MAX_FUNCTIONS_PER_RENDER,
-	MINIMUM_FRAMES_PER_FUNCTION,
-} from './constants';
-
-export const validateFramesPerFunction = ({
-	framesPerFunction,
-	durationInFrames,
-	concurrency,
-}: {
-	framesPerFunction: number | null;
-	durationInFrames: number;
-	concurrency: number | null;
-}): number => {
-	if (concurrency !== null && framesPerFunction !== null) {
-		throw new TypeError(
-			`Both 'framesPerLambda' and 'concurrency' were set. Please use only one of them.`,
-		);
-	}
-
-	const effectiveMinimum = Math.min(
-		MINIMUM_FRAMES_PER_FUNCTION,
-		durationInFrames,
-	);
-
-	if (concurrency !== null) {
-		// Validate concurrency is a number
-		if (typeof concurrency !== 'number') {
-			throw new TypeError(
-				`'concurrency' needs to be a number, passed ${JSON.stringify(
-					concurrency,
-				)}`,
-			);
-		}
-
-		// Validate concurrency is finite
-		if (!Number.isFinite(concurrency)) {
-			throw new TypeError(
-				`'concurrency' needs to be finite, passed ${concurrency}`,
-			);
-		}
-
-		// Validate concurrency is not NaN
-		if (Number.isNaN(concurrency)) {
-			throw new TypeError(
-				`'concurrency' needs to be a valid number, passed ${concurrency}`,
-			);
-		}
-
-		// Validate concurrency is an integer
-		if (concurrency % 1 !== 0) {
-			throw new TypeError(
-				`'concurrency' needs to be an integer, passed ${concurrency}`,
-			);
-		}
-
-		// Validate concurrency is positive
-		if (concurrency <= 0) {
-			throw new TypeError(
-				`'concurrency' needs to be positive, passed ${concurrency}`,
-			);
-		}
-
-		// Validate concurrency doesn't exceed maximum
-		if (concurrency > MAX_FUNCTIONS_PER_RENDER) {
-			throw new TypeError(
-				`'concurrency' cannot exceed ${MAX_FUNCTIONS_PER_RENDER}, passed ${concurrency}`,
-			);
-		}
-
-		return Math.max(
-			Math.ceil(durationInFrames / concurrency),
-			effectiveMinimum,
-		);
-	}
-
-	if (framesPerFunction === null) {
-		return Math.max(
-			bestFramesPerFunctionParam(durationInFrames),
-			effectiveMinimum,
-		);
-	}
-
-	if (framesPerFunction === undefined) {
-		return Math.max(
-			bestFramesPerFunctionParam(durationInFrames),
-			effectiveMinimum,
-		);
-	}
-
-	if (typeof framesPerFunction !== 'number') {
-		throw new TypeError(
-			`'framesPerLambda' needs to be a number, passed ${JSON.stringify(
-				framesPerFunction,
-			)}`,
-		);
-	}
-
-	if (!Number.isFinite(framesPerFunction)) {
-		throw new TypeError(
-			`'framesPerLambda' needs to be finite, passed ${framesPerFunction}`,
-		);
-	}
-
-	if (Number.isNaN(framesPerFunction)) {
-		throw new TypeError(
-			`'framesPerLambda' needs to be NaN, passed ${framesPerFunction}`,
-		);
-	}
-
-	if (framesPerFunction % 1 !== 0) {
-		throw new TypeError(
-			`'framesPerLambda' needs to be an integer, passed ${framesPerFunction}`,
-		);
-	}
-
-	if (framesPerFunction < effectiveMinimum) {
-		throw new TypeError(
-			`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerFunction}`,
-		);
-	}
-
-	return framesPerFunction;
-};