REST & JSON Libraries

@Configuration
public class SecurityConfig {

  @Bean
  SecurityFilterChain api(HttpSecurity http) throws Exception {
    http
        .csrf(csrf -> csrf.spa())
        .authorizeHttpRequests(auth -> auth
            .requestMatchers(HttpMethod.GET, "/api/**", "/", "/*.html", "/restdemo/**").permitAll()
            .requestMatchers("/api/**").hasRole("LIBRARIAN")
            .anyRequest().denyAll())
        .httpBasic(Customizer.withDefaults());
    return http.build();
  }
}

curl -si "http://localhost:8934/api/books?start=0&length=2"

HTTP/1.1 200
Set-Cookie: XSRF-TOKEN=CSRF_TOKEN_PLACEHOLDER; Path=/
X-Content-Type-Options: nosniff
Content-Type: application/json

{"total":4,"books":[{"id":1,"title":"The Pragmatic Programmer","author":"Andrew Hunt","year":1999,"copies":3},{"id":2,"title":"Effective Java","author":"Joshua Bloch","year":2001,"copies":2}]}

curl -si -u librarian:PASSWORD_PLACEHOLDER -X POST http://localhost:8934/api/books \
  -H 'Content-Type: application/json' \
  -H 'Cookie: XSRF-TOKEN=CSRF_TOKEN_PLACEHOLDER' -H 'X-XSRF-TOKEN: CSRF_TOKEN_PLACEHOLDER' \
  -d '{"title":"Dune","author":"Frank Herbert","year":1965,"copies":2}'

HTTP/1.1 201
Location: /api/books/5
Content-Type: application/json

{"id":5,"title":"Dune","author":"Frank Herbert","year":1965,"copies":2}

HTTP/1.1 401
WWW-Authenticate: Basic realm="Realm", charset="UTF-8"
Content-Length: 0

HTTP/1.1 400
Content-Type: application/problem+json

{"detail":"Invalid request content.","instance":"/api/books","status":400,"title":"Bad Request"}

HTTP/1.1 404
Content-Type: application/problem+json

{"detail":"No book 99","instance":"/api/books/99","status":404,"title":"Not Found"}

@JsType(isNative = true, namespace = JsPackage.GLOBAL, name = "Object")
public class BookJson {
  public double id;
  public String title;
  public String author;
  public int year;
  public int copies;

  @JsOverlay
  public static BookJson create(String title, String author, int year, int copies) {
    BookJson book = new BookJson();
    book.title = title;
    book.author = author;
    book.year = year;
    book.copies = copies;
    return book;
  }
}

@JsType(isNative = true, namespace = JsPackage.GLOBAL, name = "Object")
public class BookPageJson {
  public int total;
  public JsArray<BookJson> books;
}

public final class Rest {
  static final String XSRF_COOKIE = "XSRF-TOKEN";
  static final String XSRF_HEADER = "X-XSRF-TOKEN";
  static final double DEFAULT_TIMEOUT_MS = 5000;

  public static Promise<Response> send(String method, String url, Object body, double timeoutMs) {
    RequestInit init = RequestInit.create();
    init.setMethod(method);
    init.setCredentials("same-origin");
    init.setSignal(AbortSignal.timeout(timeoutMs));

    Headers headers = new Headers();
    headers.set("Accept", "application/json");
    if (body != null) {
      headers.set("Content-Type", "application/json");
      init.setBody(Global.JSON.stringify(body));
    }
    if (!isSafe(method)) {
      String token = Cookies.getCookie(XSRF_COOKIE);
      if (token != null) {
        headers.set(XSRF_HEADER, token);
      }
    }
    init.setHeaders(headers);

    return DomGlobal.fetch(url, init).then(res -> res.ok ? Promise.resolve(res) : failed(res));
  }

  public static <T> Promise<T> json(String method, String url, Object body) {
    return send(method, url, body, DEFAULT_TIMEOUT_MS)
        .then(res -> res.status == 204 ? Promise.resolve((Object) null) : res.json())
        .then(value -> Promise.resolve(Js.<T>uncheckedCast(value)));
  }

  static boolean isSafe(String method) {
    return "GET".equals(method) || "HEAD".equals(method) || "OPTIONS".equals(method);
  }

  private static Promise<Response> failed(Response res) {
    return res.text().then(text -> {
      String detail = res.status + " " + res.statusText;
      if (text != null && text.startsWith("{")) {
        JsPropertyMap<Object> problem = Js.asPropertyMap(Global.JSON.parse(text));
        Object d = problem.get("detail");
        if (d != null) {
          detail = res.status + " " + d;
        }
      }
      return Promise.reject(new HttpException(res.status, detail));
    });
  }
}

public final class BooksClient {
  private static final String BASE = "/api/books";

  public static Promise<BookPageJson> list(int start, int length) {
    return Rest.json("GET", BASE + "?start=" + start + "&length=" + length, null);
  }

  public static Promise<BookJson> get(long id) {
    return Rest.json("GET", BASE + "/" + id, null);
  }

  public static Promise<BookJson> create(BookJson draft) {
    return Rest.json("POST", BASE, draft);
  }

  public static Promise<BookJson> update(long id, BookJson book) {
    return Rest.json("PUT", BASE + "/" + id, book);
  }

  public static Promise<Object> delete(long id) {
    return Rest.json("DELETE", BASE + "/" + id, null);
  }
}

BooksClient.list(0, 2)
    .then(page -> {
      log("list         : total=" + page.total + " returned=" + page.books.length);
      for (int i = 0; i < page.books.length; i++) {
        BookJson b = page.books.getAt(i);
        log("  book       : #" + (long) b.id + " " + b.title + " (" + b.year + ")");
      }
      return BooksClient.get(2);
    })
    .then(book -> {
      log("get(2)       : " + book.title + " by " + book.author);
      log("xsrf cookie  : " + (Cookies.getCookie(Rest.XSRF_COOKIE) != null ? "present" : "missing"));
      return BooksClient.create(BookJson.create("Dune", "Frank Herbert", 1965, 2));
    })
    .then(created -> {
      log("create       : id=" + (long) created.id + " " + created.title);
      created.copies = 5;
      return BooksClient.update((long) created.id, created);
    })
    // ... delete, invalid, unknown id, no token, timeout, callback, Promise.all
    .catch_(error -> {
      log("UNEXPECTED   : " + describe(error));
      return null;
    });

list         : total=4 returned=2
  book       : #1 The Pragmatic Programmer (1999)
  book       : #2 Effective Java (2001)
get(2)       : Effective Java by Joshua Bloch
xsrf cookie  : present
create       : id=7 Dune
update       : copies=5
delete       : 204, no body
invalid      : HttpException 400 Invalid request content.
get(99)      : HttpException 404 No book 99
no token     : HttpException 403
timeout 0 ms : TimeoutError: signal timed out
callback     : success Clean Code
Promise.all  : 2 responses
html as json : SyntaxError: Unexpected token '<', "<!doctype "... is not valid JSON
cross origin : TypeError: Failed to fetch

public static <T> void call(Promise<T> promise, AsyncCallback<T> callback) {
  promise.then(
      value -> {
        callback.onSuccess(value);
        return null;
      },
      error -> {
        callback.onFailure(error instanceof Throwable ? (Throwable) error : new RuntimeException(String.valueOf(error)));
        return null;
      });
}

<properties>
  <domino.rest.version>2.0.2</domino.rest.version>
</properties>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.gwtproject</groupId>
      <artifactId>gwt</artifactId>
      <version>2.13.1</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
    <dependency>
      <groupId>com.google.elemental2</groupId>
      <artifactId>elemental2-dom</artifactId>
      <version>1.3.2</version>
    </dependency>
    <dependency>
      <groupId>com.google.elemental2</groupId>
      <artifactId>elemental2-core</artifactId>
      <version>1.3.2</version>
    </dependency>
    <dependency>
      <groupId>com.google.elemental2</groupId>
      <artifactId>elemental2-promise</artifactId>
      <version>1.3.2</version>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.gwtproject</groupId>
    <artifactId>gwt-user</artifactId>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.gwtproject</groupId>
    <artifactId>gwt-dev</artifactId>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.dominokit</groupId>
    <artifactId>domino-rest-client</artifactId>
    <version>${domino.rest.version}</version>
  </dependency>
  <dependency>
    <groupId>org.dominokit</groupId>
    <artifactId>domino-rest-processor</artifactId>
    <version>${domino.rest.version}</version>
    <scope>provided</scope>
  </dependency>
</dependencies>

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.15.0</version>
      <configuration>
        <release>17</release>
        <annotationProcessorPaths>
          <path>
            <groupId>org.dominokit</groupId>
            <artifactId>domino-rest-processor</artifactId>
            <version>${domino.rest.version}</version>
          </path>
        </annotationProcessorPaths>
      </configuration>
    </plugin>
    <plugin>
      <groupId>net.ltgt.gwt.maven</groupId>
      <artifactId>gwt-maven-plugin</artifactId>
      <version>1.3.0</version>
      <extensions>true</extensions>
      <configuration>
        <moduleName>com.example.bookshelf.DominoDemo</moduleName>
        <moduleShortName>dominodemo</moduleShortName>
        <sourceLevel>17</sourceLevel>
        <failOnError>true</failOnError>
      </configuration>
    </plugin>
  </plugins>
</build>

<module rename-to="dominodemo">
  <inherits name="com.google.gwt.user.User"/>
  <inherits name="org.dominokit.rest.Rest"/>
  <inherits name="org.dominokit.jackson.Jackson"/>

  <source path="domino"/>
  <entry-point class="com.example.bookshelf.domino.DominoDemo"/>
</module>

@JSONMapper
public class BookDto {
  public Long id;
  public String title;
  public String author;
  public int year;
  public int copies;
}

@JSONMapper
public class BookPageDto {
  public int total;
  public List<BookDto> books;
}

@RequestFactory(serviceRoot = "/api")
public interface BooksService {

  @GET
  @Path("books")
  BookPageDto list(@QueryParam("start") int start, @QueryParam("length") int length);

  @GET
  @Path("books/{id}")
  BookDto get(@PathParam("id") long id);

  @POST
  @Path("books")
  BookDto create(@RequestBody BookDto draft);
}

public ServerRequest<Void, BookPageDto> list(int start, int length) {
  BooksService_list instance = new BooksService_list();
  ParameterSetter.setParameter(instance, "start", () -> start, "Query");
  ParameterSetter.setParameter(instance, "length", () -> length, "Query");
  // ... meta parameters for GET and the path "books"
  return instance;
}

DominoRestConfig.initDefaults().addRequestInterceptor(new XsrfInterceptor());

BooksServiceFactory.INSTANCE
    .list(0, 2)
    .onSuccess(page -> {
      log("list    : total=" + page.total + " returned=" + page.books.size());
      for (BookDto b : page.books) {
        log("  book  : #" + b.id + " " + b.title + " (" + b.year + ")");
      }
    })
    .onFailed(failed -> log("list failed: " + failed.getStatusCode()))
    .send();

BooksServiceFactory.INSTANCE
    .get(99)
    .onSuccess(b -> log("get(99) : unexpected " + b.title))
    .onFailed(failed -> log("get(99) : " + failed.getStatusCode() + " " + failed.getBody()))
    .send();

public class XsrfInterceptor implements RequestInterceptor {
  @Override
  public void interceptRequest(ServerRequest request, ContextWait<ServerRequest> contextWait) {
    String token = Cookies.getCookie("XSRF-TOKEN");
    if (token != null) {
      request.setHeader("X-XSRF-TOKEN", token);
    }
    contextWait.complete(request);
  }
}

list    : total=6 returned=2
  book  : #1 The Pragmatic Programmer (1999)
  book  : #2 Effective Java (2001)
create  : id=8 Dune
get(99) : 404 {"detail":"No book 99","instance":"/api/books/99","status":404,"title":"Not Found"}

@JSONMapper
public interface PersonMapper extends ObjectMapper<Person> {}

PersonMapper mapper = PersonMapperImpl.INSTANCE;
Person person = mapper.read("{\"firstName\":\"Ada\",\"lastName\":\"Lovelace\"}");
String json = mapper.write(person);