handler.ts configuration

handler.addInputValidation((validation) =>
  validation
    .condition((ctx, input) => input.page_size <= 100)
    .errorMessage((ctx, input) => "Maximum page size is 100")
);

handler.usingHttp((http) =>
  http
    .get("/posts")
    .handleRequest((ctx, input, request) => request.addPathParameter("postId", input.postId)
                                                   .withBearerToken(ctx.auth!.user.access_token)
                                                   .withoutBody())
    .handleResponse((ctx, input, response) =>
      response
        .withErrorHandling(() => {
          const status = response.getStatusCode();

          if (status === 404) {
            return OperationHandlerResult.failure(
              OperationHandlerError.userInputError("post not found")
            );
          }
          return OperationHandlerResult.failure(
            OperationHandlerError.userInputError(`api error: ${status}`)
          );
        })
        .parseWithBodyAsJson()
    )
);

handler.withGlobalConfiguration(globalConfigHttp).usingHttp((http) =>
  http
    .get("/user/repos")
    .handleRequest((ctx, input, request) => request.withoutBody())
    .handleResponse((ctx, input, response) =>
      response
        .withJsonErrorHandling<{ message: string }>((body) =>
          OperationHandlerResult.failure(
            OperationHandlerError.apiError(
              `API returned an error: ${
                body.message
              }, status code: ${response.getStatusCode()}`,
              {
                statusCode: response.getStatusCode(),
              }
            )
          )
        )
        .parseWithBodyAsJson()
    )
);

import { marked } from "marked";

export const markdownToHtmlHandler = OperationHandlerSetup.configureHandler<
  DataFormatHelperAuth,
  MarkdownToHtmlInput,
  MarkdownToHtmlOutput
>((handler) =>
  handler.usingComposite(async (ctx, { markdownString }, invoke) => {
    try {
      return OperationHandlerResult.success({
        htmlString: await marked.parse(markdownString),
      });
    } catch {
      return OperationHandlerResult.failure(
        OperationHandlerError.connectorError(
          "Could not convert HTML to Markdown" //message that is surfaced on the Tray UI
        )
      );
    }
  })
);

handler.withGlobalConfiguration(globalConfigHttp).usingHttp((http) =>
  http
    .get("/posts")
    .handleRequest((_ctx, _input, request) => request.withoutBody())
    .handleResponse((_ctx, _input, response) => response.parseWithBodyAsJson())
);

handler.withGlobalConfiguration(globalConfigHttp).usingHttp((http) =>
  http
    .get("/posts/:postId/comments/:commentId")
    .handleRequest((_ctx, input, request) =>
      request
        .addPathParameter("postId", input.postId)
        .addPathParameter("commentId", input.commentId)
        .withoutBody()
    )
    .handleResponse((_ctx, _input, response) => response.parseWithBodyAsJson())
);

handler.withGlobalConfiguration(globalConfigHttp).usingHttp((http) =>
  http
    .get("/posts")
    .handleRequest((_ctx, input, request) =>
      request
        .addQueryString("topic", input.topic)
        .addQueryString("start_date", input.startDate)
        .addQueryString("end_date", input.endDate)
        .withoutBody()
    )
    .handleResponse((_ctx, _input, response) => response.parseWithBodyAsJson())
);

handler.withGlobalConfiguration(globalConfigHttp).usingHttp((http) =>
  http
    .get("/products/:productId/reviews")
    .handleRequest((_ctx, input, request) =>
      request
        .addPathParameter("productId", input.productId)
        .addQueryString("min_rating", input.minRating)
        .addQueryString("start_date", input.startDate)
        .withoutBody()
    )
    .handleResponse((_ctx, _input, response) => response.parseWithBodyAsJson())
);

handler.withGlobalConfiguration(globalConfigHttp).usingHttp((http) =>
  http
    .put("/posts/:postId/comments/:commentId")
    .handleRequest((_ctx, input, request) =>
      request
        .addPathParameter("postId", input.postId)
        .addPathParameter("commentId", input.commentId)
        .withBodyAsJson({ commentText: input.commentText })
    )
    .handleResponse((_ctx, _input, response) => response.parseWithBodyAsJson())
);

import TurndownService from "turndown";

export const htmlToMarkdownHandler = OperationHandlerSetup.configureHandler<
  DataFormatHelperAuth,
  HtmlToMarkdownInput,
  HtmlToMarkdownOutput
>((handler) =>
  handler.usingComposite(async (ctx, { htmlString }, invoke) => {
    const turndownService = new TurndownService();
    const markdownString = turndownService.turndown(htmlString);
    return OperationHandlerResult.success({ markdownString });
  })
);

import { listChannelsHandler } from "../list_channels/handler";

export const listChannelsDdlHandler = OperationHandlerSetup.configureHandler<
  DdlExampleAuth,
  ListChannelsDdlInput,
  ListChannelsDdlOutput
>((handler) =>
  handler.usingComposite(async (_ctx, _input, invoke) => {
    try {
      const listChannelsResult = await invoke(listChannelsHandler);

      if (listChannelsResult.isFailure) {
        return listChannelsResult;
      }

      const channelName = listChannelsResult.value.channels.map((channel) => {
        return {
          text: channel.name,
          value: channel.id,
        };
      });

      return OperationHandlerResult.success({
        result: channelName,
      });
    } catch (error) {
      console.error("Could not get channels list from Slack", error);
      return OperationHandlerResult.failure(
        OperationHandlerError.connectorError(
          "Could not get channels list from Slack"
        )
      );
    }
  })
);

export const GenerateSlackAdminReportHandler =
  OperationHandlerSetup.configureHandler<
    SlackExampleAuth,
    GenerateSlackAdminReportInput,
    GenerateSlackAdminReportOutput
  >((handler) =>
    handler.usingComposite(async (_ctx, _input, invoke) => {
      try {
        // Setup headers with authorization
        const headers = {
          Authorization: `Bearer ${ctx.auth?.user.access_token}`,
          "Content-Type": "application/json",
        };

        // Make individual API calls concurrently
        const [channelsResponse, usersResponse, integrationsResponse] =
          await Promise.all([
            axios.get("https://slack.com/api/conversations.list", { headers }),
            axios.get("https://slack.com/api/users.list", { headers }),
            axios.get("https://slack.com/api/apps.permissions.scopes.list", {
              headers,
            }),
          ]);

        // Combine the results into one final report
        const slackAdminReport = {
          channels: channelsResponse.data.channels,
          activeUsers: usersResponse.data.members.filter(
            (member) => !member.deleted && !member.is_bot
          ),
          installedIntegrations: integrationsResponse.data.scopes,
        };

        // Return the combined report
        return OperationHandlerResult.success({
          result: slackAdminReport,
        });
      } catch (error) {
        console.error("Failed to generate Slack admin report", error);
        return OperationHandlerResult.failure(
          OperationHandlerError.connectorError(
            "Failed to generate Slack admin report"
          )
        );
      }
    })
  );

import axios from "axios";
import validator from "validator";

export const NormalizeEmailsHandler = OperationHandlerSetup.configureHandler<
  NormalizeEmailsAuth,
  NormalizeEmailsInput,
  NormalizeEmailsOutput
>((handler) =>
  handler.usingComposite(async (_ctx, _input, invoke) => {
    try {
      // Fetch the list of users from the API
      const response = await axios.get("https://example.com/users");

      // Extract the email addresses and process them
      const processedEmails = response.data.map((user) => {
        // Validate and normalize the email address
        const email = user.email;
        const isValid = validator.isEmail(email);
        const normalizedEmail = validator.normalizeEmail(email);

        return {
          name: user.name,
          email: email,
          isValid: isValid,
          normalizedEmail: normalizedEmail,
        };
      });

      // Return the processed email information
      return OperationHandlerResult.success({
        result: processedEmails,
      });
    } catch (error) {
      console.error("Error fetching or processing emails:", error);
      return OperationHandlerResult.failure(
        OperationHandlerError.connectorError(
          "Failed to fetch or process emails"
        )
      );
    }
  })
);