@remotion/lambda 4.0.0-audio.0 → 4.0.0-audio.11

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

@@ -5,14 +5,26 @@ const client_s3_1 = require("@aws-sdk/client-s3");
 const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
 const renderer_1 = require("@remotion/renderer");
 const aws_clients_1 = require("../../shared/aws-clients");
-const lambdaDownloadFileWithProgress = async ({ bucketName, key, region, expectedBucketOwner, outputPath, onProgress, }) => {
-    const client = (0, aws_clients_1.getS3Client)(region);
+const lambdaDownloadFileWithProgress = async ({ bucketName, key, region, expectedBucketOwner, outputPath, onProgress, customCredentials, }) => {
+    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);
-    return renderer_1.RenderInternals.downloadFile(presigned, outputPath, onProgress);
+    const { to, sizeInBytes } = await renderer_1.RenderInternals.downloadFile({
+        url: presigned,
+        onProgress: ({ downloaded, percent, totalSize }) => {
+            // On Lambda, it should always be a number
+            onProgress({
+                downloaded,
+                percent: percent,
+                totalSize: totalSize,
+            });
+        },
+        to: () => outputPath,
+    });
+    return { sizeInBytes, to };
 };
 exports.lambdaDownloadFileWithProgress = lambdaDownloadFileWithProgress;

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

@@ -1,11 +1,20 @@
-import { openBrowser } from '@remotion/renderer';
-import { TCompMetadata } from 'remotion';
-import { Await } from '../../shared/await';
+import type { ChromiumOptions, DownloadMap, FfmpegExecutable, openBrowser } from '@remotion/renderer';
+import type { TCompMetadata } from 'remotion';
+import type { Await } from '../../shared/await';
 declare type ValidateCompositionOptions = {
     serveUrl: string;
     composition: string;
     browserInstance: Await<ReturnType<typeof openBrowser>>;
     inputProps: 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;
 };
-export declare const validateComposition: ({ serveUrl, composition, browserInstance, inputProps, }: ValidateCompositionOptions) => Promise<TCompMetadata>;
+export declare const validateComposition: ({ serveUrl, composition, browserInstance, inputProps, envVariables, timeoutInMilliseconds, ffmpegExecutable, ffprobeExecutable, chromiumOptions, port, downloadMap, forceHeight, forceWidth, }: ValidateCompositionOptions) => Promise<TCompMetadata>;
 export {};

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

@@ -2,10 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateComposition = void 0;
 const renderer_1 = require("@remotion/renderer");
-const validateComposition = async ({ serveUrl, composition, browserInstance, inputProps, }) => {
+const get_chromium_executable_path_1 = require("./get-chromium-executable-path");
+const validateComposition = async ({ serveUrl, composition, browserInstance, inputProps, envVariables, timeoutInMilliseconds, ffmpegExecutable, ffprobeExecutable, chromiumOptions, port, downloadMap, forceHeight, forceWidth, }) => {
     const compositions = await (0, renderer_1.getCompositions)(serveUrl, {
         puppeteerInstance: browserInstance,
         inputProps: inputProps,
+        envVariables,
+        ffmpegExecutable,
+        ffprobeExecutable,
+        timeoutInMilliseconds,
+        chromiumOptions,
+        port,
+        downloadMap,
+        browserExecutable: (0, get_chromium_executable_path_1.executablePath)(),
     });
     const found = compositions.find((c) => c.id === composition);
     if (!found) {
@@ -13,6 +22,10 @@ const validateComposition = async ({ serveUrl, composition, browserInstance, inp
             .map((c) => c.id)
             .join(', ')}`);
     }
-    return found;
+    return {
+        ...found,
+        height: forceHeight !== null && forceHeight !== void 0 ? forceHeight : found.height,
+        width: forceWidth !== null && forceWidth !== void 0 ? forceWidth : found.width,
+    };
 };
 exports.validateComposition = validateComposition;

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

@@ -1,6 +1,6 @@
-import { FileNameAndSize } from './get-files-in-folder';
+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

@@ -33,6 +33,8 @@ const writeLambdaError = async ({ bucketName, renderId, errorInfo, expectedBucke
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         privacy: 'private',
         expectedBucketOwner,
+        downloadBehavior: null,
+        customCredentials: null,
     });
 };
 exports.writeLambdaError = writeLambdaError;

package/dist/functions/helpers/write-post-render-data.d.ts

@@ -1,5 +1,5 @@
-import { AwsRegion } from '../../pricing/aws-regions';
-import { PostRenderData } from '../../shared/constants';
+import type { AwsRegion } from '../../pricing/aws-regions';
+import type { PostRenderData } from '../../shared/constants';
 export declare const writePostRenderData: ({ bucketName, renderId, postRenderData, expectedBucketOwner, region, }: {
     bucketName: string;
     renderId: string;

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

@@ -11,6 +11,8 @@ const writePostRenderData = async ({ bucketName, renderId, postRenderData, expec
         body: JSON.stringify(postRenderData),
         expectedBucketOwner,
         region,
+        downloadBehavior: null,
+        customCredentials: null,
     });
 };
 exports.writePostRenderData = writePostRenderData;

package/dist/functions/index.d.ts

@@ -1,5 +1,6 @@
-import { LambdaPayload, LambdaRoutines } from '../shared/constants';
-import { LambdaReturnValues } from '../shared/return-values';
+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;

package/dist/functions/index.js

@@ -1,20 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handler = void 0;
-const remotion_1 = require("remotion");
+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 info_1 = require("./info");
 const launch_1 = require("./launch");
 const progress_1 = require("./progress");
-const renderer_1 = require("./renderer");
+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();
+    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');
     }
@@ -25,6 +26,7 @@ const handler = async (params, context) => {
     if (params.type === constants_1.LambdaRoutines.still) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.still, {
             inputProps: JSON.stringify(params.inputProps),
+            isWarm,
         });
         return (0, still_1.stillHandler)(params, {
             expectedBucketOwner: currentUserId,
@@ -33,41 +35,58 @@ const handler = async (params, context) => {
     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);
+        return (0, start_1.startHandler)(params, { expectedBucketOwner: currentUserId });
     }
     if (params.type === constants_1.LambdaRoutines.launch) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.launch, {
             renderId: params.renderId,
             inputProps: JSON.stringify(params.inputProps),
+            isWarm,
+        });
+        return (0, launch_1.launchHandler)(params, {
+            expectedBucketOwner: currentUserId,
+            getRemainingTimeInMillis: context.getRemainingTimeInMillis,
         });
-        return (0, launch_1.launchHandler)(params, { expectedBucketOwner: currentUserId });
     }
     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, {
             expectedBucketOwner: currentUserId,
-            timeoutInMiliseconds,
+            timeoutInMilliseconds,
         });
     }
     if (params.type === constants_1.LambdaRoutines.renderer) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.renderer, {
             renderId: params.renderId,
             chunk: String(params.chunk),
-            dumpLogs: String(remotion_1.Internals.Logging.isEqualOrBelowLogLevel(params.logLevel, 'verbose')),
+            dumpLogs: String(renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose')),
             inputProps: JSON.stringify(params.inputProps),
+            isWarm,
         });
-        return (0, renderer_1.rendererHandler)(params, {
+        return (0, renderer_2.rendererHandler)(params, {
             expectedBucketOwner: currentUserId,
             isWarm,
         });
     }
     if (params.type === constants_1.LambdaRoutines.info) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.info, {});
+        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.info, {
+            isWarm,
+        });
         return (0, info_1.infoHandler)(params);
     }
+    if (params.type === constants_1.LambdaRoutines.compositions) {
+        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.compositions, {
+            isWarm,
+        });
+        return (0, compositions_1.compositionsHandler)(params, {
+            expectedBucketOwner: currentUserId,
+        });
+    }
     throw new Error(constants_1.COMMAND_NOT_FOUND);
 };
 exports.handler = handler;

package/dist/functions/info.d.ts

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