@comicrelief/lambda-wrapper 1.10.2 → 2.0.0-beta.10

package/README.md

@@ -4,97 +4,243 @@
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 [![semantic-release](https://badge.fury.io/js/%40comicrelief%2Flambda-wrapper.svg)](https://www.npmjs.com/package/@comicrelief/lambda-wrapper)
 
-When writing Serverless endpoints, we have found ourselves replicating a lot of boiler plate code to do basic actions, such as reading request variables or writing to SQS. The aim of this package is to provide a wrapper for our Lambda functions, to provide some level of dependency and configuration injection and to reduce time spent on project setup.
+When writing Serverless applications, we have found ourselves replicating a lot of boilerplate code to do basic actions, such as reading request data or sending messages to SQS. The aim of this package is to provide a wrapper for our Lambda functions, to provide some level of dependency and configuration injection and to reduce time spent on project setup.
 
-> 🚀 [Lambda Wrapper v2 is now available in beta!](https://github.com/comicrelief/lambda-wrapper/tree/beta) This major release includes TypeScript support and some significant design changes.
+If you're coming from v1 and updating to v2, check out the [v2 migration guide](docs/migration/v2.md).
 
-## Installation & usage
+## Getting started
 
-Install via npm:
+Install via npm or Yarn:
 
 ```bash
-npm install --save @comicrelief/lambda-wrapper
+npm i @comicrelief/lambda-wrapper@beta
+# or
+yarn add @comicrelief/lambda-wrapper@beta
 ```
 
-Or via yarn:
+You can then wrap your Lambda handler functions like this:
 
-```bash
-yarn add @comicrelief/lambda-wrapper
-```
-
-You can then wrap your lambdas as follows.
-
-```js
-import {
-  LambdaWrapper,
+```ts
+// src/action/Hello.ts
+import lambdaWrapper, {
   ResponseModel,
   RequestService,
 } from '@comicrelief/lambda-wrapper';
 
-export default LambdaWrapper({}, (di, request, done) => {
-  const response = new ResponseModel({}, 200, `hello ${request.get('name', 'nobody')}`);
-  done(null, response.generate());
+export default lambdaWrapper.wrap(async (di) => {
+  const request = di.get(RequestService);
+  return ResponseModel.generate(
+    {},
+    200,
+    `hello ${request.get('name', 'nobody')}`,
+  );
 });
 ```
 
-## Serverless Offline & SQS Emulation
+Here we've used the default export `lambdaWrapper` which is a preconfigured instance that can be used out of the box. You'll likely want to add your own dependencies and service config using the `configure` method:
+
+```ts
+// src/config/LambdaWrapper.ts
+import lambdaWrapper from '@comicrelief/lambda-wrapper';
+
+export default lambdaWrapper.configure({
+  // your config goes here
+});
+```
 
-Serverless Offline only emulates API Gateway and Lambda, so publishing an SQS message would use the real SQS queue and trigger the consumer function (if any) in AWS. When working with offline code, you often want the local functions to be invoked instead.
+`configure` returns a new Lambda Wrapper instance with the given configuration. You'll want to export it and then use this when wrapping your handler functions.
 
-Offline SQS behaviour can be configured by setting the `LAMBDA_WRAPPER_OFFLINE_SQS_MODE` environment variable. Available modes are:
+Read the next section to see what goes inside the config object!
 
-- `direct` (the default): invokes the consumer function directly via an offline Lambda endpoint
-- `local`: send messages to an offline SQS endpoint, such as Localstack
-- `aws`: no special handling of SQS offline; messages will be sent to AWS
+If you want to start from scratch without the built-in dependencies, you can use the `LambdaWrapper` constructor directly.
 
-Details of each mode are documented in the sections below. When you send a message using `SQSService.prototype.publish`, it will check which mode to use and dispatch the message appropriately. These modes take effect only when running offline (as defined by `DependencyInjection.prototype.isOffline`). In a deployed environment, SQS messages will always be sent to AWS SQS.
+```ts
+// src/config/LambdaWrapper.ts
+import { LambdaWrapper } from '@comicrelief/lambda-wrapper';
 
-### Direct Lambda mode
+export default new LambdaWrapper({
+  // your config goes here
+});
+```
 
-This is the default mode if `LAMBDA_WRAPPER_OFFLINE_SQS_MODE` is not set. A Lambda client will be created and the message will be delivered to the offline Lambda endpoint, effectively running the consumer function _immediately_ as part of the original Lambda invocation. This works very well in the offline environment because invoking a Lambda function will trigger its whole (local) execution tree.
+## Dependencies
 
-To take advantage of SQS emulation, you will need to define the following in the implementing service:
+Lambda Wrapper comes with some commonly used dependencies built in:
 
-**QUEUE_CONSUMERS**
+- [HTTPService](docs/services/HTTPService.md)
+- [LoggerService](docs/services/LoggerService.md)
+- [RequestService](docs/services/RequestService.md)
+- [SQSService](docs/services/SQSService.md)
+- [TimerService](docs/services/TimerService.md)
 
-In your `src/Config/Configuration` define a `QUEUE_CONSUMERS` object. `QUEUE_CONSUMERS` will map the queue name to the fully qualified `FunctionName` that we want to trigger when messages are published to that queue.
+Access these via dependency injection. You've already seen an example of this where we got `RequestService`. Pass the dependency class to `di.get()` to get its instance:
 
-You will need to export `QUEUE_CONSUMERS` as part of your default export, alongside `DEFINITIONS`, `DEPENDENCIES`, `QUEUES`, `QUEUE_DEFINITIONS`, etc.
+```ts
+export default lambdaWrapper.wrap(async (di) => {
+  const request = di.get(RequestService);
+  const sqs = di.get(SQSService);
+  // ...
+});
+```
 
-A `Configuration` example can be found in the `serverless-prize-platform` repository [here](https://github.com/comicrelief/serverless-prize-platform/blob/master/src/Config/Configuration.js).
+To add your own dependencies, first extend `DependencyAwareClass`.
 
-**process.env.SERVICE_LAMBDA_URL**
+```ts
+// src/services/MyService.ts
+import { DependencyAwareClass } from '@comicrelief/lambda-wrapper';
 
-While creating the Lambda client, we need to point it to our offline environment. LambdaWrapper will take care of the specifics, but it will need to know the Lambda endpoint URL. This _can_ and _must_ be specified via the `SERVICE_LAMBDA_URL` environment variable.
+export default class MyService extends DependencyAwareClass {
+  doSomething() {
+    // ...
+  }
+}
+```
 
-The URL is likely to be your localhost URL and the next available port from the offline API Gateway. So, if you are running Serverless Offline on `http://localhost:3001`, the Lambda URL is likely to be `http://localhost:3002`. You can check the port in the output during Serverless Offline startup by looking for the following line:
+Then add it to your Lambda Wrapper configuration in the `dependencies` key.
 
-    offline: Offline [http for lambda] listening on http://localhost:3002
+```ts
+// src/config/LambdaWrapper.ts
+import lambdaWrapper from '@comicrelief/lambda-wrapper';
 
-#### Caveats
+import MyService from '@/src/services/MyService';
+
+export default lambdaWrapper.configure({
+  dependencies: {
+    MyService,
+  },
+});
+```
+
+Now you can use it inside your handler functions and other dependencies!
+
+```ts
+// src/action/DoSomething.ts
+import lambdaWrapper from '@/src/config/LambdaWrapper';
+import MyService from '@/src/services/MyService';
+
+export default lambdaWrapper.wrap(async (di) => {
+  di.get(MyService).doSomething();
+});
+```
+
+## Service config
+
+Some dependencies need their own config. This goes in per-service keys within your Lambda Wrapper config. For an example, see [SQSService](docs/services/SQSService.md) which uses the `sqs` key.
+
+```ts
+export default lambdaWrapper.configure({
+  dependencies: {
+    // your dependencies
+  },
+  sqs: {
+    // your SQSService config
+  },
+  // ... other configs ...
+});
+```
 
-1. You will be running the SQS-triggered lambdas in the same Serverless Offline context as your triggering lambda. Expect logs from both lambdas in the Serverless Offline output.
+To use config with your own dependencies, you need to do three things:
 
-2. If you await `sqs.publish` you will effectively wait until all SQS-triggered lambdas (and possibly their own SQS-triggered lambdas) have all completed. This is necessary to avoid any pending execution (i.e. the lambda terminating before its async processes are completed).
+1. Define the key and type of your config object.
 
-3. If the triggered lambda incurs an exception, this will be propagated upstream, effectively killing the execution of the calling lambda.
+   Using `SQSService` as an example, we have the `sqs` key which has the `SQSServiceConfig` type:
+
+   ```ts
+   export interface SQSServiceConfig {
+     queues?: Record<string, string>;
+     queueConsumers?: Record<string, string>;
+   }
+   ```
+
+2. Define a type that can be applied to a Lambda Wrapper config.
+
+   This simply combines the key and type defined in step 1. Conventionally we name these `With...` types.
+
+   ```ts
+   export interface WithSQSServiceConfig {
+     sqs?: SQSServiceConfig;
+   }
+   ```
+
+   In the case of `SQSService`, the `sqs` key is optional because this dependency is included by default and not all applications need it. If your dependency requires config in order to work, you can make this a required key.
+
+3. In your dependency constructor, cast the config to this type.
+
+   ```ts
+   export default class SQSService extends DependencyAwareClass {
+     constructor(di: DependencyInjection) {
+       super(di);
+
+       const config = (this.di.config as WithSQSServiceConfig).sqs;
+       // Bear in mind that because the `sqs` key is optional, the type of
+       // `config` will be `SQSServiceConfig | undefined`. Take care when
+       // accessing its properties! You can use optional chaining:
+       const queues = config?.queues || {};
+       // ...
+     }
+   }
+   ```
+
+When you go to configure your Lambda Wrapper, you can now include your dependency's config type in the generic for `configure` to get IntelliSense completions and type checking for your config keys.
+
+```ts
+lambdaWrapper.configure<WithSQSServiceConfig>({
+  sqs: {
+    queues: 42 // Oops! This will be flagged as a type error by TypeScript
+  },
+});
+```
+
+You can combine types for multiple dependencies if needed using `&`:
+
+```ts
+lambdaWrapper.configure<WithSQSServiceConfig & WithOtherServiceConfig>({
+  sqs: {
+    // SQSService config
+  },
+  other: {
+    // OtherService config
+  },
+});
+```
+
+## Monitoring
+
+At Comic Relief we use [Lumigo](https://lumigo.io/) for monitoring and observability of our deployed services. Lambda Wrapper includes the Lumigo tracer to allow us to tag traces with custom labels and metrics ([execution tags](https://docs.lumigo.io/docs/execution-tags)).
+
+Lumigo integration works out-of-the-box with Lumigo's [auto-trace feature](https://docs.lumigo.io/docs/serverless-applications#automatic-instrumentation). If you prefer manual tracing, enable it by setting `LUMIGO_TRACER_TOKEN` in your Lambda environment variables.
+
+And if you don't use Lumigo, don't worry, their tracer will not be instantiated in your functions and no calls will be made to their servers unless `LUMIGO_TRACER_TOKEN` is set.
+
+## Notes
+
+Lambda Wrapper's dependency injection relies on class names being preserved. If your build process includes minifying or uglifying your code, you'll need to disable these transformations.
+
+In many of our projects we use `serverless-webpack` to bundle service code prior to deployment. To disable name mangling, set `optimization.minimize` to `false` in your webpack config:
+
+```js
+// webpack.config.js
+module.exports = {
+  // ...
+  optimization: {
+    minimize: false,
+  },
+```
 
-### Local SQS mode
+## Development
 
-Use this mode by setting `LAMBDA_WRAPPER_OFFLINE_SQS_MODE=local`. Messages will still be sent to an SQS queue, but using a locally simulated version instead of AWS. This allows you to test your service using a tool like Localstack.
+### Testing
 
-By default, messages will be sent to a SQS service running on `localhost:4576`. If you need to change the hostname, you can set `process.env.LAMBDA_WRAPPER_OFFLINE_SQS_HOST`.
-Also, if you need to change the port, you can set `process.env.LAMBDA_WRAPPER_OFFLINE_SQS_PORT`.
+Run `yarn test` to run the unit tests.
 
-### AWS SQS mode
+When writing a bugfix, start by writing a test that reproduces the problem. It should fail with the current version of Lambda Wrapper, and pass once you've implemented the fix.
 
-Use this mode by setting `LAMBDA_WRAPPER_OFFLINE_SQS_MODE=aws`. Messages will be sent to the real queue in AWS. This mode is useful when a queue is consumed by an external service, rather than another function in the service under test.
+When adding a feature, ensure it's covered by tests that adequately define its behaviour.
 
-In order for queue URLs to be correctly constructed, you must either:
+### Linting
 
-- set `AWS_ACCOUNT_ID` to the account ID that hosts your queue; or
-- invoke offline functions via the Lambda API, passing a context that contains a realistic `invokedFunctionArn` including the account ID.
+Run `yarn lint` to check code style complies to our standard. Many problems can be auto-fixed using `yarn lint --fix`.
 
-## Semantic release
+### Releases
 
 Release management is automated using [semantic-release](https://www.npmjs.com/package/semantic-release).

package/dist/core/DependencyAwareClass.d.ts

@@ -0,0 +1,16 @@
+import DependencyInjection from './DependencyInjection';
+import { LambdaWrapperConfig } from './config';
+/**
+ * Base class for dependencies.
+ */
+export default class DependencyAwareClass<TConfig extends LambdaWrapperConfig = any> {
+    readonly di: DependencyInjection<TConfig>;
+    constructor(di: DependencyInjection<TConfig>);
+    /**
+     * Get dependency injection container.
+     *
+     * @deprecated Use `this.di` instead.
+     */
+    getContainer(): DependencyInjection;
+}
+//# sourceMappingURL=DependencyAwareClass.d.ts.map

package/dist/core/DependencyAwareClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyAwareClass.d.ts","sourceRoot":"","sources":["../../src/core/DependencyAwareClass.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,oBAAoB,CAAC,OAAO,SAAS,mBAAmB,GAAG,GAAG;IACrE,QAAQ,CAAC,EAAE,EAAE,mBAAmB,CAAC,OAAO,CAAC;gBAAhC,EAAE,EAAE,mBAAmB,CAAC,OAAO,CAAC;IAErD;;;;OAIG;IACH,YAAY,IAAI,mBAAmB;CAGpC"}

package/dist/core/DependencyAwareClass.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Base class for dependencies.
+ */
+class DependencyAwareClass {
+    constructor(di) {
+        this.di = di;
+    }
+    /**
+     * Get dependency injection container.
+     *
+     * @deprecated Use `this.di` instead.
+     */
+    getContainer() {
+        return this.di;
+    }
+}
+exports.default = DependencyAwareClass;
+//# sourceMappingURL=DependencyAwareClass.js.map

package/dist/core/DependencyAwareClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyAwareClass.js","sourceRoot":"","sources":["../../src/core/DependencyAwareClass.ts"],"names":[],"mappings":";;AAGA;;GAEG;AACH,MAAqB,oBAAoB;IACvC,YAAqB,EAAgC;QAAhC,OAAE,GAAF,EAAE,CAA8B;IAAG,CAAC;IAEzD;;;;OAIG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;CACF;AAXD,uCAWC"}

package/dist/core/DependencyInjection.d.ts

@@ -0,0 +1,62 @@
+import { Context } from 'aws-lambda';
+import DependencyAwareClass from './DependencyAwareClass';
+import { LambdaWrapperConfig } from './config';
+declare type Class<TInstance, TConfig extends LambdaWrapperConfig> = new (di: DependencyInjection<TConfig>) => TInstance;
+/**
+ * Dependency injection container.
+ *
+ * Dependencies (singleton instances of dependency-aware classes) are provided
+ * to the main Lambda handler and other dependencies via this class.
+ */
+export default class DependencyInjection<TConfig extends LambdaWrapperConfig = any> {
+    readonly config: TConfig;
+    readonly event: any;
+    readonly context: Context;
+    /**
+     * Instantiated dependencies.
+     */
+    readonly dependencies: Record<string, DependencyAwareClass>;
+    /**
+     * True until all dependencies have been constructed.
+     */
+    private isConstructing;
+    constructor(config: TConfig, event: any, context: Context);
+    /**
+     * Get the singleton instance of the given dependency.
+     *
+     * @param dependency
+     */
+    get<T extends DependencyAwareClass>(dependency: Class<T, TConfig>): T;
+    /**
+     * Get the event passed to AWS Lambda.
+     *
+     * @deprecated Use `di.event` instead.
+     */
+    getEvent(): any;
+    /**
+     * Get the AWS Lambda context object.
+     *
+     * @deprecated Use `di.context` instead.
+     */
+    getContext(): Context;
+    /**
+     * Get Lambda Wrapper configuration.
+     *
+     * @deprecated Use `di.config` instead.
+     */
+    getConfiguration(): TConfig;
+    /**
+     * True if the function is being executed in `serverless-offline`.
+     *
+     * We use the following checks for this:
+     *
+     * - if there is no function ARN, or the ARN includes 'offline'
+     * - if `process.env.USE_SERVERLESS_OFFLINE` is set
+     *
+     * TODO: This is nothing to do with dependency injection and should be moved
+     *   somewhere else! Any ideas?
+     */
+    get isOffline(): boolean;
+}
+export {};
+//# sourceMappingURL=DependencyInjection.d.ts.map

package/dist/core/DependencyInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyInjection.d.ts","sourceRoot":"","sources":["../../src/core/DependencyInjection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAG/C,aAAK,KAAK,CAAC,SAAS,EAAE,OAAO,SAAS,mBAAmB,IAAI,KAAK,EAAE,EAAE,mBAAmB,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC;AAEjH;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB,CAAC,OAAO,SAAS,mBAAmB,GAAG,GAAG;IAY9E,QAAQ,CAAC,MAAM,EAAE,OAAO;IACxB,QAAQ,CAAC,KAAK,EAAE,GAAG;IACnB,QAAQ,CAAC,OAAO,EAAE,OAAO;IAb3B;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAE5D;;OAEG;IACH,OAAO,CAAC,cAAc,CAAQ;gBAGnB,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,OAAO;IAyC3B;;;;OAIG;IACH,GAAG,CAAC,CAAC,SAAS,oBAAoB,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC;IAsBrE;;;;OAIG;IACH,QAAQ;IAIR;;;;OAIG;IACH,UAAU;IAIV;;;;OAIG;IACH,gBAAgB;IAIhB;;;;;;;;;;OAUG;IACH,IAAI,SAAS,IAAI,OAAO,CAIvB;CACF"}

package/dist/core/DependencyInjection.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Dependency injection container.
+ *
+ * Dependencies (singleton instances of dependency-aware classes) are provided
+ * to the main Lambda handler and other dependencies via this class.
+ */
+class DependencyInjection {
+    constructor(config, event, context) {
+        this.config = config;
+        this.event = event;
+        this.context = context;
+        /**
+         * True until all dependencies have been constructed.
+         */
+        this.isConstructing = true;
+        // get unique dependency classes -- a class may be included several times,
+        // but should be instantiated only once
+        const classes = Array.from(new Set(Object.values(config.dependencies)));
+        // guard against duplicate keys
+        const countByName = classes
+            .map((Constructor) => Constructor.name)
+            .reduce((counts, name) => ({ ...counts, [name]: (counts[name] || 0) + 1 }), {});
+        if (Object.values(countByName).some((count) => count > 1)) {
+            const duplicateNames = Object.entries(countByName)
+                .filter(([, count]) => count > 1)
+                .map(([name]) => name);
+            // if all class names are single-letter, they're probably minified -- in
+            // this case, give a hint about how to fix it
+            const action = duplicateNames.every((it) => it.length === 1)
+                ? "If you don't recognise the single-letter names listed above, your "
+                    + "bundler may be minifying your code. You'll need to disable this "
+                    + 'for Lambda Wrapper to work correctly. Please refer to the Notes '
+                    + 'section of the Lambda Wrapper readme:\n\n'
+                    + '  https://github.com/comicrelief/lambda-wrapper/tree/beta#notes'
+                : 'Please ensure that all dependency classes have a unique name.';
+            throw new Error(`Dependency names are not unique: ${duplicateNames.join(', ')}\n\n${action}`);
+        }
+        // instantiate all dependencies
+        this.dependencies = Object.fromEntries(classes.map((Constructor) => [Constructor.name, new Constructor(this)]));
+        this.isConstructing = false;
+    }
+    /**
+     * Get the singleton instance of the given dependency.
+     *
+     * @param dependency
+     */
+    get(dependency) {
+        if (this.isConstructing) {
+            throw new Error('Dependencies are not available in dependency class constructors.\n\n'
+                + 'To fix this, call `di.get` in the function where the dependency is '
+                + 'used instead of inside your constructor.');
+        }
+        const name = dependency.name;
+        if (!this.dependencies[name]) {
+            throw new Error(`${name} does not exist in dependency container\n\n`
+                + `Make sure you've included ${name} in the 'dependencies' key of your `
+                + 'Lambda Wrapper config.');
+        }
+        return this.dependencies[name];
+    }
+    /**
+     * Get the event passed to AWS Lambda.
+     *
+     * @deprecated Use `di.event` instead.
+     */
+    getEvent() {
+        return this.event;
+    }
+    /**
+     * Get the AWS Lambda context object.
+     *
+     * @deprecated Use `di.context` instead.
+     */
+    getContext() {
+        return this.context;
+    }
+    /**
+     * Get Lambda Wrapper configuration.
+     *
+     * @deprecated Use `di.config` instead.
+     */
+    getConfiguration() {
+        return this.config;
+    }
+    /**
+     * True if the function is being executed in `serverless-offline`.
+     *
+     * We use the following checks for this:
+     *
+     * - if there is no function ARN, or the ARN includes 'offline'
+     * - if `process.env.USE_SERVERLESS_OFFLINE` is set
+     *
+     * TODO: This is nothing to do with dependency injection and should be moved
+     *   somewhere else! Any ideas?
+     */
+    get isOffline() {
+        return !this.context.invokedFunctionArn
+            || this.context.invokedFunctionArn.includes('offline')
+            || !!process.env.USE_SERVERLESS_OFFLINE;
+    }
+}
+exports.default = DependencyInjection;
+//# sourceMappingURL=DependencyInjection.js.map

package/dist/core/DependencyInjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyInjection.js","sourceRoot":"","sources":["../../src/core/DependencyInjection.ts"],"names":[],"mappings":"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"}

package/dist/core/LambdaWrapper.d.ts

@@ -0,0 +1,73 @@
+import { Context } from '../index';
+import DependencyInjection from './DependencyInjection';
+import { LambdaWrapperConfig } from './config';
+export interface WrapOptions {
+    /**
+     * Whether uncaught errors should be handled to return an HTTP 500 response
+     * instead of causing a function error. (default: `true`)
+     *
+     * This is what you usually want when working on an HTTP endpoint, but in
+     * other contexts (e.g. queue consumers) you may want AWS Lambda to report a
+     * failure so that the event is retried.
+     */
+    handleUncaughtErrors?: boolean;
+}
+export default class LambdaWrapper<TConfig extends LambdaWrapperConfig = LambdaWrapperConfig> {
+    readonly config: TConfig;
+    constructor(config: TConfig);
+    /**
+     * Returns a new Lambda Wrapper with the given configuration applied.
+     *
+     * @param config
+     */
+    configure<TMoreConfig>(config: Partial<TConfig> & TMoreConfig): LambdaWrapper<TConfig & TMoreConfig>;
+    /**
+     * Wrap the given function.
+     */
+    wrap<T>(handler: (di: DependencyInjection<TConfig>) => T | Promise<T>, options?: WrapOptions): (event: any, context: Context) => Promise<any>;
+    /**
+     * `true` if we will send traces to Lumigo.
+     *
+     * The `LUMIGO_TRACER_TOKEN` env var is present in both manually traced and
+     * auto-traced functions.
+     */
+    static get isLumigoEnabled(): boolean;
+    /**
+     * `true` if the Lambda function is already being traced by a higher-level
+     * Lumigo wrapper, in which case we don't need to manually wrap our handlers.
+     *
+     * There are two ways that this can be done, based on the documentation
+     * [here](https://docs.lumigo.io/docs/lambda-layers): using a Lambda runtime
+     * wrapper, or handler redirection. Each method can be detected via its
+     * environment variables. Auto-trace uses the runtime wrapper.
+     */
+    static get isLumigoWrappingUs(): boolean;
+    /**
+     * Process the result once we have one.
+     *
+     * @param di
+     * @param result
+     */
+    static handleSuccess(di: DependencyInjection, result: any): any;
+    /**
+     * Gracefully handles an error, logging in Lumigo and generating a response
+     * reflecting the `code` of the error, if defined.
+     *
+     * Lumigo generates alerts for logs on level ERROR. This means that
+     * `logger.error` will produce an alert. To avoid meaningless notifications,
+     * most likely coming from tests, we log INFO unless either:
+     *
+     * 1. `error.raiseOnEpsagon` is defined & truthy
+     * 2. `error.code` is defined and `error.code >= 500`.
+     *
+     * @param di
+     * @param error
+     * @param [throwError=false]
+     */
+    static handleError(di: DependencyInjection, error: Error, throwError?: boolean): {
+        statusCode: any;
+        headers: Record<string, string>;
+        body: string;
+    } | Error;
+}
+//# sourceMappingURL=LambdaWrapper.d.ts.map

package/dist/core/LambdaWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LambdaWrapper.d.ts","sourceRoot":"","sources":["../../src/core/LambdaWrapper.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAInC,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAe,MAAM,UAAU,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,CAAC,OAAO,OAAO,aAAa,CAAC,OAAO,SAAS,mBAAmB,GAAG,mBAAmB;IAC9E,QAAQ,CAAC,MAAM,EAAE,OAAO;gBAAf,MAAM,EAAE,OAAO;IAEpC;;;;OAIG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,WAAW,GAAG,aAAa,CAAC,OAAO,GAAG,WAAW,CAAC;IAIpG;;OAEG;IACH,IAAI,CAAC,CAAC,EACJ,OAAO,EAAE,CAAC,EAAE,EAAE,mBAAmB,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC7D,OAAO,CAAC,EAAE,WAAW,WAMO,GAAG,WAAW,OAAO;IAyDnD;;;;;OAKG;IACH,MAAM,KAAK,eAAe,IAAI,OAAO,CAEpC;IAED;;;;;;;;OAQG;IACH,MAAM,KAAK,kBAAkB,IAAI,OAAO,CAKvC;IAED;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,mBAAmB,EAAE,MAAM,EAAE,GAAG;IASzD;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,UAAQ;;;;;CA8B7E"}