@remotion/serverless-client 4.0.261

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

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,77 @@
+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
+	>,
+> {
+	type: string;
+	region: Region;
+	receivedArtifactType: ReceivedArtifactType;
+	creationFunctionOptions: CreateFunctionSpecifics;
+}
+
+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;
+};
+
+export type ObjectChunkTimingData = {
+	chunk: number;
+	frameRange: [number, number];
+	startDate: number;
+	timings: {
+		[key: number]: number;
+	};
+};

package/src/validate-bucket-name.ts

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,26 @@
+import type {DownloadBehavior} from './constants';
+
+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

@@ -0,0 +1,54 @@
+import {MINIMUM_FRAMES_PER_FUNCTIONS} from './constants';
+
+export const validateFramesPerFunction = ({
+	framesPerFunction,
+	durationInFrames,
+}: {
+	framesPerFunction: unknown;
+	durationInFrames: number;
+}) => {
+	if (framesPerFunction === null) {
+		return;
+	}
+
+	if (framesPerFunction === undefined) {
+		return;
+	}
+
+	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}`,
+		);
+	}
+
+	const effectiveMinimum = Math.min(
+		MINIMUM_FRAMES_PER_FUNCTIONS,
+		durationInFrames,
+	);
+
+	if (framesPerFunction < effectiveMinimum) {
+		throw new TypeError(
+			`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerFunction}`,
+		);
+	}
+};

package/src/validate-outname.ts

@@ -0,0 +1,63 @@
+import type {AudioCodec, Codec} from '@remotion/renderer';
+import {NoReactAPIs} from '@remotion/renderer/pure';
+import type {OutNameInputWithoutCredentials} from './constants';
+import {validateBucketName} from './validate-bucket-name';
+
+const validateS3Key = (s3Key: string) => {
+	if (typeof s3Key !== 'string') {
+		throw new TypeError(
+			'The S3 key must be a string. Passed an object of type ' + typeof s3Key,
+		);
+	}
+
+	// https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html
+	if (!s3Key.match(/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g)) {
+		throw new Error(
+			"The S3 Key must match the RegExp `/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g`. You passed: " +
+				s3Key +
+				'. Check for invalid characters.',
+		);
+	}
+};
+
+export const validateOutname = ({
+	outName,
+	codec,
+	audioCodecSetting,
+	separateAudioTo,
+	bucketNamePrefix,
+}: {
+	outName: OutNameInputWithoutCredentials | undefined | null;
+	codec: Codec | null;
+	audioCodecSetting: AudioCodec | null;
+	separateAudioTo: string | null;
+	bucketNamePrefix: string;
+}) => {
+	if (typeof outName === 'undefined' || outName === null) {
+		return;
+	}
+
+	if (typeof outName !== 'string') {
+		validateS3Key(outName.key);
+		validateBucketName({
+			bucketName: outName.bucketName,
+			bucketNamePrefix,
+			options: {
+				mustStartWithRemotion: false,
+			},
+		});
+		return;
+	}
+
+	if (codec) {
+		NoReactAPIs.validateOutputFilename({
+			codec,
+			audioCodecSetting,
+			extension: NoReactAPIs.getExtensionOfFilename(outName) as string,
+			preferLossless: false,
+			separateAudioTo,
+		});
+	}
+
+	validateS3Key(outName);
+};

package/src/validate-privacy.ts

@@ -0,0 +1,20 @@
+import type {Privacy} from './constants';
+
+export function validatePrivacy(
+	privacy: unknown,
+	allowPrivate: boolean,
+): asserts privacy is Privacy {
+	if (typeof privacy !== 'string') {
+		throw new TypeError('Privacy must be a string');
+	}
+
+	if (!allowPrivate && privacy === 'private') {
+		throw new TypeError('Privacy must be either "public" or "no-acl"');
+	}
+
+	if (privacy !== 'private' && privacy !== 'public' && privacy !== 'no-acl') {
+		throw new TypeError(
+			'Privacy must be either "private", "public" or "no-acl"',
+		);
+	}
+}

package/src/validate-webhook.ts

@@ -0,0 +1,18 @@
+import type {WebhookOption} from './constants';
+
+export const MAX_WEBHOOK_CUSTOM_DATA_SIZE = 1024;
+
+export const validateWebhook = (webhook?: WebhookOption | null) => {
+	if (typeof webhook === 'undefined' || webhook === null) {
+		return;
+	}
+
+	if (webhook.customData) {
+		const size = JSON.stringify(webhook.customData).length;
+		if (size > MAX_WEBHOOK_CUSTOM_DATA_SIZE) {
+			throw new Error(
+				`Webhook "customData" must be less than ${MAX_WEBHOOK_CUSTOM_DATA_SIZE} bytes. Current size: ${size} bytes.`,
+			);
+		}
+	}
+};

package/src/webhook-types.ts

@@ -0,0 +1,36 @@
+import type {AfterRenderCost} from './constants';
+import type {EnhancedErrorInfo} from './write-error-to-storage';
+
+type StaticWebhookPayload = {
+	renderId: string;
+	expectedBucketOwner: string;
+	bucketName: string;
+	customData: Record<string, unknown> | null;
+};
+
+export type WebhookErrorPayload = StaticWebhookPayload & {
+	type: 'error';
+	errors: {
+		message: string;
+		name: string;
+		stack: string;
+	}[];
+};
+
+export type WebhookSuccessPayload = StaticWebhookPayload & {
+	type: 'success';
+	lambdaErrors: EnhancedErrorInfo[];
+	outputUrl: string | undefined;
+	outputFile: string | undefined;
+	timeToFinish: number | undefined;
+	costs: AfterRenderCost;
+};
+
+export type WebhookTimeoutPayload = StaticWebhookPayload & {
+	type: 'timeout';
+};
+
+export type WebhookPayload =
+	| WebhookErrorPayload
+	| WebhookSuccessPayload
+	| WebhookTimeoutPayload;

package/src/write-error-to-storage.ts

@@ -0,0 +1,23 @@
+import type {FileNameAndSize} from './get-files-in-folder';
+
+export type FunctionErrorInfo = {
+	type: 'renderer' | 'browser' | 'stitcher' | 'webhook' | 'artifact';
+	message: string;
+	name: string;
+	stack: string;
+	frame: number | null;
+	chunk: number | null;
+	isFatal: boolean;
+	attempt: number;
+	willRetry: boolean;
+	totalAttempts: number;
+	tmpDir: {files: FileNameAndSize[]; total: number} | null;
+};
+
+export type EnhancedErrorInfo = FunctionErrorInfo & {
+	/**
+	 * @deprecated Will always be an empty string.
+	 */
+	s3Location: string;
+	explanation: string | null;
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"composite": true,
+		"rootDir": "./src",
+		"outDir": "dist",
+		"skipLibCheck": true
+	},
+	"include": ["src"],
+	"references": [
+		{
+			"path": "../licensing"
+		},
+		{
+			"path": "../streaming"
+		}
+	]
+}