Technical details

gradlew demo-chinook:runClientLocal

gradlew demo-server:run

gradlew demo-chinook:runClientRMI

gradlew demo-server-monitor:run

codion.client.connectionType=local
codion.db.url=jdbc:h2:mem:h2db
codion.db.initScripts=classpath:create_schema.sql

./gradlew test -Dcodion.test.user=scott:tiger

private static final User UNIT_TEST_USER =
        User.parse(System.getProperty("codion.test.user", "scott:tiger"));

public class ChinookTest extends DomainTest {

    public ChinookTest() {
        super(new ChinookImpl(), ChinookEntityFactory::new);
    }

    @Test
    void album() {
        test(Album.TYPE);
    }

    @Test
    void artist() {
        test(Artist.TYPE);
    }
}

public class ChinookEntityFactory extends DefaultEntityFactory {

    @Override
    public Entity entity(EntityType entityType) {
        if (entityType.equals(InvoiceLine.TYPE)) {
            return createInvoiceLine();
        }

        return super.entity(entityType);
    }

    private Entity createInvoiceLine() {
        Entity invoiceLine = entities.entity(InvoiceLine.TYPE);
        // Set required relationships and values
        invoiceLine.set(InvoiceLine.INVOICE_FK, randomInvoice());
        invoiceLine.set(InvoiceLine.TRACK_FK, randomTrack());
        invoiceLine.set(InvoiceLine.QUANTITY, 1);

        return invoiceLine;
    }
}

@Test
void randomPlaylist() {
    EntityConnection connection = connection();
    connection.startTransaction();
    try {
        List<Entity> genres = connection.select(limit(Genre.TYPE, 3));

        Entity playlist = connection.execute(Playlist.RANDOM_PLAYLIST,
                new RandomPlaylistParameters("Test Playlist", 10, genres));

        assertNotNull(playlist);
        assertEquals(10, connection.count(where(PlaylistTrack.PLAYLIST_FK.equalTo(playlist))));
    }
    finally {
        connection.rollbackTransaction();
    }
}

public class CountryEditModelTest {

    @Test
    void averageCityPopulation() {
        try (EntityConnectionProvider connectionProvider = createConnectionProvider()) {
            CountryEditModel countryEditModel = new CountryEditModel(connectionProvider);

            // Load a country
            countryEditModel.editor().set(connectionProvider.connection()
                    .selectSingle(Country.NAME.equalTo("Afghanistan")));

            // Test computed values
            assertEquals(583_025, countryEditModel.averageCityPopulation().get());

            // Test with new entity
            countryEditModel.editor().defaults();
            assertNull(countryEditModel.averageCityPopulation().get());
        }
    }
}

@Test
void albumRefreshedWhenTrackRatingIsUpdated() {
    try (EntityConnectionProvider connectionProvider = createConnectionProvider()) {
        EntityConnection connection = connectionProvider.connection();
        connection.startTransaction();

        // Setup test data
        Entity album = connection.selectSingle(Album.TITLE.equalTo("Master Of Puppets"));

        // Create model and populate
        AlbumModel albumModel = new AlbumModel(connectionProvider);
        SwingEntityTableModel albumTableModel = albumModel.tableModel();
        albumTableModel.queryModel().condition().get(Album.TITLE).set()
                .equalTo("Master Of Puppets");
        albumTableModel.items().refresh();

        // Modify tracks through detail model
        List<Entity> tracks = connection.select(Track.ALBUM_FK.equalTo(album));
        tracks.forEach(track -> track.set(Track.RATING, 10));
        albumModel.detailModels().get(Track.TYPE).editModel().update(tracks);

        // Verify album rating was updated
        assertEquals(10, albumTableModel.items().visible().get(0).get(Album.RATING));

        connection.rollbackTransaction();
    }
}

@Test
void countryReport() throws JRException {
    EntityConnectionProvider connectionProvider = createConnectionProvider();
    EntityConnection connection = connectionProvider.connection();

    CountryReportDataSource dataSource =
            new CountryReportDataSource(connection, "North America");

    Map<String, Object> parameters = new HashMap<>();
    parameters.put("CONTINENT", "North America");

    JasperPrint jasperPrint = JasperFillManager.fillReport(
            loadReport(), parameters, dataSource);

    assertNotNull(jasperPrint);
    assertFalse(jasperPrint.getPages().isEmpty());
}

-Dcodion.db.url=jdbc:h2:mem:h2db

private static EntityConnectionProvider createConnectionProvider() {
    return LocalEntityConnectionProvider.builder()
            .domain(new WorldImpl())
            .user(UNIT_TEST_USER)
            .build();
}

private static EntityConnectionProvider createConnectionProvider() {
    Database database = H2DatabaseFactory.createDatabase("jdbc:h2:mem:testdb");

    return LocalEntityConnectionProvider.builder()
            .domain(new WorldImpl())
            .database(database)
            .user(UNIT_TEST_USER)
            .build();
}

@Test
void updateTest() {
    EntityConnection connection = connection();
    connection.startTransaction();
    try {
        // Perform updates
        Entity entity = connection.selectSingle(Country.CODE2.equalTo("IS"));
        entity.set(Country.POPULATION, 400_000);
        connection.update(entity);

        // Verify changes
        Entity updated = connection.selectSingle(Country.CODE2.equalTo("IS"));
        assertEquals(400_000, updated.get(Country.POPULATION));
    }
    finally {
        connection.rollbackTransaction();
    }
}

public class TestDataBuilder {

    public static Entity.Builder customer() {
        return entities.entity(Customer.TYPE)
                .with(Customer.FIRST_NAME, "Test")
                .with(Customer.LAST_NAME, "Customer")
                .with(Customer.EMAIL, "test@example.com");
    }

    public static Entity.Builder invoice(Entity customer) {
        return entities.entity(Invoice.TYPE)
                .with(Invoice.CUSTOMER_FK, customer)
                .with(Invoice.INVOICE_DATE, LocalDate.now())
                .with(Invoice.TOTAL, BigDecimal.ZERO);
    }
}

codion.server.objectInputFilterFactoryClassName=\
    my.serialization.filter.MyObjectInputFilterFactory

# Database configuration
codion.db.url=jdbc:h2:mem:h2db
codion.db.useOptimisticLocking=true
codion.db.countQueries=true
codion.db.initScripts=\
    ../config/employees/create_schema.sql,\
    ../config/chinook/create_schema.sql,\
    ../config/petstore/create_schema.sql,\
    ../config/world/create_schema.sql

# The admin user credentials, used by the server monitor application
codion.server.admin.user=scott:tiger

# Client logging disabled by default
codion.server.clientLogging=false

# A connection pool based on this user is created on startup
codion.server.connectionPoolUsers=scott:tiger

# The port used by clients
codion.server.port=2222

# The port for the admin interface, used by the server monitor
codion.server.admin.port=4444

# RMI Registry port
codion.server.registryPort=1099

# Any auxiliary servers to run alongside this server
codion.server.auxiliaryServerFactoryClassNames=\
    is.codion.framework.servlet.EntityServiceFactory

# The http port
codion.server.http.port=8080

# Specifies whether or not to use https
codion.server.http.secure=false

# The ObjectInputFilterFactory class to use
codion.server.objectInputFilterFactoryClassName=\
    is.codion.common.rmi.server.SerializationFilterFactory

# The serialization pattern file to use for RMI deserialization filtering
codion.server.serialization.filter.patternFile=\
    ../config/serialization-whitelist.txt

# RMI configuration
java.rmi.server.hostname=localhost
java.rmi.server.randomIDs=true

# SSL configuration
javax.net.ssl.keyStore=../config/keystore.jks
javax.net.ssl.keyStorePassword=crappypass

# Used to connect to the server to shut it down
#codion.client.trustStore=../config/truststore.jks

    Database database = H2DatabaseFactory
            .createDatabase("jdbc:h2:mem:testdb",
                    "src/main/sql/create_schema.sql");

    EntityServerConfiguration configuration =
            EntityServerConfiguration.builder(SERVER_PORT, REGISTRY_PORT)
                    .domainClassNames(List.of(Store.class.getName()))
                    .database(database)
                    .sslEnabled(false)
                    .build();

    EntityServer server = EntityServer.startServer(configuration);

    RemoteEntityConnectionProvider connectionProvider =
            RemoteEntityConnectionProvider.builder()
                    .port(SERVER_PORT)
                    .registryPort(REGISTRY_PORT)
                    .domainType(Store.DOMAIN)
                    .user(parse("scott:tiger"))
                    .clientType("ClientServer")
                    .build();

    EntityConnection connection = connectionProvider.connection();

    List<Entity> customers = connection.select(all(Customer.TYPE));
    customers.forEach(System.out::println);

    connection.close();

    server.shutdown();

    Database database = H2DatabaseFactory
            .createDatabase("jdbc:h2:mem:testdb",
                    "src/main/sql/create_schema.sql");

    EntityService.HTTP_SERVER_PORT.set(HTTP_PORT);

    EntityServerConfiguration configuration =
            EntityServerConfiguration.builder(SERVER_PORT, REGISTRY_PORT)
                    .domainClassNames(List.of(Store.class.getName()))
                    .database(database)
                    .sslEnabled(false)
                    .auxiliaryServerFactoryClassNames(List.of(EntityServiceFactory.class.getName()))
                    .build();

    EntityServer server = EntityServer.startServer(configuration);

    HttpEntityConnectionProvider connectionProvider =
            HttpEntityConnectionProvider.builder()
                    .port(HTTP_PORT)
                    .https(false)
                    .domainType(Store.DOMAIN)
                    .user(parse("scott:tiger"))
                    .clientType("ClientServer")
                    .build();

    EntityConnection connection = connectionProvider.connection();

    List<Entity> customers = connection.select(all(Customer.TYPE));
    customers.forEach(System.out::println);

    connection.close();

    server.shutdown();

Event<String> event = event(); // Event.event()

Value<Integer> value = Value.nullable();

State state = State.state(true);

EntityTableConditionModel conditionModel =
        entityTableConditionModel(Customer.TYPE, connectionProvider);

TaskScheduler scheduler =
        TaskScheduler.builder(() -> {})
                .interval(5, TimeUnit.SECONDS)
                .initialDelay(15)
                .build();

TemporalField<LocalDate> field =
        TemporalField.builder(LocalDate.class)
                .dateTimePattern("dd.MM.yyyy")
                .columns(12)
                .border(createTitledBorder("Date"))
                .build();

FilterListSelection<List<String>> selection = tableModel.selection();

List<Integer> selectedIndexes = selection.indexes().get();

selection.indexes().set(List.of(0, 1, 2));

selection.items().addListener(() -> System.out.println("Selected items changed"));

table.sortingEnabled().set(false);

public interface State extends ObservableState, Value<Boolean> {
    @NonNull Boolean get();  // Never null

    ObservableState observable();  // Read-only view
}

public interface Event<T> extends Runnable, Consumer<T>, Observer<T> {
    void run();                    // Trigger without data
    void accept(@Nullable T data); // Trigger with data

    Observer<T> observer();        // Read-only access
}

// Simple event
Event<Void> refreshRequested = Event.event();
refreshRequested.addListener(this::refresh);
refreshRequested.run();

// Data event
Event<String> errorOccurred = Event.event();
errorOccurred.addConsumer(this::showError);
errorOccurred.accept("Connection failed");

// Both listeners and consumers are notified
Event<Integer> progress = Event.event();
progress.addListener(() -> updateProgressBar());
progress.addConsumer(percent -> setProgress(percent));
progress.accept(75);  // Both are called

private void notifyListeners() {
    synchronized (listeners) {
        for (Runnable listener : listeners) {
            listener.run();  // Exception here stops the loop
        }
    }
}

event.addListener(() -> {
    try {
        riskyOperation();
    } catch (Exception e) {
        LOG.error("Error in listener", e);
    }
});

Value<Integer> age = Value.builder()
       .nonNull(0)
       .validator(a -> a >= 0 && a <= 150)
       .build();

// Instead of:
source.addConsumer(value -> target.set(value));

// Use:
target.link(source);

public class Model {
   private final State processing = State.state();

   public ObservableState processing() {
       return processing.observable();
   }
}