return program(); // 6
}
`

1. We import an interface Article { ... } generated by
xp-codegen-plugin.
2. We use the imported Request and Response to control the shape of our controller.
3. We use the pipe function from fp-ts to pipe the result of one function into the next one.
4. We use the get function from content – here renamed getContent so it won't collide with the get function in
the controller – to return some content where the type is IOEither>.
5. The last thing we usually do in a controller is to unpack the IOEither. This is done with
fold(handleError, handleSuccess). _enonic-fp_ comes with a set of functions that creates an IO with
the data. There are pre-configured functions that can be used in fold for some of the most common http status
numbers. Like ok() and internalServerError().
6. We have so far constructed a constant program of type IO, but we have not yet performed a single
side effect. It's time to perform those side effects, so we run the IO by calling it, and return the Response we
get back.

$3

In this example we delete come content by key. We are first doing this on the draft branch. And then we publish it
to the master branch.

We will return a http error based on the type of error that happened (trough a lookup in the errorsKeyToStatus map).
Or we return a http status 204, indicating success.

`typescript
import {chain, fold} from "fp-ts/IOEither";
import {pipe} from "fp-ts/pipeable";
import {publish, remove} from "enonic-fp/content";
import {run} from "enonic-fp/context";
import {errorResponse, noContent} from "enonic-fp/controller";

function del(req: XP.Request): XP.Response {
const program = pipe(
runOnBranchDraft(
remove(req.params.key!) // 1
),
chain(() => publish(req.params.key!)), // 2
fold( // 3
errorResponse({ req, i18nPrefix: "articleErrors" }), // 4
noContent // 5
)
);

return program();
}

export {del as delete}; // 6

const runOnBranchDraft = run({ branch: 'draft' }); // 7
`

1. We call the remove function with the key to delete some content. We want to do this on the _draft_ branch, so we
wrap the call in the runInDraftContext function that is defined below.
Remove returns IOEither. If the content didn't exist, it will return an EnonicError with of
type "https://problem.item.no/xp/not-found", that can be handled in the
fold().
2. We want to publish our change from the _draft_ branch to the _master_ branch. The publish() function in
_enonic-fp_ has an overload that only takes the key as a string and defaults to publish from _draft_ to
_master_.
3. To create our Response we call fold, where we handle the error and success cases, and return IO.
4. The errorResponse() function use the HttpError.status field to know which http status number to use on the
Response. It can optionally take the Request and a i18nPrefix as parameters.
* The Request adds the HttpError.instance on the return object, and it will check if req.mode !== 'live',
and if yes, return more details about the error (this is to prevent exploits based on the error messages).
* The usage of i18nPrefix is detailed the i18n for error messages chapter.
5. Since this is a delete operation we return a
https status 204 on the success case, which means
"no content".
6. Since delete is a keyword in JavaScript and TypeScript, we have to do this hack to return the delete function.
7. This is a curried version of ContextLib.run. It returns a new function – here assigned to the constant
runOnBranchDraft – that takes an IO as parameter (which all the wrapped functions already return as IOEither).

$3

In this example we do three queries. First we look up an article by key, then we search for comments related to that
article based on the articles key. And then we get a list of open positions in the company, that we want to display on
the web page.

`typescript
import {sequenceT} from "fp-ts/Apply";
import {Json} from "fp-ts/Either";
import {chain, fold, ioEither, IOEither, map} from "fp-ts/IOEither";
import {pipe} from "fp-ts/pipeable";
import {Content, QueryResponse} from "/lib/xp/content";
import {getRenderer} from "enonic-fp/thymeleaf";
import {EnonicError} from "enonic-fp/errors";
import {get as getContent, query} from "enonic-fp/content";
import {bodyAsJson, request} from "enonic-fp/http";
import {Article} from "../../site/content-types/article/article";
import {Comment} from "../../site/content-types/comment/comment";
import {ok, unsafeRenderErrorPage} from "enonic-fp/controller";
import {tupled} from "fp-ts/function";

const view = resolve('./article.html');
const errorView = resolve('../../templates/error.html');
const renderer = getRenderer(view); // 1

export function get(req: XP.Request): XP.Response {
const articleId = req.params.key!;

return pipe(
sequenceT(ioEither)( // 2
getContent