@remotion/lambda 3.3.94 → 3.3.96

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/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

@@ -7,13 +7,14 @@ 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) {
@@ -28,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, {
@@ -45,20 +54,25 @@ const handler = async (params, context) => {
             inputProps: JSON.stringify(params.inputProps),
             isWarm,
         });
-        return (0, launch_1.launchHandler)(params, {
+        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, {
@@ -68,25 +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,
         });
-        return (0, compositions_1.compositionsHandler)(params, {
+        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/shared/call-lambda.js

@@ -5,30 +5,44 @@ const client_lambda_1 = require("@aws-sdk/client-lambda");
 const aws_clients_1 = require("./aws-clients");
 const callLambda = async ({ functionName, type, payload, region, }) => {
     var _a;
-    const res = await (0, aws_clients_1.getLambdaClient)(region).send(new client_lambda_1.InvokeCommand({
+    const res = await (0, aws_clients_1.getLambdaClient)(region).send(new client_lambda_1.InvokeWithResponseStreamCommand({
         FunctionName: functionName,
         // @ts-expect-error
         Payload: JSON.stringify({ type, ...payload }),
     }));
-    const string = Buffer.from(res.Payload).toString();
-    const json = JSON.parse(string);
-    if (json === null) {
-        throw new Error('Lambda function unexpectedly returned null: ' +
-            JSON.stringify({
-                payload,
-                type,
-                functionName,
-                json,
-                error: res.FunctionError,
-                version: res.$metadata,
-            }));
+    const events = res.EventStream;
+    let responsePayload = new Uint8Array();
+    for await (const event of events) {
+        // There are two types of events you can get on a stream.
+        // `PayloadChunk`: These contain the actual raw bytes of the chunk
+        // It has a single property: `Payload`
+        if (event.PayloadChunk) {
+            // Decode the raw bytes into a string a human can read
+            const decoded = new TextDecoder('utf-8').decode(event.PayloadChunk.Payload);
+            responsePayload = Buffer.concat([responsePayload, Buffer.from(decoded)]);
+        }
+        if (event.InvokeComplete) {
+            if (event.InvokeComplete.ErrorCode) {
+                throw new Error(`Lambda function ${functionName} failed with error code ${event.InvokeComplete.ErrorCode}: ${event.InvokeComplete.ErrorDetails}}`);
+            }
+        }
     }
+    const string = Buffer.from(responsePayload).toString();
+    const json = JSON.parse(string);
     if ('errorMessage' in json) {
         const err = new Error(json.errorMessage);
         err.name = json.errorType;
         err.stack = ((_a = json.trace) !== null && _a !== void 0 ? _a : []).join('\n');
         throw err;
     }
+    // Streaming: 3.3.96+
+    if ('statusCode' in json) {
+        if (json.statusCode !== 200) {
+            throw new Error(`Lambda function ${functionName} failed with status code ${json.statusCode}: ${json.body}`);
+        }
+        return JSON.parse(json.body);
+    }
+    // Non-streaming: 3.3.95 and below
     return json;
 };
 exports.callLambda = callLambda;

package/dist/shared/return-values.d.ts

@@ -15,3 +15,8 @@ export interface LambdaReturnValues {
     [LambdaRoutines.still]: ReturnType<typeof stillHandler>;
     [LambdaRoutines.compositions]: ReturnType<typeof compositionsHandler>;
 }
+export declare type StreamedResponse = {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/lambda",
-  "version": "3.3.94",
+  "version": "3.3.96",
   "description": "Distributed renderer for Remotion based on AWS Lambda",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -13,28 +13,28 @@
     "url": "https://github.com/JonnyBurger/remotion"
   },
   "dependencies": {
-    "@aws-sdk/abort-controller": "3.272.0",
-    "@aws-sdk/client-cloudwatch-logs": "3.272.0",
-    "@aws-sdk/client-iam": "3.272.0",
-    "@aws-sdk/client-lambda": "3.272.0",
-    "@aws-sdk/client-s3": "3.272.0",
-    "@aws-sdk/client-service-quotas": "3.272.0",
-    "@aws-sdk/client-sts": "3.272.0",
-    "@aws-sdk/credential-providers": "3.272.0",
-    "@aws-sdk/lib-storage": "3.272.0",
-    "@aws-sdk/s3-request-presigner": "3.272.0",
-    "@remotion/bundler": "3.3.94",
-    "@remotion/cli": "3.3.94",
-    "@remotion/renderer": "3.3.94",
+    "@aws-sdk/abort-controller": "3.338.0",
+    "@aws-sdk/client-cloudwatch-logs": "3.338.0",
+    "@aws-sdk/client-iam": "3.338.0",
+    "@aws-sdk/client-lambda": "3.338.0",
+    "@aws-sdk/client-s3": "3.338.0",
+    "@aws-sdk/client-service-quotas": "3.338.0",
+    "@aws-sdk/client-sts": "3.338.0",
+    "@aws-sdk/credential-providers": "3.338.0",
+    "@aws-sdk/lib-storage": "3.338.0",
+    "@aws-sdk/s3-request-presigner": "3.338.0",
+    "@remotion/bundler": "3.3.96",
+    "@remotion/cli": "3.3.96",
+    "@remotion/renderer": "3.3.96",
     "aws-policies": "^1.0.1",
     "mime-types": "2.1.34",
-    "remotion": "3.3.94"
+    "remotion": "3.3.96"
   },
   "devDependencies": {
     "@jonny/eslint-config": "3.0.266",
-    "@remotion/bundler": "3.3.94",
-    "@remotion/compositor-linux-arm64-musl": "3.3.94",
-    "@remotion/compositor-linux-x64-musl": "3.3.94",
+    "@remotion/bundler": "3.3.96",
+    "@remotion/compositor-linux-arm64-musl": "3.3.96",
+    "@remotion/compositor-linux-x64-musl": "3.3.96",
     "@types/mime-types": "2.1.1",
     "@types/minimist": "1.2.2",
     "@types/node": "^14.14.14",
@@ -48,7 +48,7 @@
     "zip-lib": "^0.7.2"
   },
   "peerDependencies": {
-    "@remotion/bundler": "3.3.94"
+    "@remotion/bundler": "3.3.96"
   },
   "publishConfig": {
     "access": "public"