feat(typescript): getInternal type safety + other type improvements

packages/core/index.d.ts

@@ -28,33 +28,34 @@ export interface Request<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > {
   event: TEvent
   context: TContext
   response: TResult | null
   error: TErr | null
-  internal: {
-    [key: string]: any
-  }
+  internal: TInternal
 }
 
 declare type MiddlewareFn<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
-> = (request: Request<TEvent, TResult, TErr, TContext>) => any
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = (request: Request<TEvent, TResult, TErr, TContext, TInternal>) => any
 
 export interface MiddlewareObj<
   TEvent = unknown,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > {
-  before?: MiddlewareFn<TEvent, TResult, TErr, TContext>
-  after?: MiddlewareFn<TEvent, TResult, TErr, TContext>
-  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext>
+  before?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  after?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
 }
 
 // The AWS provided Handler type uses void | Promise<TResult> so we have no choice but to follow and suppress the linter warning
@@ -79,57 +80,63 @@ export interface MiddyfiedHandler<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > extends MiddyInputHandler<TEvent, TResult, TContext>,
   MiddyInputPromiseHandler<TEvent, TResult, TContext> {
-  use: UseFn<TEvent, TResult, TErr, TContext>
-  before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
-  after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
-  onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
+  use: UseFn<TEvent, TResult, TErr, TContext, TInternal>
+  before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
   handler: <TAdditional>(
     handler: MiddlewareHandler<
     LambdaHandler<TEvent & TAdditional, TResult>,
     TContext
     >
-  ) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+  ) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 }
 
 declare type AttachMiddlewareFn<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > = (
-  middleware: MiddlewareFn<TEvent, TResult, TErr, TContext>
-) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+  middleware: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
 declare type AttachMiddlewareObj<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > = (
-  middleware: MiddlewareObj<TEvent, TResult, TErr, TContext>
-) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+  middleware: MiddlewareObj<TEvent, TResult, TErr, TContext, TInternal>
+) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
 declare type UseFn<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
-> = <TMiddleware extends MiddlewareObj<any, any, Error, any>>(
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = <TMiddleware extends MiddlewareObj<any, any, Error, any, any>>(
   middlewares: TMiddleware | TMiddleware[]
 ) => TMiddleware extends MiddlewareObj<
 infer TMiddlewareEvent,
 any,
 Error,
-infer TMiddlewareContext
+infer TMiddlewareContext,
+infer TMiddlewareInternal
 >
   ? MiddyfiedHandler<
   TMiddlewareEvent & TEvent,
   TResult,
   TErr,
-  TMiddlewareContext & TContext
+  TMiddlewareContext & TContext,
+  TMiddlewareInternal & TInternal
   > // always true
   : never
 
@@ -149,11 +156,14 @@ declare function middy<
   TEvent = unknown,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > (
-  handler?: MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext> | PluginObject,
+  handler?:
+  | MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext>
+  | PluginObject,
   plugin?: PluginObject
-): MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+): MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
 declare namespace middy {
   export {

packages/ssm/index.d.ts

@@ -2,27 +2,39 @@ import middy from '@middy/core'
 import { Options as MiddyOptions } from '@middy/util'
 import { Context as LambdaContext } from 'aws-lambda'
 import { SSMClient, SSMClientConfig } from '@aws-sdk/client-ssm'
-import { JsonValue } from 'type-fest'
 
-interface Options<AwsSSMClient = SSMClient>
-  extends MiddyOptions<AwsSSMClient, SSMClientConfig> {}
+export type ParamType<T> = string & { __returnType?: T }
+export declare function ssmParam<T> (path: string): ParamType<T>
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-type ExtractSingles<T> = T extends `/${infer _}` ? never : T
-
-export type Context<TOptions extends Options | undefined> = TOptions extends {
-  setToContext: true
+export interface SSMOptions<AwsSSMClient = SSMClient>
+  extends Omit<MiddyOptions<AwsSSMClient, SSMClientConfig>, 'fetchData'> {
+  fetchData?: { [key: string]: string | ParamType<unknown> }
 }
-  ? LambdaContext &
-  Record<ExtractSingles<keyof TOptions['fetchData']>, JsonValue> &
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  (keyof TOptions['fetchData'] extends `${infer _P}/${infer _S}`
-    ? Record<string, JsonValue>
-    : unknown)
+
+export type Context<TOptions extends SSMOptions | undefined> =
+TOptions extends { setToContext: true }
+  ? TOptions extends { fetchData: infer TFetchData }
+    ? LambdaContext & {
+      [Key in keyof TFetchData]: TFetchData[Key] extends ParamType<infer T>
+        ? T
+        : unknown
+    }
+    : never
   : LambdaContext
 
-declare function ssm<TOptions extends Options> (
+export type Internal<TOptions extends SSMOptions | undefined> =
+TOptions extends SSMOptions
+  ? TOptions extends { fetchData: infer TFetchData }
+    ? {
+        [Key in keyof TFetchData]: TFetchData[Key] extends ParamType<infer T>
+          ? T
+          : unknown
+      }
+    : {}
+  : {}
+
+declare function ssm<TOptions extends SSMOptions> (
   options?: TOptions
-): middy.MiddlewareObj<unknown, any, Error, Context<TOptions>>
+): middy.MiddlewareObj<unknown, any, Error, Context<TOptions>, Internal<TOptions>>
 
 export default ssm

packages/ssm/index.js

@@ -179,4 +179,8 @@ const ssmMiddleware = (opts = {}) => {
     before: ssmMiddlewareBefore
   }
 }
+
 export default ssmMiddleware
+export function ssmParam (name) {
+  return name
+}

packages/ssm/index.test-d.ts

@@ -1,8 +1,10 @@
 import middy from '@middy/core'
+import { getInternal } from '@middy/util'
 import { SSMClient } from '@aws-sdk/client-ssm'
 import { captureAWSv3Client } from 'aws-xray-sdk'
-import { expectType } from 'tsd'
-import ssm, { Context } from '.'
+import { expectType, expectAssignable } from 'tsd'
+import ssm, { Context, ssmParam } from '.'
+import { Context as LambdaContext } from 'aws-lambda/handler'
 
 // use with default options
 expectType<middy.MiddlewareObj<unknown, any, Error, Context<undefined>>>(ssm())
@@ -24,3 +26,52 @@ const options = {
 expectType<middy.MiddlewareObj<unknown, any, Error, Context<typeof options>>>(
   ssm(options)
 )
+
+expectType<middy.MiddlewareObj<unknown, any, Error, LambdaContext, Record<'lorem' | 'ipsum', unknown>>>(
+  ssm({
+    fetchData: {
+      lorem: '/lorem',
+      ipsum: '/lorem'
+    }
+  })
+)
+
+const handler = middy(async (event: {}, context: LambdaContext) => {
+  return await Promise.resolve({})
+})
+
+// chain of multiple ssm middleware
+handler
+  .use(
+    ssm({
+      fetchData: {
+        defaults: ssmParam<string>('/dev/defaults')
+      },
+      cacheKey: 'ssm-defaults'
+    })
+  )
+  .use(
+    ssm({
+      fetchData: {
+        accessToken: ssmParam<string>('/dev/service_name/access_token'), // single value
+        dbParams: ssmParam<{ user: string, pass: string }>('/dev/service_name/database/') // object of values, key for each path
+      },
+      cacheExpiry: 15 * 60 * 1000,
+      cacheKey: 'ssm-secrets',
+      setToContext: true
+    })
+  )
+  // ... other middleware that fetch
+  .before(async (request) => {
+    const data = await getInternal(
+      ['accessToken', 'dbParams', 'defaults'],
+      request
+    )
+
+    expectType<string>(data.accessToken)
+    expectType<{ user: string, pass: string }>(data.dbParams)
+    expectType<string>(data.defaults)
+
+    // make sure data is set to context as well (only for the second instantiation of the middleware)
+    expectAssignable<{ accessToken: string, dbParams: { user: string, pass: string } }>(request.context)
+  })

packages/ssm/package.json

@@ -72,8 +72,7 @@
     "@aws-sdk/client-ssm": "^3.0.0",
     "@middy/core": "4.6.0",
     "@types/aws-lambda": "^8.10.101",
-    "aws-xray-sdk": "^3.3.3",
-    "type-fest": "^4.0.0"
+    "aws-xray-sdk": "^3.3.3"
   },
   "gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431"
 }

packages/util/index.d.ts

@@ -1,4 +1,6 @@
 import middy from '@middy/core'
+import { Context as LambdaContext } from 'aws-lambda'
+import { ArrayValues, Choose, DeepAwaited, IsUnknown, SanitizeKey, SanitizeKeys } from './type-utils'
 
 interface Options<Client, ClientOptions> {
   AwsClient?: new (...[config]: [any] | any) => Client
@@ -33,12 +35,77 @@ declare function canPrefetch<Client, ClientOptions> (
   options: Options<Client, ClientOptions>
 ): boolean
 
-declare function getInternal (
-  variables: any,
-  request: middy.Request
-): Promise<any>
+type InternalOutput<TVariables> = TVariables extends string[] ? { [key in TVariables[number]]: unknown } : never
+
+// get an empty object if false is passed
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>
+> (
+  variables: false,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<{}>
+
+// get all internal values if true is passed (with promises resolved)
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>
+> (
+  variables: true,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<DeepAwaited<TInternal>>
+
+// get a single value
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>,
+  TVars extends keyof TInternal | string
+> (
+  variables: TVars,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): TVars extends keyof TInternal
+  ? Promise<DeepAwaited<{ [_ in SanitizeKey<TVars>]: TInternal[TVars] }>>
+  : TVars extends string
+    ? IsUnknown<Choose<DeepAwaited<TInternal>, TVars>> extends true
+      ? unknown // could not find the path
+      : Promise<{ [_ in SanitizeKey<TVars>]: Choose<DeepAwaited<TInternal>, TVars> }>
+    : unknown // path is not a string or a keyof TInternal
+
+// get multiple values
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>,
+  TVars extends Array<keyof TInternal | string>
+> (
+  variables: TVars,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<SanitizeKeys<{
+  [TVar in ArrayValues<TVars>]:
+  TVar extends keyof TInternal
+    ? DeepAwaited<TInternal[TVar]>
+    : TVar extends string
+      ? Choose<DeepAwaited<TInternal>, TVar>
+      : unknown // path is not a string or a keyof TInternal
+}>>
+
+// remap object
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>,
+  TMap extends Record<string, keyof TInternal | string>
+> (
+  variables: TMap,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<{
+  [P in keyof TMap]:
+  TMap[P] extends keyof TInternal
+    ? DeepAwaited<TInternal[TMap[P]]>
+    : TMap[P] extends string
+      ? Choose<DeepAwaited<TInternal>, TMap[P]>
+      : unknown // path is not a string or a keyof TInternal
+}>
 
-declare function sanitizeKey (key: string): string
+declare function sanitizeKey<T extends string> (key: T): SanitizeKey<T>
 
 declare function processCache<Client, ClientOptions> (
   options: Options<Client, ClientOptions>,