Implementing Views

import customer.domain.Customer;
import customer.api.CustomerEntity;
import kalix.javasdk.view.View;
import kalix.javasdk.annotations.Query;
import kalix.javasdk.annotations.Subscribe;
import kalix.javasdk.annotations.Table;
import kalix.javasdk.annotations.ViewId;
import org.springframework.web.bind.annotation.GetMapping;
import reactor.core.publisher.Flux;

@ViewId("view_customers_by_name") (1)
@Table("customers_by_name")  (2)
@Subscribe.ValueEntity(CustomerEntity.class) (3)
public class CustomersByNameView extends View<Customer> { (4)

  @GetMapping("/customer/by_name/{customer_name}")   (5)
  @Query("SELECT * FROM customers_by_name WHERE name = :customer_name") (6)
  public Flux<Customer> getCustomer(String name) { (7)
    return null; (8)
  }
}

public record CustomerSummary(String id, String name) { }

@Table("customers")
public class CustomerSummaryByName extends View<CustomerSummary> { (1)

  @Subscribe.ValueEntity(CustomerEntity.class) (2)
  public UpdateEffect<CustomerSummary> onChange(Customer customer) { (3)
    return effects()
        .updateState(new CustomerSummary(customer.email(), customer.name())); (4)
  }
  @GetMapping("/summary/by_name/{customerName}")   (5)
  @Query("SELECT * FROM customers WHERE name = :customerName") (6)
  public CustomerSummary getCustomer() { (7)
    return null;
  }
}

  @Subscribe.ValueEntity(value = CustomerEntity.class, handleDeletes = true) (1)
  public UpdateEffect<CustomerSummary> onDelete() { (2)
    return effects()
        .deleteState(); (3)
  }

import customer.api.CustomerEntity;
import customer.domain.CustomerEvent;
import kalix.javasdk.view.View;
import kalix.javasdk.annotations.Query;
import kalix.javasdk.annotations.Subscribe;
import kalix.javasdk.annotations.Table;
import kalix.javasdk.annotations.ViewId;
import reactor.core.publisher.Flux;

import org.springframework.web.bind.annotation.GetMapping;

@ViewId("view_customers_by_name") (1)
@Table("customers_by_name")
public class CustomerByNameView extends View<CustomerView> {

  @GetMapping("/customer/by_name/{customer_name}")
  @Query("SELECT * FROM customers_by_name WHERE name = :customer_name")
  public Flux<CustomerView> getCustomer(String name) {
    return null;
  }

  @Subscribe.EventSourcedEntity(CustomerEntity.class)
  public UpdateEffect<CustomerView> onEvent(CustomerEvent.CustomerCreated created) {
    return effects().updateState(new CustomerView(created.email(), created.name(), created.address()));
  }

  @Subscribe.EventSourcedEntity(CustomerEntity.class)
  public UpdateEffect<CustomerView> onEvent(CustomerEvent.NameChanged event) {
    return effects().updateState(viewState().withName(event.newName())); (2)
  }

  @Subscribe.EventSourcedEntity(CustomerEntity.class)
  public UpdateEffect<CustomerView> onEvent(CustomerEvent.AddressChanged event) {
    return effects().updateState(viewState().withAddress(event.address()));
  }
}

@Table("customers")
@Subscribe.ValueEntity(CustomerEntity.class)
public class CustomersStreamByName extends View<Customer> { (1)

  @GetMapping("/summary/by_name/{customerName}")   (2)
  @Query(
      value = """
        SELECT customerId AS id, name
          FROM customers
          WHERE name = :customerName
        """, (3)
      streamUpdates = true) (4)
  public Flux<CustomerSummary> getCustomer() { (5)
    return null;
  }
}

SELECT :requestId, customerId as id, name FROM customers
WHERE name = :customerName

public record CustomersResponse(Collection<Customer> customers) { }

@Subscribe.ValueEntity(CustomerEntity.class)
public class CustomersResponseByName extends View<Customer> { (1)

  @GetMapping("/wrapped/by_name/{customerName}")   (2)
  @Query("""
    SELECT * AS customers
      FROM customers_by_name
      WHERE name = :customerName
    """) (3)
  public CustomersResponse getCustomers() { (4)
    return null;
  }
}

SELECT * FROM customers WHERE name = :name AND age > :min_age ORDER BY age DESC

public record Product(String name, Money price) {
  public Product withName(String newName) {
    return new Product(newName, price);
  }

  public Product withPrice(Money newPrice) {
    return new Product(name, newPrice);
  }
}

public record Money(String currency, long units, int cents) {}

public record Order(
    String orderId,
    String productId,
    String customerId,
    int quantity,
    long createdTimestamp) {}

public record CustomerOrder(
    String orderId,
    String productId,
    String productName,
    Money price,
    int quantity,
    String customerId,
    String email,
    String name,
    Address address,
    long createdTimestamp) {}

@ViewId("joined-customer-orders") (1)
public class JoinedCustomerOrdersView {

  @GetMapping("/joined-customer-orders/{customerId}")
  @Query( (2)
      """
      SELECT *
      FROM customers
      JOIN orders ON customers.customerId = orders.customerId
      JOIN products ON products.productId = orders.productId
      WHERE customers.customerId = :customerId
      ORDER BY orders.createdTimestamp
      """)
  public Flux<CustomerOrder> get(String customerId) { (3)
    return null;
  }

  @Table("customers") (4)
  @Subscribe.EventSourcedEntity(CustomerEntity.class)
  public static class Customers extends View<Customer> {
    public UpdateEffect<Customer> onEvent(CustomerEvent.CustomerCreated created) {
      String id = updateContext().eventSubject().orElse("");
      return effects()
          .updateState(new Customer(id, created.email(), created.name(), created.address()));
    }

    public UpdateEffect<Customer> onEvent(CustomerEvent.CustomerNameChanged event) {
      return effects().updateState(viewState().withName(event.newName()));
    }

    public UpdateEffect<Customer> onEvent(CustomerEvent.CustomerAddressChanged event) {
      return effects().updateState(viewState().withAddress(event.newAddress()));
    }
  }

  @Table("products") (4)
  @Subscribe.EventSourcedEntity(ProductEntity.class)
  public static class Products extends View<Product> {
    public UpdateEffect<Product> onEvent(ProductEvent.ProductCreated created) {
      String id = updateContext().eventSubject().orElse("");
      return effects().updateState(new Product(id, created.name(), created.price()));
    }

    public UpdateEffect<Product> onEvent(ProductEvent.ProductNameChanged event) {
      return effects().updateState(viewState().withProductName(event.newName()));
    }

    public UpdateEffect<Product> onEvent(ProductEvent.ProductPriceChanged event) {
      return effects().updateState(viewState().withPrice(event.newPrice()));
    }
  }

  @Table("orders") (4)
  @Subscribe.ValueEntity(OrderEntity.class)
  public static class Orders extends View<Order> {}
}

public record CustomerOrders(
    String customerId,
    String email,
    String name,
    Address address,
    List<CustomerOrder> orders) {} (1)

public record CustomerOrder(
    String customerId,
    String orderId,
    String productId,
    String productName,
    Money price,
    int quantity,
    long createdTimestamp) {}

@GetMapping("/nested-customer-orders/{customerId}")
@Query( (1)
    """
    SELECT customers.*, (orders.*, products.*) AS orders
    FROM customers
    JOIN orders ON customers.customerId = orders.customerId
    JOIN products ON products.productId = orders.productId
    WHERE customers.customerId = :customerId
    ORDER BY orders.createdTimestamp
    """)
public CustomerOrders get(String customerId) { (2)
  return null;
}

public record CustomerOrders(
    String id,
    CustomerShipping shipping,
    List<ProductOrder> orders) {}

public record CustomerShipping(
    String name,
    String address1,
    String address2,
    String contactEmail) {}

public record ProductOrder(
    String id,
    String name,
    int quantity,
    ProductValue value,
    String orderId,
    long orderCreatedTimestamp) {}

public record ProductValue(String currency, long units, int cents) {}

@GetMapping("/structured-customer-orders/{customerId}")
@Query( (1)
    """
    SELECT
     customers.customerId AS id,
     (name,
      address.street AS address1,
      address.city AS address2,
      email AS contactEmail) AS shipping,
     (products.productId AS id,
      productName AS name,
      quantity,
      (price.currency, price.units, price.cents) AS value,
      orderId,
      createdTimestamp AS orderCreatedTimestamp) AS orders
    FROM customers
    JOIN orders ON orders.customerId = customers.customerId
    JOIN products ON products.productId = orders.productId
    WHERE customers.customerId = :customerId
    ORDER BY orders.createdTimestamp
    """)
public CustomerOrders get(String customerId) {
  return null;
}

@TestConfiguration
public class TestKitConfig {
  @Bean
  public KalixTestKit.Settings settings() {
    return KalixTestKit.Settings.DEFAULT.withAdvancedViews();
  }
}