Is there a flatMapLeft or similar when transforming errors?

[batusai513]

I wanted to know if there is a way to mapLeft on a TaskEither pipe that does something similar to the flatMap function, it can take a transformer function that return a Task and flatten the type, the reason I'm asking is that the http library that I use when there is a response other than in the range of 200, it throws and the response is a Response object, which I can extract the server response using the async json or text method, which makes my left side handling a Task.

I was able to workaround by using TE.swap then transforming the error with TE.flatMapTask, and then swapping them back, it works, but it would be nice If there is a more terse way of doing this.

export function getHTTPErrorWithDetails(
  reason: IGenericResponseError,
): T.Task<IGenericResponseError> {
  return pipe(
    T.of(reason),
    T.flatMap((reason) => {
      return matchWildcard(reason, {
        HTTPApiError: (reason) => {
          return pipe(
            getHttpErrorDetailCause(reason.cause),
            T.map((r) => {
              return GenericResponseError.HTTPApiError({
                message: reason.message,
                cause: reason.cause,
                detailCause: r,
              });
            }),
          );
        },
        [WILDCARD]: () => T.of(reason),
      });
    }),
  );
}

export function getHttpErrorDetailCause(cause: HTTPApiError['value']['cause']) {
  return pipe(
    TE.tryCatch(
      () => {
        return cause.response.clone().json() as Promise<unknown>;
      },
      () => null,
    ),
    TE.altW(() =>
      TE.tryCatch(
        () => cause.response.clone().text(),
        () => null,
      ),
    ),
    TE.getOrElseW(() => T.of(null)),
  );
}

export function createAction(payload: unknown) {
  return pipe(
    payload,
    E.fromNullable(
      IGenericResponseError.BadArgumentsError({
        message: 'Empty post arguments',
      }),
    ),
    E.map(templateCreatePayloadSchema.safeParse),
    E.flatMap((result) => {
      return result.success
        ? E.right(result.data)
        : E.left(
            IGenericResponseError.ParseEntityError({
              message: 'Error parsing payload',
              cause: result.error,
            }),
          );
    }),
    TE.fromEither,
    TE.flatMap(
      TE.tryCatchK(
        createTemplateRequest,
        transformResponseErrorsTo(IGenericResponseError, {
          httpError: 'Error creating',
          httpTimeoutError: 'creation timed out',
          parseEntityError: 'Error parsing payload from response',
          genericError: 'Error creating',
          unknownError: 'Something bad happened :(',
        }),
      ),
    ),
    TE.swap,
    TE.flatMapTask(getHTTPErrorWithDetails),
    TE.swap,
    TE.match(
      (reason: IMutateTemplateErrors) => {
        console.log(reason);
        handleSubmitMutationError(reason);
        return json({ message: reason.value.message }, { status: 400 });
      },
      (result) => {
        return redirect(`/${result.id}`);
      },
    ),
  );
}