Browser-Callable Services for Accessing Java Backend

package com.vaadin.demo.fusion.accessingbackend;

import com.vaadin.flow.server.auth.AnonymousAllowed;
import com.vaadin.hilla.Endpoint;

/**
 * A browser-callable service that counts numbers.
 */
@Endpoint
@AnonymousAllowed
public class CounterEndpoint {
    /**
     * A method that adds one to the argument.
     */
    public int addOne(int number) {
        return number + 1;
    }
}

@EndpointExposed
public class ExposedClass {
    public String fromExposedClass() { 1
        return "Hello from ExposedClass";
    }
}

public class NonExposedClass extends ExposedClass {
    public String fromNonExposedClass() { 2
        return "Hello from NonExposedClass";
    }
}

@BrowserCallable
public class ServiceClass extends NonExposedClass {
    public String fromServiceClass() { 3
        return "Hello from ServiceClass";
    }
}

public class Account {

  @Positive
  private Long id;

  @NotEmpty(message = "Each account must have a non-empty username")
  private String username;

  private void sendAccountData(@NotNull String destination) {
    // ...
  }
}

// A validator for validating beans
Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
// non-empty set if there are any constraint validation errors
Set<ConstraintViolation<Object>> violations = validator.validate(bean);

// A validator for validating methods and constructors (return values, parameters)
ExecutableValidator executableValidator = validator.forExecutables();
// non-empty set if there are any constraint validation errors
Set<ConstraintViolation<Object>> violations = executableValidator.validateReturnValue(object, method, returnValue);

package com.vaadin.demo.fusion.errorhandling;

import com.vaadin.flow.server.auth.AnonymousAllowed;
import com.vaadin.hilla.BrowserCallable;

import java.time.LocalDate;

@BrowserCallable
public class DateService {

    @AnonymousAllowed
    public LocalDate getTomorrow(LocalDate date) {
        return date.plusDays(1);
    }
}

import { EndpointValidationError } from '@vaadin/hilla-frontend';
import { DateService } from 'Frontend/generated/endpoints';

export async function callService() {
  try {
    // pass an illegal date
    const tomorrow = await DateService.getTomorrow('2021-02-29');
    console.log(tomorrow);
    // handle result...
  } catch (error) {
    if (error instanceof EndpointValidationError) {
      error.validationErrorData.forEach(({ parameterName, message }) => {
        console.warn(parameterName); // "date"
        console.warn(message); // "Unable to deserialize an endpoint method parameter into type 'java.time.LocalDate'"
      });
    } else {
      // handle other error types...
    }
  }
}

package com.vaadin.demo.pwa.offline;

import com.vaadin.hilla.BrowserCallable;
import com.vaadin.hilla.exception.EndpointException;

@BrowserCallable
public class DataService {

    public String getViewData() {
        throw new EndpointException("Not implemented");
    }
}

import { EndpointError } from '@vaadin/hilla-frontend';
import { DataService } from 'Frontend/generated/endpoints';

export async function callService() {
  try {
    await DataService.getViewData();
  } catch (error) {
    if (error instanceof EndpointError) {
      console.warn(error.message); // "Not implemented"
      console.warn(error.type); // "com.vaadin.hilla.exception.EndpointException"
    }
  }
}

import { EndpointError } from '@vaadin/hilla-frontend';
// Import the remote service
import { DataService } from 'Frontend/generated/endpoints';

// Wrap service calls to return fallback data when offline
export async function getViewData() {
  try {
    return await DataService.getViewData();
  } catch (e) {
    if (!(e instanceof EndpointError)) {
      // Network failure: return fallback data
      return [];
    }

    // Service reached but returned abnormal status code:
    // pass exception on to caller
    throw e;
  }
}

import { SlowService } from 'Frontend/generated/endpoints';

export function abortCall() {
  const controller = new AbortController();

  SlowService.takesTime({ signal: controller.signal }).then((msg) => console.log(msg));

  // The `AbortController` can be used to abort the request, for example after a timeout
  // or an user action like a button click
  const timeoutId = setTimeout(() => {
    controller.abort();
  }, 5000);

  return () => clearTimeout(timeoutId);
}

export function muteCall() {
  SlowService.takesTime({ mute: true }).then((msg) => console.log(msg));
}

import { SlowService } from 'Frontend/generated/endpoints';

export function abortCall() {
  const controller = new AbortController();

  SlowService.takesTime({ signal: controller.signal }).then((msg) => console.log(msg));

  // The `AbortController` can be used to abort the request, for example after a timeout
  // or an user action like a button click
  const timeoutId = setTimeout(() => {
    controller.abort();
  }, 5000);

  return () => clearTimeout(timeoutId);
}

export function muteCall() {
  SlowService.takesTime({ mute: true }).then((msg) => console.log(msg));
}