@remotion/lambda 4.0.0-prefetch.10 → 4.0.0-prefetch.12

package/dist/shared/aws-clients.d.ts

@@ -11,9 +11,20 @@ export declare type ServiceMapping = {
     lambda: LambdaClient;
     servicequotas: ServiceQuotasClient;
 };
-export declare const getServiceClient: <T extends keyof ServiceMapping>(region: AwsRegion, service: T) => ServiceMapping[T];
+export declare type CustomCredentialsWithoutSensitiveData = {
+    endpoint: string;
+};
+export declare type CustomCredentials = CustomCredentialsWithoutSensitiveData & {
+    accessKeyId: string | null;
+    secretAccessKey: string | null;
+};
+export declare const getServiceClient: <T extends keyof ServiceMapping>({ region, service, customCredentials, }: {
+    region: AwsRegion;
+    service: T;
+    customCredentials: CustomCredentials | null;
+}) => ServiceMapping[T];
 export declare const getCloudWatchLogsClient: (region: AwsRegion) => CloudWatchLogsClient;
-export declare const getS3Client: (region: AwsRegion) => S3Client;
+export declare const getS3Client: (region: AwsRegion, customCredentials: CustomCredentials | null) => S3Client;
 export declare const getLambdaClient: (region: AwsRegion) => LambdaClient;
 export declare const getIamClient: (region: AwsRegion) => IAMClient;
 export declare const getServiceQuotasClient: (region: AwsRegion) => ServiceQuotasClient;

package/dist/shared/aws-clients.js

@@ -28,11 +28,17 @@ const getCredentials = () => {
     }
     return undefined;
 };
-const getCredentialsKey = () => JSON.stringify(getCredentials());
-const getServiceClient = (region, service) => {
-    if (!_clients[region]) {
-        _clients[region] = {};
-    }
+const getKey = ({ credentials, customCredentials, region, service, }) => [
+    credentials === null || credentials === void 0 ? void 0 : credentials.accessKeyId,
+    credentials === null || credentials === void 0 ? void 0 : credentials.secretAccessKey,
+    customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.accessKeyId,
+    customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.endpoint,
+    customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.secretAccessKey,
+    region,
+    service,
+].join('-');
+const getServiceClient = ({ region, service, customCredentials, }) => {
+    var _a;
     const Client = (() => {
         if (service === 'cloudwatch') {
             return client_cloudwatch_logs_1.CloudWatchLogsClient;
@@ -49,43 +55,67 @@ const getServiceClient = (region, service) => {
         if (service === 'servicequotas') {
             return client_service_quotas_1.ServiceQuotasClient;
         }
+        throw new TypeError('unknown client ' + service);
     })();
-    const key = getCredentialsKey();
-    // @ts-expect-error
-    if (!_clients[region][key]) {
-        // @ts-expect-error
-        _clients[region][key] = {};
-    }
-    // @ts-expect-error
-    if (!_clients[region][key][service]) {
+    const key = getKey({
+        credentials: (_a = getCredentials()) !== null && _a !== void 0 ? _a : null,
+        region,
+        customCredentials,
+        service,
+    });
+    if (!_clients[key]) {
         (0, check_credentials_1.checkCredentials)();
-        // @ts-expect-error
-        _clients[region][key][service] = new Client({
-            region,
-            credentials: getCredentials(),
-        });
+        if (customCredentials) {
+            _clients[key] = new Client({
+                region: 'us-east-1',
+                credentials: customCredentials.accessKeyId && customCredentials.secretAccessKey
+                    ? {
+                        accessKeyId: customCredentials.accessKeyId,
+                        secretAccessKey: customCredentials.secretAccessKey,
+                    }
+                    : undefined,
+                endpoint: customCredentials.endpoint,
+            });
+        }
+        else {
+            _clients[key] = new Client({
+                region,
+                credentials: getCredentials(),
+            });
+        }
     }
-    // @ts-expect-error
-    return _clients[region][key][service];
+    return _clients[key];
 };
 exports.getServiceClient = getServiceClient;
 const getCloudWatchLogsClient = (region) => {
-    return (0, exports.getServiceClient)(region, 'cloudwatch');
+    return (0, exports.getServiceClient)({
+        region,
+        service: 'cloudwatch',
+        customCredentials: null,
+    });
 };
 exports.getCloudWatchLogsClient = getCloudWatchLogsClient;
-const getS3Client = (region) => {
-    return (0, exports.getServiceClient)(region, 's3');
+const getS3Client = (region, customCredentials) => {
+    return (0, exports.getServiceClient)({ region, service: 's3', customCredentials });
 };
 exports.getS3Client = getS3Client;
 const getLambdaClient = (region) => {
-    return (0, exports.getServiceClient)(region, 'lambda');
+    return (0, exports.getServiceClient)({
+        region,
+        service: 'lambda',
+        customCredentials: null,
+    });
 };
 exports.getLambdaClient = getLambdaClient;
 const getIamClient = (region) => {
-    return (0, exports.getServiceClient)(region, 'iam');
+    return (0, exports.getServiceClient)({ region, service: 'iam', customCredentials: null });
 };
 exports.getIamClient = getIamClient;
 const getServiceQuotasClient = (region) => {
-    return (0, exports.getServiceClient)(region, 'servicequotas');
+    return (0, exports.getServiceClient)({
+        region,
+        service: 'servicequotas',
+        customCredentials: null,
+    });
 };
 exports.getServiceQuotasClient = getServiceQuotasClient;

package/dist/shared/bundle-site.d.ts

@@ -1 +1,2 @@
-export declare const bundleSite: (entryPoint: string, onProgressUpdate?: ((progress: number) => void) | undefined, options?: import("@remotion/bundler").BundleOptions | undefined) => Promise<string>;
+import { bundle } from '@remotion/bundler';
+export declare const bundleSite: typeof bundle;

package/dist/shared/constants.d.ts

@@ -3,6 +3,7 @@ import type { VideoConfig } from 'remotion';
 import type { ChunkRetry } from '../functions/helpers/get-retry-stats';
 import type { EnhancedErrorInfo } from '../functions/helpers/write-lambda-error';
 import type { AwsRegion } from '../pricing/aws-regions';
+import type { CustomCredentials, CustomCredentialsWithoutSensitiveData } from './aws-clients';
 import type { DownloadBehavior } from './content-disposition-header';
 import type { ExpensiveChunk } from './get-most-expensive-chunks';
 import type { LambdaArchitecture } from './validate-architecture';
@@ -62,10 +63,17 @@ export declare const getErrorFileName: ({ renderId, chunk, attempt, }: {
 export declare type OutNameInput = string | {
     bucketName: string;
     key: string;
+    s3OutputProvider?: CustomCredentials;
+};
+export declare type OutNameInputWithoutCredentials = string | {
+    bucketName: string;
+    key: string;
+    s3OutputProvider?: CustomCredentialsWithoutSensitiveData;
 };
 export declare type OutNameOutput = {
     renderBucketName: string;
     key: string;
+    customCredentials: CustomCredentials | null;
 };
 export declare const optimizationProfile: (siteId: string, compositionId: string) => string;
 export declare const getSitesKey: (siteId: string) => string;
@@ -85,6 +93,10 @@ export declare enum LambdaRoutines {
     renderer = "renderer",
     still = "still"
 }
+declare type WebhookOption = null | {
+    url: string;
+    secret: string | null;
+};
 export declare type LambdaPayloads = {
     info: {
         type: LambdaRoutines.info;
@@ -116,6 +128,10 @@ export declare type LambdaPayloads = {
         downloadBehavior: DownloadBehavior;
         muted: boolean;
         version: string;
+        overwrite: boolean;
+        audioBitrate: string | null;
+        videoBitrate: string | null;
+        webhook: WebhookOption;
     };
     launch: {
         type: LambdaRoutines.launch;
@@ -145,12 +161,17 @@ export declare type LambdaPayloads = {
         concurrencyPerLambda: number;
         downloadBehavior: DownloadBehavior;
         muted: boolean;
+        overwrite: boolean;
+        audioBitrate: string | null;
+        videoBitrate: string | null;
+        webhook: WebhookOption;
     };
     status: {
         type: LambdaRoutines.status;
         bucketName: string;
         renderId: string;
         version: string;
+        s3OutputProvider?: CustomCredentials;
     };
     renderer: {
         concurrencyPerLambda: number;
@@ -182,6 +203,8 @@ export declare type LambdaPayloads = {
         scale: number;
         everyNthFrame: number;
         muted: boolean;
+        audioBitrate: string | null;
+        videoBitrate: string | null;
     };
     still: {
         type: LambdaRoutines.still;
@@ -229,7 +252,8 @@ export declare type RenderMetadata = {
     lambdaVersion: string;
     region: AwsRegion;
     renderId: string;
-    outName: OutNameInput | undefined;
+    outName: OutNameInputWithoutCredentials | undefined;
+    privacy: Privacy;
 };
 export declare type PostRenderData = {
     cost: {
@@ -292,3 +316,4 @@ export declare type RenderProgress = {
 export declare type Privacy = 'public' | 'private' | 'no-acl';
 export declare const LAMBDA_CONCURRENCY_LIMIT_QUOTA = "L-B99A9384";
 export declare const LAMBDA_BURST_LIMIT_QUOTA = "L-548AE339";
+export {};

package/dist/shared/constants.js

@@ -60,13 +60,19 @@ exports.outName = outName;
 const outStillName = (renderId, imageFormat) => `${(0, exports.rendersPrefix)(renderId)}/out.${imageFormat}`;
 exports.outStillName = outStillName;
 const customOutName = (renderId, bucketName, name) => {
+    var _a;
     if (typeof name === 'string') {
         return {
             renderBucketName: bucketName,
             key: `${(0, exports.rendersPrefix)(renderId)}/${name}`,
+            customCredentials: null,
         };
     }
-    return { key: name.key, renderBucketName: name.bucketName };
+    return {
+        key: name.key,
+        renderBucketName: name.bucketName,
+        customCredentials: (_a = name.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
+    };
 };
 exports.customOutName = customOutName;
 const postRenderDataKey = (renderId) => {

package/dist/shared/invoke-webhook.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+import type { EnhancedErrorInfo } from '../functions/helpers/write-lambda-error';
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+export declare function calculateSignature(payload: string, secret: string | null): string;
+declare type DynamicWebhookPayload = {
+    type: 'error';
+    errors: {
+        message: string;
+        name: string;
+        stack: string;
+    }[];
+} | {
+    type: 'success';
+    lambdaErrors: EnhancedErrorInfo[];
+    outputUrl: string | undefined;
+    outputFile: string | undefined;
+    timeToFinish: number | undefined;
+} | {
+    type: 'timeout';
+};
+export declare type WebhookPayload = {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+} & DynamicWebhookPayload;
+export declare const mockableHttpClients: {
+    http: typeof http.request;
+    https: typeof https.request;
+};
+export declare function invokeWebhook({ payload, secret, url, }: {
+    payload: WebhookPayload;
+    url: string;
+    secret: string | null;
+}): Promise<void>;
+export {};

package/dist/shared/invoke-webhook.js

@@ -0,0 +1,89 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeWebhook = exports.mockableHttpClients = exports.calculateSignature = void 0;
+const Crypto = __importStar(require("crypto"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+function calculateSignature(payload, secret) {
+    if (!secret) {
+        return 'NO_SECRET_PROVIDED';
+    }
+    const hmac = Crypto.createHmac('sha512', secret);
+    const signature = 'sha512=' + hmac.update(payload).digest('hex');
+    return signature;
+}
+exports.calculateSignature = calculateSignature;
+const getWebhookClient = (url) => {
+    if (url.startsWith('https://')) {
+        return exports.mockableHttpClients.https;
+    }
+    if (url.startsWith('http://')) {
+        return exports.mockableHttpClients.http;
+    }
+    throw new Error('Can only request URLs starting with http:// or https://');
+};
+exports.mockableHttpClients = {
+    http: http_1.default.request,
+    https: https_1.default.request,
+};
+function invokeWebhook({ payload, secret, url, }) {
+    const jsonPayload = JSON.stringify(payload);
+    return new Promise((resolve, reject) => {
+        const req = getWebhookClient(url)(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': jsonPayload.length,
+                'X-Remotion-Mode': 'production',
+                'X-Remotion-Signature': calculateSignature(jsonPayload, secret),
+                'X-Remotion-Status': payload.type,
+            },
+            timeout: 5000,
+        }, (res) => {
+            if (res.statusCode && res.statusCode > 299) {
+                reject(new Error(`Sent a webhook but got a status code of ${res.statusCode} with message '${res.statusMessage}'`));
+                return;
+            }
+            resolve();
+        });
+        req.write(jsonPayload);
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.end();
+    });
+}
+exports.invokeWebhook = invokeWebhook;

package/dist/shared/validate-frames-per-lambda.d.ts

@@ -1 +1,4 @@
-export declare const validateFramesPerLambda: (framesPerLambda: unknown) => void;
+export declare const validateFramesPerLambda: ({ framesPerLambda, durationInFrames, }: {
+    framesPerLambda: unknown;
+    durationInFrames: number;
+}) => void;

package/dist/shared/validate-frames-per-lambda.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateFramesPerLambda = void 0;
 const constants_1 = require("./constants");
-const validateFramesPerLambda = (framesPerLambda) => {
+const validateFramesPerLambda = ({ framesPerLambda, durationInFrames, }) => {
     if (framesPerLambda === null) {
         return;
     }
@@ -21,8 +21,9 @@ const validateFramesPerLambda = (framesPerLambda) => {
     if (framesPerLambda % 1 !== 0) {
         throw new TypeError(`'framesPerLambda' needs to be an integer, passed ${framesPerLambda}`);
     }
-    if (framesPerLambda < constants_1.MINIMUM_FRAMES_PER_LAMBDA) {
-        throw new TypeError(`The framesPerLambda needs to be at least 4, but is ${framesPerLambda}`);
+    const effectiveMinimum = Math.min(constants_1.MINIMUM_FRAMES_PER_LAMBDA, durationInFrames);
+    if (framesPerLambda < effectiveMinimum) {
+        throw new TypeError(`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerLambda}`);
     }
 };
 exports.validateFramesPerLambda = validateFramesPerLambda;

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

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

package/dist/shared/validate-outname.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOutname = void 0;
+const renderer_1 = require("@remotion/renderer");
 const validate_bucketname_1 = require("./validate-bucketname");
 const validateS3Key = (s3Key) => {
     if (typeof s3Key !== 'string') {
@@ -12,11 +13,14 @@ const validateS3Key = (s3Key) => {
             '. Check for invalid characters.');
     }
 };
-const validateOutname = (outName) => {
+const validateOutname = (outName, codec) => {
     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);
         return;
     }