@remotion/lambda 4.0.0-alpha.4 → 4.0.0-alpha11

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

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

@@ -2,24 +2,25 @@
 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, downloadMap, forceHeight, forceWidth, logLevel, }) => {
+    const comp = await (0, renderer_1.selectComposition)({
+        id: composition,
         puppeteerInstance: browserInstance,
-        inputProps: inputProps,
+        inputProps,
         envVariables,
-        ffmpegExecutable,
-        ffprobeExecutable,
         timeoutInMilliseconds,
         chromiumOptions,
         port,
         downloadMap,
+        browserExecutable: (0, get_chromium_executable_path_1.executablePath)(),
+        serveUrl,
+        verbose: renderer_1.RenderInternals.isEqualOrBelowLogLevel(logLevel, 'verbose'),
     });
-    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,6 +1,6 @@
 import type { FileNameAndSize } from './get-files-in-folder';
 export declare type LambdaErrorInfo = {
-    type: 'renderer' | 'browser' | 'stitcher';
+    type: 'renderer' | 'browser' | 'stitcher' | 'webhook';
     message: string;
     name: string;
     stack: string;

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

@@ -34,6 +34,7 @@ const writeLambdaError = async ({ bucketName, renderId, errorInfo, expectedBucke
         privacy: 'private',
         expectedBucketOwner,
         downloadBehavior: null,
+        customCredentials: null,
     });
 };
 exports.writeLambdaError = writeLambdaError;

package/dist/functions/helpers/write-post-render-data.js

@@ -12,6 +12,7 @@ const writePostRenderData = async ({ bucketName, renderId, postRenderData, expec
         expectedBucketOwner,
         region,
         downloadBehavior: null,
+        customCredentials: null,
     });
 };
 exports.writePostRenderData = writePostRenderData;

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,18 +3,20 @@ 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) => {
-    process.env.REMOTION_LAMBDA = 'true';
-    const timeoutInMiliseconds = context.getRemainingTimeInMillis();
+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) {
         throw new Error('Lambda function unexpectedly does not have context.invokedFunctionArn');
     }
@@ -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);
+        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,
-            timeoutInMiliseconds,
+            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/info.d.ts

@@ -1,4 +1,4 @@
-import type { LambdaPayload, LambdaVersions } from '../shared/constants';
+import type { LambdaPayload } from '../shared/constants';
 export declare const infoHandler: (lambdaParams: LambdaPayload) => Promise<{
-    version: LambdaVersions;
+    version: string;
 }>;

package/dist/functions/info.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.infoHandler = void 0;
+const version_1 = require("remotion/version");
 const constants_1 = require("../shared/constants");
 const infoHandler = (lambdaParams) => {
     if (lambdaParams.type !== constants_1.LambdaRoutines.info) {
         throw new TypeError('Expected info type');
     }
     const returnValue = {
-        version: constants_1.CURRENT_VERSION,
+        version: version_1.VERSION,
     };
     return Promise.resolve(returnValue);
 };

package/dist/functions/launch.d.ts

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