@remotion/lambda 4.0.163 → 4.0.165

package/dist/functions/helpers/write-lambda-error.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeLambdaError = exports.getTmpDirStateIfENoSp = void 0;
-const constants_1 = require("../../shared/constants");
-const get_current_region_1 = require("./get-current-region");
+exports.getTmpDirStateIfENoSp = void 0;
 const get_files_in_folder_1 = require("./get-files-in-folder");
-const io_1 = require("./io");
 const is_enosp_err_1 = require("./is-enosp-err");
 const getTmpDirStateIfENoSp = (err) => {
     if (!(0, is_enosp_err_1.errorIsOutOfSpaceError)(err)) {
@@ -21,20 +18,3 @@ const getTmpDirStateIfENoSp = (err) => {
     };
 };
 exports.getTmpDirStateIfENoSp = getTmpDirStateIfENoSp;
-const writeLambdaError = async ({ bucketName, renderId, errorInfo, expectedBucketOwner, }) => {
-    await (0, io_1.lambdaWriteFile)({
-        bucketName,
-        key: `${(0, constants_1.getErrorFileName)({
-            renderId,
-            chunk: errorInfo.chunk,
-            attempt: errorInfo.attempt,
-        })}.txt`,
-        body: JSON.stringify(errorInfo),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        privacy: 'private',
-        expectedBucketOwner,
-        downloadBehavior: null,
-        customCredentials: null,
-    });
-};
-exports.writeLambdaError = writeLambdaError;

package/dist/functions/index.d.ts

@@ -1 +1,6 @@
+export type OrError<T> = T | {
+    type: 'error';
+    message: string;
+    stack: string;
+};
 export declare const handler: Function;

package/dist/functions/index.js

@@ -10,15 +10,15 @@ const leak_detection_1 = require("./helpers/leak-detection");
 const lifecycle_1 = require("./helpers/lifecycle");
 const print_cloudwatch_helper_1 = require("./helpers/print-cloudwatch-helper");
 const streamify_response_1 = require("./helpers/streamify-response");
-const streaming_payloads_1 = require("./helpers/streaming-payloads");
 const info_1 = require("./info");
 const launch_1 = require("./launch");
-const merge_1 = require("./merge");
 const progress_1 = require("./progress");
 const renderer_2 = require("./renderer");
 const start_1 = require("./start");
 const still_1 = require("./still");
-const innerHandler = async (params, responseStream, context) => {
+const stream_writer_1 = require("./streaming/stream-writer");
+const streaming_1 = require("./streaming/streaming");
+const innerHandler = async ({ params, responseWriter, context, }) => {
     (0, leak_detection_1.setCurrentRequestId)(context.awsRequestId);
     process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
     const timeoutInMilliseconds = context.getRemainingTimeInMillis();
@@ -39,19 +39,36 @@ const innerHandler = async (params, responseStream, context) => {
             inputProps: JSON.stringify(params.inputProps),
             isWarm,
         }, params.logLevel);
-        const renderIdDetermined = {
-            type: 'render-id-determined',
-            renderId,
-        };
-        (0, streaming_payloads_1.sendProgressEvent)(responseStream, renderIdDetermined);
-        const response = await (0, still_1.stillHandler)({
-            expectedBucketOwner: currentUserId,
-            params,
-            renderId,
-        });
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
+        await new Promise((resolve, reject) => {
+            const onStream = (payload) => {
+                const message = (0, streaming_1.makeStreamPayload)({
+                    message: payload,
+                });
+                responseWriter.write(message).catch((err) => {
+                    reject(err);
+                });
+            };
+            if (params.streamed) {
+                onStream({
+                    type: 'render-id-determined',
+                    payload: { renderId },
+                });
+            }
+            (0, still_1.stillHandler)({
+                expectedBucketOwner: currentUserId,
+                params,
+                renderId,
+                onStream,
+                timeoutInMilliseconds,
+            })
+                .then((r) => {
+                resolve(r);
+            })
+                .catch((err) => {
+                reject(err);
+            });
         });
+        await responseWriter.end();
         return;
     }
     if (params.type === constants_1.LambdaRoutines.start) {
@@ -61,10 +78,10 @@ const innerHandler = async (params, responseStream, context) => {
         }, params.logLevel);
         const response = await (0, start_1.startHandler)(params, {
             expectedBucketOwner: currentUserId,
+            timeoutInMilliseconds,
         });
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
-        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
         return;
     }
     if (params.type === constants_1.LambdaRoutines.launch) {
@@ -77,9 +94,8 @@ const innerHandler = async (params, responseStream, context) => {
             expectedBucketOwner: currentUserId,
             getRemainingTimeInMillis: context.getRemainingTimeInMillis,
         });
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
-        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
         return;
     }
     if (params.type === constants_1.LambdaRoutines.status) {
@@ -92,9 +108,8 @@ const innerHandler = async (params, responseStream, context) => {
             timeoutInMilliseconds,
             retriesRemaining: 2,
         });
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
-        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
         return;
     }
     if (params.type === constants_1.LambdaRoutines.renderer) {
@@ -105,13 +120,26 @@ const innerHandler = async (params, responseStream, context) => {
             resolvedProps: JSON.stringify(params.resolvedProps),
             isWarm,
         }, params.logLevel);
-        const response = await (0, renderer_2.rendererHandler)(params, {
-            expectedBucketOwner: currentUserId,
-            isWarm,
-        }, context);
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
+        await new Promise((resolve, reject) => {
+            (0, renderer_2.rendererHandler)(params, {
+                expectedBucketOwner: currentUserId,
+                isWarm,
+            }, (payload) => {
+                const message = (0, streaming_1.makeStreamPayload)({
+                    message: payload,
+                });
+                responseWriter.write(message).catch((err) => {
+                    reject(err);
+                });
+            }, context)
+                .then((res) => {
+                resolve(res);
+            })
+                .catch((err) => {
+                reject(err);
+            });
         });
+        await responseWriter.end();
         return;
     }
     if (params.type === constants_1.LambdaRoutines.info) {
@@ -119,23 +147,10 @@ const innerHandler = async (params, responseStream, context) => {
             isWarm,
         }, params.logLevel);
         const response = await (0, info_1.infoHandler)(params);
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
-        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.merge) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.merge, {
-            renderId: params.renderId,
-            isWarm,
-        }, params.logLevel);
-        const response = await (0, merge_1.mergeHandler)(params, {
-            expectedBucketOwner: currentUserId,
-        });
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
-        });
-    }
     if (params.type === constants_1.LambdaRoutines.compositions) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.compositions, {
             isWarm,
@@ -143,16 +158,20 @@ const innerHandler = async (params, responseStream, context) => {
         const response = await (0, compositions_1.compositionsHandler)(params, {
             expectedBucketOwner: currentUserId,
         });
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
-        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
         return;
     }
     throw new Error(constants_1.COMMAND_NOT_FOUND);
 };
 const routine = async (params, responseStream, context) => {
+    const responseWriter = (0, stream_writer_1.streamWriter)(responseStream);
     try {
-        await innerHandler(params, responseStream, context);
+        await innerHandler({
+            params,
+            responseWriter,
+            context,
+        });
     }
     catch (err) {
         const res = {
@@ -160,8 +179,8 @@ const routine = async (params, responseStream, context) => {
             message: err.message,
             stack: err.stack,
         };
-        responseStream.write(JSON.stringify(res));
-        responseStream.end();
+        await responseWriter.write(Buffer.from(JSON.stringify(res)));
+        await responseWriter.end();
     }
 };
 exports.handler = (0, streamify_response_1.streamifyResponse)(routine);