@remotion/lambda 4.0.0-webhook.27 → 4.0.1

package/dist/shared/make-s3-key.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeS3Key = void 0;
-const path_1 = __importDefault(require("path"));
+const node_path_1 = __importDefault(require("node:path"));
 const makeS3Key = (folder, dir, filePath) => {
-    return `${folder}/${path_1.default.relative(dir, filePath).split(path_1.default.sep).join('/')}`;
+    return `${folder}/${node_path_1.default.relative(dir, filePath).split(node_path_1.default.sep).join('/')}`;
 };
 exports.makeS3Key = makeS3Key;

package/dist/shared/make-s3-url.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getServeUrlHash = exports.makeS3ServeUrl = void 0;
-const crypto_1 = __importDefault(require("crypto"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
 const makeS3ServeUrl = ({ bucketName, subFolder, region, }) => {
     return `https://${bucketName}.s3.${region}.amazonaws.com/${subFolder}/index.html`;
 };
@@ -14,7 +14,7 @@ const getServeUrlHash = (url) => {
     if (hashCache[url]) {
         return hashCache[url];
     }
-    const hash = crypto_1.default.createHash('md5').update(url).digest('hex');
+    const hash = node_crypto_1.default.createHash('md5').update(url).digest('hex');
     hashCache[url] = hash;
     return hash;
 };

package/dist/shared/parse-chunk-key.d.ts

@@ -0,0 +1,4 @@
+export declare const parseLambdaChunkKey: (key: string) => {
+    renderId: string;
+    chunk: number;
+};

package/dist/shared/parse-chunk-key.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLambdaChunkKey = void 0;
+const parseLambdaChunkKey = (key) => {
+    const match = key.match(/^renders\/(.*)\/chunks\/chunk:([0-9]+)$/);
+    if (!match) {
+        throw new Error(`Cannot parse filename ${key} into timing information. Malformed data.`);
+    }
+    return {
+        renderId: match[1],
+        chunk: Number(match[2]),
+    };
+};
+exports.parseLambdaChunkKey = parseLambdaChunkKey;

package/dist/shared/parse-lambda-timings-key.d.ts

@@ -1,4 +1,4 @@
-export declare type ParsedTiming = {
+export type ParsedTiming = {
     renderId: string;
     chunk: number;
     start: number;

package/dist/shared/read-dir.d.ts

@@ -0,0 +1,9 @@
+export declare function readDirectory({ dir, etags, originalDir, }: {
+    dir: string;
+    etags: {
+        [key: string]: string;
+    };
+    originalDir: string;
+}): Promise<{
+    [key: string]: string;
+}>;

package/dist/shared/read-dir.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDirectory = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const get_etag_1 = require("./get-etag");
+// Function to recursively read a directory and return a list of files
+// with their etags and file names
+async function readDirectory({ dir, etags, originalDir, }) {
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        if (file.startsWith('.DS_Store'))
+            continue;
+        const filePath = path.join(dir, file);
+        if (fs.lstatSync(filePath).isDirectory()) {
+            etags = {
+                ...etags,
+                ...(await readDirectory({ dir: filePath, etags, originalDir })),
+            };
+            continue;
+        }
+        // eslint-disable-next-line no-lonely-if
+        if (fs.lstatSync(filePath).isSymbolicLink()) {
+            const realPath = fs.realpathSync(filePath);
+            etags[path.relative(originalDir, filePath)] = await (0, get_etag_1.getEtagOfFile)(realPath);
+        }
+        else {
+            etags[path.relative(originalDir, filePath)] = await (0, get_etag_1.getEtagOfFile)(filePath);
+        }
+    }
+    // Return the list of files with their etags and file names
+    return etags;
+}
+exports.readDirectory = readDirectory;

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

@@ -1,3 +1,4 @@
+import type { compositionsHandler } from '../functions/compositions';
 import type { infoHandler } from '../functions/info';
 import type { launchHandler } from '../functions/launch';
 import type { progressHandler } from '../functions/progress';
@@ -12,4 +13,10 @@ export interface LambdaReturnValues {
     [LambdaRoutines.status]: ReturnType<typeof progressHandler>;
     [LambdaRoutines.info]: ReturnType<typeof infoHandler>;
     [LambdaRoutines.still]: ReturnType<typeof stillHandler>;
+    [LambdaRoutines.compositions]: ReturnType<typeof compositionsHandler>;
 }
+export type StreamedResponse = {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+};

package/dist/shared/serialize-props.d.ts

@@ -0,0 +1,20 @@
+import type { AwsRegion } from '../client';
+import type { SerializedInputProps } from './constants';
+type PropsType = 'input-props' | 'resolved-props' | 'default-props';
+export declare const serializeOrThrow: (inputProps: Record<string, unknown>, propsType: PropsType) => string;
+export declare const getNeedsToUpload: (type: 'still' | 'video-or-audio', stringifiedInputProps: string) => boolean;
+export declare const serializeInputProps: ({ stringifiedInputProps, region, userSpecifiedBucketName, propsType, needsToUpload, }: {
+    stringifiedInputProps: string;
+    region: AwsRegion;
+    userSpecifiedBucketName: string | null;
+    propsType: PropsType;
+    needsToUpload: boolean;
+}) => Promise<SerializedInputProps>;
+export declare const deserializeInputProps: ({ serialized, region, bucketName, expectedBucketOwner, propsType, }: {
+    serialized: SerializedInputProps;
+    region: AwsRegion;
+    bucketName: string;
+    expectedBucketOwner: string;
+    propsType: PropsType;
+}) => Promise<Record<string, unknown>>;
+export {};

package/dist/shared/serialize-props.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeInputProps = exports.serializeInputProps = exports.getNeedsToUpload = exports.serializeOrThrow = void 0;
+const get_or_create_bucket_1 = require("../api/get-or-create-bucket");
+const io_1 = require("../functions/helpers/io");
+const constants_1 = require("./constants");
+const random_hash_1 = require("./random-hash");
+const stream_to_string_1 = require("./stream-to-string");
+const serializeOrThrow = (inputProps, propsType) => {
+    try {
+        const payload = JSON.stringify(inputProps);
+        return payload;
+    }
+    catch (err) {
+        throw new Error(`Error serializing ${propsType}. Check it has no circular references or reduce the size if the object is big.`);
+    }
+};
+exports.serializeOrThrow = serializeOrThrow;
+const getNeedsToUpload = (type, stringifiedInputProps) => {
+    const MAX_INLINE_PAYLOAD_SIZE = type === 'still' ? 5000000 : 200000;
+    if (stringifiedInputProps.length > MAX_INLINE_PAYLOAD_SIZE) {
+        console.warn(`Warning: The props are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(stringifiedInputProps.length / 1024)}KB) in size. Uploading them to S3 to circumvent AWS Lambda payload size, which may lead to slowdown.`);
+        return true;
+    }
+    return false;
+};
+exports.getNeedsToUpload = getNeedsToUpload;
+const serializeInputProps = async ({ stringifiedInputProps, region, userSpecifiedBucketName, propsType, needsToUpload, }) => {
+    const hash = (0, random_hash_1.randomHash)();
+    if (needsToUpload) {
+        const bucketName = userSpecifiedBucketName !== null && userSpecifiedBucketName !== void 0 ? userSpecifiedBucketName : (await (0, get_or_create_bucket_1.getOrCreateBucket)({
+            region,
+        })).bucketName;
+        await (0, io_1.lambdaWriteFile)({
+            body: stringifiedInputProps,
+            bucketName,
+            region,
+            customCredentials: null,
+            downloadBehavior: null,
+            expectedBucketOwner: null,
+            key: makeKey(propsType, hash),
+            privacy: 'public',
+        });
+        return {
+            type: 'bucket-url',
+            hash,
+        };
+    }
+    return {
+        type: 'payload',
+        payload: stringifiedInputProps,
+    };
+};
+exports.serializeInputProps = serializeInputProps;
+const deserializeInputProps = async ({ serialized, region, bucketName, expectedBucketOwner, propsType, }) => {
+    if (serialized.type === 'payload') {
+        return JSON.parse(serialized.payload);
+    }
+    try {
+        const response = await (0, io_1.lambdaReadFile)({
+            bucketName,
+            expectedBucketOwner,
+            key: makeKey(propsType, serialized.hash),
+            region,
+        });
+        const body = await (0, stream_to_string_1.streamToString)(response);
+        const payload = JSON.parse(body);
+        return payload;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse input props that were serialized: ${err.stack}`);
+    }
+};
+exports.deserializeInputProps = deserializeInputProps;
+const makeKey = (type, hash) => {
+    if (type === 'input-props') {
+        return (0, constants_1.inputPropsKey)(hash);
+    }
+    if (type === 'default-props') {
+        return (0, constants_1.defaultPropsKey)(hash);
+    }
+    return (0, constants_1.resolvedPropsKey)(hash);
+};

package/dist/shared/truthy.d.ts

@@ -1,3 +1,3 @@
-declare type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
 export declare function truthy<T>(value: T): value is Truthy<T>;
 export {};

package/dist/shared/validate-bucketname.d.ts

@@ -1,3 +1,8 @@
+import type { AwsRegion } from '../client';
 export declare const validateBucketName: (bucketName: unknown, options: {
     mustStartWithRemotion: boolean;
 }) => void;
+export declare const parseBucketName: (name: string) => {
+    region: AwsRegion | null;
+};
+export declare const makeBucketName: (region: AwsRegion) => string;

package/dist/shared/validate-bucketname.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateBucketName = void 0;
+exports.makeBucketName = exports.parseBucketName = exports.validateBucketName = void 0;
+const regions_1 = require("../regions");
 const constants_1 = require("./constants");
+const random_hash_1 = require("./random-hash");
 const validateBucketName = (bucketName, options) => {
     if (typeof bucketName !== 'string') {
         throw new TypeError(`'bucketName' must be a string, but is ${JSON.stringify(bucketName)}`);
@@ -15,3 +17,19 @@ const validateBucketName = (bucketName, options) => {
     }
 };
 exports.validateBucketName = validateBucketName;
+const parseBucketName = (name) => {
+    const parsed = name.match(new RegExp(`^${constants_1.REMOTION_BUCKET_PREFIX}(.*)-([a-z0-9A-Z]+)$`));
+    const region = parsed === null || parsed === void 0 ? void 0 : parsed[1];
+    if (!region) {
+        return { region: null };
+    }
+    const realRegionFound = regions_1.AWS_REGIONS.find((r) => r.replace(/-/g, '') === region);
+    return { region: realRegionFound !== null && realRegionFound !== void 0 ? realRegionFound : null };
+};
+exports.parseBucketName = parseBucketName;
+const makeBucketName = (region) => {
+    return `${constants_1.REMOTION_BUCKET_PREFIX}${region.replace(/-/g, '')}-${(0, random_hash_1.randomHash)({
+        randomInTests: false,
+    })}`;
+};
+exports.makeBucketName = makeBucketName;

package/dist/shared/validate-lambda-codec.d.ts

@@ -1,4 +1,4 @@
-declare const lambdaCodecs: readonly ["h264-mkv", "h264", "vp8", "mp3", "aac", "wav", "gif", "prores"];
-export declare type LambdaCodec = typeof lambdaCodecs[number];
+declare const lambdaCodecs: readonly ["h264", "vp8", "vp9", "mp3", "aac", "wav", "gif", "prores"];
+export type LambdaCodec = typeof lambdaCodecs[number];
 export declare const validateLambdaCodec: (codec: unknown) => LambdaCodec;
 export {};

package/dist/shared/validate-lambda-codec.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateLambdaCodec = void 0;
 const lambdaCodecs = [
-    'h264-mkv',
     'h264',
     'vp8',
+    'vp9',
     'mp3',
     'aac',
     'wav',

package/dist/shared/validate-outname.d.ts

@@ -1,3 +1,3 @@
-import type { Codec } from '@remotion/renderer';
+import type { AudioCodec, Codec } from '@remotion/renderer';
 import type { OutNameInputWithoutCredentials } from './constants';
-export declare const validateOutname: (outName: OutNameInputWithoutCredentials | undefined | null, codec?: Codec) => void;
+export declare const validateOutname: (outName: OutNameInputWithoutCredentials | undefined | null, codec: Codec | null, audioCodec: AudioCodec | null) => void;

package/dist/shared/validate-outname.js

@@ -7,24 +7,30 @@ const validateS3Key = (s3Key) => {
     if (typeof s3Key !== 'string') {
         throw new TypeError('The S3 key must be a string. Passed an object of type ' + typeof s3Key);
     }
-    if (!s3Key.match(/^([0-9a-zA-Z-!_.*'()/]+)$/g)) {
-        throw new Error("The S3 Key must match the RegExp `/([0-9a-zA-Z-!_.*'()/]+)/g`. You passed: " +
+    // https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html
+    if (!s3Key.match(/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g)) {
+        throw new Error("The S3 Key must match the RegExp `/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g`. You passed: " +
             s3Key +
             '. Check for invalid characters.');
     }
 };
-const validateOutname = (outName, codec) => {
+const validateOutname = (outName, codec, audioCodec) => {
     if (typeof outName === 'undefined' || outName === null) {
         return;
     }
-    if (typeof outName === 'string') {
-        if (codec) {
-            (0, renderer_1.validateOutputFilename)(codec, renderer_1.RenderInternals.getExtensionOfFilename(outName !== null && outName !== void 0 ? outName : null));
-        }
-        validateS3Key(outName);
+    if (typeof outName !== 'string') {
+        validateS3Key(outName.key);
+        (0, validate_bucketname_1.validateBucketName)(outName.bucketName, { mustStartWithRemotion: false });
         return;
     }
-    validateS3Key(outName.key);
-    (0, validate_bucketname_1.validateBucketName)(outName.bucketName, { mustStartWithRemotion: false });
+    if (codec) {
+        (0, renderer_1.validateOutputFilename)({
+            codec,
+            audioCodec,
+            extension: renderer_1.RenderInternals.getExtensionOfFilename(outName),
+            preferLossless: false,
+        });
+    }
+    validateS3Key(outName);
 };
 exports.validateOutname = validateOutname;

package/dist/shared/validate-privacy.d.ts

@@ -1,2 +1,2 @@
 import type { Privacy } from './constants';
-export declare function validatePrivacy(privacy: unknown): asserts privacy is Privacy;
+export declare function validatePrivacy(privacy: unknown, allowPrivate: boolean): asserts privacy is Privacy;

package/dist/shared/validate-privacy.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatePrivacy = void 0;
-function validatePrivacy(privacy) {
+function validatePrivacy(privacy, allowPrivate) {
     if (typeof privacy !== 'string') {
         throw new TypeError('Privacy must be a string');
     }
+    if (!allowPrivate && privacy === 'private') {
+        throw new TypeError('Privacy must be either "public" or "no-acl"');
+    }
     if (privacy !== 'private' && privacy !== 'public' && privacy !== 'no-acl') {
-        throw new TypeError('Privacy must be either "private", "public-read" or "no-acl"');
+        throw new TypeError('Privacy must be either "private", "public" or "no-acl"');
     }
 }
 exports.validatePrivacy = validatePrivacy;