Merge pull request #220 from lkhari/moreTypings

feat: added typing for patterns

Author: Gurarpit Singh

packages/lambda-powertools-middleware-correlation-ids/index.d.ts

@@ -0,0 +1,62 @@
+import middy from "@middy/core";
+import {
+  Context,
+  SQSRecord,
+  Handler,
+  DynamoDBRecord,
+  DynamoDBStreamEvent,
+  Callback,
+  FirehoseTransformationEvent,
+  FirehoseTransformationResult,
+  KinesisStreamEvent,
+} from "aws-lambda";
+import Log from "@dazn/lambda-powertools-logger";
+import CorrelationIds from "@dazn/lambda-powertools-correlation-ids";
+
+export default function <T, R, C extends Context = Context>(params: {
+  sampleDebugLogRate: number;
+}): middy.MiddlewareObject<T, R, C>;
+
+export type ExtractedCorrelationIdAndLogger<L = Log> = {
+  logger: L;
+  correlationIds: CorrelationIds;
+};
+
+export type SQSEvent<L = Log> = {
+  Records: (SQSRecord & ExtractedCorrelationIdAndLogger<L>)[];
+};
+
+export type SQSHandler<L = Log> = Handler<SQSEvent<L>, void>;
+
+export type KinesisContext<T, L = Log> = Context & {
+  parsedKinesisEvents: ((T & ExtractedCorrelationIdAndLogger<L>) | undefined)[];
+};
+
+export type KinesisStreamHandler<T, L = Log> = (
+  event: KinesisStreamEvent,
+  context: KinesisContext<T, L>,
+  callback: Callback<void>
+) => void | Promise<void>;
+
+export type FirehoseContext<T, L = Log> = Context & {
+  parsedFirehoseEvents: (
+    | (T & ExtractedCorrelationIdAndLogger<L>)
+    | undefined
+  )[];
+};
+
+export type FirehoseTransformationHandler<T, L = Log> = (
+  event: FirehoseTransformationEvent,
+  context: FirehoseContext<T, L>,
+  callback: Callback<FirehoseTransformationResult>
+) => void | Promise<FirehoseTransformationResult>;
+
+export type DynamoStreamsContext<L = Log> = Context & {
+  parsedDynamoDbEvents: (DynamoDBRecord & ExtractedCorrelationIdAndLogger<L>)[];
+};
+
+export type DynamoDBStreamHandler<L = Log> = (
+  event: DynamoDBStreamEvent,
+  context: DynamoStreamsContext<L>,
+  callback: Callback<void>
+) => void | Promise<void>;

packages/lambda-powertools-middleware-correlation-ids/index.js

@@ -1,5 +1,4 @@
 const CorrelationIds = require('@dazn/lambda-powertools-correlation-ids')
-
 const generic = require('./event-sources/generic')
 const eventSources = [
   require('./event-sources/api-gateway'),

packages/lambda-powertools-middleware-correlation-ids/package-lock.json

@@ -3,6 +3,7 @@
   "version": "1.25.0",
   "description": "Middy middleware for capturing correlation IDs from inbound event",
   "main": "index.js",
+  "types": "index.d.ts",
   "license": "MIT",
   "author": "Yan Cui",
   "dependencies": {
@@ -11,6 +12,7 @@
   },
   "devDependencies": {
     "@middy/core": "^1.0.0",
+    "@types/aws-lambda": "^8.10.3",
     "aws-sdk": "^2.496.0",
     "lodash": "^4.17.15",
     "uuid": "^3.2.1"

packages/lambda-powertools-middleware-correlation-ids/package.json

@@ -67,7 +67,7 @@ const handler = async (event, context) => {
 }
 
 module.exports = middy(handler)
-  .use(obfuscatedLogging({ sampleRate: 0.01, obfuscationFilters: ["example.example"] }))
+  .use(obfuscatedLogging.obfuscaterMiddleware({ sampleRate: 0.01, obfuscationFilters: ["example.example"] }))
 }
 ```
 

packages/lambda-powertools-middleware-obfuscater/README.md

@@ -0,0 +1,35 @@
+import middy from "@middy/core";
+import { Callback, Context } from "aws-lambda";
+export * from "@dazn/lambda-powertools-middleware-correlation-ids";
+
+declare type EventType<T, C> = T extends (
+  event: infer EventArgType,
+  context: C,
+  callback: Callback<any>
+) => void
+  ? EventArgType
+  : T extends (event: infer EventArgType, context: C) => Promise<any>
+  ? EventArgType
+  : never;
+
+declare type HandlerReturnType<T, C> = T extends (
+  event: any,
+  context: C
+) => Promise<infer RetType>
+  ? RetType
+  : T extends (
+      event: any,
+      context: C,
+      callback: Callback<infer RetType>
+    ) => void
+  ? RetType
+  : never;
+
+declare type AsyncHandler<C extends Context> =
+  | ((event: any, context: C, callback: Callback<any>) => void)
+  | ((event: any, context: C) => Promise<any>);
+
+export default function <
+  H extends AsyncHandler<C>,
+  C extends Context = Context
+>(f: H): middy.Middy<EventType<H, C>, HandlerReturnType<H, C>, C>;

packages/lambda-powertools-pattern-basic/index.d.ts

@@ -3,6 +3,7 @@
   "version": "1.25.0",
   "description": "Basic template that configures a 1% smaple rate for debug logs",
   "main": "index.js",
+  "types": "index.d.ts",
   "license": "MIT",
   "author": "Yan Cui",
   "dependencies": {
@@ -13,5 +14,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.57"
   }
 }

packages/lambda-powertools-pattern-basic/package-lock.json

@@ -27,7 +27,7 @@ Install from NPM: `npm install @dazn/lambda-powertools-pattern-obfuscate`
 ```js
 const obfuscatedWrap = require('@dazn/lambda-powertools-pattern-obfuscated')
 
-module.exports.handler = obfuscatedWrap(['Records.*.firstName', 'Records.*.lastName'], async (event, context) => {
+module.exports.handler = obfuscatedWrap.obfuscaterPattern(['Records.*.firstName', 'Records.*.lastName'], async (event, context) => {
   return 42
 })
 ```

packages/lambda-powertools-pattern-basic/package.json

@@ -0,0 +1,51 @@
+import middy from "@middy/core";
+import { Callback, Context } from "aws-lambda";
+export * from "@dazn/lambda-powertools-middleware-correlation-ids";
+
+declare type EventType<T, C> = T extends (
+  event: infer EventArgType,
+  context: C,
+  callback: Callback<any>
+) => void
+  ? EventArgType
+  : T extends (event: infer EventArgType, context: C) => Promise<any>
+  ? EventArgType
+  : never;
+
+declare type HandlerReturnType<T, C> = T extends (
+  event: any,
+  context: C
+) => Promise<infer RetType>
+  ? RetType
+  : T extends (
+      event: any,
+      context: C,
+      callback: Callback<infer RetType>
+    ) => void
+  ? RetType
+  : never;
+
+declare type AsyncHandler<C extends Context> =
+  | ((event: any, context: C, callback: Callback<any>) => void)
+  | ((event: any, context: C) => Promise<any>);
+
+declare enum FILTERING_MODE {
+  BLACKLIST = "BLACKLIST",
+  WHITELIST = "WHITELIST",
+}
+
+declare namespace dazn__lambda_powertools_pattern_obfuscate {
+  const FILTERING_MODE: FILTERING_MODE;
+
+  function obfuscaterPattern<
+    H extends AsyncHandler<C>,
+    C extends Context = Context
+  >(
+    obfuscationFilters: string[],
+    f: H,
+    filterOnAfter?: boolean,
+    filteringMode?: FILTERING_MODE
+  ): middy.Middy<EventType<H, C>, HandlerReturnType<H, C>, C>;
+}
+
+export default dazn__lambda_powertools_pattern_obfuscate;