@remotion/lambda 4.0.0-webhook.27 → 4.1.0-alpha3

package/dist/functions/helpers/make-timeout-error.d.ts

@@ -0,0 +1,8 @@
+import type { _Object } from '@aws-sdk/client-s3';
+import type { RenderMetadata } from '../../defaults';
+import type { EnhancedErrorInfo } from './write-lambda-error';
+export declare const makeTimeoutError: ({ timeoutInMilliseconds, chunks, renderMetadata, }: {
+    timeoutInMilliseconds: number;
+    chunks: _Object[];
+    renderMetadata: RenderMetadata;
+}) => EnhancedErrorInfo;

package/dist/functions/helpers/make-timeout-error.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTimeoutError = void 0;
+const parse_chunk_key_1 = require("../../shared/parse-chunk-key");
+const make_timeout_message_1 = require("./make-timeout-message");
+const makeTimeoutError = ({ timeoutInMilliseconds, chunks, renderMetadata, }) => {
+    const availableChunks = chunks.map((c) => (0, parse_chunk_key_1.parseLambdaChunkKey)(c.Key));
+    const missingChunks = new Array(renderMetadata.totalChunks)
+        .fill(true)
+        .filter((_, i) => {
+        return !availableChunks.find((c) => c.chunk === i);
+    })
+        .map((_, i) => i);
+    const message = (0, make_timeout_message_1.makeTimeoutMessage)({
+        missingChunks,
+        renderMetadata,
+        timeoutInMilliseconds,
+    });
+    return {
+        attempt: 1,
+        chunk: null,
+        explanation: message,
+        frame: null,
+        isFatal: true,
+        s3Location: '',
+        stack: new Error().stack,
+        tmpDir: null,
+        totalAttempts: 1,
+        type: 'stitcher',
+        willRetry: false,
+        message,
+        name: 'TimeoutError',
+    };
+};
+exports.makeTimeoutError = makeTimeoutError;

package/dist/functions/helpers/make-timeout-message.d.ts

@@ -0,0 +1,6 @@
+import type { RenderMetadata } from '../../defaults';
+export declare const makeTimeoutMessage: ({ timeoutInMilliseconds, missingChunks, renderMetadata, }: {
+    timeoutInMilliseconds: number;
+    missingChunks: number[];
+    renderMetadata: RenderMetadata;
+}) => string;

package/dist/functions/helpers/make-timeout-message.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTimeoutMessage = void 0;
+const docs_url_1 = require("../../shared/docs-url");
+const makeChunkMissingMessage = ({ missingChunks, renderMetadata, }) => {
+    const missingChunksMessageList = missingChunks
+        .map((ch) => {
+        const isLastChunk = ch === renderMetadata.totalChunks - 1;
+        const start = ch * renderMetadata.framesPerLambda;
+        const end = isLastChunk
+            ? renderMetadata.frameRange[1]
+            : (ch + 1) * renderMetadata.framesPerLambda - 1;
+        return `Chunk ${ch} (Frames ${start} - ${end})`;
+    })
+        .slice(0, 5);
+    if (missingChunksMessageList.length === 0) {
+        return 'All chunks have been successfully rendered, but the main function has timed out.';
+    }
+    return `The following chunks are missing (showing ${missingChunksMessageList.length} out of ${missingChunks.length}): ${missingChunksMessageList.join(', ')}.`;
+};
+const makeTimeoutMessage = ({ timeoutInMilliseconds, missingChunks, renderMetadata, }) => {
+    const message = [
+        `The main function timed out after ${timeoutInMilliseconds}ms.`,
+        `Consider increasing the timeout of your function.`,
+        makeChunkMissingMessage({ missingChunks, renderMetadata }),
+        `You can use the "--timeout" parameter when deploying a function via CLI, or the "timeoutInSeconds" parameter when using the deployFunction() API.`,
+        `${docs_url_1.DOCS_URL}/docs/lambda/cli/functions#deploy`,
+    ].join('\n');
+    return message;
+};
+exports.makeTimeoutMessage = makeTimeoutMessage;

package/dist/functions/helpers/read-with-progress.d.ts

@@ -1,6 +1,6 @@
 import type { AwsRegion } from '../../pricing/aws-regions';
 import type { CustomCredentials } from '../../shared/aws-clients';
-export declare type LambdaReadFileProgress = (progress: {
+export type LambdaReadFileProgress = (progress: {
     totalSize: number;
     downloaded: number;
     percent: number;

package/dist/functions/helpers/read-with-progress.js

@@ -9,7 +9,7 @@ const lambdaDownloadFileWithProgress = async ({ bucketName, key, region, expecte
     const client = (0, aws_clients_1.getS3Client)(region, customCredentials);
     const command = new client_s3_1.GetObjectCommand({
         Bucket: bucketName,
-        ExpectedBucketOwner: expectedBucketOwner,
+        ExpectedBucketOwner: customCredentials ? undefined : expectedBucketOwner,
         Key: key,
     });
     const presigned = await (0, s3_request_presigner_1.getSignedUrl)(client, command);

package/dist/functions/helpers/streamify-response.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { Stream } from 'stream';
+export declare class ResponseStream extends Stream.Writable {
+    private response;
+    _contentType?: string;
+    _isBase64Encoded?: boolean;
+    constructor();
+    _write(chunk: string, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    getBufferedData(): Buffer;
+    setContentType(contentType: string): void;
+    setIsBase64Encoded(isBase64Encoded: boolean): void;
+}
+export declare const HANDLER_STREAMING: unique symbol;
+export declare const STREAM_RESPONSE = "response";
+export declare function isInAWS(handler: Function): boolean;
+export declare function streamifyResponse(handler: Function): Function;

package/dist/functions/helpers/streamify-response.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamifyResponse = exports.isInAWS = exports.STREAM_RESPONSE = exports.HANDLER_STREAMING = exports.ResponseStream = void 0;
+const stream_1 = require("stream");
+class ResponseStream extends stream_1.Stream.Writable {
+    constructor() {
+        super();
+        this.response = [];
+    }
+    _write(chunk, encoding, callback) {
+        this.response.push(Buffer.from(chunk, encoding));
+        callback();
+    }
+    getBufferedData() {
+        return Buffer.concat(this.response);
+    }
+    setContentType(contentType) {
+        this._contentType = contentType;
+    }
+    setIsBase64Encoded(isBase64Encoded) {
+        this._isBase64Encoded = isBase64Encoded;
+    }
+}
+exports.ResponseStream = ResponseStream;
+exports.HANDLER_STREAMING = Symbol.for('aws.lambda.runtime.handler.streaming');
+exports.STREAM_RESPONSE = 'response';
+function isInAWS(handler) {
+    return (
+    // @ts-expect-error
+    handler[exports.HANDLER_STREAMING] !== undefined &&
+        // @ts-expect-error
+        handler[exports.HANDLER_STREAMING] === exports.STREAM_RESPONSE);
+}
+exports.isInAWS = isInAWS;
+function streamifyResponse(handler) {
+    // Check for global awslambda
+    if (isInAWS(handler)) {
+        // @ts-expect-error
+        return awslambda.streamifyResponse(handler);
+    }
+    return new Proxy(handler, {
+        async apply(target, _, argList) {
+            const responseStream = patchArgs(argList);
+            await target(...argList);
+            return {
+                statusCode: 200,
+                headers: {
+                    'content-type': responseStream._contentType || 'application/json',
+                },
+                ...(responseStream._isBase64Encoded
+                    ? { isBase64Encoded: responseStream._isBase64Encoded }
+                    : {}),
+                body: responseStream._isBase64Encoded
+                    ? responseStream.getBufferedData().toString('base64')
+                    : responseStream.getBufferedData().toString(),
+            };
+        },
+    });
+}
+exports.streamifyResponse = streamifyResponse;
+function patchArgs(argList) {
+    if (!(argList[1] instanceof ResponseStream)) {
+        const responseStream = new ResponseStream();
+        argList.splice(1, 0, responseStream);
+    }
+    return argList[1];
+}

package/dist/functions/helpers/validate-composition.d.ts

@@ -1,18 +1,19 @@
-import type { ChromiumOptions, DownloadMap, FfmpegExecutable, openBrowser } from '@remotion/renderer';
-import type { TCompMetadata } from 'remotion';
+import type { ChromiumOptions, LogLevel, openBrowser, RemotionServer } from '@remotion/renderer';
+import type { AnyCompMetadata } from 'remotion';
 import type { Await } from '../../shared/await';
-declare type ValidateCompositionOptions = {
+type ValidateCompositionOptions = {
     serveUrl: string;
     composition: string;
     browserInstance: Await<ReturnType<typeof openBrowser>>;
-    inputProps: unknown;
-    envVariables: Record<string, string> | undefined;
-    ffmpegExecutable: FfmpegExecutable;
-    ffprobeExecutable: FfmpegExecutable;
+    inputProps: Record<string, unknown>;
+    envVariables: Record<string, string>;
     timeoutInMilliseconds: number;
     chromiumOptions: ChromiumOptions;
     port: number | null;
-    downloadMap: DownloadMap;
+    forceHeight: number | null;
+    forceWidth: number | null;
+    logLevel: LogLevel;
+    server: RemotionServer | undefined;
 };
-export declare const validateComposition: ({ serveUrl, composition, browserInstance, inputProps, envVariables, timeoutInMilliseconds, ffmpegExecutable, ffprobeExecutable, chromiumOptions, port, downloadMap, }: ValidateCompositionOptions) => Promise<TCompMetadata>;
+export declare const validateComposition: ({ serveUrl, composition, browserInstance, inputProps, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, }: ValidateCompositionOptions) => Promise<AnyCompMetadata>;
 export {};

package/dist/functions/helpers/validate-composition.js

@@ -2,24 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateComposition = void 0;
 const renderer_1 = require("@remotion/renderer");
-const validateComposition = async ({ serveUrl, composition, browserInstance, inputProps, envVariables, timeoutInMilliseconds, ffmpegExecutable, ffprobeExecutable, chromiumOptions, port, downloadMap, }) => {
-    const compositions = await (0, renderer_1.getCompositions)(serveUrl, {
+const get_chromium_executable_path_1 = require("./get-chromium-executable-path");
+const validateComposition = async ({ serveUrl, composition, browserInstance, inputProps, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, }) => {
+    const comp = await renderer_1.RenderInternals.internalSelectComposition({
+        id: composition,
         puppeteerInstance: browserInstance,
-        inputProps: inputProps,
+        inputProps,
         envVariables,
-        ffmpegExecutable,
-        ffprobeExecutable,
         timeoutInMilliseconds,
         chromiumOptions,
         port,
-        downloadMap,
+        browserExecutable: (0, get_chromium_executable_path_1.executablePath)(),
+        serveUrl,
+        logLevel,
+        indent: false,
+        onBrowserLog: null,
+        server,
     });
-    const found = compositions.find((c) => c.id === composition);
-    if (!found) {
-        throw new Error(`No composition with ID ${composition} found. Available compositions: ${compositions
-            .map((c) => c.id)
-            .join(', ')}`);
-    }
-    return found;
+    return {
+        ...comp,
+        height: forceHeight !== null && forceHeight !== void 0 ? forceHeight : comp.height,
+        width: forceWidth !== null && forceWidth !== void 0 ? forceWidth : comp.width,
+    };
 };
 exports.validateComposition = validateComposition;

package/dist/functions/helpers/write-lambda-error.d.ts

@@ -1,5 +1,5 @@
 import type { FileNameAndSize } from './get-files-in-folder';
-export declare type LambdaErrorInfo = {
+export type LambdaErrorInfo = {
     type: 'renderer' | 'browser' | 'stitcher' | 'webhook';
     message: string;
     name: string;
@@ -16,7 +16,7 @@ export declare type LambdaErrorInfo = {
     } | null;
 };
 export declare const getTmpDirStateIfENoSp: (err: string) => LambdaErrorInfo['tmpDir'];
-export declare type EnhancedErrorInfo = LambdaErrorInfo & {
+export type EnhancedErrorInfo = LambdaErrorInfo & {
     s3Location: string;
     explanation: string | null;
 };

package/dist/functions/index.d.ts

@@ -1,7 +1 @@
-import type { LambdaPayload } from '../shared/constants';
-import { LambdaRoutines } from '../shared/constants';
-import type { LambdaReturnValues } from '../shared/return-values';
-export declare const handler: <T extends LambdaRoutines>(params: LambdaPayload, context: {
-    invokedFunctionArn: string;
-    getRemainingTimeInMillis: () => number;
-}) => Promise<LambdaReturnValues[T]>;
+export declare const handler: Function;

package/dist/functions/index.js

@@ -3,19 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handler = void 0;
 const renderer_1 = require("@remotion/renderer");
 const constants_1 = require("../shared/constants");
+const compositions_1 = require("./compositions");
 const clean_tmpdir_1 = require("./helpers/clean-tmpdir");
 const is_warm_1 = require("./helpers/is-warm");
 const print_cloudwatch_helper_1 = require("./helpers/print-cloudwatch-helper");
+const streamify_response_1 = require("./helpers/streamify-response");
 const info_1 = require("./info");
 const launch_1 = require("./launch");
 const progress_1 = require("./progress");
 const renderer_2 = require("./renderer");
 const start_1 = require("./start");
 const still_1 = require("./still");
-const handler = async (params, context) => {
+exports.handler = (0, streamify_response_1.streamifyResponse)(async (params, responseStream, context) => {
     process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
     const timeoutInMilliseconds = context.getRemainingTimeInMillis();
-    if (!context || !context.invokedFunctionArn) {
+    if (!(context === null || context === void 0 ? void 0 : context.invokedFunctionArn)) {
         throw new Error('Lambda function unexpectedly does not have context.invokedFunctionArn');
     }
     (0, clean_tmpdir_1.deleteTmpDir)();
@@ -27,16 +29,24 @@ const handler = async (params, context) => {
             inputProps: JSON.stringify(params.inputProps),
             isWarm,
         });
-        return (0, still_1.stillHandler)(params, {
+        const response = await (0, still_1.stillHandler)(params, {
             expectedBucketOwner: currentUserId,
         });
+        responseStream.write(JSON.stringify(response));
+        responseStream.end();
+        return;
     }
     if (params.type === constants_1.LambdaRoutines.start) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.start, {
             inputProps: JSON.stringify(params.inputProps),
             isWarm,
         });
-        return (0, start_1.startHandler)(params, { expectedBucketOwner: currentUserId });
+        const response = await (0, start_1.startHandler)(params, {
+            expectedBucketOwner: currentUserId,
+        });
+        responseStream.write(JSON.stringify(response));
+        responseStream.end();
+        return;
     }
     if (params.type === constants_1.LambdaRoutines.launch) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.launch, {
@@ -44,17 +54,25 @@ const handler = async (params, context) => {
             inputProps: JSON.stringify(params.inputProps),
             isWarm,
         });
-        return (0, launch_1.launchHandler)(params, { expectedBucketOwner: currentUserId });
+        await (0, launch_1.launchHandler)(params, {
+            expectedBucketOwner: currentUserId,
+            getRemainingTimeInMillis: context.getRemainingTimeInMillis,
+        });
+        responseStream.end();
+        return;
     }
     if (params.type === constants_1.LambdaRoutines.status) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.status, {
             renderId: params.renderId,
             isWarm,
         });
-        return (0, progress_1.progressHandler)(params, {
+        const response = await (0, progress_1.progressHandler)(params, {
             expectedBucketOwner: currentUserId,
             timeoutInMilliseconds,
         });
+        responseStream.write(JSON.stringify(response));
+        responseStream.end();
+        return;
     }
     if (params.type === constants_1.LambdaRoutines.renderer) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.renderer, {
@@ -64,17 +82,32 @@ const handler = async (params, context) => {
             inputProps: JSON.stringify(params.inputProps),
             isWarm,
         });
-        return (0, renderer_2.rendererHandler)(params, {
+        await (0, renderer_2.rendererHandler)(params, {
             expectedBucketOwner: currentUserId,
             isWarm,
         });
+        responseStream.end();
+        return;
     }
     if (params.type === constants_1.LambdaRoutines.info) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.info, {
             isWarm,
         });
-        return (0, info_1.infoHandler)(params);
+        const response = await (0, info_1.infoHandler)(params);
+        responseStream.write(JSON.stringify(response));
+        responseStream.end();
+        return;
+    }
+    if (params.type === constants_1.LambdaRoutines.compositions) {
+        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.compositions, {
+            isWarm,
+        });
+        const response = await (0, compositions_1.compositionsHandler)(params, {
+            expectedBucketOwner: currentUserId,
+        });
+        responseStream.write(JSON.stringify(response));
+        responseStream.end();
+        return;
     }
     throw new Error(constants_1.COMMAND_NOT_FOUND);
-};
-exports.handler = handler;
+});

package/dist/functions/launch.d.ts

@@ -1,6 +1,7 @@
 import type { LambdaPayload } from '../shared/constants';
-declare type Options = {
+type Options = {
     expectedBucketOwner: string;
+    getRemainingTimeInMillis: () => number;
 };
 export declare const launchHandler: (params: LambdaPayload, options: Options) => Promise<void>;
 export {};