Fixes and polish for stable release

Author: misscoded

src/App.ts

@@ -54,6 +54,7 @@ import {
   SlashCommand,
   WorkflowStepEdit,
   SlackOptions,
+  FunctionInputs,
 } from './types';
 import { IncomingEventType, getTypeAndConversation, assertNever, isBodyWithTypeEnterpriseInstall, isEventTypeToSkipAuthorize } from './helpers';
 import { CodedError, asCodedError, AppInitializationError, MultipleListenerError, ErrorCode, InvalidCustomPropertyError } from './errors';
@@ -964,9 +965,12 @@ export default class App<AppCustomContext extends StringIndexed = StringIndexed>
       retryReason: event.retryReason,
     };
 
-    // Extract function-related information and augment to context
-    const { functionExecutionId, functionBotAccessToken } = extractFunctionContext(body);
-    if (functionExecutionId) { context.functionExecutionId = functionExecutionId; }
+    // Extract function-related information and augment context
+    const { functionExecutionId, functionBotAccessToken, functionInputs } = extractFunctionContext(body);
+    if (functionExecutionId) {
+      context.functionExecutionId = functionExecutionId;
+      if (functionInputs) { context.functionInputs = functionInputs; }
+    }
 
     if (this.attachFunctionToken) {
       if (functionBotAccessToken) { context.functionBotAccessToken = functionBotAccessToken; }
@@ -1029,6 +1033,7 @@ export default class App<AppCustomContext extends StringIndexed = StringIndexed>
       ack?: AckFn<any>;
       complete?: FunctionCompleteFn;
       fail?: FunctionFailFn;
+      inputs?: FunctionInputs;
     } = {
       body: bodyArg,
       payload,
@@ -1088,6 +1093,7 @@ export default class App<AppCustomContext extends StringIndexed = StringIndexed>
     if (type === IncomingEventType.Action && context.functionExecutionId !== undefined) {
       listenerArgs.complete = CustomFunction.createFunctionComplete(context, client);
       listenerArgs.fail = CustomFunction.createFunctionFail(context, client);
+      listenerArgs.inputs = context.functionInputs;
     }
 
     if (token !== undefined) {
@@ -1599,6 +1605,7 @@ function escapeHtml(input: string | undefined | null): string {
 function extractFunctionContext(body: StringIndexed) {
   let functionExecutionId;
   let functionBotAccessToken;
+  let functionInputs;
 
   // function_executed event
   if (body.event && body.event.type === 'function_executed' && body.event.function_execution_id) {
@@ -1610,9 +1617,10 @@ function extractFunctionContext(body: StringIndexed) {
   if (body.function_data) {
     functionExecutionId = body.function_data.execution_id;
     functionBotAccessToken = body.bot_access_token;
+    functionInputs = body.function_data.inputs;
   }
 
-  return { functionExecutionId, functionBotAccessToken };
+  return { functionExecutionId, functionBotAccessToken, functionInputs };
 }
 
 // ----------------------------

src/CustomFunction.spec.ts

@@ -65,7 +65,7 @@ describe('CustomFunction class', () => {
       assert(fakeNext.called);
     });
 
-    it('should call next if not a workflow step event', async () => {
+    it('should call next if not a function executed event', async () => {
       const fn = new CustomFunction('test_view_callback_id', MOCK_MIDDLEWARE_SINGLE);
       const middleware = fn.getMiddleware();
       const fakeViewArgs = createFakeViewEvent() as unknown as
@@ -215,6 +215,7 @@ function createFakeFunctionExecutedEvent() {
     },
     context: {
       functionBotAccessToken: 'xwfp-123',
+      functionExecutionId: 'test_executed_callback_id',
     },
   };
 }

src/CustomFunction.ts

@@ -13,7 +13,7 @@ import {
   FunctionExecutedEvent,
 } from './types';
 import processMiddleware from './middleware/process';
-import { CustomFunctionInitializationError } from './errors';
+import { CustomFunctionCompleteFailError, CustomFunctionCompleteSuccessError, CustomFunctionInitializationError } from './errors';
 
 /** Interfaces */
 
@@ -105,6 +105,11 @@ export class CustomFunction {
     const token = selectToken(context);
     const { functionExecutionId } = context;
 
+    if (!functionExecutionId) {
+      const errorMsg = 'No function_execution_id found';
+      throw new CustomFunctionCompleteSuccessError(errorMsg);
+    }
+
     return (params: Parameters<FunctionCompleteFn>[0] = {}) => client.functions.completeSuccess({
       token,
       outputs: params.outputs || {},
@@ -123,6 +128,11 @@ export class CustomFunction {
       const { error } = params ?? {};
       const { functionExecutionId } = context;
 
+      if (!functionExecutionId) {
+        const errorMsg = 'No function_execution_id found';
+        throw new CustomFunctionCompleteFailError(errorMsg);
+      }
+
       return client.functions.completeError({
         token,
         error,
@@ -158,8 +168,8 @@ export function validate(callbackId: string, middleware: CustomFunctionExecuteMi
 }
 
 /**
- * `processFunctionMiddleware()` invokes each callback for lifecycle event
- * @param args workflow_step_edit action
+ * `processFunctionMiddleware()` invokes each listener middleware
+ * @param args function_executed event
  */
 export async function processFunctionMiddleware(
   args: AllCustomFunctionMiddlewareArgs,

src/errors.ts

@@ -41,6 +41,8 @@ export enum ErrorCode {
   WorkflowStepInitializationError = 'slack_bolt_workflow_step_initialization_error',
 
   CustomFunctionInitializationError = 'slack_bolt_custom_function_initialization_error',
+  CustomFunctionCompleteSuccessError = 'slack_bolt_custom_function_complete_success_error',
+  CustomFunctionCompleteFailError = 'slack_bolt_custom_function_complete_fail_error',
 }
 
 export class UnknownError extends Error implements CodedError {
@@ -149,3 +151,11 @@ export class WorkflowStepInitializationError extends Error implements CodedError
 export class CustomFunctionInitializationError extends Error implements CodedError {
   public code = ErrorCode.CustomFunctionInitializationError;
 }
+
+export class CustomFunctionCompleteSuccessError extends Error implements CodedError {
+  public code = ErrorCode.CustomFunctionCompleteSuccessError;
+}
+
+export class CustomFunctionCompleteFailError extends Error implements CodedError {
+  public code = ErrorCode.CustomFunctionCompleteFailError;
+}

src/types/events/base-events.ts

@@ -432,11 +432,11 @@ export interface FileUnsharedEvent {
 }
 
 export interface FunctionParams {
-  type?: string;
-  name?: string;
+  type: string;
+  name: string;
   description?: string;
   title?: string;
-  is_required?: boolean;
+  is_required: boolean;
 }
 
 export interface FunctionInputs {
@@ -451,7 +451,7 @@ export interface FunctionExecutedEvent {
     id: string;
     callback_id: string;
     title: string;
-    description: string;
+    description?: string;
     type: string;
     input_parameters: FunctionParams[];
     output_parameters: FunctionParams[];

src/types/middleware.ts

@@ -1,7 +1,7 @@
 import { WebClient } from '@slack/web-api';
 import { Logger } from '@slack/logger';
 import { StringIndexed } from './helpers';
-import { SlackEventMiddlewareArgs } from './events';
+import { FunctionInputs, SlackEventMiddlewareArgs } from './events';
 import { SlackActionMiddlewareArgs } from './actions';
 import { SlackCommandMiddlewareArgs } from './command';
 import { SlackOptionsMiddlewareArgs } from './options';
@@ -73,6 +73,23 @@ export interface Context extends StringIndexed {
    */
   isEnterpriseInstall: boolean,
 
+  /**
+   * A JIT and function-specific token that, when used to make API calls,
+   * creates an association between a function's execution and subsequent actions
+   * (e.g., buttons and other interactivity)
+   */
+  functionBotAccessToken?: string;
+
+  /**
+   * Function execution ID associated with the event
+   */
+  functionExecutionId?: string;
+
+  /**
+   * Inputs that were provided to a function when it was executed
+   */
+  functionInputs?: FunctionInputs;
+
   /**
    * Retry count of an Events API request (this property does not exist for other requests)
    */
@@ -90,6 +107,9 @@ export const contextBuiltinKeys: string[] = [
   'botUserId',
   'teamId',
   'enterpriseId',
+  'functionBotAccessToken',
+  'functionExecutionId',
+  'functionInputs',
   'retryNum',
   'retryReason',
 ];