serverless-spy 0.0.11 → 0.0.12

package/lib/src/ServerlessSpy.mjs

@@ -0,0 +1,293 @@
+import * as path from 'path';
+import * as apiGwV2 from '@aws-cdk/aws-apigatewayv2-alpha';
+import * as apiGwV2Int from '@aws-cdk/aws-apigatewayv2-integrations-alpha';
+import { Duration, Stack } from 'aws-cdk-lib';
+import * as dynamoDb from 'aws-cdk-lib/aws-dynamodb';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as targets from 'aws-cdk-lib/aws-events-targets';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as dynamoDbStream from 'aws-cdk-lib/aws-lambda-event-sources';
+import * as lambdaNode from 'aws-cdk-lib/aws-lambda-nodejs';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3notif from 'aws-cdk-lib/aws-s3-notifications';
+import * as sns from 'aws-cdk-lib/aws-sns';
+import * as snsSubs from 'aws-cdk-lib/aws-sns-subscriptions';
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import { Construct } from 'constructs';
+export class ServerlessSpy extends Construct {
+    constructor(scope, id) {
+        super(scope, id);
+        this.ownContructs = [];
+        this.functionSubscriptionPool = [];
+        this.extensionLayer = new lambda.LayerVersion(this, 'Extension', {
+            compatibleRuntimes: [
+                lambda.Runtime.NODEJS_12_X,
+                lambda.Runtime.NODEJS_14_X,
+                lambda.Runtime.NODEJS_16_X,
+            ],
+            code: lambda.Code.fromAsset(path.join(__dirname, '../lambda-extension/dist/layer')),
+        });
+        this.ownContructs.push(this.extensionLayer);
+        this.table = new dynamoDb.Table(this, 'WebSocket', {
+            partitionKey: {
+                name: 'connectionId',
+                type: dynamoDb.AttributeType.STRING,
+            },
+            billingMode: dynamoDb.BillingMode.PAY_PER_REQUEST,
+        });
+        this.ownContructs.push(this.table);
+        const functionOnConnect = new lambdaNode.NodejsFunction(this, 'OnConnect', {
+            memorySize: 512,
+            timeout: Duration.seconds(5),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            handler: 'handler',
+            entry: path.join(__dirname, '../functions/onConnect.ts'),
+            environment: {
+                TABLE_NAME: this.table.tableName,
+            },
+        });
+        this.table.grantWriteData(functionOnConnect);
+        this.ownContructs.push(functionOnConnect);
+        const functionOnDisconnect = new lambdaNode.NodejsFunction(this, 'OnDisconnect', {
+            memorySize: 512,
+            timeout: Duration.seconds(5),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            handler: 'handler',
+            entry: path.join(__dirname, '../functions/onDisconnect.ts'),
+            environment: {
+                TABLE_NAME: this.table.tableName,
+            },
+        });
+        this.table.grantWriteData(functionOnDisconnect);
+        this.ownContructs.push(functionOnDisconnect);
+        this.webSocketApi = new apiGwV2.WebSocketApi(this, 'ApiGwWebSocket');
+        this.ownContructs.push(this.webSocketApi);
+        this.webSocketStage = new apiGwV2.WebSocketStage(this, 'ApiGwWebSocketStage', {
+            webSocketApi: this.webSocketApi,
+            stageName: 'prod',
+            autoDeploy: true,
+        });
+        this.ownContructs.push(this.webSocketStage);
+        const webSocketApiRoute = this.webSocketApi.addRoute('$connect', {
+            integration: new apiGwV2Int.WebSocketLambdaIntegration('$connect', functionOnConnect),
+        });
+        webSocketApiRoute.node.defaultChild.authorizationType =
+            'AWS_IAM';
+        this.webSocketApi.addRoute('$disconnect', {
+            integration: new apiGwV2Int.WebSocketLambdaIntegration('$disconnect', functionOnDisconnect),
+        });
+        this.functionSubscriptionMain = this.provideFunctionForSubscription();
+        this.webSocketApi.addRoute('sendmessage', {
+            integration: new apiGwV2Int.WebSocketLambdaIntegration('SendMessage', this.functionSubscriptionMain.function),
+        });
+        this.iterateAllElements(Stack.of(this));
+        for (const func of this.functionSubscriptionPool) {
+            func.function.addEnvironment('INFRA_MAPPING', JSON.stringify(func.mapping));
+        }
+        // new CfnOutput(this, "API_URL", {
+        //   value: `wss://${this.webSocketApi.apiId}.execute-api.${
+        //     Stack.of(scope).region
+        //   }.amazonaws.com/${this.webSocketStage.stageName}`,
+        // });
+        this.wsUrl = `wss://${this.webSocketApi.apiId}.execute-api.${Stack.of(this).region}.amazonaws.com/${this.webSocketStage.stageName}`;
+        // new CfnOutput(this, "API_URL", {
+        //   value: this.wsUrl,
+        // });
+    }
+    iterateAllElements(parent) {
+        for (const node of parent.node.children) {
+            if (this.ownContructs.includes(node)) {
+                continue;
+            }
+            if (this.functionSubscriptionPool.find((s) => s.function === node)) {
+                continue;
+            }
+            console.log('NODE', node.constructor.name);
+            if (node instanceof lambda.Function) {
+                this.interceptFunction(node);
+            }
+            else if (node instanceof sns.Topic) {
+                console.log('interceptSnsTopic');
+                this.interceptSnsTopic(node);
+            }
+            else if (node instanceof sns.Subscription) {
+                this.interceptSnsSubscription(node);
+            }
+            else if (node instanceof s3.Bucket) {
+                this.interceptS3(node);
+            }
+            else if (node instanceof dynamoDb.Table) {
+                this.interceptDynamodb(node);
+            }
+            else if (node instanceof events.EventBus) {
+                this.interceptEventBus(node);
+            }
+            else if (node instanceof events.Rule) {
+                this.interceptEventBusRule(node);
+            }
+            else if (node instanceof lambda.CfnEventSourceMapping) {
+                this.interceptSqs(node);
+            }
+            else {
+                // console.log('NO MATCH', node);
+            }
+            this.iterateAllElements(node);
+        }
+    }
+    interceptSqs(node) {
+        const queue = this.findElement((n) => n instanceof sqs.Queue &&
+            n.queueArn === node.eventSourceArn);
+        const func = this.findElement((n) => n instanceof lambda.Function &&
+            n.functionName === node.functionName);
+        if (queue && func) {
+            const queueName = this.getConstructName(queue);
+            this.functionSubscriptionMain.mapping[queue.queueArn] = `Sqs#${queueName}`;
+            func.addEnvironment('FLUENT_TEST_SUBSCRIBED_TO_SQS', 'true');
+        }
+    }
+    createFunctionForSubscription(index) {
+        const func = new lambdaNode.NodejsFunction(this, `Subscription${index}`, {
+            memorySize: 512,
+            timeout: Duration.seconds(5),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            handler: 'handler',
+            entry: path.join(__dirname, '../functions/sendMessage.ts'),
+            environment: {
+                TABLE_NAME: this.table.tableName,
+            },
+        });
+        this.table.grantWriteData(func);
+        this.table.grantReadData(func);
+        func.addEnvironment('WS_ENDPOINT', `https://${this.webSocketApi.apiId}.execute-api.${Stack.of(this).region}.amazonaws.com/${this.webSocketStage.stageName}`);
+        this.webSocketApi.grantManageConnections(func);
+        return func;
+    }
+    interceptS3(s3Bucket) {
+        s3Bucket.addEventNotification(s3.EventType.OBJECT_CREATED_PUT, new s3notif.LambdaDestination(this.functionSubscriptionMain.function));
+        const name = this.getConstructName(s3Bucket);
+        this.functionSubscriptionMain.mapping[s3Bucket.bucketArn] = `S3#${name}`;
+    }
+    interceptDynamodb(table) {
+        // enable DynamoDB streams with a hack
+        table.node.defaultChild.streamSpecification = {
+            streamViewType: dynamoDb.StreamViewType.NEW_AND_OLD_IMAGES,
+        };
+        table.tableStreamArn = table.node.defaultChild.attrStreamArn;
+        this.functionSubscriptionMain.function.addEventSource(new dynamoDbStream.DynamoEventSource(table, {
+            startingPosition: lambda.StartingPosition.LATEST,
+            batchSize: 1,
+            retryAttempts: 0,
+        }));
+        const name = this.getConstructName(table);
+        this.functionSubscriptionMain.mapping[table.tableArn] = `DynamoDB#${name}`;
+    }
+    interceptEventBusRule(rule) {
+        const { eventBusName } = rule.node.defaultChild;
+        const eventBridge = this.getEventBridge(rule.node.defaultChild.eventBusName);
+        if (!eventBridge) {
+            throw new Error(`Can not find EventBridge with name "${eventBusName}"`);
+        }
+        const functionSubscription = this.provideFunctionForSubscription((s) => !s.usedForEventBridge);
+        functionSubscription.usedForEventBridge = true;
+        rule.addTarget(new targets.LambdaFunction(functionSubscription.function));
+        const bridgeName = this.getConstructName(eventBridge);
+        const ruleName = this.getConstructName(rule);
+        functionSubscription.mapping.eventBridge = `EventBridgeRule#${bridgeName}#${ruleName}`;
+    }
+    interceptEventBus(eventBus) {
+        const functionSubscription = this.provideFunctionForSubscription((s) => !s.usedForEventBridge);
+        functionSubscription.usedForEventBridge = true;
+        const bridgeName = this.getConstructName(eventBus);
+        const rule = new events.Rule(this, `RuleAll${bridgeName}`, {
+            eventBus,
+            eventPattern: { version: ['0'] },
+            targets: [new targets.LambdaFunction(functionSubscription.function)],
+        });
+        this.ownContructs.push(rule);
+        functionSubscription.mapping.eventBridge = `EventBridge#${bridgeName}`;
+    }
+    interceptSnsTopic(topic) {
+        const functionSubscription = this.provideFunctionForSubscription((s) => !s.subsribedTopics.includes(topic));
+        topic.addSubscription(new snsSubs.LambdaSubscription(functionSubscription.function));
+        const topicName = this.getConstructName(topic);
+        functionSubscription.mapping[topic.topicArn] = `SnsTopic#${topicName}`;
+        functionSubscription.subsribedTopics.push(topic);
+    }
+    interceptSnsSubscription(subscription) {
+        if (!subscription.node.scope) {
+            return;
+        }
+        const topic = this.getTopic(subscription.node.defaultChild.topicArn);
+        if (!topic) {
+            throw new Error('Can not find Topic');
+        }
+        const functionSubscription = this.provideFunctionForSubscription((s) => !s.subsribedTopics.includes(topic));
+        const { filterPolicy } = subscription.node
+            .defaultChild;
+        const subscriptionClone = topic.addSubscription(new snsSubs.LambdaSubscription(functionSubscription.function));
+        subscriptionClone.node.defaultChild.filterPolicy =
+            filterPolicy;
+        this.ownContructs.push(subscriptionClone);
+        const topicName = this.getConstructName(topic);
+        const targetName = this.getConstructName(subscription.node.scope);
+        functionSubscription.subsribedTopics.push(topic);
+        functionSubscription.mapping[topic.topicArn] = `SnsSubscription#${topicName}#${targetName}`;
+    }
+    provideFunctionForSubscription(filterFunction) {
+        let functionSubscription;
+        if (filterFunction) {
+            functionSubscription = this.functionSubscriptionPool.find(filterFunction);
+        }
+        else if (this.functionSubscriptionPool.length > 0) {
+            functionSubscription = this.functionSubscriptionPool[0];
+        }
+        if (!functionSubscription) {
+            functionSubscription = {
+                subsribedTopics: [],
+                usedForEventBridge: false,
+                mapping: {},
+                function: this.createFunctionForSubscription(this.functionSubscriptionPool.length),
+            };
+            this.functionSubscriptionPool.push(functionSubscription);
+        }
+        return functionSubscription;
+    }
+    interceptFunction(func) {
+        func.addLayers(this.extensionLayer);
+        this.functionSubscriptionMain.function.grantInvoke(func);
+        const functionName = this.getConstructName(func);
+        func.addEnvironment('FUNCTION_NAME', functionName);
+        func.addEnvironment('AWS_LAMBDA_EXEC_WRAPPER', '/opt/spy-wrapper');
+        func.addEnvironment('FLUENT_TEST_SEND_FUNCTION_NAME', this.functionSubscriptionMain.function.functionName);
+    }
+    getConstructName(construct) {
+        let functionName = construct.node.path;
+        const { stackName } = Stack.of(this);
+        if (functionName.startsWith(stackName)) {
+            functionName = functionName.substring(stackName.length + 1);
+        }
+        return functionName;
+    }
+    getTopic(topicArn) {
+        const topic = this.findElement((node) => node instanceof sns.Topic && node.topicArn === topicArn);
+        return topic;
+    }
+    getEventBridge(eventBusName) {
+        const eventBridge = this.findElement((node) => node instanceof events.EventBus &&
+            node.eventBusName === eventBusName);
+        return eventBridge;
+    }
+    findElement(filterFunc, parent) {
+        if (!parent) {
+            parent = Stack.of(this);
+        }
+        for (const node of parent.node.children) {
+            if (filterFunc(node)) {
+                return node;
+            }
+            this.findElement(filterFunc, node);
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ServerlessSpy.js","sourceRoot":"","sources":["../../src/ServerlessSpy.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as apiGwV2 from '@aws-cdk/aws-apigatewayv2-alpha';\nimport * as apiGwV2Int from '@aws-cdk/aws-apigatewayv2-integrations-alpha';\nimport { 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 * as lambdaNode 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';\n\nexport class ServerlessSpy extends Construct {\n  private extensionLayer: lambda.LayerVersion;\n\n  private table: dynamoDb.Table;\n\n  private webSocketApi: apiGwV2.WebSocketApi;\n\n  private ownContructs: IConstruct[] = [];\n\n  private functionSubscriptionPool: FunctionSubscription[] = [];\n\n  private functionSubscriptionMain: FunctionSubscription;\n\n  private webSocketStage: apiGwV2.WebSocketStage;\n\n  wsUrl: string;\n\n  constructor(scope: Construct, id: string) {\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(\n        path.join(__dirname, '../lambda-extension/dist/layer')\n      ),\n    });\n    this.ownContructs.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.ownContructs.push(this.table);\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: path.join(__dirname, '../functions/onConnect.ts'),\n      environment: {\n        TABLE_NAME: this.table.tableName,\n      },\n    });\n    this.table.grantWriteData(functionOnConnect);\n    this.ownContructs.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: path.join(__dirname, '../functions/onDisconnect.ts'),\n        environment: {\n          TABLE_NAME: this.table.tableName,\n        },\n      }\n    );\n    this.table.grantWriteData(functionOnDisconnect);\n    this.ownContructs.push(functionOnDisconnect);\n\n    this.webSocketApi = new apiGwV2.WebSocketApi(this, 'ApiGwWebSocket');\n    this.ownContructs.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.ownContructs.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.functionSubscriptionMain = this.provideFunctionForSubscription();\n\n    this.webSocketApi.addRoute('sendmessage', {\n      integration: new apiGwV2Int.WebSocketLambdaIntegration(\n        'SendMessage',\n        this.functionSubscriptionMain.function\n      ),\n    });\n\n    this.iterateAllElements(Stack.of(this));\n\n    for (const func of this.functionSubscriptionPool) {\n      func.function.addEnvironment(\n        'INFRA_MAPPING',\n        JSON.stringify(func.mapping)\n      );\n    }\n\n    // new CfnOutput(this, \"API_URL\", {\n    //   value: `wss://${this.webSocketApi.apiId}.execute-api.${\n    //     Stack.of(scope).region\n    //   }.amazonaws.com/${this.webSocketStage.stageName}`,\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(this, \"API_URL\", {\n    //   value: this.wsUrl,\n    // });\n  }\n\n  private iterateAllElements(parent: IConstruct) {\n    for (const node of parent.node.children) {\n      if (this.ownContructs.includes(node)) {\n        continue;\n      }\n\n      if (this.functionSubscriptionPool.find((s) => s.function === node)) {\n        continue;\n      }\n\n      console.log('NODE', node.constructor.name);\n\n      if (node instanceof lambda.Function) {\n        this.interceptFunction(node);\n      } else if (node instanceof sns.Topic) {\n        console.log('interceptSnsTopic');\n        this.interceptSnsTopic(node);\n      } else if (node instanceof sns.Subscription) {\n        this.interceptSnsSubscription(node);\n      } else if (node instanceof s3.Bucket) {\n        this.interceptS3(node);\n      } else if (node instanceof dynamoDb.Table) {\n        this.interceptDynamodb(node);\n      } else if (node instanceof events.EventBus) {\n        this.interceptEventBus(node);\n      } else if (node instanceof events.Rule) {\n        this.interceptEventBusRule(node);\n      } else if (node instanceof lambda.CfnEventSourceMapping) {\n        this.interceptSqs(node);\n      } else {\n        // console.log('NO MATCH', node);\n      }\n\n      this.iterateAllElements(node);\n    }\n  }\n\n  private interceptSqs(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      this.functionSubscriptionMain.mapping[\n        queue.queueArn\n      ] = `Sqs#${queueName}`;\n      func.addEnvironment('FLUENT_TEST_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: path.join(__dirname, '../functions/sendMessage.ts'),\n      environment: {\n        TABLE_NAME: this.table.tableName,\n      },\n    });\n\n    this.table.grantWriteData(func);\n    this.table.grantReadData(func);\n    func.addEnvironment(\n      'WS_ENDPOINT',\n      `https://${this.webSocketApi.apiId}.execute-api.${\n        Stack.of(this).region\n      }.amazonaws.com/${this.webSocketStage.stageName}`\n    );\n\n    this.webSocketApi.grantManageConnections(func);\n    return func;\n  }\n\n  private interceptS3(s3Bucket: s3.Bucket) {\n    s3Bucket.addEventNotification(\n      s3.EventType.OBJECT_CREATED_PUT,\n      new s3notif.LambdaDestination(this.functionSubscriptionMain.function)\n    );\n\n    const name = this.getConstructName(s3Bucket);\n    this.functionSubscriptionMain.mapping[s3Bucket.bucketArn] = `S3#${name}`;\n  }\n\n  private interceptDynamodb(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.functionSubscriptionMain.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    this.functionSubscriptionMain.mapping[table.tableArn] = `DynamoDB#${name}`;\n  }\n\n  private interceptEventBusRule(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    functionSubscription.mapping.eventBridge = `EventBridgeRule#${bridgeName}#${ruleName}`;\n  }\n\n  private interceptEventBus(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.ownContructs.push(rule);\n    functionSubscription.mapping.eventBridge = `EventBridge#${bridgeName}`;\n  }\n\n  private interceptSnsTopic(topic: sns.Topic) {\n    const functionSubscription = this.provideFunctionForSubscription(\n      (s) => !s.subsribedTopics.includes(topic)\n    );\n\n    topic.addSubscription(\n      new snsSubs.LambdaSubscription(functionSubscription.function)\n    );\n    const topicName = this.getConstructName(topic);\n    functionSubscription.mapping[topic.topicArn] = `SnsTopic#${topicName}`;\n    functionSubscription.subsribedTopics.push(topic);\n  }\n\n  private interceptSnsSubscription(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.ownContructs.push(subscriptionClone);\n\n    const topicName = this.getConstructName(topic);\n    const targetName = this.getConstructName(subscription.node.scope);\n\n    functionSubscription.subsribedTopics.push(topic);\n    functionSubscription.mapping[\n      topic.topicArn\n    ] = `SnsSubscription#${topicName}#${targetName}`;\n  }\n\n  private provideFunctionForSubscription(\n    filterFunction?: (subscription: FunctionSubscription) => boolean\n  ) {\n    let functionSubscription: FunctionSubscription | undefined;\n\n    if (filterFunction) {\n      functionSubscription = this.functionSubscriptionPool.find(filterFunction);\n    } else if (this.functionSubscriptionPool.length > 0) {\n      functionSubscription = this.functionSubscriptionPool[0];\n    }\n\n    if (!functionSubscription) {\n      functionSubscription = {\n        subsribedTopics: [],\n        usedForEventBridge: false,\n        mapping: {},\n        function: this.createFunctionForSubscription(\n          this.functionSubscriptionPool.length\n        ),\n      };\n      this.functionSubscriptionPool.push(functionSubscription);\n    }\n    return functionSubscription;\n  }\n\n  private interceptFunction(func: lambda.Function) {\n    func.addLayers(this.extensionLayer);\n    this.functionSubscriptionMain.function.grantInvoke(func);\n\n    const functionName = this.getConstructName(func);\n\n    func.addEnvironment('FUNCTION_NAME', functionName);\n    func.addEnvironment('AWS_LAMBDA_EXEC_WRAPPER', '/opt/spy-wrapper');\n    func.addEnvironment(\n      'FLUENT_TEST_SEND_FUNCTION_NAME',\n      this.functionSubscriptionMain.function.functionName\n    );\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\ntype FunctionSubscription = {\n  subsribedTopics: sns.Topic[];\n  usedForEventBridge: boolean;\n  function: lambdaNode.NodejsFunction;\n  mapping: Record<string, string>;\n};\n"]}

package/lib/src/index.mjs

@@ -0,0 +1,2 @@
+export * from './ServerlessSpy';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vU2VydmVybGVzc1NweSc7XG4iXX0=

package/package.json

@@ -104,15 +104,15 @@
     "cdk"
   ],
   "bin": {
-    "spy": "lib/cjs/cli/cli.js"
+    "spy": "lib/cli/cli.js"
   },
-  "main": "lib/cjs/index.js",
+  "main": "lib/index.js",
   "exports": {
-    "import": "./lib/mjs/index.js",
-    "require": "./lib/cjs/index.js"
+    "import": "./lib/index.mjs",
+    "require": "./lib/index.js"
   },
   "license": "Apache-2.0",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "types": "lib/index.d.ts",
   "stability": "stable",
   "jsii": {

package/tsconfig.npm.json

@@ -43,6 +43,7 @@
   },
   "include": [
     "src/**/*.ts",    
+    "common/**/*.ts",        
     "listener/**/*.ts",    
     "cli/**/*.ts",        
     "index.ts",    

package/lib/cjs/cli/cli.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require("fs");
-const http = require("http");
-const path = require("path");
-const getWebSocketUrl_1 = require("../common/getWebSocketUrl");
-async function run() {
-    const cdkExportFileName = '../.spy/cdkExports.json';
-    let serverlessSpyWsUrl;
-    if (fs.existsSync(cdkExportFileName)) {
-        const rawdata = fs.readFileSync(cdkExportFileName);
-        const config = JSON.parse(rawdata.toString());
-        if (config && config[Object.keys(config)[0]]) {
-            // get first ServerlessSpyWsUrl
-            // {
-            //   "my-stack": {
-            //     "ServerlessSpyWsUrl": "xxx"
-            //   }
-            // }
-            serverlessSpyWsUrl = config[Object.keys(config)[0]].ServerlessSpyWsUrl;
-        }
-    }
-    serverlessSpyWsUrl =
-        'wss://preh1xo1xh.execute-api.eu-west-1.amazonaws.com/prod';
-    if (!serverlessSpyWsUrl) {
-        throw new Error('Missing WS url');
-    }
-    console.log('serverlessSpyWsUrl', serverlessSpyWsUrl);
-    const wsUrl = await (0, getWebSocketUrl_1.getWebSocketUrl)(serverlessSpyWsUrl);
-    // source https://developer.mozilla.org/en-US/docs/Learn/Server-side/Node_server_without_framework
-    http
-        .createServer((request, response) => {
-        console.log('request ', request.url);
-        let filePath = `.${request.url}`;
-        if (filePath === './') {
-            filePath = './index.html';
-        }
-        const extname = String(path.extname(filePath)).toLowerCase();
-        const mimeTypes = {
-            '.html': 'text/html',
-            '.js': 'text/javascript',
-            '.css': 'text/css',
-            '.json': 'application/json',
-            '.png': 'image/png',
-            '.jpg': 'image/jpg',
-            '.gif': 'image/gif',
-            '.svg': 'image/svg+xml',
-            '.wav': 'audio/wav',
-            '.mp4': 'video/mp4',
-            '.woff': 'application/font-woff',
-            '.ttf': 'application/font-ttf',
-            '.eot': 'application/vnd.ms-fontobject',
-            '.otf': 'application/font-otf',
-            '.wasm': 'application/wasm',
-        };
-        const contentType = mimeTypes[extname] || 'application/octet-stream';
-        fs.readFile(filePath, (error, content) => {
-            if (error) {
-                if (error.code === 'ENOENT') {
-                    fs.readFile('./404.html', (_err, cont) => {
-                        response.writeHead(404, { 'Content-Type': 'text/html' });
-                        response.end(cont, 'utf-8');
-                    });
-                }
-                else {
-                    response.writeHead(500);
-                    response.end(`Sorry, check with the site admin for error: ${error.code} ..\n`);
-                }
-            }
-            else {
-                response.writeHead(200, { 'Content-Type': contentType });
-                if (request.url === '/serverlessSpy.js') {
-                    const contentNew = content
-                        .toString()
-                        .replace('SERVERLESS_SPY_WS_URL', wsUrl);
-                    response.end(contentNew, 'utf-8');
-                }
-                else {
-                    response.end(content, 'utf-8');
-                }
-            }
-        });
-    })
-        .listen(8125);
-}
-run().catch(console.error);
-//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/cli/ws.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require("fs");
-const readline = require("readline");
-const ws_1 = require("ws");
-const getWebSocketUrl_1 = require("../common/getWebSocketUrl");
-async function run() {
-    // var credentialsProvider = awsCp.fromTemporaryCredentials();
-    // const credentials = await credentialsProvider();
-    // const client = new STSClient({});
-    // client.send()
-    // const command = new GetSessionTokenCommand({});
-    // const { Credentials: credentials } = await client.send(command);
-    // //const credentials = s.Credentials;
-    // console.log("credentials", credentials);
-    // const url = process.argv[2];
-    const url = 'wss://preh1xo1xh.execute-api.eu-west-1.amazonaws.com/prod';
-    // https://medium.com/@o.bredenberg/iam-sign-your-api-gateway-websocket-connection-request-no-custom-auth-from-your-frontend-65451166757d
-    const url2 = await (0, getWebSocketUrl_1.getWebSocketUrl)(url);
-    const ws = new ws_1.default(url2);
-    const fileDescriptor = fs.openSync('spy_log.json', 'w');
-    // 📢📁⚡️💾 💽 💾 💿 📀🛢🪣📑🔊
-    ws.on('open', () => console.log(`connected ${new Date().toISOString()}`));
-    ws.on('message', (data) => {
-        // console.log(`From server: ${data}`);
-        let parsed;
-        try {
-            parsed = JSON.parse(data);
-        }
-        catch (err) {
-            console.error(`Can not parse ${data}`);
-        }
-        if (parsed) {
-            console.log(`\x1b[47m\x1b[34m${parsed.timestamp} \x1b[31m🍕 ${parsed.serviceKey}\x1b[0m\x1b[32m\n${JSON.stringify(parsed.data, null, 2)}\x1b[0m`);
-        }
-        fs.write(fileDescriptor, data, (error) => {
-            if (!error) {
-                // fs.close(fileDescriptor);
-            }
-            else {
-                console.error(error);
-            }
-        });
-        fs.write(fileDescriptor, '\n', (error) => {
-            if (!error) {
-                // fs.close(fileDescriptor);
-            }
-            else {
-                console.error(error);
-            }
-        });
-    });
-    ws.on('close', () => {
-        console.log(`disconnected ${new Date().toISOString()}`);
-        fs.close(fileDescriptor, () => undefined);
-        process.exit();
-    });
-    readline
-        .createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    })
-        .on('line', (data) => {
-        ws.send(data);
-    });
-}
-run().catch(console.error);
-//# sourceMappingURL=data:application/json;base64,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