feat: enable post run actions for plugin queries

app/client/src/PluginActionEditor/components/PluginActionResponse/components/Response/Response.test.tsx

@@ -28,6 +28,13 @@ const defaultProps = {
   responseTabHeight: 200,
 };
 
+// mock the postrunactionmap
+jest.mock("ee/components/PostActionRunComponents", () => ({
+  PostRunActionComponentMap: {
+    test_modal: () => <div data-testid="t--post-run-action-test-modal-form" />,
+  },
+}));
+
 const storeData = getIDETestState({});
 
 describe("Response", () => {
@@ -36,6 +43,7 @@ describe("Response", () => {
 
   beforeEach(() => {
     store = mockStore(storeData);
+    jest.clearAllMocks();
   });
 
   /** Test use prepared statement warning **/
@@ -208,4 +216,152 @@ describe("Response", () => {
       container.querySelector("[data-testid='t--prepared-statement-warning']"),
     ).toBeNull();
   });
+
+  it("6. Should show post run action container when post run action exists", () => {
+    const postRunAction = {
+      type: "FORM",
+      name: "test_modal",
+    };
+    const actionResponse = {
+      isExecutionSuccess: true,
+      body: [{ key: "value" }],
+      postRunAction,
+      dataTypes: [{ dataType: "JSON" }],
+      responseDisplayFormat: "JSON",
+    } as unknown as ActionResponse;
+
+    store = mockStore({
+      ...storeData,
+      entities: {
+        ...storeData.entities,
+        actions: [
+          {
+            config: {
+              id: "test-action-id",
+              name: "Test Action",
+            },
+            isLoading: false,
+            data: actionResponse,
+          },
+        ],
+      },
+    });
+
+    const props = {
+      ...defaultProps,
+      actionResponse,
+      currentContentType: "JSON",
+    };
+
+    const { getByTestId } = render(
+      <Provider store={store}>
+        <ThemeProvider theme={lightTheme}>
+          <Router>
+            <Response {...props} />
+          </Router>
+        </ThemeProvider>
+      </Provider>,
+    );
+
+    // Check if post run action container is showing
+    expect(getByTestId("t--post-run-action-container")).not.toBeNull();
+    expect(getByTestId("t--post-run-action-test-modal-form")).not.toBeNull();
+  });
+
+  it("7. Should not show post run action container when post run action doesn't exist", () => {
+    const actionResponse = {
+      isExecutionSuccess: true,
+      body: [{ key: "value" }],
+      dataTypes: [{ dataType: "JSON" }],
+      responseDisplayFormat: "JSON",
+    } as unknown as ActionResponse;
+
+    store = mockStore({
+      ...storeData,
+      entities: {
+        ...storeData.entities,
+        actions: [
+          {
+            config: {
+              id: "test-action-id",
+              name: "Test Action",
+            },
+            isLoading: false,
+            data: actionResponse,
+          },
+        ],
+      },
+    });
+
+    const props = {
+      ...defaultProps,
+      actionResponse,
+    };
+
+    const { container } = render(
+      <Provider store={store}>
+        <ThemeProvider theme={lightTheme}>
+          <Router>
+            <Response {...props} />
+          </Router>
+        </ThemeProvider>
+      </Provider>,
+    );
+
+    // Check if post run action container is not showing
+    expect(
+      container.querySelector("[data-testid='t--post-run-action-container']"),
+    ).toBeNull();
+  });
+
+  it("8. Should not show post run action container when correct mapping is not found", () => {
+    const postRunAction = {
+      type: "FORM",
+      name: "invalid_modal",
+    };
+    const actionResponse = {
+      isExecutionSuccess: true,
+      body: [{ key: "value" }],
+      postRunAction,
+      dataTypes: [{ dataType: "JSON" }],
+      responseDisplayFormat: "JSON",
+    } as unknown as ActionResponse;
+
+    store = mockStore({
+      ...storeData,
+      entities: {
+        ...storeData.entities,
+        actions: [
+          {
+            config: {
+              id: "test-action-id",
+              name: "Test Action",
+            },
+            isLoading: false,
+            data: actionResponse,
+          },
+        ],
+      },
+    });
+
+    const props = {
+      ...defaultProps,
+      actionResponse,
+    };
+
+    const { container } = render(
+      <Provider store={store}>
+        <ThemeProvider theme={lightTheme}>
+          <Router>
+            <Response {...props} />
+          </Router>
+        </ThemeProvider>
+      </Provider>,
+    );
+
+    // Check if post run action container is not showing
+    expect(
+      container.querySelector("[data-testid='t--post-run-action-container']"),
+    ).toBeNull();
+  });
 });

app/client/src/PluginActionEditor/components/PluginActionResponse/components/Response/Response.tsx

@@ -32,6 +32,8 @@ import { RESPONSE_TABLE_HEIGHT_OFFSET } from "./constants";
 import * as Styled from "./styles";
 import { checkForPreparedStatement, parseActionResponse } from "./utils";
 import ActionExecutionInProgressView from "./components/ActionExecutionInProgressView";
+import { checkForPostRunAction } from "./utils/postRunActionsUtil";
+import PostActionRunContainer from "./components/PostActionRunContainer";
 
 interface ResponseProps {
   action: Action;
@@ -126,6 +128,9 @@ export function Response(props: ResponseProps) {
     checkForPreparedStatement(action) && errorMessage,
   );
 
+  const showPostRunAction =
+    actionResponse && checkForPostRunAction(actionResponse?.postRunAction);
+
   const actionSource: SourceEntity = useMemo(
     () => ({
       type: ENTITY_TYPE.ACTION,
@@ -267,6 +272,11 @@ export function Response(props: ResponseProps) {
               }
             />
           </Styled.Response>
+          {showPostRunAction && (
+            <PostActionRunContainer
+              postRunAction={actionResponse?.postRunAction}
+            />
+          )}
           <ContentTypeSelector
             contentTypeOptions={contentTypeOptions}
             currentContentType={currentContentType}

app/client/src/PluginActionEditor/components/PluginActionResponse/components/Response/components/PostActionRunContainer.tsx

@@ -0,0 +1,43 @@
+import React from "react";
+import { getPostRunActionName } from "../utils/postRunActionsUtil";
+import styled from "styled-components";
+import { PostRunActionComponentMap } from "ee/components/PostActionRunComponents";
+import type { PostRunActionNamesInterface } from "ee/components/PostActionRunComponents/types";
+import type { PostActionRunConfig } from "api/types";
+
+interface Props {
+  postRunAction?: PostActionRunConfig;
+}
+
+const Container = styled.div`
+  border: 1px solid var(--ads-v2-color-border);
+  z-index: 100;
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  height: auto;
+  padding-bottom: var(--ads-bottom-bar-height);
+  background-color: var(--ads-v2-color-bg);
+`;
+
+export default function PostActionRunContainer({ postRunAction }: Props) {
+  if (!postRunAction) {
+    return null;
+  }
+
+  const name: string = getPostRunActionName(postRunAction);
+  const Component = PostRunActionComponentMap[
+    name as PostRunActionNamesInterface
+  ] as React.ComponentType;
+
+  if (!Component) {
+    return null;
+  }
+
+  return (
+    <Container data-testid="t--post-run-action-container">
+      <Component />
+    </Container>
+  );
+}

app/client/src/PluginActionEditor/components/PluginActionResponse/components/Response/utils/postRunActionsUtil.test.ts

@@ -0,0 +1,54 @@
+import {
+  checkForPostRunAction,
+  getPostRunActionName,
+} from "../postRunActionsUtil";
+import type { PostActionRunConfig } from "api/types";
+
+describe("checkForPostRunAction", () => {
+  it("should return true for valid post run action", () => {
+    const validAction: PostActionRunConfig = {
+      type: "FORM",
+      name: "some_name",
+    };
+
+    expect(checkForPostRunAction(validAction)).toBe(true);
+  });
+
+  it("should return false for undefined input", () => {
+    expect(checkForPostRunAction(undefined)).toBe(false);
+  });
+
+  it("should return false for input without type property", () => {
+    const invalidAction = {
+      name: "some_name",
+    };
+
+    expect(checkForPostRunAction(invalidAction as PostActionRunConfig)).toBe(
+      false,
+    );
+  });
+});
+
+describe("getPostRunActionName", () => {
+  it("should return name for valid post run action", () => {
+    const validAction: PostActionRunConfig = {
+      type: "FORM",
+      name: "test_action",
+    };
+
+    expect(getPostRunActionName(validAction)).toBe("test_action");
+  });
+
+  it("should return empty string for undefined input", () => {
+    expect(getPostRunActionName(undefined)).toBe("");
+  });
+
+  it("should return empty string for action without name", () => {
+    const actionWithoutName: PostActionRunConfig = {
+      type: "FORM",
+      name: "",
+    };
+
+    expect(getPostRunActionName(actionWithoutName)).toBe("");
+  });
+});

app/client/src/PluginActionEditor/components/PluginActionResponse/components/Response/utils/postRunActionsUtil.ts

@@ -0,0 +1,27 @@
+import type { PostActionRunConfig } from "api/types";
+
+export function checkForPostRunAction(postRunAction?: PostActionRunConfig) {
+  if (
+    postRunAction &&
+    typeof postRunAction === "object" &&
+    "type" in postRunAction
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+export function getPostRunActionName(postRunAction?: PostActionRunConfig) {
+  if (!postRunAction) {
+    return "";
+  }
+
+  const { name } = postRunAction;
+
+  if (!name) {
+    return "";
+  }
+
+  return name;
+}

app/client/src/api/ActionAPI.tsx

@@ -9,6 +9,7 @@ import type { Action, ActionViewMode } from "entities/Action";
 import type { APIRequest } from "constants/AppsmithActionConstants/ActionConstants";
 import type { WidgetType } from "constants/WidgetConstants";
 import type { ActionParentEntityTypeInterface } from "ee/entities/Engine/actionHelpers";
+import type { PostActionRunConfig } from "./types";
 
 export interface Property {
   key: string;
@@ -86,6 +87,7 @@ export interface ActionResponse {
   readableError?: string;
   responseDisplayFormat?: string;
   pluginErrorDetails?: PluginErrorDetails;
+  postRunAction?: PostActionRunConfig;
 }
 
 //This contains the error details from the plugin that is sent to the client in the response

app/client/src/api/types.ts

@@ -22,3 +22,9 @@ export type AxiosResponseData<T> = AxiosResponse<ApiResponse<T>>["data"];
 export type ErrorHandler = (
   error: AxiosError<ApiResponse>,
 ) => Promise<unknown | null>;
+
+export interface PostActionRunConfig {
+  type: "FORM";
+  name: string;
+  config?: Record<string, unknown>;
+}

app/client/src/ce/components/PostActionRunComponents/index.ts

@@ -0,0 +1,6 @@
+import type { PostRunActionNamesInterface } from "./types";
+
+export const PostRunActionComponentMap: Record<
+  PostRunActionNamesInterface,
+  React.ElementType
+> = {};

app/client/src/ce/components/PostActionRunComponents/types.ts

@@ -0,0 +1,4 @@
+export const PostRunActionNames = {} as const;
+
+export type PostRunActionNamesInterface =
+  (typeof PostRunActionNames)[keyof typeof PostRunActionNames];

app/client/src/ee/components/PostActionRunComponents/index.ts

@@ -0,0 +1 @@
+export * from "ce/components/PostActionRunComponents";

app/client/src/ee/components/PostActionRunComponents/types.ts

@@ -0,0 +1,4 @@
+import type { PostRunActionNames } from "ce/components/PostActionRunComponents/types";
+
+export type PostRunActionNamesInterface =
+  (typeof PostRunActionNames)[keyof typeof PostRunActionNames];

app/client/src/sagas/ActionExecution/PluginActionSaga.ts

@@ -208,7 +208,7 @@ export const getActionTimeout = (
   return undefined;
 };
 
-const createActionExecutionResponse = (
+export const createActionExecutionResponse = (
   response: ActionExecutionResponse,
 ): ActionResponse => {
   const payload = response.data;