AbstractRepositoryOrmLite.java

package com.eternalcode.parcellockers.database.wrapper;

import com.eternalcode.commons.ThrowingFunction;
import com.eternalcode.commons.scheduler.Scheduler;
import com.eternalcode.parcellockers.database.DatabaseManager;
import com.eternalcode.parcellockers.shared.exception.DatabaseException;
import com.j256.ormlite.dao.Dao;
import java.sql.SQLException;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.logging.Level;
import java.util.logging.Logger;

public abstract class AbstractRepositoryOrmLite {

    private static final Logger LOGGER = Logger.getLogger(AbstractRepositoryOrmLite.class.getName());

    protected final DatabaseManager databaseManager;
    protected final Scheduler scheduler;

    protected AbstractRepositoryOrmLite(DatabaseManager databaseManager, Scheduler scheduler) {
        this.databaseManager = databaseManager;
        this.scheduler = scheduler;
    }

    protected <T> CompletableFuture<Dao.CreateOrUpdateStatus> save(Class<T> type, T entity) {
        return this.action(type, dao -> dao.createOrUpdate(entity));
    }

    protected <T> CompletableFuture<T> saveIfNotExist(Class<T> type, T entity) {
        return this.action(type, dao -> dao.createIfNotExists(entity));
    }

    protected <T, ID> CompletableFuture<T> select(Class<T> type, ID id) {
        return this.action(type, dao -> dao.queryForId(id));
    }

    protected <T, ID> CompletableFuture<Optional<T>> selectSafe(Class<T> type, ID id) {
        return this.action(type, dao -> Optional.ofNullable(dao.queryForId(id)));
    }

    protected <T> CompletableFuture<Integer> delete(Class<T> type, T entity) {
        return this.action(type, dao -> dao.delete(entity));
    }

    protected <T> CompletableFuture<Integer> deleteAll(Class<T> type) {
        return this.action(type, dao -> dao.deleteBuilder().delete());
    }

    protected <T, ID> CompletableFuture<Integer> deleteById(Class<T> type, ID id) {
        return this.action(type, dao -> dao.deleteById(id));
    }

    protected <T> CompletableFuture<List<T>> selectAll(Class<T> type) {
        return this.action(type, Dao::queryForAll);
    }

    protected <T, ID, R> CompletableFuture<R> action(Class<T> type, ThrowingFunction<Dao<T, ID>, R, SQLException> action) {
        CompletableFuture<R> completableFuture = new CompletableFuture<>();

        this.scheduler.runAsync(() -> {
            Dao<T, ID> dao = this.databaseManager.getDao(type);

            try {
                completableFuture.complete(action.apply(dao));
            } catch (SQLException sqlException) {
                DatabaseException databaseException = new DatabaseException(
                    "Database operation failed for type: " + type.getSimpleName(),
                    sqlException
                );
                LOGGER.log(Level.SEVERE, "Database operation failed", databaseException);
                completableFuture.completeExceptionally(databaseException);
            } catch (Throwable throwable) {
                LOGGER.log(Level.SEVERE, "Unexpected error during database operation", throwable);
                completableFuture.completeExceptionally(throwable);
            }
        });

        return completableFuture;
    }

}