netlify · emilyzhang · Nov 22, 2021 · Nov 8, 2021 · Nov 8, 2021 · Nov 9, 2021
diff --git a/src/function/handler.ts b/src/function/handler.ts
@@ -1,12 +1,15 @@
 import type { Context } from './context'
 import type { Event } from './event'
-import type { Response } from './response'
+import type { Response, BuilderResponse } from './response'
 
-export interface HandlerCallback {
+export interface HandlerCallback<ResponseType extends Response = Response> {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (error: any, response: Response): void
+  (error: any, response: ResponseType): void
 }
 
-export interface Handler<C extends Context = Context> {
-  (event: Event, context: C, callback: HandlerCallback): void | Response | Promise<Response>
+export interface BaseHandler<ResponseType extends Response = Response, C extends Context = Context> {
+  (event: Event, context: C, callback: HandlerCallback<ResponseType>): void | ResponseType | Promise<ResponseType>
 }
+
+export type Handler = BaseHandler<Response, Context>
+export type BuilderHandler = BaseHandler<BuilderResponse, Context>
diff --git a/src/function/response.ts b/src/function/response.ts
@@ -9,3 +9,6 @@ export interface Response {
   body?: string
   isBase64Encoded?: boolean
 }
+export interface BuilderResponse extends Response {
+  ttl?: number
+}
diff --git a/src/lib/builder.ts b/src/lib/builder.ts
@@ -1,26 +1,27 @@
 import isPromise from 'is-promise'
 
-import { HandlerCallback, HandlerContext, HandlerEvent } from '../function'
-import { Handler } from '../function/handler'
-import { Response } from '../function/response'
+import { HandlerContext, HandlerEvent } from '../function'
+import { BuilderHandler, Handler, HandlerCallback } from '../function/handler'
+import { Response, BuilderResponse } from '../function/response'
 
 import { BUILDER_FUNCTIONS_FLAG, HTTP_STATUS_METHOD_NOT_ALLOWED, HTTP_STATUS_OK, METADATA_VERSION } from './consts'
 
-const augmentResponse = (response: Response) => {
+const augmentResponse = (response: BuilderResponse) => {
   if (!response || response.statusCode !== HTTP_STATUS_OK) {
     return response
   }
+  const metadata = { version: METADATA_VERSION, builder_function: BUILDER_FUNCTIONS_FLAG, ttl: response.ttl ?? 0 }
 
   return {
     ...response,
-    metadata: { version: METADATA_VERSION, builder_function: BUILDER_FUNCTIONS_FLAG },
+    metadata,
   }
 }
 
 const wrapHandler =
-  (handler: Handler<HandlerContext>): Handler<HandlerContext> =>
+  (handler: BuilderHandler): Handler =>
   // eslint-disable-next-line promise/prefer-await-to-callbacks
-  (event: HandlerEvent, context: HandlerContext, callback: HandlerCallback) => {
+  (event: HandlerEvent, context: HandlerContext, callback: HandlerCallback<Response>) => {
     if (event.httpMethod !== 'GET' && event.httpMethod !== 'HEAD') {
       return Promise.resolve({
         body: 'Method Not Allowed',
@@ -36,7 +37,7 @@ const wrapHandler =
     }
 
     // eslint-disable-next-line promise/prefer-await-to-callbacks
-    const wrappedCallback = (error: unknown, response: Response) => callback(error, augmentResponse(response))
+    const wrappedCallback = (error: unknown, response: BuilderResponse) => callback(error, augmentResponse(response))
     const execution = handler(modifiedEvent, context, wrappedCallback)
 
     if (isPromise(execution)) {

diff --git a/src/lib/secrets.ts b/src/lib/secrets.ts
@@ -1,6 +1,7 @@
 import { Context as HandlerContext, Context } from '../function/context'
 import { Event as HandlerEvent } from '../function/event'
-import { Handler, HandlerCallback } from '../function/handler'
+import { BaseHandler, HandlerCallback } from '../function/handler'
+import { Response } from '../function/response'
 
 import { getSecrets, HandlerEventWithOneGraph, NetlifySecrets } from './secrets_helper'
 // Fine-grained control during the preview, less necessary with a more proactive OneGraph solution
@@ -10,13 +11,17 @@ export interface ContextWithSecrets extends Context {
   secrets: NetlifySecrets
 }
 
-export type HandlerWithSecrets = Handler<ContextWithSecrets>
+export type HandlerWithSecrets = BaseHandler<Response, ContextWithSecrets>
 
 // The common usage of this module
 export const withSecrets =
-  (handler: Handler<ContextWithSecrets>) =>
-  // eslint-disable-next-line promise/prefer-await-to-callbacks
-  async (event: HandlerEventWithOneGraph | HandlerEvent, context: HandlerContext, callback: HandlerCallback) => {
+  (handler: BaseHandler<Response, ContextWithSecrets>) =>
+  async (
+    event: HandlerEventWithOneGraph | HandlerEvent,
+    context: HandlerContext,
+    // eslint-disable-next-line promise/prefer-await-to-callbacks
+    callback: HandlerCallback<Response>,
+  ) => {
     const secrets = await getSecrets(event as HandlerEventWithOneGraph)
 
     return handler(event, { ...context, secrets }, callback)

diff --git a/test/builder.js b/test/builder.js
@@ -4,12 +4,13 @@ const { builder } = require('../dist/lib/builder')
 
 const { invokeLambda } = require('./helpers/main')
 
-const METADATA_OBJECT = { metadata: { version: 1, builder_function: true } }
+const METADATA_OBJECT = { metadata: { version: 1, builder_function: true, ttl: 0 } }
 
 test('Injects the metadata object into an asynchronous handler', async (t) => {
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
+    ttl: 3600,
   }
   const myHandler = async () => {
     const asyncTask = new Promise((resolve) => {
@@ -22,7 +23,7 @@ test('Injects the metadata object into an asynchronous handler', async (t) => {
   }
   const response = await invokeLambda(builder(myHandler))
 
-  t.deepEqual(response, { ...originalResponse, ...METADATA_OBJECT })
+  t.deepEqual(response, { ...originalResponse, metadata: { version: 1, builder_function: true, ttl: 3600 } })
 })
 
 test('Injects the metadata object into a synchronous handler', async (t) => {