@remotion/lambda 4.0.200 → 4.0.201

package/dist/functions/helpers/io.d.ts

@@ -1,6 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import type { _Object } from '@aws-sdk/client-s3';
-import type { CustomCredentials } from '@remotion/serverless/client';
-import type { AwsRegion } from '../../regions';
+import type { AwsRegion, CustomCredentials, DownloadBehavior, Privacy } from '@remotion/serverless/client';
+import type { ReadStream } from 'node:fs';
+import type { Readable } from 'stream';
 export type LambdaLSInput = {
     bucketName: string;
     prefix: string;
@@ -9,12 +12,39 @@ export type LambdaLSInput = {
     continuationToken?: string;
 };
 export type LambdaLsReturnType = Promise<_Object[]>;
+export declare const lambdaLs: ({ bucketName, prefix, region, expectedBucketOwner, continuationToken, }: LambdaLSInput) => LambdaLsReturnType;
+export declare const lambdaDeleteFile: ({ bucketName, key, region, customCredentials, }: {
+    region: AwsRegion;
+    bucketName: string;
+    key: string;
+    customCredentials: CustomCredentials | null;
+}) => Promise<void>;
+type LambdaWriteFileInput = {
+    bucketName: string;
+    key: string;
+    body: ReadStream | string | Uint8Array;
+    region: AwsRegion;
+    privacy: Privacy;
+    expectedBucketOwner: string | null;
+    downloadBehavior: DownloadBehavior | null;
+    customCredentials: CustomCredentials | null;
+};
+export declare const lambdaWriteFile: (params: LambdaWriteFileInput & {
+    retries?: number;
+}) => Promise<void>;
+export declare const lambdaReadFile: ({ bucketName, key, region, expectedBucketOwner, }: {
+    bucketName: string;
+    key: string;
+    region: AwsRegion;
+    expectedBucketOwner: string;
+}) => Promise<Readable>;
 export declare const lambdaHeadCommand: ({ bucketName, key, region, customCredentials, }: {
     bucketName: string;
     key: string;
     region: AwsRegion;
-    customCredentials: CustomCredentials<AwsRegion> | null;
+    customCredentials: CustomCredentials | null;
 }) => Promise<{
     LastModified?: Date | undefined;
     ContentLength?: number | undefined;
 }>;
+export {};

package/dist/functions/helpers/io.js

@@ -1,10 +1,111 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lambdaHeadCommand = void 0;
+exports.lambdaHeadCommand = exports.lambdaReadFile = exports.lambdaWriteFile = exports.lambdaDeleteFile = exports.lambdaLs = void 0;
 const client_s3_1 = require("@aws-sdk/client-s3");
-const get_s3_client_1 = require("../../shared/get-s3-client");
+const mime_types_1 = __importDefault(require("mime-types"));
+const aws_clients_1 = require("../../shared/aws-clients");
+const content_disposition_header_1 = require("../../shared/content-disposition-header");
+const lambdaLs = async ({ bucketName, prefix, region, expectedBucketOwner, continuationToken, }) => {
+    var _a, _b, _c;
+    try {
+        const list = await (0, aws_clients_1.getS3Client)(region, null).send(new client_s3_1.ListObjectsV2Command({
+            Bucket: bucketName,
+            Prefix: prefix,
+            ExpectedBucketOwner: expectedBucketOwner !== null && expectedBucketOwner !== void 0 ? expectedBucketOwner : undefined,
+            ContinuationToken: continuationToken,
+        }));
+        if (list.NextContinuationToken) {
+            return [
+                ...((_a = list.Contents) !== null && _a !== void 0 ? _a : []),
+                ...(await (0, exports.lambdaLs)({
+                    bucketName,
+                    prefix,
+                    expectedBucketOwner,
+                    region,
+                    continuationToken: list.NextContinuationToken,
+                })),
+            ];
+        }
+        return (_b = list.Contents) !== null && _b !== void 0 ? _b : [];
+    }
+    catch (err) {
+        if (!expectedBucketOwner) {
+            throw err;
+        }
+        // Prevent from accessing a foreign bucket, retry without ExpectedBucketOwner and see if it works. If it works then it's an owner mismatch.
+        if ((_c = err.stack) === null || _c === void 0 ? void 0 : _c.includes('AccessDenied')) {
+            await (0, aws_clients_1.getS3Client)(region, null).send(new client_s3_1.ListObjectsV2Command({
+                Bucket: bucketName,
+                Prefix: prefix,
+            }));
+            throw new Error(`Bucket owner mismatch: Expected the bucket ${bucketName} to be owned by you (AWS Account ID: ${expectedBucketOwner}) but it's not the case. Did you accidentially specify the wrong bucket?`);
+        }
+        throw err;
+    }
+};
+exports.lambdaLs = lambdaLs;
+const lambdaDeleteFile = async ({ bucketName, key, region, customCredentials, }) => {
+    await (0, aws_clients_1.getS3Client)(region, customCredentials).send(new client_s3_1.DeleteObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+    }));
+};
+exports.lambdaDeleteFile = lambdaDeleteFile;
+const tryLambdaWriteFile = async ({ bucketName, key, body, region, privacy, expectedBucketOwner, downloadBehavior, customCredentials, }) => {
+    await (0, aws_clients_1.getS3Client)(region, customCredentials).send(new client_s3_1.PutObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+        Body: body,
+        ACL: privacy === 'no-acl'
+            ? undefined
+            : privacy === 'private'
+                ? 'private'
+                : 'public-read',
+        ExpectedBucketOwner: customCredentials
+            ? undefined
+            : expectedBucketOwner !== null && expectedBucketOwner !== void 0 ? expectedBucketOwner : undefined,
+        ContentType: mime_types_1.default.lookup(key) || 'application/octet-stream',
+        ContentDisposition: (0, content_disposition_header_1.getContentDispositionHeader)(downloadBehavior),
+    }));
+};
+const lambdaWriteFile = async (params) => {
+    var _a;
+    const remainingRetries = (_a = params.retries) !== null && _a !== void 0 ? _a : 2;
+    try {
+        await tryLambdaWriteFile(params);
+    }
+    catch (err) {
+        if (remainingRetries === 0) {
+            throw err;
+        }
+        const backoff = 2 ** (2 - remainingRetries) * 2000;
+        await new Promise((resolve) => {
+            setTimeout(resolve, backoff);
+        });
+        console.warn('Failed to write file to Lambda:');
+        console.warn(err);
+        console.warn(`Retrying (${remainingRetries} retries remaining)...`);
+        return (0, exports.lambdaWriteFile)({
+            ...params,
+            retries: remainingRetries - 1,
+        });
+    }
+};
+exports.lambdaWriteFile = lambdaWriteFile;
+const lambdaReadFile = async ({ bucketName, key, region, expectedBucketOwner, }) => {
+    const { Body } = await (0, aws_clients_1.getS3Client)(region, null).send(new client_s3_1.GetObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+        ExpectedBucketOwner: expectedBucketOwner,
+    }));
+    return Body;
+};
+exports.lambdaReadFile = lambdaReadFile;
 const lambdaHeadCommand = async ({ bucketName, key, region, customCredentials, }) => {
-    const head = await (0, get_s3_client_1.getS3Client)(region, customCredentials).send(new client_s3_1.HeadObjectCommand({
+    const head = await (0, aws_clients_1.getS3Client)(region, customCredentials).send(new client_s3_1.HeadObjectCommand({
         Bucket: bucketName,
         Key: key,
     }));

package/dist/functions/helpers/print-cloudwatch-helper.d.ts

@@ -1,3 +1,3 @@
 import type { LogLevel } from '@remotion/renderer';
 import type { ServerlessRoutines } from '@remotion/serverless/client';
-export declare const printCloudwatchHelper: (type: ServerlessRoutines, data: Record<string, string | boolean>, logLevel: LogLevel) => void;
+export declare const printLoggingGrepHelper: (type: ServerlessRoutines, data: Record<string, string | boolean>, logLevel: LogLevel) => void;

package/dist/functions/helpers/print-cloudwatch-helper.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printCloudwatchHelper = void 0;
+exports.printLoggingGrepHelper = void 0;
 const renderer_1 = require("@remotion/renderer");
-const printCloudwatchHelper = (type, data, logLevel) => {
+const printLoggingGrepHelper = (type, data, logLevel) => {
     const d = Object.keys(data).reduce((a, b) => {
         return [...a, `${b}=${data[b]}`];
     }, []);
     const msg = [`method=${type}`, ...d].join(',');
     renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, msg);
 };
-exports.printCloudwatchHelper = printCloudwatchHelper;
+exports.printLoggingGrepHelper = printLoggingGrepHelper;

package/dist/functions/helpers/streaming-payloads.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { ResponseStream } from './streamify-response';
+declare const streamingPayloadSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"render-id-determined">;
+    renderId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "render-id-determined";
+    renderId: string;
+}, {
+    type: "render-id-determined";
+    renderId: string;
+}>]>;
+export type StreamingPayloads = z.infer<typeof streamingPayloadSchema>;
+export declare const isStreamingPayload: (str: string) => false | {
+    type: "render-id-determined";
+    renderId: string;
+};
+export declare const sendProgressEvent: (responseStream: ResponseStream, payload: StreamingPayloads) => void;
+export {};

package/dist/functions/helpers/streaming-payloads.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendProgressEvent = exports.isStreamingPayload = void 0;
+const zod_1 = require("zod");
+const streamingPayloadSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({
+        type: zod_1.z.literal('render-id-determined'),
+        renderId: zod_1.z.string(),
+    }),
+]);
+const isStreamingPayload = (str) => {
+    try {
+        const parsed = JSON.parse(str);
+        return streamingPayloadSchema.parse(parsed);
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.isStreamingPayload = isStreamingPayload;
+const sendProgressEvent = (responseStream, payload) => {
+    const stringified = JSON.stringify(payload);
+    responseStream.write(stringified);
+};
+exports.sendProgressEvent = sendProgressEvent;

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

@@ -1,4 +1,5 @@
-import type { FileNameAndSize } from './get-files-in-folder';
+import type { ProviderSpecifics } from '@remotion/serverless';
+import type { FileNameAndSize } from '@remotion/serverless/client';
 export type LambdaErrorInfo = {
     type: 'renderer' | 'browser' | 'stitcher' | 'webhook' | 'artifact';
     message: string;
@@ -15,7 +16,7 @@ export type LambdaErrorInfo = {
         total: number;
     } | null;
 };
-export declare const getTmpDirStateIfENoSp: (err: string) => LambdaErrorInfo['tmpDir'];
+export declare const getTmpDirStateIfENoSp: <Region extends string>(err: string, providerSpecifics: ProviderSpecifics<Region>) => LambdaErrorInfo['tmpDir'];
 export type EnhancedErrorInfo = LambdaErrorInfo & {
     /**
      * @deprecated Will always be an empty string.

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

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTmpDirStateIfENoSp = void 0;
-const get_files_in_folder_1 = require("./get-files-in-folder");
 const is_enosp_err_1 = require("./is-enosp-err");
-const getTmpDirStateIfENoSp = (err) => {
+const getTmpDirStateIfENoSp = (err, providerSpecifics) => {
     if (!(0, is_enosp_err_1.errorIsOutOfSpaceError)(err)) {
         return null;
     }
-    const files = (0, get_files_in_folder_1.getFolderFiles)('/tmp');
+    const files = providerSpecifics.getFolderFiles('/tmp');
     return {
         files: files
             .slice(0)

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

@@ -0,0 +1,9 @@
+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;
+    postRenderData: PostRenderData;
+    expectedBucketOwner: string;
+    region: AwsRegion;
+}) => Promise<void>;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePostRenderData = void 0;
+const constants_1 = require("../../shared/constants");
+const io_1 = require("./io");
+const writePostRenderData = async ({ bucketName, renderId, postRenderData, expectedBucketOwner, region, }) => {
+    await (0, io_1.lambdaWriteFile)({
+        bucketName,
+        key: (0, constants_1.postRenderDataKey)(renderId),
+        privacy: 'private',
+        body: JSON.stringify(postRenderData),
+        expectedBucketOwner,
+        region,
+        downloadBehavior: null,
+        customCredentials: null,
+    });
+};
+exports.writePostRenderData = writePostRenderData;

package/dist/functions/merge.d.ts

@@ -0,0 +1,9 @@
+import type { LambdaPayload, PostRenderData } from '../defaults';
+type Options = {
+    expectedBucketOwner: string;
+};
+export declare const mergeHandler: (params: LambdaPayload, options: Options) => Promise<{
+    type: 'success';
+    postRenderData: PostRenderData;
+}>;
+export {};

package/dist/functions/merge.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const defaults_1 = require("../defaults");
+const expected_out_name_1 = require("./helpers/expected-out-name");
+const get_current_region_1 = require("./helpers/get-current-region");
+const get_render_metadata_1 = require("./helpers/get-render-metadata");
+const merge_chunks_1 = require("./helpers/merge-chunks");
+const mergeHandler = async (params, options) => {
+    var _a, _b;
+    if (params.type !== defaults_1.LambdaRoutines.merge) {
+        throw new Error('Expected launch type');
+    }
+    renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'This function has been started because the previous main function has timed out while merging together the chunks.');
+    renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'The merging of chunks will now restart.');
+    const renderMetadata = await (0, get_render_metadata_1.getRenderMetadata)({
+        bucketName: params.bucketName,
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        renderId: params.renderId,
+    });
+    if (!renderMetadata.codec) {
+        throw new Error('expected codec');
+    }
+    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
+        ? null
+        : (_b = (_a = params.outName) === null || _a === void 0 ? void 0 : _a.s3OutputProvider) !== null && _b !== void 0 ? _b : null);
+    const frameCount = renderer_1.RenderInternals.getFramesToRender(renderMetadata.frameRange, renderMetadata.everyNthFrame);
+    const fps = renderMetadata.videoConfig.fps / renderMetadata.everyNthFrame;
+    const postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
+        audioCodec: renderMetadata.audioCodec,
+        bucketName: params.bucketName,
+        chunkCount: renderMetadata.totalChunks,
+        codec: renderMetadata.codec,
+        customCredentials,
+        downloadBehavior: renderMetadata.downloadBehavior,
+        expectedBucketOwner: options.expectedBucketOwner,
+        fps,
+        numberOfFrames: frameCount.length,
+        inputProps: params.inputProps,
+        key,
+        numberOfGifLoops: renderMetadata.numberOfGifLoops,
+        privacy: renderMetadata.privacy,
+        renderBucketName,
+        renderId: params.renderId,
+        renderMetadata,
+        serializedResolvedProps: params.serializedResolvedProps,
+        onAllChunks: () => {
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'All chunks have been downloaded now.');
+        },
+        audioBitrate: renderMetadata.audioBitrate,
+        logLevel: params.logLevel,
+        framesPerLambda: params.framesPerLambda,
+        binariesDirectory: null,
+        preferLossless: params.preferLossless,
+        compositionStart: params.compositionStart,
+    });
+    return { type: 'success', postRenderData };
+};
+exports.mergeHandler = mergeHandler;

package/dist/internals.d.ts

@@ -37,6 +37,7 @@ export declare const LambdaInternals: {
         options: {
             onBundleProgress?: ((progress: number) => void) | undefined;
             onUploadProgress?: ((upload: import("./api/upload-dir").UploadDirProgress) => void) | undefined;
+            onDiffingProgress?: ((bytes: number, done: boolean) => void) | undefined;
             webpackOverride?: import("@remotion/bundler").WebpackOverrideFn | undefined;
             ignoreRegisterRootWarning?: boolean | undefined;
             enableCaching?: boolean | undefined;

package/dist/shared/__mocks__/read-dir.js

@@ -6,8 +6,8 @@ const readDirectory = ({ dir }) => {
     const files = (0, upload_dir_1.getDirFiles)(dir);
     const obj = {};
     for (const file of files) {
-        obj[file.name] = 'etag';
+        obj[file.name] = () => Promise.resolve('etag');
     }
-    return Promise.resolve(obj);
+    return obj;
 };
 exports.readDirectory = readDirectory;

package/dist/shared/chunk-progress.d.ts

@@ -0,0 +1,9 @@
+export declare const writeLambdaInitializedFile: ({ bucketName, expectedBucketOwner, attempt, chunk, renderId, framesRendered, }: {
+    bucketName: string;
+    expectedBucketOwner: string;
+    renderId: string;
+    chunk: number;
+    attempt: number;
+    framesRendered: number;
+}) => Promise<void>;
+export declare const getProgressOfChunk: (etag: string) => number;