@remotion/serverless 4.0.244 → 4.0.245

package/dist/handlers/compositions.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositionsHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const version_1 = require("remotion/version");
+const compress_props_1 = require("../compress-props");
+const constants_1 = require("../constants");
+const get_or_create_bucket_1 = require("../get-or-create-bucket");
+const compositionsHandler = async (lambdaParams, options, providerSpecifics) => {
+    var _a;
+    if (lambdaParams.type !== constants_1.ServerlessRoutines.compositions) {
+        throw new TypeError('Expected info compositions');
+    }
+    if (lambdaParams.version !== version_1.VERSION) {
+        if (!lambdaParams.version) {
+            throw new Error(`Version mismatch: When calling getCompositionsOnLambda(), you called the function ${process.env.AWS_LAMBDA_FUNCTION_NAME} which has the version ${version_1.VERSION} but the @remotion/lambda package is an older version. Deploy a new function and use it to call getCompositionsOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
+        }
+        throw new Error(`Version mismatch: When calling getCompositionsOnLambda(), you passed ${process.env.AWS_LAMBDA_FUNCTION_NAME} as the function, which has the version ${version_1.VERSION}, but the @remotion/lambda package you used to invoke the function has version ${lambdaParams.version}. Deploy a new function and use it to call getCompositionsOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
+    }
+    try {
+        const region = providerSpecifics.getCurrentRegionInFunction();
+        const browserInstancePromise = providerSpecifics.getBrowserInstance({
+            logLevel: lambdaParams.logLevel,
+            indent: false,
+            chromiumOptions: lambdaParams.chromiumOptions,
+            providerSpecifics,
+        });
+        const bucketNamePromise = lambdaParams.bucketName
+            ? Promise.resolve(lambdaParams.bucketName)
+            : (0, get_or_create_bucket_1.internalGetOrCreateBucket)({
+                region,
+                enableFolderExpiry: null,
+                customCredentials: null,
+                providerSpecifics,
+                forcePathStyle: lambdaParams.forcePathStyle,
+                skipPutAcl: false,
+            }).then((b) => b.bucketName);
+        const bucketName = await bucketNamePromise;
+        const serializedInputPropsWithCustomSchema = await (0, compress_props_1.decompressInputProps)({
+            bucketName: await bucketNamePromise,
+            expectedBucketOwner: options.expectedBucketOwner,
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            serialized: lambdaParams.inputProps,
+            propsType: 'input-props',
+            providerSpecifics,
+            forcePathStyle: lambdaParams.forcePathStyle,
+        });
+        const realServeUrl = providerSpecifics.convertToServeUrl({
+            urlOrId: lambdaParams.serveUrl,
+            region,
+            bucketName,
+        });
+        const compositions = await renderer_1.RenderInternals.internalGetCompositions({
+            serveUrlOrWebpackUrl: realServeUrl,
+            puppeteerInstance: (await browserInstancePromise).instance,
+            serializedInputPropsWithCustomSchema,
+            envVariables: (_a = lambdaParams.envVariables) !== null && _a !== void 0 ? _a : {},
+            timeoutInMilliseconds: lambdaParams.timeoutInMilliseconds,
+            chromiumOptions: lambdaParams.chromiumOptions,
+            port: null,
+            server: undefined,
+            logLevel: lambdaParams.logLevel,
+            indent: false,
+            browserExecutable: null,
+            onBrowserLog: null,
+            offthreadVideoCacheSizeInBytes: lambdaParams.offthreadVideoCacheSizeInBytes,
+            binariesDirectory: null,
+            onBrowserDownload: () => {
+                throw new Error('Should not download a browser in Lambda');
+            },
+        });
+        return Promise.resolve({
+            compositions,
+            type: 'success',
+        });
+    }
+    finally {
+        providerSpecifics.forgetBrowserEventLoop(lambdaParams.logLevel);
+    }
+};
+exports.compositionsHandler = compositionsHandler;

package/dist/handlers/launch.d.ts

@@ -0,0 +1,17 @@
+import type { ServerlessPayload } from '../constants';
+import type { WebhookClient } from '../invoke-webhook';
+import type { ProviderSpecifics } from '../provider-implementation';
+import type { CloudProvider } from '../types';
+type Options = {
+    expectedBucketOwner: string;
+    getRemainingTimeInMillis: () => number;
+};
+export declare const launchHandler: <Provider extends CloudProvider>({ params, options, providerSpecifics, client, }: {
+    params: ServerlessPayload<Provider>;
+    options: Options;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    client: WebhookClient;
+}) => Promise<{
+    type: "success";
+}>;
+export {};