serverless-spy 0.0.52 → 0.0.54

package/.jsii

@@ -3177,7 +3177,7 @@
   },
   "name": "serverless-spy",
   "readme": {
-    "markdown": "![ServerlessSpy](/logo/full_logo.svg)\n\n# **DECLAREMENT: THE PROJECT IS IN THE DEEP  DEVELOPMENT PHASE AND NOT JET MENT FOR USE.**\n\nCDK-based library for writing integration tests on AWS serverless architecture and web console to monitor events in real-time.\n\n# How it works\n\n**Add ServerlessSpy construct to your CDK stack, which creates infrastructure to intercept events in Lambda, SNS, SQS, EventBridge, DynamoDB... and send it to a testing library or your local web console via API Gateway websocket. The testing library subscribes to events so tests can be executed fast without checking/retrying if the event has been received. The testing library is integrated with Jest but can also be used with another library. The web console can be used to see and inspect events in real-time.**\n\n![Concept](/doc/concept.svg)\n\n\n# What is not\n - ServerlessSpy can not be used if your infrastructure is not created with CDK.\n - The solution is meant for development and (automatic) testing environment only. You should **EXCLUDE**  ServerlessSpy CDK construct in any other environment, especially production or high load. ServerlessSpy is not meant for those environments; it just induces costs and could contribute to hitting AWS quotas (Lambda concurrent executions, ...).\n\n# Documentation\n - [Quick start](doc/quick_start.md)\n - [Writing tests](doc/writing_tests.md)\n - Integrations\n   - [Lambda](doc/lambda.md)\n   - [SQS](doc/SQS.md)\n   - [SNS](doc/SNS.md)\n   - [EventBridge](doc/eventBridge.md)\n   - [DynamoDB](doc/DynamoDB.md)\n - [Using web console](doc/web_console.md)\n - [Code of Conduct](doc/CODE_OF_CONDUCT.md)\n - [Contributing Guide](doc/CONTRIBUTING.md)"
+    "markdown": "![ServerlessSpy](./logo/full_logo.svg)\n\nCDK-based library for writing elegant, fast executing integration tests on AWS serverless architecture and additional web console to monitor events in real-time.\n\n# How it works\n\n**Add ServerlessSpy construct to your CDK stack, which creates infrastructure to intercept events in Lambda, SNS, SQS, EventBridge, DynamoDB, S3... and send it to a testing library or your local web console via API Gateway websocket. The testing library subscribes to events so tests can be executed fast without checking/retrying if the process has finished. The testing library is integrated with Jest but can also be used with another library. The web console can be used to see and inspect events in real-time.**\n\n![Concept](./doc/concept.svg)\n\n![Web console](./doc/web_console.gif)\n\n# Key benefits\n - **Easy** to write tests that are strongly typed thanks to TypeScript ❤️.\n - **Tests are executed much FASTER** 🏎️💨 No need to write tests in a way to periodically check if the process has finished because all events are pushed to the testing library.\n - **Tests can run in parallel** if you use conditions and filter events specific to your test. This drastically reduces the execution time of the CI/CD process.\n - **Web console** enables you see all events in real-time during. Debugging 🕵 has never been easier. Search is supported(with regular expression).\n\n# What ServerlessSpy is not\n - ServerlessSpy can not be used if your infrastructure is not created with CDK.\n - The solution is meant for development and (automatic) testing environment only. You should **EXCLUDE** ServerlessSpy CDK construct in any other environment, especially production or environment with high load. ServerlessSpy is not meant for those; it just induces costs and could contribute to hitting AWS quotas (Lambda concurrent executions, ...).\n - Only Node.js stack is supported. There are no plans to support Python or any other. Use of TypeScript is deeply encouraged.\n - Web console only runs on your local computer. No cloud hosting of any kind (for now).\n\n# Documentation\n - [Quick Start](doc/quick_start.md)\n - [CDK Construct](doc/CDK_construct.md)\n - [Writing tests](doc/writing_tests.md)\n   - [Lambda](doc/Lambda.md)\n   - [SQS](doc/SQS.md)\n   - [SNS](doc/SNS.md)\n   - [EventBridge](doc/EventBridge.md)\n   - [DynamoDB](doc/DynamoDB.md)\n   - [S3](doc/S3.md)\n   - Kinesis (work in progress)\n   - Step Functions (work in progress)\n - [Web Console](doc/web_console.md)\n - [Frequently Asked Questions (FAQ)](doc/FAQ.md)\n - [Sample Application](doc/sample_app.md)\n - [Roadmap](doc/roadmap.md)\n - [Code of Conduct](doc/CODE_OF_CONDUCT.md)\n - [Contributing Guide](doc/CONTRIBUTING.md)"
   },
   "repository": {
     "type": "git",
@@ -3554,6 +3554,6 @@
       "symbolId": "src/ServerlessSpy:SpyFilter"
     }
   },
-  "version": "0.0.52",
-  "fingerprint": "AhyMBXg8/pE/5cco8irkO97LZs0+OHnGkQ8423krN+w="
+  "version": "0.0.54",
+  "fingerprint": "9eOnbU11xuHz1NwAIy7voJ2eXaWXdl/WEgDH0Gk76Oc="
 }

package/README.md

@@ -1,29 +1,42 @@
-![ServerlessSpy](/logo/full_logo.svg)
+![ServerlessSpy](./logo/full_logo.svg)
 
-# **DECLAREMENT: THE PROJECT IS IN THE DEEP  DEVELOPMENT PHASE AND NOT JET MENT FOR USE.**
-
-CDK-based library for writing integration tests on AWS serverless architecture and web console to monitor events in real-time.
+CDK-based library for writing elegant, fast executing integration tests on AWS serverless architecture and additional web console to monitor events in real-time. 
 
 # How it works
 
-**Add ServerlessSpy construct to your CDK stack, which creates infrastructure to intercept events in Lambda, SNS, SQS, EventBridge, DynamoDB... and send it to a testing library or your local web console via API Gateway websocket. The testing library subscribes to events so tests can be executed fast without checking/retrying if the event has been received. The testing library is integrated with Jest but can also be used with another library. The web console can be used to see and inspect events in real-time.**
+**Add ServerlessSpy construct to your CDK stack, which creates infrastructure to intercept events in Lambda, SNS, SQS, EventBridge, DynamoDB, S3... and send it to a testing library or your local web console via API Gateway websocket. The testing library subscribes to events so tests can be executed fast without checking/retrying if the process has finished. The testing library is integrated with Jest but can also be used with another library. The web console can be used to see and inspect events in real-time.**
+
+![Concept](./doc/concept.svg)
 
-![Concept](/doc/concept.svg)
+![Web console](./doc/web_console.gif)
 
+# Key benefits
+ - **Easy** to write tests that are strongly typed thanks to TypeScript ❤️.
+ - **Tests are executed much FASTER** 🏎️💨 No need to write tests in a way to periodically check if the process has finished because all events are pushed to the testing library.
+ - **Tests can run in parallel** if you use conditions and filter events specific to your test. This drastically reduces the execution time of the CI/CD process.
+ - **Web console** enables you see all events in real-time during. Debugging 🕵 has never been easier. Search is supported(with regular expression).
 
-# What is not
+# What ServerlessSpy is not
  - ServerlessSpy can not be used if your infrastructure is not created with CDK. 
- - The solution is meant for development and (automatic) testing environment only. You should **EXCLUDE**  ServerlessSpy CDK construct in any other environment, especially production or high load. ServerlessSpy is not meant for those environments; it just induces costs and could contribute to hitting AWS quotas (Lambda concurrent executions, ...).
+ - The solution is meant for development and (automatic) testing environment only. You should **EXCLUDE** ServerlessSpy CDK construct in any other environment, especially production or environment with high load. ServerlessSpy is not meant for those; it just induces costs and could contribute to hitting AWS quotas (Lambda concurrent executions, ...).
+ - Only Node.js stack is supported. There are no plans to support Python or any other. Use of TypeScript is deeply encouraged.
+ - Web console only runs on your local computer. No cloud hosting of any kind (for now).
 
 # Documentation
- - [Quick start](doc/quick_start.md)
- - [Writing tests](doc/writing_tests.md)
- - Integrations
-   - [Lambda](doc/lambda.md) 
+ - [Quick Start](doc/quick_start.md)
+ - [CDK Construct](doc/CDK_construct.md)
+ - [Writing tests](doc/writing_tests.md) 
+   - [Lambda](doc/Lambda.md) 
    - [SQS](doc/SQS.md)
    - [SNS](doc/SNS.md)
-   - [EventBridge](doc/eventBridge.md)
+   - [EventBridge](doc/EventBridge.md)
    - [DynamoDB](doc/DynamoDB.md)
- - [Using web console](doc/web_console.md) 
+   - [S3](doc/S3.md)   
+   - Kinesis (work in progress)
+   - Step Functions (work in progress)
+ - [Web Console](doc/web_console.md)  
+ - [Frequently Asked Questions (FAQ)](doc/FAQ.md)  
+ - [Sample Application](doc/sample_app.md)   
+ - [Roadmap](doc/roadmap.md)   
  - [Code of Conduct](doc/CODE_OF_CONDUCT.md) 
  - [Contributing Guide](doc/CONTRIBUTING.md) 

package/_layouts/archive.html

@@ -22,10 +22,13 @@ layout: default
     <p><a href="../"><img src="/logo/full_logo_white.svg" alt="ServerlessSpy"></a></p>
     <div class="link-author">
       <h2>
-        <a href="https://www.serverlesslife.com/about.html">Marko (ServerlessLife)</a>
+        <a class="link-author" href="https://www.serverlesslife.com/about.html">Marko (ServerlessLife)</a>
         <a href="https://www.serverlesslife.com/">
           <img class="logo-serverlesslife" src="/logo/serverlesslife_logo_invert.png">
         </a>
+        <a href="https://github.com/ServerlessLife/serverless-spy">
+          <img class="logo-serverlesslife" src="/doc/github.svg">
+        </a>
       </h2>
     </div>
     {% endunless %}

package/assets/css/main.scss

@@ -17,12 +17,16 @@ img[src$="/logo/full_logo.svg"] {
 }
 
 .logo-serverlesslife {
-  width: 10%;
+  width: 7%;
+  text-decoration: none !important;
 }
 
 .link-author
 { 
   margin-top: -60px !important;
-  text-align: right;
+  text-align: right;  
+}
+
+.link-author a{
   text-decoration: none !important;
-}
+}

package/cli/cli.ts

@@ -22,7 +22,7 @@ async function run() {
   let options: any;
 
   progam
-    .description('ServerlessSpy')
+    .description('ServerlessSpy web console')
     .option('--ws <ws>', 'Websocket link')
     .option(
       '--cdkoutput <cdkoutput>',
@@ -35,7 +35,7 @@ async function run() {
     .option('--open <open>', 'Open browser', progam.BOOL, true)
     .option(
       '--port <p>',
-      `CDK stack in cdk output file. If not specified the first one is picked.`,
+      `A port on localhost where ServerlessSpy web console is accessible.`,
       progam.INT,
       '3456'
     )

package/dist/releasetag.txt

@@ -1 +1 @@
-v0.0.52
+v0.0.54

package/doc/CDK_construct.md

@@ -0,0 +1,57 @@
+# CDK Construct
+
+Adding ServerlessSpy construct is super simple.
+
+# Step 1: Create object:
+```typescript
+const serverlessSpy = new ServerlessSpy(this, 'ServerlessSpy', {
+  generateSpyEventsFileLocation: 'serverlessSpyEvents/ServerlessSpyEvents.ts'              
+});
+```
+
+Parameters:
+ - `generateSpyEventsFileLocation: serverlessSpyEvents/ServerlessSpyEvents.ts`  
+is a TypeScript file that makes your tests strongly typed 💪. It just contains an interface with a list of possible events, but with the magic of TypeScript, every test becomes strongly typed thanks to this file.
+
+ - `debugMode: true`  
+You can enable the debug mode with this parameter.
+
+ - `spySqsWithNoSubscriptionAndDropAllMessages`.   
+If no Lambda is subscribed to SQS, the ServerlessSpy can not intercept events. With this flag on, additional Lambda will be created that will just consume messages and throw them away (= lost forever ⛔). Of course, that is undesirable in most cases, but for some tests could be useful.
+
+
+# Step 2: Star spying
+
+You can spy on everything:
+```typescript
+serverlessSpy.spy();
+```
+
+or you can limit what to spy on:
+```typescript
+serverlessSpy.spy({
+  spyLambda: true,
+  spySqs: true,
+  spySnsTopic: true,
+  spySnsSubsription: true,
+  spyEventBridge: true,
+  spyEventBridgeRule: true,
+  spyS3: true,
+  spyDynamoDB: true,
+});
+```
+
+You can also specify just some nodes
+```typescript
+serverlessSpy.spyNodes([...]);
+```
+All child nodes are also included in the spying.
+
+You can mix&match both methods.
+
+**Why would you exclude some of the notes***
+For DynamoDB, there could be only two Lambdas subscribed to DynamoDB Streams, and S3 can have only one. If you reach the quotas with your primary stack, you can use ServerlessSpy on those resources. 
+
+There could also be other reasons to exclude some of the nodes specific to your use case.
+
+ 

package/doc/CONTRIBUTING.md

@@ -29,7 +29,7 @@ All types of contributions are encouraged and valued. See the [Table of Contents
 ## Code of Conduct
 
 This project and everyone participating in it is governed by the
-[ServerlessSpy Code of Conduct](https://github.com/ServerlessLife/serverless-spyblob/master/CODE_OF_CONDUCT.md).
+[ServerlessSpy Code of Conduct](CODE_OF_CONDUCT.md).
 By participating, you are expected to uphold this code. Please report unacceptable behavior
 to <marko@serverlesslife.com>.
 

package/doc/DynamoDB.md

@@ -0,0 +1,44 @@
+# DynamoDB
+
+DynamoDB integration subscribes to DynamoDb Stream and intercept events. The event has following properties
+ - `keys`
+ - `newImage`
+ - `oldImage`
+ - `eventName` (`INSERT`, `MODIFY`, `REMOVE`) 
+ 
+ You can use `eventName` and compare `newImage` and `oldImage` to validate if the correct operation has been executed.
+
+Basic example:
+
+```typescript
+await serverlessSpyListener.waitForDynamoDBMyTable<TestData>();
+```
+
+You can use conditions to wait for particular event. You can also use generic (`TestData`) to strongly type the event.
+
+```typescript    
+await serverlessSpyListener.waitForDynamoDBMyTable<TestData>({
+  condition: (d) => d.keys.pk === id,
+});
+```
+
+Validating the data with Jest would look like this:
+```typescript
+(
+  await serverlessSpyListener.waitForDynamoDBMyTable<TestData>({
+    condition: (d) => d.keys.pk === id,
+  })
+).toMatchObject({
+  eventName: 'INSERT',
+  newImage: data,
+});
+```
+
+**⚠️Warning: DynamoDB can have only two Lambdas subscribed to DynamoDB Streams. If your primary stack already has two, you could not use DynamoDB interception. You should [exclude DynamoDB interception in your CDK stack](./CDK_construct.md):
+```typescript
+serverlessSpy.spy({
+  spyDynamoDB: false,
+});
+```
+
+Check [this test](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/lambdaToDynamoDb.test.ts){:target="_blank"}.

package/doc/EventBridge.md

@@ -0,0 +1,27 @@
+# EventBridge
+
+EventBridge integration has two types of methods:
+ - `waitForEventBridgeXxx()` - Intercept all events on EventBridge.
+ - `waitForEventBridgeRuleXxxYyy` - Intercept only events on Rule.
+
+Basic example:
+
+```typescript
+await serverlessSpyListener.waitForEventBridgeMyEventBus<TestData>();
+
+await serverlessSpyListener.waitForEventBridgeRuleMyEventBusMyRule<TestData>();
+```
+
+You can use conditions to wait for particular event. You can also use generic (`TestData`) to strongly type the event.
+
+```typescript     
+await serverlessSpyListener.waitForEventBridgeMyEventBus<TestData>({
+  condition: (d) => d.detail.id === id,
+});
+
+await serverlessSpyListener.waitForEventBridgeRuleMyEventBusMyRule<TestData>({
+  condition: (d) => d.detail.id === id,
+});
+```
+Check [this](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/eventBridgeToLambda.test.ts){:target="_blank"} and 
+[this](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/lambdaToEventBridge.test.ts){:target="_blank"} test.

package/doc/FAQ.md

@@ -0,0 +1,23 @@
+# Frequently asked questions (FAQ)
+
+## In which environment should ServerlessSpy be used?
+ - Development environment: so you can write tests. Web console also helps you with insight into what is happening in the system.
+ - Automatic test environment: You execute written tests via CI.
+
+ ## Can ServerlessSpy be used as distributer tracing like XRay, Lumigo, Epsagon...
+No. ServerlessSpy can be useful as a developer tool to see events that are happening in the development environment. The main benefit compared to mentioned tools is that you can see events in real-time. But ServerlessSpy does not have near capabilities of those tools, especially not tracing an event through services, which is the main point of distributed tracing.
+
+## What kind of costs does ServerlessSpy induce?
+If you are using ServerlessSpy in low traffic environment like dev and test usually are, the const are negligible. For high load environments, like production, you should exclude the ServerlessSpy. It has no use there, and it will just induce costs and could contribute to hitting AWS quotas & limits like Lambda concurrent executions.
+
+## Does ServerlessSpy increase response time?
+Negligible, and that's only when hitting Lambda. You should exclude the ServerlessSpy construct in the production environment anyway.
+
+## I do not want a new resource created by ServerlessSpy in my stack.
+Additional resources do not harm and do not cause any noticeable costs (in a dev or test environment). But if you still do not want them, you can add them just for the period of executing the test, as some similar libraries do. Just redeploy before executing the tests with SperverlessSpy construct included via parameter and then again redeploy afterward with SperverlessSpy construct excluded.
+
+## I want to use ServerlessSpy in a developer environment that is used by many developers.
+The recommended way to develop serverless systems is to have a separate environment for each developer or/and each feature. You can still use ServerlessSpy if you share an environment, but when using the web console, you will see events that other developers trigger. And test events of other tests could interfere with your tests if you do not use conditions that filters events by some unique attribute.
+
+## Why API Gateway and AppSync are not supported
+They are, but not directly. API Gateway and AppSync services do not support intercepting events, except via CloudWatch, which is slooooow 🐌🐌🐌. ServerlessSpy needs to be fast. You can intercept those events when they hit other supported services like Lambda.

package/doc/Lambda.md

@@ -0,0 +1,68 @@
+# Lambda
+
+Basic example:
+
+```typescript
+await serverlessSpyListener.waitForFunctionMyLambdaRequest();
+```
+
+You can use conditions to wait for particular event. You can also use generic (`TestData`) to strongly type the event.
+
+```typescript
+await serverlessSpyListener.waitForFunctionMyLambdaRequest<TestData>({
+  condition: (d) => d.request.id === myData.id,
+});
+```
+
+Lambda produce three kind of events: **Request, Console, Response**
+```typescript
+await serverlessSpyListener.waitForFunctionMyLambdaRequest();
+await serverlessSpyListener.waitForFunctionMyLambdaConsole();
+await serverlessSpyListener.waitForFunctionMyLambdaResponse();
+```
+Console can be useful to validate intermediate steps of processing.
+
+You can chain calls for the same request:
+```typescript
+await (
+  await (
+    await serverlessSpyListener.waitForFunctionMyLambdaRequest({
+      condition: (d) => d.request.id === myData.id,
+    })
+  ).followedByConsole()
+).followedByResponse();
+```
+
+The condition `condition: (d) => d.request.id === myData.id` finds the correct request and than you can use on each part `getData()` to get the event or any Jest functions to validate.
+
+So fully blown test would look like this:
+```typescript
+(
+  await (
+    await (
+      await serverlessSpyListener.waitForFunctionMyLambdaRequest<TestData>({
+        condition: (d) => d.request.id === myData.id,
+      })
+    )
+      .toMatchObject({
+        request: myData,
+      })
+      .followedByConsole()
+  )
+    .toMatchObject({
+      request: myData,
+      console: {
+        message: 'My console log message',
+        optionalParams: [myData],
+      },
+    })
+    .followedByResponse()
+).toMatchObject({
+  request: myData,
+  response: {
+    ...myData,
+    message: `${myData.message} ServerlessSpy`,
+  },
+```
+
+You can see all combinations in [this test](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/lambda.test.ts){:target="_blank"}.

package/doc/S3.md

@@ -0,0 +1,30 @@
+# S3
+
+S3 integration subscribes to S3 notification and intercept events. The event has following properties:
+ - `eventName` (`s3:ObjectCreated:Put`, `s3:ObjectCreated:Post`, `s3:ObjectRemoved:Delete`, ...) 
+ - `key` - file name
+
+You can not receive file content (it could be gigabytes 🚚). You have to read it yourself.
+
+Basic example:
+
+```typescript
+await serverlessSpyListener.waitForS3MyBucket()
+```
+
+You can use conditions to wait for particular event.
+
+```typescript
+await serverlessSpyListener.waitForS3MyBucket({
+  condition: (d) => d.key === `${id}.json`,
+})
+```
+
+**⚠️Warning: DynamoDB can have only one Lambdas subscribed to notification. If your primary stack already use it, you could not use S3 interception. You should [exclude S3 interception in your CDK stack](./CDK_construct.md):**
+```typescript
+serverlessSpy.spy({
+  spyS3: false,
+});
+```
+
+Check [this test](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/lambdaToS3.test.ts){:target="_blank"}.

package/doc/SNS.md

@@ -0,0 +1,27 @@
+# SNS
+
+SNS integration has two types of methods:
+ - `waitForSnsTopicXxx()` - Intercept all events on SNS.
+ - `waitForSnsSubscriptionXxxYyy` - Intercept all events for SNS subscription. If the subscription has no filters it is the same as previous method.
+
+Basic example:
+
+```typescript
+await serverlessSpyListener.waitForSnsTopicMyTopic();
+
+await serverlessSpyListener.waitForSnsSubscriptionMyTopicMyLambda();    
+```
+
+You can use conditions to wait for particular event. You can also use generic (`TestData`) to strongly type the event.
+
+```typescript    
+await serverlessSpyListener.waitForSnsTopicMyTopic<TestData>({
+  condition: (d) => d.message.id === id,
+});
+
+await serverlessSpyListener.waitForSnsSubscriptionMyTopicMyLambda<TestData>({
+    condition: (d) => d.message.id === id,
+});    
+```
+Check [this](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/lambdaToSnS.test.ts){:target="_blank"} and 
+[this](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/snsToLambda.test.ts){:target="_blank"} test.

package/doc/SQS.md

@@ -0,0 +1,20 @@
+# SQS
+
+Basic example:
+
+```typescript
+await serverlessSpyListener.waitForSqsMyQueue();
+```
+
+You can use conditions to wait for particular event. You can also use generic (`TestData`) to strongly type the event.
+
+```typescript
+await serverlessSpyListener.waitForSqsMyQueue<TestData>({
+  condition: (d) => d.body.id === id,
+});
+```
+
+Intercept of SQS event actually intercept events that are consumed by Lambda subscribed to SQS. **⚠️If no Lambda is subscribed to SQS, the ServerlessSpy can not intercept, events.** If you still want to catch them enable `spySqsWithNoSubscriptionAndDropAllMessages` when [creating ServerlessSpy in CDK](./CDK_construct.md). With this flag on, additional Lambda will be created that will just consume messages and throw them away (= lost forever ⛔). Of course, that is undesirable in most cases, but for some tests it could be useful.
+
+Check [this](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/sqs.test.ts){:target="_blank"} and 
+[this](https://github.com/ServerlessLife/serverless-spy/blob/main/test/cdk/test/lambdaToSqs.test.ts){:target="_blank"} test.

package/doc/github.svg

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg   xmlns="http://www.w3.org/2000/svg" height="32" aria-hidden="true" viewBox="0 0 16 16" version="1.1" width="32" data-view-component="true">
+    <path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z" fill="#FFFFFF"></path>
+</svg>

package/doc/quick_start.md

@@ -1,11 +1,62 @@
 # Quick Start
 
-Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Quis risus sed vulputate odio ut. Vel pretium lectus quam id leo in vitae turpis massa. Sed vulputate odio ut enim blandit volutpat maecenas. Etiam dignissim diam quis enim lobortis scelerisque fermentum. Tortor consequat id porta nibh. Risus ultricies tristique nulla aliquet enim tortor. Elit pellentesque habitant morbi tristique senectus et. Proin sed libero enim sed faucibus turpis in. Mauris ultrices eros in cursus turpis massa tincidunt. Orci ac auctor augue mauris augue. Cras ornare arcu dui vivamus arcu felis bibendum. Dolor sed viverra ipsum nunc aliquet bibendum enim facilisis gravida. Non arcu risus quis varius quam. Ullamcorper morbi tincidunt ornare massa.
+You should use ServerlessSpy in the following environments:
+ - Development environment: so you can write tests. Web console helps you with insight into what is happening in the system.
+ - Automatic test environment: You execute written tests via CI.
 
-Augue mauris augue neque gravida. Fusce ut placerat orci nulla pellentesque dignissim enim. Duis ut diam quam nulla. Proin sagittis nisl rhoncus mattis rhoncus urna neque viverra. Parturient montes nascetur ridiculus mus mauris vitae ultricies leo integer. Cursus sit amet dictum sit amet. Eu turpis egestas pretium aenean pharetra magna ac. Et netus et malesuada fames ac turpis egestas integer eget. Mi ipsum faucibus vitae aliquet nec ullamcorper sit amet. Non nisi est sit amet facilisis magna etiam. Adipiscing bibendum est ultricies integer quis auctor. Ac tincidunt vitae semper quis lectus. Tortor aliquam nulla facilisi cras fermentum odio. Et magnis dis parturient montes nascetur ridiculus mus mauris. Tempor orci dapibus ultrices in iaculis nunc sed augue lacus. Pellentesque massa placerat duis ultricies lacus sed turpis. Ipsum consequat nisl vel pretium. Venenatis tellus in metus vulputate eu scelerisque felis imperdiet proin. Laoreet id donec ultrices tincidunt arcu. Ac turpis egestas sed tempus urna.
+## Step 1: Install
+```bash
+npm install serverless-spy
+```
 
-Vitae tortor condimentum lacinia quis vel eros donec ac. Non arcu risus quis varius quam quisque. Varius duis at consectetur lorem donec massa sapien faucibus. Rhoncus urna neque viverra justo nec ultrices dui sapien eget. Tellus cras adipiscing enim eu. Laoreet id donec ultrices tincidunt arcu non sodales neque. Tempor nec feugiat nisl pretium fusce id velit. Lacinia at quis risus sed vulputate odio ut. Malesuada proin libero nunc consequat interdum varius. Vulputate dignissim suspendisse in est ante in nibh mauris cursus. Malesuada bibendum arcu vitae elementum curabitur vitae nunc. Orci eu lobortis elementum nibh tellus molestie nunc non. Eget velit aliquet sagittis id consectetur purus ut faucibus pulvinar. At consectetur lorem donec massa sapien faucibus et molestie ac.
+## Step 2: Include ServerlessSpy in the CDK stack 
+```typescript
+const serverlessSpy = new ServerlessSpy(this, 'ServerlessSpy', {
+  generateSpyEventsFileLocation: 'serverlessSpyEvents/ServerlessSpyEvents.ts'              
+});
+serverlessSpy.spy();
+```
+[more](CDK_construct.md)
 
-Cras fermentum odio eu feugiat pretium nibh. Est pellentesque elit ullamcorper dignissim cras tincidunt lobortis feugiat vivamus. Tortor at auctor urna nunc id cursus. Mi ipsum faucibus vitae aliquet nec. Vitae semper quis lectus nulla at volutpat diam ut venenatis. Enim neque volutpat ac tincidunt vitae. Enim sit amet venenatis urna. Ultrices vitae auctor eu augue ut. Dolor sit amet consectetur adipiscing elit pellentesque habitant. Quis eleifend quam adipiscing vitae proin sagittis nisl rhoncus. Volutpat sed cras ornare arcu. Aliquam nulla facilisi cras fermentum odio eu feugiat pretium nibh. Sit amet tellus cras adipiscing enim eu turpis egestas pretium. Mauris rhoncus aenean vel elit scelerisque mauris pellentesque pulvinar. Elit duis tristique sollicitudin nibh sit. Arcu dui vivamus arcu felis bibendum ut tristique et.
+## Step 3: Deploy CDK stack with exporting CloudFormation outputs
+```bash
+cdk deploy --outputs-file cdkOutput.json
+```
 
-Morbi enim nunc faucibus a pellentesque sit amet. Nulla facilisi morbi tempus iaculis urna id. Nec tincidunt praesent semper feugiat nibh. Vitae tempus quam pellentesque nec. Massa massa ultricies mi quis. Eget felis eget nunc lobortis mattis aliquam. Sollicitudin tempor id eu nisl nunc mi. At urna condimentum mattis pellentesque. Tincidunt tortor aliquam nulla facilisi. Et ligula ullamcorper malesuada proin. Augue mauris augue neque gravida in fermentum et sollicitudin ac. Sit amet massa vitae tortor condimentum lacinia quis vel eros.
+The key part of the output is `ServerlessSpyWsUrl`, which is the URL to the websocket where the testing library and web console receive events. Exclude the `cdkOutput.json` file from `git` (like you always do), especially if it has secrets.
+
+Apart from CF output, the ServerlessSpy generates the TypeScript file `serverlessSpyEvents/ServerlessSpyEvents.ts` specified in the first step. This makes your test strongly typed 💪.
+
+## Step 4: Write tests 🔨
+Initialize the `ServerlessSpyListener`
+```typescript
+import { ServerlessSpyEvents } from '../serverlessSpyEvents/ServerlessSpyEvents';
+
+let serverlessSpyListener: ServerlessSpyListener<ServerlessSpyEvents>;
+beforeEach(async () => {
+  serverlessSpyListener =
+    await createServerlessSpyListener<ServerlessSpyEvents>({
+      serverlessSpyWsUrl: output.ServerlessSpyWsUrl, // ServerlessSpy WebSocket URL from CloudFormation output
+    });
+});
+```  
+
+Write test:
+```typescript
+(
+  await serverlessSpyListener.waitForSnsTopicMyTopic<TestData>()
+).toMatchObject({ message: data });
+```
+Close the `ServerlessSpyListener`
+```typescript
+afterEach(async () => {
+  serverlessSpyListener.stop();
+});
+```
+[more](writing_tests.md)
+
+## Step 5: Start local web console to gain more insights 🕵
+```bash
+npx sspy --cdkoutput cdkOutput.json
+```
+[more](web_console.md)

package/doc/roadmap.md

@@ -0,0 +1,8 @@
+# Roadmap
+
+The following additional features are in development but with no timeframe.
+ - Support for Kinesis
+ - Support for Step Functions 🌟
+ - Support for [Vitest](https://vitest.dev/) in addition to [Jest](https://jestjs.io/) (note: You can already use Vitest or any other testing framwork. There is just no deep integration with it.)
+
+Let me know what should be [prioritized](https://twitter.com/ServerlessL).

package/doc/web_console.md

@@ -0,0 +1,27 @@
+# Web console
+
+The web console runs on your local computer and displays all events that ServerlessSpy intercepts in the environment. That is useful when developing to investigate what is happening in the system. The web console receives events via web socket and displays them in the table with a timestamp, event name, and data. You can filter events by event name and data. You can use regular expressions.
+
+If events are hierarchical like Lambda request & response, you can see an arrow from a parent to child event.
+
+![Web console](./web_console.gif)
+
+## Start
+```bash
+npx sspy --cdkoutput cdkOutput.json
+```
+The browser window will open [http://localhost:3456/](http://localhost:3456/).
+
+`cdkOutput.json` contains exported CloudFormation outputs ([see](./quick_start.md)). The key output is `ServerlessSpyWsUrl`, which is the URL to the WebSocket where the testing library and web console receive events. You can also set websocket directly with parameter `--ws`.
+
+## Parameters:
+`--ws <ws>` - Websocket link (optional)
+
+`--cdkoutput <cdkoutput>` - CDK output file that contains Websocket link in a property ServerlessSpyWsUrl (optional)
+
+`--cdkstack <cdkstack>` - CDK stack in cdk output file. If not specified the first one is picked (optional)
+
+`--open <open>` - Open browser (optional, default: true)
+
+`--port` - A port on localhost where ServerlessSpy web console is accessible (optional, default: "3456")  
+

package/doc/writing_tests.md

@@ -0,0 +1,115 @@
+# Writing tests
+
+## Creating `ServerlessSpyListener`
+
+### Include the typescript file that was generated when deploying.
+
+```typescript
+import { ServerlessSpyEvents } from '../serverlessSpyEvents/ServerlessSpyEvents';
+```
+
+### Get ServerlessSpy WebSocket URL from CloudFormation output
+```typescript
+const exportLocation = path.join(__dirname, 'cdkOutput.json');
+const output = JSON.parse(fs.readFileSync(exportLocation).toString())[
+  'YourStackName'
+];
+```
+
+### Initialize the `ServerlessSpyListener`
+```typescript
+let serverlessSpyListener: ServerlessSpyListener<ServerlessSpyEvents>;
+beforeEach(async () => {
+  serverlessSpyListener =
+    await createServerlessSpyListener<ServerlessSpyEvents>({
+      serverlessSpyWsUrl: output.ServerlessSpyWsUrl,
+    });
+});
+```  
+
+### Close the `ServerlessSpyListener`
+```typescript
+afterEach(async () => {
+  serverlessSpyListener.stop();
+});
+```
+## Writing test
+
+There are several ways how can you write a test.
+
+## Waiting for the event to occur
+
+```typescript
+await serverlessSpyListener.waitForXXX<TestData>()
+```
+or
+```typescript
+await serverlessSpyListener.waitForXXX()
+```
+
+`WaitFor` methods are generated with TypeScript. You should name your resources in CDK so that these methods are easy to read.
+
+Please note that there is no order enforced on events. The same event can match with multiple `WaitFor` calls. When `WaitFor` is called, it checks for a matching event in the bucket of all received events since initializing `ServerlessSpyListener`. The matching event will not be removed. If the event is not found, it starts to wait for one. So if you write  `await serverlessSpyListener.waitForXXX<TestData>()` twice, because you expect events to occur twice, it will not work. The first event will satisfy both `WaitFor` calls. 
+
+`TestData` is an optional generic argument that makes things all parameters strongly typed. If that is useful, decide based on your use case.
+
+## Filtering the events
+
+It makes a lot of sense to filter a message by some condition, like ID.
+```typescript
+await serverlessSpyListener.waitForSnsTopicMyTopic<TestData>({
+  condition: (d) => d.message.id === id,
+})
+```
+This way, you can run tests in parallel and handle cases when a similar event occurs multiple times as part of the same test.
+
+**💡Recommendation: Try not to use condition for validating the event. Just find the event with help of conditions and than validate it with Jest. Test are easier to debug this way, because the error shows which part of the data does not match. But if you like using just conditions so tests are easily to read, go ahead.**
+
+## Extracting the event data with `getData()`
+```typescript
+const event = (await serverlessSpyListener.waitForXXX<TestData>()).getData();
+```
+You can validate that event with Jest, or any other testing framework like you always do:
+```typescript
+expect(event).toMatchObject(...);
+```
+
+## Using ServerlessSpy integration with Jest
+The previous example can be done in a much slicker way:
+
+```typescript
+(await serverlessSpyListener.waitForXXX<TestData>()).toMatchObject(...);
+```
+
+## Tracing event through the same Lambda call
+Tests for the same Lambda request can be chained together:
+```typescript
+(
+  await (
+    await (
+      await serverlessSpyListener.waitForFunctionMyLambdaRequest<TestData>({
+        condition: (d) => d.request.id === myData.id,
+      })
+    )
+      .toMatchObject({
+        request: myData,
+      })
+      .followedByConsole()
+  )
+    .toMatchObject({
+      request: myData,
+      console: {
+        message: 'My console log message',
+        optionalParams: [myData],
+      },
+    })
+    .followedByResponse()
+).toMatchObject({
+  request: myData,
+  response: {
+    ...myData,
+    message: `${myData.message} ServerlessSpy`,
+  },
+```
+That is useful when you expect a Lambda request that will produce some data. You can also validate intermediate steps of processing with console log events.
+[more on spying on Lambda](Lambda.md)

package/lib/cli/cli.js

@@ -19,12 +19,12 @@ async function run() {
     let cdkOutput;
     let options;
     progam
-        .description('ServerlessSpy')
+        .description('ServerlessSpy web console')
         .option('--ws <ws>', 'Websocket link')
         .option('--cdkoutput <cdkoutput>', 'CDK output file that contains Websocket link in a property ServerlessSpyWsUrl')
         .option('--cdkstack <cdkstack>', 'CDK stack in cdk output file. If not specified the first one is picked.')
         .option('--open <open>', 'Open browser', progam.BOOL, true)
-        .option('--port <p>', `CDK stack in cdk output file. If not specified the first one is picked.`, progam.INT, '3456')
+        .option('--port <p>', `A port on localhost where ServerlessSpy web console is accessible.`, progam.INT, '3456')
         .action((_args, opt, _logger) => {
         options = opt;
     });
@@ -173,4 +173,4 @@ function getCompiledJsPath() {
     }
     throw new Error(`Can not find compiled files in folder ${folder} and ${folderAsPackage}`);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../cli/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\nimport * as fs from 'fs';\nimport * as http from 'http';\nimport * as path from 'path';\nimport { promisify } from 'util';\nimport * as progam from 'caporal';\nimport * as open from 'open';\nimport { getSignedWebSocketUrl } from '../common/getWebSocketUrl';\n\nconst readFileAsync = promisify(fs.readFile);\n\n//resolve issue with module import\nlet opener = open;\nif ((open as any).default) {\n  opener = (open as any).default;\n}\n\nasync function run() {\n  let stackList: string[] | undefined;\n  let cdkOutput: Record<string, Record<string, string>>;\n\n  let options: any;\n\n  progam\n    .description('ServerlessSpy')\n    .option('--ws <ws>', 'Websocket link')\n    .option(\n      '--cdkoutput <cdkoutput>',\n      'CDK output file that contains Websocket link in a property ServerlessSpyWsUrl'\n    )\n    .option(\n      '--cdkstack <cdkstack>',\n      'CDK stack in cdk output file. If not specified the first one is picked.'\n    )\n    .option('--open <open>', 'Open browser', progam.BOOL, true)\n    .option(\n      '--port <p>',\n      `CDK stack in cdk output file. If not specified the first one is picked.`,\n      progam.INT,\n      '3456'\n    )\n    .action((_args, opt, _logger) => {\n      options = opt;\n    });\n\n  progam.parse(process.argv);\n\n  if (!options.ws && !options.cdkoutput) {\n    throw new Error('--ws or --cdkstack parameter not specified');\n  }\n\n  if (options.cdkoutput) {\n    const rawdata = fs.readFileSync(path.join(__dirname, options.cdkoutput));\n    cdkOutput = JSON.parse(rawdata.toString());\n    stackList = Object.keys(cdkOutput);\n  }\n\n  http\n    .createServer((request, response) => {\n      void (async () => {\n        try {\n          //console.log('request ', request.url);\n          let filePath: string = `.${request.url}`;\n          //remove query parameters\n          filePath = filePath.split('?')[0];\n          let rootFolder = __dirname;\n\n          if (request.url?.startsWith('/webServerlessSpy.js')) {\n            //get transpiled TS to JS files\n            rootFolder = getCompiledJsPath();\n          } else if (request.url?.startsWith('/bootstrap/')) {\n            filePath = filePath.substring('/bootstrap/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else if (request.url?.startsWith('/bootstrap-icons/')) {\n            filePath = filePath.substring('/bootstrap-icons/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap-icons'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else {\n            if (filePath === './') {\n              filePath = './index.html';\n            }\n          }\n\n          filePath = path.join(rootFolder, filePath);\n          //console.log(`${request.url} --> ${filePath}`);\n\n          const extname = String(path.extname(filePath)).toLowerCase();\n          const mimeTypes: any = {\n            '.html': 'text/html',\n            '.js': 'text/javascript',\n            '.css': 'text/css',\n            '.json': 'application/json',\n            '.png': 'image/png',\n            '.jpg': 'image/jpg',\n            '.gif': 'image/gif',\n            '.svg': 'image/svg+xml',\n            '.wav': 'audio/wav',\n            '.mp4': 'video/mp4',\n            '.woff': 'application/font-woff',\n            '.ttf': 'application/font-ttf',\n            '.eot': 'application/vnd.ms-fontobject',\n            '.otf': 'application/font-otf',\n            '.wasm': 'application/wasm',\n          };\n\n          const contentType = mimeTypes[extname] || 'application/octet-stream';\n\n          if (request.url === '/stackList') {\n            response.writeHead(200, { 'Content-Type': 'application/json' });\n            response.end(JSON.stringify(stackList), 'utf-8');\n          } else if (request.url?.match('^/wsUrl')) {\n            let wsUrl: string | undefined;\n            if (options.ws) {\n              wsUrl = options.ws;\n            } else {\n              // options.cdkoutput\n              const urlPaths = request.url.split('/');\n              let stack = urlPaths[2];\n\n              if (!stack) {\n                stack = options.cdkstack;\n              }\n\n              if (stack) {\n                wsUrl = cdkOutput[stack].ServerlessSpyWsUrl;\n              } else {\n                if (cdkOutput && cdkOutput[Object.keys(cdkOutput)[0]]) {\n                  wsUrl =\n                    cdkOutput[Object.keys(cdkOutput)[0]].ServerlessSpyWsUrl;\n                }\n              }\n            }\n\n            if (!wsUrl) {\n              throw new Error('Missing websocket url');\n            }\n\n            //console.log(`WS URL: ${wsUrl}`);\n            const signedWSUrl = await getSignedWebSocketUrl(wsUrl);\n            response.writeHead(200, { 'Content-Type': 'text/html' });\n            response.end(signedWSUrl, 'utf-8');\n          } else {\n            try {\n              const content = await readFileAsync(filePath);\n\n              response.writeHead(200, { 'Content-Type': contentType });\n              response.end(content, 'utf-8');\n            } catch (error: any) {\n              if (error.code === 'ENOENT') {\n                response.writeHead(404, { 'Content-Type': 'text/html' });\n                response.end(\n                  `No such file or directory ${request.url}`,\n                  'utf-8'\n                );\n              } else {\n                response.writeHead(500);\n                response.end(`Error: ${error.code} ..\\n`);\n              }\n            }\n          }\n        } catch (err: any) {\n          response.writeHead(500, { 'Content-Type': 'text/html' });\n          response.end(err.message, 'utf-8');\n        }\n      })();\n    })\n    .listen(options.port);\n\n  console.log(\n    `ServerlessSoy console runing at http://localhost:${options.port}`\n  );\n  if (options.open) {\n    await opener(`http://localhost:${options.port}`);\n  }\n}\n\nrun().catch(console.error);\n\nfunction getNpmModuleInstalledPath(npm: string) {\n  let folder = path.join(__dirname, '../', 'node_modules', npm);\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'node_modules', npm);\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find package in folder ${folder} and ${folderAsPackage}`\n  );\n}\n\nfunction getCompiledJsPath() {\n  let folder = path.join(__dirname, '../', 'lib/cli');\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'lib/cli');\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find compiled files in folder ${folder} and ${folderAsPackage}`\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../cli/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\nimport * as fs from 'fs';\nimport * as http from 'http';\nimport * as path from 'path';\nimport { promisify } from 'util';\nimport * as progam from 'caporal';\nimport * as open from 'open';\nimport { getSignedWebSocketUrl } from '../common/getWebSocketUrl';\n\nconst readFileAsync = promisify(fs.readFile);\n\n//resolve issue with module import\nlet opener = open;\nif ((open as any).default) {\n  opener = (open as any).default;\n}\n\nasync function run() {\n  let stackList: string[] | undefined;\n  let cdkOutput: Record<string, Record<string, string>>;\n\n  let options: any;\n\n  progam\n    .description('ServerlessSpy web console')\n    .option('--ws <ws>', 'Websocket link')\n    .option(\n      '--cdkoutput <cdkoutput>',\n      'CDK output file that contains Websocket link in a property ServerlessSpyWsUrl'\n    )\n    .option(\n      '--cdkstack <cdkstack>',\n      'CDK stack in cdk output file. If not specified the first one is picked.'\n    )\n    .option('--open <open>', 'Open browser', progam.BOOL, true)\n    .option(\n      '--port <p>',\n      `A port on localhost where ServerlessSpy web console is accessible.`,\n      progam.INT,\n      '3456'\n    )\n    .action((_args, opt, _logger) => {\n      options = opt;\n    });\n\n  progam.parse(process.argv);\n\n  if (!options.ws && !options.cdkoutput) {\n    throw new Error('--ws or --cdkstack parameter not specified');\n  }\n\n  if (options.cdkoutput) {\n    const rawdata = fs.readFileSync(path.join(__dirname, options.cdkoutput));\n    cdkOutput = JSON.parse(rawdata.toString());\n    stackList = Object.keys(cdkOutput);\n  }\n\n  http\n    .createServer((request, response) => {\n      void (async () => {\n        try {\n          //console.log('request ', request.url);\n          let filePath: string = `.${request.url}`;\n          //remove query parameters\n          filePath = filePath.split('?')[0];\n          let rootFolder = __dirname;\n\n          if (request.url?.startsWith('/webServerlessSpy.js')) {\n            //get transpiled TS to JS files\n            rootFolder = getCompiledJsPath();\n          } else if (request.url?.startsWith('/bootstrap/')) {\n            filePath = filePath.substring('/bootstrap/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else if (request.url?.startsWith('/bootstrap-icons/')) {\n            filePath = filePath.substring('/bootstrap-icons/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap-icons'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else {\n            if (filePath === './') {\n              filePath = './index.html';\n            }\n          }\n\n          filePath = path.join(rootFolder, filePath);\n          //console.log(`${request.url} --> ${filePath}`);\n\n          const extname = String(path.extname(filePath)).toLowerCase();\n          const mimeTypes: any = {\n            '.html': 'text/html',\n            '.js': 'text/javascript',\n            '.css': 'text/css',\n            '.json': 'application/json',\n            '.png': 'image/png',\n            '.jpg': 'image/jpg',\n            '.gif': 'image/gif',\n            '.svg': 'image/svg+xml',\n            '.wav': 'audio/wav',\n            '.mp4': 'video/mp4',\n            '.woff': 'application/font-woff',\n            '.ttf': 'application/font-ttf',\n            '.eot': 'application/vnd.ms-fontobject',\n            '.otf': 'application/font-otf',\n            '.wasm': 'application/wasm',\n          };\n\n          const contentType = mimeTypes[extname] || 'application/octet-stream';\n\n          if (request.url === '/stackList') {\n            response.writeHead(200, { 'Content-Type': 'application/json' });\n            response.end(JSON.stringify(stackList), 'utf-8');\n          } else if (request.url?.match('^/wsUrl')) {\n            let wsUrl: string | undefined;\n            if (options.ws) {\n              wsUrl = options.ws;\n            } else {\n              // options.cdkoutput\n              const urlPaths = request.url.split('/');\n              let stack = urlPaths[2];\n\n              if (!stack) {\n                stack = options.cdkstack;\n              }\n\n              if (stack) {\n                wsUrl = cdkOutput[stack].ServerlessSpyWsUrl;\n              } else {\n                if (cdkOutput && cdkOutput[Object.keys(cdkOutput)[0]]) {\n                  wsUrl =\n                    cdkOutput[Object.keys(cdkOutput)[0]].ServerlessSpyWsUrl;\n                }\n              }\n            }\n\n            if (!wsUrl) {\n              throw new Error('Missing websocket url');\n            }\n\n            //console.log(`WS URL: ${wsUrl}`);\n            const signedWSUrl = await getSignedWebSocketUrl(wsUrl);\n            response.writeHead(200, { 'Content-Type': 'text/html' });\n            response.end(signedWSUrl, 'utf-8');\n          } else {\n            try {\n              const content = await readFileAsync(filePath);\n\n              response.writeHead(200, { 'Content-Type': contentType });\n              response.end(content, 'utf-8');\n            } catch (error: any) {\n              if (error.code === 'ENOENT') {\n                response.writeHead(404, { 'Content-Type': 'text/html' });\n                response.end(\n                  `No such file or directory ${request.url}`,\n                  'utf-8'\n                );\n              } else {\n                response.writeHead(500);\n                response.end(`Error: ${error.code} ..\\n`);\n              }\n            }\n          }\n        } catch (err: any) {\n          response.writeHead(500, { 'Content-Type': 'text/html' });\n          response.end(err.message, 'utf-8');\n        }\n      })();\n    })\n    .listen(options.port);\n\n  console.log(\n    `ServerlessSoy console runing at http://localhost:${options.port}`\n  );\n  if (options.open) {\n    await opener(`http://localhost:${options.port}`);\n  }\n}\n\nrun().catch(console.error);\n\nfunction getNpmModuleInstalledPath(npm: string) {\n  let folder = path.join(__dirname, '../', 'node_modules', npm);\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'node_modules', npm);\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find package in folder ${folder} and ${folderAsPackage}`\n  );\n}\n\nfunction getCompiledJsPath() {\n  let folder = path.join(__dirname, '../', 'lib/cli');\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'lib/cli');\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find compiled files in folder ${folder} and ${folderAsPackage}`\n  );\n}\n"]}

package/lib/cli/cli.mjs

@@ -17,12 +17,12 @@ async function run() {
     let cdkOutput;
     let options;
     progam
-        .description('ServerlessSpy')
+        .description('ServerlessSpy web console')
         .option('--ws <ws>', 'Websocket link')
         .option('--cdkoutput <cdkoutput>', 'CDK output file that contains Websocket link in a property ServerlessSpyWsUrl')
         .option('--cdkstack <cdkstack>', 'CDK stack in cdk output file. If not specified the first one is picked.')
         .option('--open <open>', 'Open browser', progam.BOOL, true)
-        .option('--port <p>', `CDK stack in cdk output file. If not specified the first one is picked.`, progam.INT, '3456')
+        .option('--port <p>', `A port on localhost where ServerlessSpy web console is accessible.`, progam.INT, '3456')
         .action((_args, opt, _logger) => {
         options = opt;
     });
@@ -171,4 +171,4 @@ function getCompiledJsPath() {
     }
     throw new Error(`Can not find compiled files in folder ${folder} and ${folderAsPackage}`);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../cli/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\nimport * as fs from 'fs';\nimport * as http from 'http';\nimport * as path from 'path';\nimport { promisify } from 'util';\nimport * as progam from 'caporal';\nimport * as open from 'open';\nimport { getSignedWebSocketUrl } from '../common/getWebSocketUrl';\n\nconst readFileAsync = promisify(fs.readFile);\n\n//resolve issue with module import\nlet opener = open;\nif ((open as any).default) {\n  opener = (open as any).default;\n}\n\nasync function run() {\n  let stackList: string[] | undefined;\n  let cdkOutput: Record<string, Record<string, string>>;\n\n  let options: any;\n\n  progam\n    .description('ServerlessSpy')\n    .option('--ws <ws>', 'Websocket link')\n    .option(\n      '--cdkoutput <cdkoutput>',\n      'CDK output file that contains Websocket link in a property ServerlessSpyWsUrl'\n    )\n    .option(\n      '--cdkstack <cdkstack>',\n      'CDK stack in cdk output file. If not specified the first one is picked.'\n    )\n    .option('--open <open>', 'Open browser', progam.BOOL, true)\n    .option(\n      '--port <p>',\n      `CDK stack in cdk output file. If not specified the first one is picked.`,\n      progam.INT,\n      '3456'\n    )\n    .action((_args, opt, _logger) => {\n      options = opt;\n    });\n\n  progam.parse(process.argv);\n\n  if (!options.ws && !options.cdkoutput) {\n    throw new Error('--ws or --cdkstack parameter not specified');\n  }\n\n  if (options.cdkoutput) {\n    const rawdata = fs.readFileSync(path.join(__dirname, options.cdkoutput));\n    cdkOutput = JSON.parse(rawdata.toString());\n    stackList = Object.keys(cdkOutput);\n  }\n\n  http\n    .createServer((request, response) => {\n      void (async () => {\n        try {\n          //console.log('request ', request.url);\n          let filePath: string = `.${request.url}`;\n          //remove query parameters\n          filePath = filePath.split('?')[0];\n          let rootFolder = __dirname;\n\n          if (request.url?.startsWith('/webServerlessSpy.js')) {\n            //get transpiled TS to JS files\n            rootFolder = getCompiledJsPath();\n          } else if (request.url?.startsWith('/bootstrap/')) {\n            filePath = filePath.substring('/bootstrap/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else if (request.url?.startsWith('/bootstrap-icons/')) {\n            filePath = filePath.substring('/bootstrap-icons/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap-icons'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else {\n            if (filePath === './') {\n              filePath = './index.html';\n            }\n          }\n\n          filePath = path.join(rootFolder, filePath);\n          //console.log(`${request.url} --> ${filePath}`);\n\n          const extname = String(path.extname(filePath)).toLowerCase();\n          const mimeTypes: any = {\n            '.html': 'text/html',\n            '.js': 'text/javascript',\n            '.css': 'text/css',\n            '.json': 'application/json',\n            '.png': 'image/png',\n            '.jpg': 'image/jpg',\n            '.gif': 'image/gif',\n            '.svg': 'image/svg+xml',\n            '.wav': 'audio/wav',\n            '.mp4': 'video/mp4',\n            '.woff': 'application/font-woff',\n            '.ttf': 'application/font-ttf',\n            '.eot': 'application/vnd.ms-fontobject',\n            '.otf': 'application/font-otf',\n            '.wasm': 'application/wasm',\n          };\n\n          const contentType = mimeTypes[extname] || 'application/octet-stream';\n\n          if (request.url === '/stackList') {\n            response.writeHead(200, { 'Content-Type': 'application/json' });\n            response.end(JSON.stringify(stackList), 'utf-8');\n          } else if (request.url?.match('^/wsUrl')) {\n            let wsUrl: string | undefined;\n            if (options.ws) {\n              wsUrl = options.ws;\n            } else {\n              // options.cdkoutput\n              const urlPaths = request.url.split('/');\n              let stack = urlPaths[2];\n\n              if (!stack) {\n                stack = options.cdkstack;\n              }\n\n              if (stack) {\n                wsUrl = cdkOutput[stack].ServerlessSpyWsUrl;\n              } else {\n                if (cdkOutput && cdkOutput[Object.keys(cdkOutput)[0]]) {\n                  wsUrl =\n                    cdkOutput[Object.keys(cdkOutput)[0]].ServerlessSpyWsUrl;\n                }\n              }\n            }\n\n            if (!wsUrl) {\n              throw new Error('Missing websocket url');\n            }\n\n            //console.log(`WS URL: ${wsUrl}`);\n            const signedWSUrl = await getSignedWebSocketUrl(wsUrl);\n            response.writeHead(200, { 'Content-Type': 'text/html' });\n            response.end(signedWSUrl, 'utf-8');\n          } else {\n            try {\n              const content = await readFileAsync(filePath);\n\n              response.writeHead(200, { 'Content-Type': contentType });\n              response.end(content, 'utf-8');\n            } catch (error: any) {\n              if (error.code === 'ENOENT') {\n                response.writeHead(404, { 'Content-Type': 'text/html' });\n                response.end(\n                  `No such file or directory ${request.url}`,\n                  'utf-8'\n                );\n              } else {\n                response.writeHead(500);\n                response.end(`Error: ${error.code} ..\\n`);\n              }\n            }\n          }\n        } catch (err: any) {\n          response.writeHead(500, { 'Content-Type': 'text/html' });\n          response.end(err.message, 'utf-8');\n        }\n      })();\n    })\n    .listen(options.port);\n\n  console.log(\n    `ServerlessSoy console runing at http://localhost:${options.port}`\n  );\n  if (options.open) {\n    await opener(`http://localhost:${options.port}`);\n  }\n}\n\nrun().catch(console.error);\n\nfunction getNpmModuleInstalledPath(npm: string) {\n  let folder = path.join(__dirname, '../', 'node_modules', npm);\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'node_modules', npm);\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find package in folder ${folder} and ${folderAsPackage}`\n  );\n}\n\nfunction getCompiledJsPath() {\n  let folder = path.join(__dirname, '../', 'lib/cli');\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'lib/cli');\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find compiled files in folder ${folder} and ${folderAsPackage}`\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../cli/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\nimport * as fs from 'fs';\nimport * as http from 'http';\nimport * as path from 'path';\nimport { promisify } from 'util';\nimport * as progam from 'caporal';\nimport * as open from 'open';\nimport { getSignedWebSocketUrl } from '../common/getWebSocketUrl';\n\nconst readFileAsync = promisify(fs.readFile);\n\n//resolve issue with module import\nlet opener = open;\nif ((open as any).default) {\n  opener = (open as any).default;\n}\n\nasync function run() {\n  let stackList: string[] | undefined;\n  let cdkOutput: Record<string, Record<string, string>>;\n\n  let options: any;\n\n  progam\n    .description('ServerlessSpy web console')\n    .option('--ws <ws>', 'Websocket link')\n    .option(\n      '--cdkoutput <cdkoutput>',\n      'CDK output file that contains Websocket link in a property ServerlessSpyWsUrl'\n    )\n    .option(\n      '--cdkstack <cdkstack>',\n      'CDK stack in cdk output file. If not specified the first one is picked.'\n    )\n    .option('--open <open>', 'Open browser', progam.BOOL, true)\n    .option(\n      '--port <p>',\n      `A port on localhost where ServerlessSpy web console is accessible.`,\n      progam.INT,\n      '3456'\n    )\n    .action((_args, opt, _logger) => {\n      options = opt;\n    });\n\n  progam.parse(process.argv);\n\n  if (!options.ws && !options.cdkoutput) {\n    throw new Error('--ws or --cdkstack parameter not specified');\n  }\n\n  if (options.cdkoutput) {\n    const rawdata = fs.readFileSync(path.join(__dirname, options.cdkoutput));\n    cdkOutput = JSON.parse(rawdata.toString());\n    stackList = Object.keys(cdkOutput);\n  }\n\n  http\n    .createServer((request, response) => {\n      void (async () => {\n        try {\n          //console.log('request ', request.url);\n          let filePath: string = `.${request.url}`;\n          //remove query parameters\n          filePath = filePath.split('?')[0];\n          let rootFolder = __dirname;\n\n          if (request.url?.startsWith('/webServerlessSpy.js')) {\n            //get transpiled TS to JS files\n            rootFolder = getCompiledJsPath();\n          } else if (request.url?.startsWith('/bootstrap/')) {\n            filePath = filePath.substring('/bootstrap/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else if (request.url?.startsWith('/bootstrap-icons/')) {\n            filePath = filePath.substring('/bootstrap-icons/'.length);\n            const bootstrapFolder = await getNpmModuleInstalledPath(\n              'bootstrap-icons'\n            );\n\n            rootFolder = bootstrapFolder;\n          } else {\n            if (filePath === './') {\n              filePath = './index.html';\n            }\n          }\n\n          filePath = path.join(rootFolder, filePath);\n          //console.log(`${request.url} --> ${filePath}`);\n\n          const extname = String(path.extname(filePath)).toLowerCase();\n          const mimeTypes: any = {\n            '.html': 'text/html',\n            '.js': 'text/javascript',\n            '.css': 'text/css',\n            '.json': 'application/json',\n            '.png': 'image/png',\n            '.jpg': 'image/jpg',\n            '.gif': 'image/gif',\n            '.svg': 'image/svg+xml',\n            '.wav': 'audio/wav',\n            '.mp4': 'video/mp4',\n            '.woff': 'application/font-woff',\n            '.ttf': 'application/font-ttf',\n            '.eot': 'application/vnd.ms-fontobject',\n            '.otf': 'application/font-otf',\n            '.wasm': 'application/wasm',\n          };\n\n          const contentType = mimeTypes[extname] || 'application/octet-stream';\n\n          if (request.url === '/stackList') {\n            response.writeHead(200, { 'Content-Type': 'application/json' });\n            response.end(JSON.stringify(stackList), 'utf-8');\n          } else if (request.url?.match('^/wsUrl')) {\n            let wsUrl: string | undefined;\n            if (options.ws) {\n              wsUrl = options.ws;\n            } else {\n              // options.cdkoutput\n              const urlPaths = request.url.split('/');\n              let stack = urlPaths[2];\n\n              if (!stack) {\n                stack = options.cdkstack;\n              }\n\n              if (stack) {\n                wsUrl = cdkOutput[stack].ServerlessSpyWsUrl;\n              } else {\n                if (cdkOutput && cdkOutput[Object.keys(cdkOutput)[0]]) {\n                  wsUrl =\n                    cdkOutput[Object.keys(cdkOutput)[0]].ServerlessSpyWsUrl;\n                }\n              }\n            }\n\n            if (!wsUrl) {\n              throw new Error('Missing websocket url');\n            }\n\n            //console.log(`WS URL: ${wsUrl}`);\n            const signedWSUrl = await getSignedWebSocketUrl(wsUrl);\n            response.writeHead(200, { 'Content-Type': 'text/html' });\n            response.end(signedWSUrl, 'utf-8');\n          } else {\n            try {\n              const content = await readFileAsync(filePath);\n\n              response.writeHead(200, { 'Content-Type': contentType });\n              response.end(content, 'utf-8');\n            } catch (error: any) {\n              if (error.code === 'ENOENT') {\n                response.writeHead(404, { 'Content-Type': 'text/html' });\n                response.end(\n                  `No such file or directory ${request.url}`,\n                  'utf-8'\n                );\n              } else {\n                response.writeHead(500);\n                response.end(`Error: ${error.code} ..\\n`);\n              }\n            }\n          }\n        } catch (err: any) {\n          response.writeHead(500, { 'Content-Type': 'text/html' });\n          response.end(err.message, 'utf-8');\n        }\n      })();\n    })\n    .listen(options.port);\n\n  console.log(\n    `ServerlessSoy console runing at http://localhost:${options.port}`\n  );\n  if (options.open) {\n    await opener(`http://localhost:${options.port}`);\n  }\n}\n\nrun().catch(console.error);\n\nfunction getNpmModuleInstalledPath(npm: string) {\n  let folder = path.join(__dirname, '../', 'node_modules', npm);\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'node_modules', npm);\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find package in folder ${folder} and ${folderAsPackage}`\n  );\n}\n\nfunction getCompiledJsPath() {\n  let folder = path.join(__dirname, '../', 'lib/cli');\n  if (fs.existsSync(folder)) {\n    return folder;\n  }\n\n  let folderAsPackage = path.join(__dirname, '../../', 'lib/cli');\n\n  if (fs.existsSync(folderAsPackage)) {\n    return folderAsPackage;\n  }\n\n  throw new Error(\n    `Can not find compiled files in folder ${folder} and ${folderAsPackage}`\n  );\n}\n"]}

package/lib/cli/cli.ts

@@ -22,7 +22,7 @@ async function run() {
   let options: any;
 
   progam
-    .description('ServerlessSpy')
+    .description('ServerlessSpy web console')
     .option('--ws <ws>', 'Websocket link')
     .option(
       '--cdkoutput <cdkoutput>',
@@ -35,7 +35,7 @@ async function run() {
     .option('--open <open>', 'Open browser', progam.BOOL, true)
     .option(
       '--port <p>',
-      `CDK stack in cdk output file. If not specified the first one is picked.`,
+      `A port on localhost where ServerlessSpy web console is accessible.`,
       progam.INT,
       '3456'
     )

package/lib/src/ServerlessSpy.js

@@ -537,5 +537,5 @@ class ServerlessSpy extends constructs_1.Construct {
 }
 exports.ServerlessSpy = ServerlessSpy;
 _a = JSII_RTTI_SYMBOL_1;
-ServerlessSpy[_a] = { fqn: "serverless-spy.ServerlessSpy", version: "0.0.52" };
+ServerlessSpy[_a] = { fqn: "serverless-spy.ServerlessSpy", version: "0.0.54" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ServerlessSpy.js","sourceRoot":"","sources":["../src/ServerlessSpy.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport * as apiGwV2 from '@aws-cdk/aws-apigatewayv2-alpha';\nimport * as apiGwV2Int from '@aws-cdk/aws-apigatewayv2-integrations-alpha';\nimport { CfnOutput, Duration, Stack } from 'aws-cdk-lib';\nimport * as agw from 'aws-cdk-lib/aws-apigatewayv2';\nimport * as dynamoDb from 'aws-cdk-lib/aws-dynamodb';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as targets from 'aws-cdk-lib/aws-events-targets';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as dynamoDbStream from 'aws-cdk-lib/aws-lambda-event-sources';\nimport { SqsEventSource } from 'aws-cdk-lib/aws-lambda-event-sources';\nimport * as lambdaNode from 'aws-cdk-lib/aws-lambda-nodejs';\nimport { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as s3notif from 'aws-cdk-lib/aws-s3-notifications';\nimport * as sns from 'aws-cdk-lib/aws-sns';\nimport * as snsSubs from 'aws-cdk-lib/aws-sns-subscriptions';\nimport * as sqs from 'aws-cdk-lib/aws-sqs';\nimport { Construct, IConstruct } from 'constructs';\nimport { envVariableNames } from './common/envVariableNames';\n\nexport interface ServerlessSpyProps {\n  readonly generateSpyEventsFileLocation?: string;\n  readonly spySqsWithNoSubscriptionAndDropAllMessages?: boolean;\n  readonly debugMode?: boolean;\n}\n\nexport interface SpyFilter {\n  readonly spyLambda?: boolean;\n  readonly spySqs?: boolean;\n  readonly spySnsTopic?: boolean;\n  readonly spySnsSubsription?: boolean;\n  readonly spyEventBridge?: boolean;\n  readonly spyEventBridgeRule?: boolean;\n  readonly spyS3?: boolean;\n  readonly spyDynamoDB?: boolean;\n}\n\nexport class ServerlessSpy extends Construct {\n  private extensionLayer: lambda.LayerVersion;\n  private table: dynamoDb.Table;\n  private webSocketApi: apiGwV2.WebSocketApi;\n  private createdResourcesBySSpy: IConstruct[] = [];\n  private lambdaSubscriptionPool: LambdaSubscription[] = [];\n  private lambdaSubscriptionMain: LambdaSubscription;\n  private lambdasSpied: LambdaSpied[] = [];\n  private webSocketStage: apiGwV2.WebSocketStage;\n  public serviceKeys: string[] = [];\n  private spiedNodes: IConstruct[] = [];\n  wsUrl: string;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    private props?: ServerlessSpyProps\n  ) {\n    super(scope, id);\n\n    this.extensionLayer = new lambda.LayerVersion(this, 'Extension', {\n      compatibleRuntimes: [\n        lambda.Runtime.NODEJS_12_X,\n        lambda.Runtime.NODEJS_14_X,\n        lambda.Runtime.NODEJS_16_X,\n      ],\n      code: lambda.Code.fromAsset(this.getExtensionAssetLocation()),\n    });\n    this.createdResourcesBySSpy.push(this.extensionLayer);\n\n    this.table = new dynamoDb.Table(this, 'WebSocket', {\n      partitionKey: {\n        name: 'connectionId',\n        type: dynamoDb.AttributeType.STRING,\n      },\n      billingMode: dynamoDb.BillingMode.PAY_PER_REQUEST,\n    });\n    this.createdResourcesBySSpy.push(this.table);\n\n    const envVars = this.getDafaultLambdaEnvironmentVariables();\n\n    if (this.props?.debugMode) {\n      envVars[envVariableNames.SSPY_DEBUG] = 'true';\n    }\n\n    const functionOnConnect = new lambdaNode.NodejsFunction(this, 'OnConnect', {\n      memorySize: 512,\n      timeout: Duration.seconds(5),\n      runtime: lambda.Runtime.NODEJS_16_X,\n      handler: 'handler',\n      entry: this.getAssetLocation('functions/onConnect.ts'),\n      environment: envVars,\n    });\n    this.table.grantWriteData(functionOnConnect);\n    this.createdResourcesBySSpy.push(functionOnConnect);\n\n    const functionOnDisconnect = new lambdaNode.NodejsFunction(\n      this,\n      'OnDisconnect',\n      {\n        memorySize: 512,\n        timeout: Duration.seconds(5),\n        runtime: lambda.Runtime.NODEJS_16_X,\n        handler: 'handler',\n        entry: this.getAssetLocation('functions/onDisconnect.ts'),\n        environment: envVars,\n      }\n    );\n    this.table.grantWriteData(functionOnDisconnect);\n    this.createdResourcesBySSpy.push(functionOnDisconnect);\n\n    this.webSocketApi = new apiGwV2.WebSocketApi(this, 'ApiGwWebSocket');\n    this.createdResourcesBySSpy.push(this.webSocketApi);\n    this.webSocketStage = new apiGwV2.WebSocketStage(\n      this,\n      'ApiGwWebSocketStage',\n      {\n        webSocketApi: this.webSocketApi,\n        stageName: 'prod',\n        autoDeploy: true,\n      }\n    );\n    this.createdResourcesBySSpy.push(this.webSocketStage);\n    const webSocketApiRoute = this.webSocketApi.addRoute('$connect', {\n      integration: new apiGwV2Int.WebSocketLambdaIntegration(\n        '$connect',\n        functionOnConnect\n      ),\n    });\n    (webSocketApiRoute.node.defaultChild as agw.CfnRoute).authorizationType =\n      'AWS_IAM';\n\n    this.webSocketApi.addRoute('$disconnect', {\n      integration: new apiGwV2Int.WebSocketLambdaIntegration(\n        '$disconnect',\n        functionOnDisconnect\n      ),\n    });\n\n    this.lambdaSubscriptionMain = this.provideFunctionForSubscription();\n\n    this.webSocketApi.addRoute('sendmessage', {\n      integration: new apiGwV2Int.WebSocketLambdaIntegration(\n        'SendMessage',\n        this.lambdaSubscriptionMain.function\n      ),\n    });\n\n    this.wsUrl = `wss://${this.webSocketApi.apiId}.execute-api.${\n      Stack.of(this).region\n    }.amazonaws.com/${this.webSocketStage.stageName}`;\n\n    new CfnOutput(Stack.of(this), 'ServerlessSpyWsUrl', {\n      value: this.wsUrl,\n    });\n  }\n\n  private getDafaultLambdaEnvironmentVariables(): { [key: string]: string } {\n    return {\n      [envVariableNames.SSPY_WS_TABLE_NAME]: this.table.tableName,\n      NODE_OPTIONS: '--enable-source-maps',\n    };\n  }\n\n  /**\n   * Initalize spying on resources given as parameter.\n   * @param nodes Which reources and their children to spy on.\n   */\n  public spyNodes(nodes: IConstruct[]) {\n    for (const node of nodes) {\n      let ns = this.getAllNodes(node);\n      this.internalSpyNodes(ns);\n    }\n\n    this.finializeSpy();\n  }\n\n  /**\n   * Initalize spying on resources.\n   * @param filter Limit which resources to spy on.\n   */\n  public spy(filter?: SpyFilter) {\n    let nodes = this.getAllNodes(Stack.of(this));\n\n    const filterWithDefaults: Required<SpyFilter> = {\n      spyLambda: true,\n      spySqs: true,\n      spySnsTopic: true,\n      spySnsSubsription: true,\n      spyEventBridge: true,\n      spyEventBridgeRule: true,\n      spyS3: true,\n      spyDynamoDB: true,\n      ...filter,\n    };\n\n    nodes = nodes.filter((node) => {\n      if (filterWithDefaults.spyLambda && node instanceof lambda.Function) {\n        return true;\n      } else if (filterWithDefaults.spySnsTopic && node instanceof sns.Topic) {\n        return true;\n      } else if (\n        filterWithDefaults.spySnsSubsription &&\n        node instanceof sns.Subscription\n      ) {\n        return true;\n      } else if (filterWithDefaults.spyS3 && node instanceof s3.Bucket) {\n        return true;\n      } else if (\n        filterWithDefaults.spyDynamoDB &&\n        node instanceof dynamoDb.Table\n      ) {\n        return true;\n      } else if (\n        filterWithDefaults.spyEventBridge &&\n        node instanceof events.EventBus\n      ) {\n        return true;\n      } else if (\n        filterWithDefaults.spyEventBridgeRule &&\n        node instanceof events.Rule\n      ) {\n        return true;\n      } else if (\n        filterWithDefaults.spySqs &&\n        node instanceof lambda.CfnEventSourceMapping\n      ) {\n        return true;\n      } else if (\n        filterWithDefaults.spySqs &&\n        this.props?.spySqsWithNoSubscriptionAndDropAllMessages &&\n        node instanceof sqs.Queue\n      ) {\n        return true;\n      }\n\n      return false;\n    });\n\n    this.internalSpyNodes(nodes);\n    this.finializeSpy();\n  }\n\n  private internalSpyNodes(nodes: IConstruct[]) {\n    for (const node of nodes) {\n      this.internalSpyNode(node);\n    }\n  }\n\n  private finializeSpy() {\n    //set mapping property for all functions we created\n    for (const func of this.lambdaSubscriptionPool) {\n      func.function.addEnvironment(\n        envVariableNames.SSPY_INFRA_MAPPING,\n        JSON.stringify(func.mapping)\n      );\n    }\n\n    //set mapping property for all functions we spy on\n    for (const func of this.lambdasSpied) {\n      func.function.addEnvironment(\n        envVariableNames.SSPY_INFRA_MAPPING,\n        JSON.stringify(func.mapping)\n      );\n    }\n\n    if (this.props?.generateSpyEventsFileLocation) {\n      this.writeSpyEventsClass(this.props?.generateSpyEventsFileLocation);\n    }\n  }\n\n  private getExtensionAssetLocation() {\n    let extensionAssetLocation = path.join(\n      __dirname,\n      '../extension/dist/layer'\n    );\n\n    const extensionAssetLocationAlt = path.join(\n      __dirname,\n      '../lib/extension/dist/layer'\n    );\n\n    if (!fs.existsSync(extensionAssetLocation)) {\n      if (!fs.existsSync(extensionAssetLocationAlt)) {\n        throw new Error(\n          `Folder with assets for extension does not exists at ${extensionAssetLocation} or at ${extensionAssetLocationAlt} `\n        );\n      } else {\n        extensionAssetLocation = extensionAssetLocationAlt;\n      }\n    }\n\n    const extensionAssetLocationWraper = path.join(\n      extensionAssetLocation,\n      'spy-wrapper'\n    );\n    if (!fs.existsSync(extensionAssetLocationWraper)) {\n      throw new Error(\n        `Wraper script for extension does not exists ${extensionAssetLocation}`\n      );\n    }\n\n    const extensionAssetLocationCode = path.join(\n      extensionAssetLocation,\n      'nodejs/node_modules/interceptor.js'\n    );\n    if (!fs.existsSync(extensionAssetLocationCode)) {\n      throw new Error(\n        `Code for extension does not exists ${extensionAssetLocationCode}`\n      );\n    }\n    return extensionAssetLocation;\n  }\n\n  /**\n   * Write SpyEvents class, which helps with writing the code for tests.\n   * @param fileLocation\n   */\n  private writeSpyEventsClass(fileLocation: string) {\n    fs.mkdirSync(path.dirname(fileLocation), { recursive: true });\n\n    const properties = this.serviceKeys\n      .map((sk) => `  ${sk.replace(/#/g, '')}: '${sk}' = '${sk}';\\n`)\n      .join('');\n\n    const code = `/* eslint-disable */\\nexport class ServerlessSpyEvents {\\n${properties}}\\n`;\n\n    fs.writeFileSync(fileLocation, code);\n  }\n\n  private getAllNodes(parent: IConstruct) {\n    const nodes: IConstruct[] = [];\n    nodes.push(parent);\n    this.getAllNodesRecursive(parent, nodes);\n    return nodes;\n  }\n\n  private getAllNodesRecursive(parent: IConstruct, nodes: IConstruct[]) {\n    for (const node of parent.node.children) {\n      nodes.push(node);\n      this.getAllNodesRecursive(node, nodes);\n    }\n  }\n\n  private internalSpyNode(node: IConstruct) {\n    if (this.spiedNodes.includes(node)) {\n      return;\n    }\n\n    this.spiedNodes.push(node);\n\n    if (this.createdResourcesBySSpy.includes(node)) {\n      return;\n    }\n\n    if (this.lambdaSubscriptionPool.find((s) => s.function === node)) {\n      return;\n    }\n\n    if (this.props?.debugMode) {\n      console.info('Spy on node', this.getConstructName(node));\n    }\n\n    if (node instanceof lambda.Function) {\n      this.internalSpyLambda(node);\n    } else if (node instanceof sns.Topic) {\n      this.internalSpySnsTopic(node);\n    } else if (node instanceof sns.Subscription) {\n      this.internalSpySnsSubscription(node);\n    } else if (node instanceof s3.Bucket) {\n      this.internalSpyS3(node);\n    } else if (node instanceof dynamoDb.Table) {\n      this.internalSpyDynamodb(node);\n    } else if (node instanceof events.EventBus) {\n      this.internalSpyEventBus(node);\n    } else if (node instanceof events.Rule) {\n      this.internalSpyEventBusRule(node);\n    } else if (node instanceof lambda.CfnEventSourceMapping) {\n      this.internalSpySqs(node);\n    } else if (node instanceof sqs.Queue) {\n      if (this.props?.spySqsWithNoSubscriptionAndDropAllMessages) {\n        this.internalSpySpySqsWithNoSubscription(node);\n      }\n    }\n  }\n\n  private internalSpySpySqsWithNoSubscription(queue: sqs.Queue) {\n    const subscription = this.findElement<lambda.CfnEventSourceMapping>(\n      (n: IConstruct) =>\n        n instanceof lambda.CfnEventSourceMapping &&\n        (n as lambda.CfnEventSourceMapping).eventSourceArn === queue.queueArn\n    );\n\n    if (subscription) {\n      return; //already have subscription\n    }\n\n    const queueName = this.getConstructName(queue);\n    const func = new NodejsFunction(\n      this,\n      `${queueName}SqsSubscriptionAndDropAllMessages`,\n      {\n        memorySize: 512,\n        timeout: Duration.seconds(5),\n        runtime: lambda.Runtime.NODEJS_16_X,\n        handler: 'handler',\n        entry: this.getAssetLocation(\n          'functions/sqsSubscriptionAndDropAllMessages.ts'\n        ),\n        environment: this.getDafaultLambdaEnvironmentVariables(),\n      }\n    );\n    func.addEventSource(new SqsEventSource(queue));\n\n    //\n    func.addLayers(this.extensionLayer);\n\n    //const functionName = this.getConstructName(func);\n\n    //func.addEnvironment(envVariableNames.SSPY_FUNCTION_NAME, functionName);\n    func.addEnvironment('AWS_LAMBDA_EXEC_WRAPPER', '/opt/spy-wrapper');\n    func.addEnvironment(\n      envVariableNames.SSPY_WS_ENDPOINT,\n      this.getWsEndpoint()\n    );\n\n    if (this.props?.debugMode) {\n      func.addEnvironment(envVariableNames.SSPY_DEBUG, 'true');\n    }\n\n    this.table.grantWriteData(func);\n    this.table.grantReadData(func);\n    this.webSocketApi.grantManageConnections(func);\n    //\n\n    this.createdResourcesBySSpy.push(func);\n\n    const serviceKey = `Sqs#${queueName}`;\n\n    this.addMappingToFunction(func, {\n      key: queue.queueArn,\n      value: serviceKey,\n    });\n\n    this.serviceKeys.push(serviceKey);\n    func.addEnvironment(envVariableNames.SSPY_SUBSCRIBED_TO_SQS, 'true');\n  }\n\n  private internalSpySqs(node: lambda.CfnEventSourceMapping) {\n    const queue = this.findElement<sqs.Queue>(\n      (n: IConstruct) =>\n        n instanceof sqs.Queue &&\n        (n as sqs.Queue).queueArn === node.eventSourceArn\n    );\n\n    const func = this.findElement<lambda.Function>(\n      (n: IConstruct) =>\n        n instanceof lambda.Function &&\n        (n as lambda.Function).functionName === node.functionName\n    );\n\n    if (queue && func) {\n      const queueName = this.getConstructName(queue);\n\n      const serviceKey = `Sqs#${queueName}`;\n\n      this.addMappingToFunction(func, {\n        key: queue.queueArn,\n        value: serviceKey,\n      });\n\n      this.serviceKeys.push(serviceKey);\n      func.addEnvironment(envVariableNames.SSPY_SUBSCRIBED_TO_SQS, 'true');\n    }\n  }\n\n  private createFunctionForSubscription(index: number) {\n    const func = new lambdaNode.NodejsFunction(this, `Subscription${index}`, {\n      memorySize: 512,\n      timeout: Duration.seconds(5),\n      runtime: lambda.Runtime.NODEJS_16_X,\n      handler: 'handler',\n      entry: this.getAssetLocation('functions/sendMessage.ts'),\n      environment: {\n        [envVariableNames.SSPY_WS_TABLE_NAME]: this.table.tableName,\n        NODE_OPTIONS: '--enable-source-maps',\n      },\n    });\n\n    this.table.grantWriteData(func);\n    this.table.grantReadData(func);\n    func.addEnvironment(\n      envVariableNames.SSPY_WS_ENDPOINT,\n      this.getWsEndpoint()\n    );\n\n    this.webSocketApi.grantManageConnections(func);\n    return func;\n  }\n\n  private getWsEndpoint(): string {\n    return `https://${this.webSocketApi.apiId}.execute-api.${\n      Stack.of(this).region\n    }.amazonaws.com/${this.webSocketStage.stageName}`;\n  }\n\n  private internalSpyS3(s3Bucket: s3.Bucket) {\n    s3Bucket.addEventNotification(\n      s3.EventType.OBJECT_CREATED_PUT,\n      new s3notif.LambdaDestination(this.lambdaSubscriptionMain.function)\n    );\n\n    const name = this.getConstructName(s3Bucket);\n\n    const serviceKey = `S3#${name}`;\n    this.lambdaSubscriptionMain.mapping[s3Bucket.bucketArn] = serviceKey;\n    this.serviceKeys.push(serviceKey);\n  }\n\n  private internalSpyDynamodb(table: dynamoDb.Table) {\n    // enable DynamoDB streams with a hack\n    (table.node.defaultChild as dynamoDb.CfnTable).streamSpecification = {\n      streamViewType: dynamoDb.StreamViewType.NEW_AND_OLD_IMAGES,\n    };\n    (table as any).tableStreamArn = (\n      table.node.defaultChild as dynamoDb.CfnTable\n    ).attrStreamArn;\n\n    this.lambdaSubscriptionMain.function.addEventSource(\n      new dynamoDbStream.DynamoEventSource(table, {\n        startingPosition: lambda.StartingPosition.LATEST,\n        batchSize: 1,\n        retryAttempts: 0,\n      })\n    );\n\n    const name = this.getConstructName(table);\n\n    const serviceKey = `DynamoDB#${name}`;\n    this.lambdaSubscriptionMain.mapping[table.tableArn] = serviceKey;\n    this.serviceKeys.push(serviceKey);\n  }\n\n  private internalSpyEventBusRule(rule: events.Rule) {\n    const { eventBusName } = rule.node.defaultChild as events.CfnRule;\n    const eventBridge = this.getEventBridge(\n      (rule.node.defaultChild as any).eventBusName\n    );\n\n    if (!eventBridge) {\n      throw new Error(`Can not find EventBridge with name \"${eventBusName}\"`);\n    }\n\n    const functionSubscription = this.provideFunctionForSubscription(\n      (s) => !s.usedForEventBridge\n    );\n    functionSubscription.usedForEventBridge = true;\n\n    rule.addTarget(new targets.LambdaFunction(functionSubscription.function));\n\n    const bridgeName = this.getConstructName(eventBridge);\n    const ruleName = this.getConstructName(rule);\n    const serviceKey = `EventBridgeRule#${bridgeName}#${ruleName}`;\n    functionSubscription.mapping.eventBridge = serviceKey;\n    this.serviceKeys.push(serviceKey);\n  }\n\n  private internalSpyEventBus(eventBus: events.EventBus) {\n    const functionSubscription = this.provideFunctionForSubscription(\n      (s) => !s.usedForEventBridge\n    );\n    functionSubscription.usedForEventBridge = true;\n\n    const bridgeName = this.getConstructName(eventBus);\n    const rule = new events.Rule(this, `RuleAll${bridgeName}`, {\n      eventBus,\n      eventPattern: { version: ['0'] },\n      targets: [new targets.LambdaFunction(functionSubscription.function)],\n    });\n\n    this.createdResourcesBySSpy.push(rule);\n    const serviceKey = `EventBridge#${bridgeName}`;\n    functionSubscription.mapping.eventBridge = serviceKey;\n    this.serviceKeys.push(serviceKey);\n  }\n\n  private internalSpySnsTopic(topic: sns.Topic) {\n    const functionSubscription = this.provideFunctionForSubscription(\n      (s) => !s.subsribedTopics.includes(topic)\n    );\n\n    const subscription = topic.addSubscription(\n      new snsSubs.LambdaSubscription(functionSubscription.function)\n    );\n    this.createdResourcesBySSpy.push(subscription);\n    const topicName = this.getConstructName(topic);\n    const serviceKey = `SnsTopic#${topicName}`;\n    functionSubscription.mapping[topic.topicArn] = serviceKey;\n    this.serviceKeys.push(serviceKey);\n    functionSubscription.subsribedTopics.push(topic);\n  }\n\n  private internalSpySnsSubscription(subscription: sns.Subscription) {\n    if (!subscription.node.scope) {\n      return;\n    }\n\n    const topic = this.getTopic(\n      (subscription.node.defaultChild as sns.CfnSubscription).topicArn\n    );\n\n    if (!topic) {\n      throw new Error('Can not find Topic');\n    }\n\n    const functionSubscription = this.provideFunctionForSubscription(\n      (s) => !s.subsribedTopics.includes(topic)\n    );\n\n    const { filterPolicy } = subscription.node\n      .defaultChild as sns.CfnSubscription;\n\n    const subscriptionClone = topic.addSubscription(\n      new snsSubs.LambdaSubscription(functionSubscription.function)\n    );\n    (subscriptionClone.node.defaultChild as sns.CfnSubscription).filterPolicy =\n      filterPolicy;\n\n    this.createdResourcesBySSpy.push(subscriptionClone);\n\n    const topicName = this.getConstructName(topic);\n    const targetName = this.getConstructName(subscription.node.scope);\n\n    functionSubscription.subsribedTopics.push(topic);\n    const serviceKey = `SnsSubscription#${topicName}#${targetName}`;\n    functionSubscription.mapping[topic.topicArn] = serviceKey;\n    this.serviceKeys.push(serviceKey);\n  }\n\n  private provideFunctionForSubscription(\n    filterFunction?: (subscription: LambdaSubscription) => boolean\n  ) {\n    let functionSubscription: LambdaSubscription | undefined;\n\n    if (filterFunction) {\n      functionSubscription = this.lambdaSubscriptionPool.find(filterFunction);\n    } else if (this.lambdaSubscriptionPool.length > 0) {\n      functionSubscription = this.lambdaSubscriptionPool[0];\n    }\n\n    if (!functionSubscription) {\n      functionSubscription = {\n        subsribedTopics: [],\n        usedForEventBridge: false,\n        mapping: {},\n        function: this.createFunctionForSubscription(\n          this.lambdaSubscriptionPool.length\n        ),\n      };\n      this.lambdaSubscriptionPool.push(functionSubscription);\n    }\n    return functionSubscription;\n  }\n\n  private internalSpyLambda(func: lambda.Function) {\n    func.addLayers(this.extensionLayer);\n\n    const functionName = this.getConstructName(func);\n\n    func.addEnvironment(envVariableNames.SSPY_FUNCTION_NAME, functionName);\n    func.addEnvironment('AWS_LAMBDA_EXEC_WRAPPER', '/opt/spy-wrapper');\n    func.addEnvironment(\n      envVariableNames.SSPY_WS_TABLE_NAME,\n      this.table.tableName\n    );\n    func.addEnvironment(\n      envVariableNames.SSPY_WS_ENDPOINT,\n      this.getWsEndpoint()\n    );\n\n    if (this.props?.debugMode) {\n      func.addEnvironment(envVariableNames.SSPY_DEBUG, 'true');\n    }\n\n    this.table.grantWriteData(func);\n    this.table.grantReadData(func);\n    this.webSocketApi.grantManageConnections(func);\n\n    this.serviceKeys.push(`Function#${functionName}#Request`);\n    this.serviceKeys.push(`Function#${functionName}#Error`);\n    this.serviceKeys.push(`Function#${functionName}#Console`);\n    this.serviceKeys.push(`Function#${functionName}#Response`);\n\n    this.addMappingToFunction(func);\n  }\n\n  public getConstructName(construct: IConstruct) {\n    let functionName = construct.node.path;\n    const { stackName } = Stack.of(this);\n\n    if (functionName.startsWith(stackName)) {\n      functionName = functionName.substring(stackName.length + 1);\n    }\n    return functionName;\n  }\n\n  private getTopic(topicArn: string): sns.Topic | undefined {\n    const topic = this.findElement<sns.Topic>(\n      (node: IConstruct) =>\n        node instanceof sns.Topic && (node as sns.Topic).topicArn === topicArn\n    );\n\n    return topic;\n  }\n\n  private getEventBridge(eventBusName: string): events.EventBus | undefined {\n    const eventBridge = this.findElement<events.EventBus>(\n      (node: IConstruct) =>\n        node instanceof events.EventBus &&\n        (node as events.EventBus).eventBusName === eventBusName\n    );\n\n    return eventBridge;\n  }\n\n  private findElement<T extends IConstruct = IConstruct>(\n    filterFunc: (node: IConstruct) => boolean,\n    parent?: IConstruct\n  ): T | undefined {\n    if (!parent) {\n      parent = Stack.of(this);\n    }\n\n    for (const node of parent.node.children) {\n      if (filterFunc(node)) {\n        return node as T;\n      }\n      this.findElement<T>(filterFunc, node);\n    }\n\n    return undefined;\n  }\n\n  private addMappingToFunction(\n    func: lambda.Function,\n    keyValue?: { key: string; value: string }\n  ) {\n    for (const fs of this.lambdasSpied) {\n      if (fs.function === func) {\n        if (keyValue) {\n          fs.mapping[keyValue.key] = keyValue.value;\n        }\n        return;\n      }\n    }\n\n    const fs: LambdaSpied = {\n      function: func,\n      mapping: {},\n    };\n\n    if (keyValue) {\n      fs.mapping[keyValue.key] = keyValue.value;\n    }\n\n    this.lambdasSpied.push(fs);\n  }\n\n  private getAssetLocation(location: string) {\n    const loc = path.join(__dirname, '../' + location);\n\n    if (fs.existsSync(loc)) {\n      return loc;\n    }\n\n    const loc2 = path.join(__dirname, '../../' + location);\n\n    if (fs.existsSync(loc2)) {\n      return loc2;\n    }\n\n    throw new Error(`Location ${loc} and ${loc2} does not exists.`);\n  }\n}\n\ntype LambdaSubscription = {\n  subsribedTopics: sns.Topic[];\n  usedForEventBridge: boolean;\n  function: lambdaNode.NodejsFunction;\n  mapping: Record<string, string>;\n};\n\ntype LambdaSpied = {\n  function: lambda.Function;\n  mapping: Record<string, string>;\n};\n"]}

package/package.json

@@ -34,7 +34,8 @@
     "lint-fix": "eslint --fix './**/*.ts'",
     "pretty": "prettier --write '**/*.ts'",
     "bundle-extension": "scripts/run-task bundle-extension",
-    "cli": "scripts/run-task cli"
+    "cli": "scripts/run-task cli",
+    "homepage": "bundle exec jekyll serve --watch"
   },
   "author": {
     "name": "Marko (ServerlessLife.com)",
@@ -132,7 +133,7 @@
     "require": "./lib/index.js"
   },
   "license": "MPL-2.0",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "types": "lib/index.d.ts",
   "stability": "stable",
   "jsii": {

package/serverlessSpyEvents/ServerlessSpyEventsE2e.ts

@@ -0,0 +1,32 @@
+/* eslint-disable */
+export class ServerlessSpyEvents {
+  S3MyBucket: 'S3#MyBucket' = 'S3#MyBucket';
+  SnsSubscriptionMyTopicNo1MyQueueNo1: 'SnsSubscription#MyTopicNo1#MyQueueNo1' = 'SnsSubscription#MyTopicNo1#MyQueueNo1';
+  SnsTopicMyTopicNo1: 'SnsTopic#MyTopicNo1' = 'SnsTopic#MyTopicNo1';
+  EventBridgeMyEventBus: 'EventBridge#MyEventBus' = 'EventBridge#MyEventBus';
+  DynamoDBMyTable: 'DynamoDB#MyTable' = 'DynamoDB#MyTable';
+  FunctionToSnsAndDynamoDbRequest: 'Function#ToSnsAndDynamoDb#Request' = 'Function#ToSnsAndDynamoDb#Request';
+  FunctionToSnsAndDynamoDbError: 'Function#ToSnsAndDynamoDb#Error' = 'Function#ToSnsAndDynamoDb#Error';
+  FunctionToSnsAndDynamoDbConsole: 'Function#ToSnsAndDynamoDb#Console' = 'Function#ToSnsAndDynamoDb#Console';
+  FunctionToSnsAndDynamoDbResponse: 'Function#ToSnsAndDynamoDb#Response' = 'Function#ToSnsAndDynamoDb#Response';
+  FunctionFromSnsToSqsAndS3Request: 'Function#FromSnsToSqsAndS3#Request' = 'Function#FromSnsToSqsAndS3#Request';
+  FunctionFromSnsToSqsAndS3Error: 'Function#FromSnsToSqsAndS3#Error' = 'Function#FromSnsToSqsAndS3#Error';
+  FunctionFromSnsToSqsAndS3Console: 'Function#FromSnsToSqsAndS3#Console' = 'Function#FromSnsToSqsAndS3#Console';
+  FunctionFromSnsToSqsAndS3Response: 'Function#FromSnsToSqsAndS3#Response' = 'Function#FromSnsToSqsAndS3#Response';
+  SnsSubscriptionMyTopicNo1FromSnsToSqsAndS3: 'SnsSubscription#MyTopicNo1#FromSnsToSqsAndS3' = 'SnsSubscription#MyTopicNo1#FromSnsToSqsAndS3';
+  FunctionFromSqsToEventBridgeRequest: 'Function#FromSqsToEventBridge#Request' = 'Function#FromSqsToEventBridge#Request';
+  FunctionFromSqsToEventBridgeError: 'Function#FromSqsToEventBridge#Error' = 'Function#FromSqsToEventBridge#Error';
+  FunctionFromSqsToEventBridgeConsole: 'Function#FromSqsToEventBridge#Console' = 'Function#FromSqsToEventBridge#Console';
+  FunctionFromSqsToEventBridgeResponse: 'Function#FromSqsToEventBridge#Response' = 'Function#FromSqsToEventBridge#Response';
+  SqsMyQueueNo2: 'Sqs#MyQueueNo2' = 'Sqs#MyQueueNo2';
+  FunctionReceiveSqsRequest: 'Function#ReceiveSqs#Request' = 'Function#ReceiveSqs#Request';
+  FunctionReceiveSqsError: 'Function#ReceiveSqs#Error' = 'Function#ReceiveSqs#Error';
+  FunctionReceiveSqsConsole: 'Function#ReceiveSqs#Console' = 'Function#ReceiveSqs#Console';
+  FunctionReceiveSqsResponse: 'Function#ReceiveSqs#Response' = 'Function#ReceiveSqs#Response';
+  SqsMyQueueNo1: 'Sqs#MyQueueNo1' = 'Sqs#MyQueueNo1';
+  FunctionReceiveEventBridgeRequest: 'Function#ReceiveEventBridge#Request' = 'Function#ReceiveEventBridge#Request';
+  FunctionReceiveEventBridgeError: 'Function#ReceiveEventBridge#Error' = 'Function#ReceiveEventBridge#Error';
+  FunctionReceiveEventBridgeConsole: 'Function#ReceiveEventBridge#Console' = 'Function#ReceiveEventBridge#Console';
+  FunctionReceiveEventBridgeResponse: 'Function#ReceiveEventBridge#Response' = 'Function#ReceiveEventBridge#Response';
+  EventBridgeRuleMyEventBusMyEventBridge: 'EventBridgeRule#MyEventBus#MyEventBridge' = 'EventBridgeRule#MyEventBus#MyEventBridge';
+}