Module runtime/closure



interface CodePathOptions

interface CodePathOptions

Options for controlling what gets returned by [computeCodePaths].

property extraExcludePackages

extraExcludePackages?: string[];

Packages to explicitly exclude from the Assets for a serialized closure. This can be used when clients want to trim down the size of a closure, and they know that some package won’t ever actually be needed at runtime, but is still a dependency of some package that is being used at runtime.

property extraIncludePackages

extraIncludePackages?: string[];

Extra packages to include when producing the Assets for a serialized closure. This can be useful if the packages are acquired in a way that the serialization code does not understand. For example, if there was some sort of module that was pulled in based off of a computed string.

property extraIncludePaths

extraIncludePaths?: string[];

Local file/directory paths that we always want to include when producing the Assets to be included for a serialized closure.

property logResource

logResource?: Resource;

The resource to log any errors we encounter against.

function computeCodePaths

computeCodePaths(options?: CodePathOptions): Promise<Map<string, Asset | Archive>>

computeCodePaths computes the local node_module paths to include in an uploaded cloud ‘Lambda’. Specifically, it will examine the package.json for the caller’s code, and will transitively walk it’s ‘dependencies’ section to determine what packages should be included.

During this walk, if a package is encountered that contains a "pulumi": { ... } section then the normal "dependencies": { ... } section of that package will not be included. These are “pulumi” packages, and those dependencies are only intended for use at deployment time. However, a “pulumi” package can also specify package that should be available at cloud-runtime. These packages are found in a "runtimeDependencies": { ... } section in the package.json file with the same format as the normal “dependencies” section.

See [CodePathOptions] for information on ways to control and configure the final set of paths included in the resultant asset/archive map.

Note: this functionality is specifically intended for use by downstream library code that is determining what is needed for a cloud-lambda. i.e. the aws.serverless.Function or azure.serverless.FunctionApp libraries. In general, other clients should not need to use this helper.

DEPRECATED Use the [computeCodePaths] overload that takes a [CodePathOptions] instead.
computeCodePaths(extraIncludePaths?: string[], extraIncludePackages?: string[], extraExcludePackages?: string[]): Promise<Map<string, Asset | Archive>>

interface SerializedFunction

interface SerializedFunction

SerializeFunction is a representation of a serialized JavaScript function.

property exportName

exportName: string;

The name of the exported module member.

property text

text: string;

The text of a JavaScript module which exports a single name bound to an appropriate value. In the case of a normal function, this value will just be serialized function. In the case of a factory function this value will be the result of invoking the factory function.

function serializeFunction

serializeFunction(func: Function, args: SerializeFunctionArgs): Promise<SerializedFunction>

serializeFunction serializes a JavaScript function into a text form that can be loaded in another execution context, for example as part of a function callback associated with an AWS Lambda. The function serialization captures any variables captured by the function body and serializes those values into the generated text along with the function body. This process is recursive, so that functions referenced by the body of the serialized function will themselves be serialized as well. This process also deeply serializes captured object values, including prototype chains and property descriptors, such that the semantics of the function when deserialized should match the original function.

There are several known limitations: - If a native function is captured either directly or indirectly, closure serialization will return an error. - Captured values will be serialized based on their values at the time that serializeFunction is called. Mutations to these values after that (but before the deserialized function is used) will not be observed by the deserialized function.

interface SerializeFunctionArgs

interface SerializeFunctionArgs

SerializeFunctionArgs are arguments used to serialize a JavaScript function

property exportName

exportName?: undefined | string;

The name to export from the module defined by the generated module text. Defaults to ‘handler’.

property isFactoryFunction

isFactoryFunction?: undefined | false | true;

If this is a function which, when invoked, will produce the actual entrypoint function. Useful for when serializing a function that has high startup cost that only wants to be run once. The signature of this function should be: () => (provider_handler_args…) => provider_result

This will then be emitted as: exports.[exportName] = serialized_func_name();

In other words, the function will be invoked (once) and the resulting inner function will be what is exported.

property logResource

logResource?: Resource;

The resource to log any errors we encounter against.

property serialize

serialize?: undefined | (o: any) => boolean;

A function to prevent serialization of certain objects captured during the serialization. Primarily used to prevent potential cycles.

function serializeFunctionAsync

DEPRECATED Please use 'serializeFunction' instead.
serializeFunctionAsync(func: Function, serialize?: undefined | (o: any) => boolean): Promise<string>