Feature/branch 46 (#53)

* Clean up API.
* Unwrap templates before adding where clause.

Author: zantvoort

storm-core/src/main/java/st/orm/core/template/impl/QueryBuilderImpl.java

@@ -31,6 +31,7 @@
 import st.orm.core.template.TemplateString;
 import st.orm.core.template.TypedJoinBuilder;
 import st.orm.core.template.WhereBuilder;
+import st.orm.core.template.impl.Elements.Expression;
 import st.orm.core.template.impl.Elements.ObjectExpression;
 import st.orm.core.template.impl.Elements.TableSource;
 import st.orm.core.template.impl.Elements.TableTarget;
@@ -41,6 +42,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -524,8 +526,22 @@ protected <V> PredicateBuilder<TX, RX, IDX> whereImpl(@Nonnull Metamodel<?, V> p
             }
         }
 
+        private Object unwrap(@Nonnull TemplateString template) {
+            if (template.fragments().equals(List.of("", ""))) {
+                return template.values().getFirst();
+            }
+            return null;
+        }
+
         private QueryBuilder<TX, RX, IDX> build(List<TemplateString> templates) {
-            return queryBuilder.addWhere(new Where(new TemplateExpression(combine(templates)), null));
+            var template = combine(templates);
+            Where where;
+            if (unwrap(template) instanceof Expression expression) {
+                where = new Where(expression, null);
+            } else {
+                where = new Where(new TemplateExpression(template), null);
+            }
+            return queryBuilder.addWhere(where);
         }
     }
 

storm-kotlin/src/main/kotlin/st/orm/repository/RepositoryLookup.kt

@@ -16,13 +16,9 @@
 package st.orm.repository
 
 import kotlinx.coroutines.flow.Flow
-import st.orm.Data
-import st.orm.Entity
-import st.orm.Metamodel
+import st.orm.*
 import st.orm.Operator.EQUALS
 import st.orm.Operator.IN
-import st.orm.Projection
-import st.orm.Ref
 import st.orm.template.PredicateBuilder
 import st.orm.template.QueryBuilder
 import st.orm.template.WhereBuilder
@@ -70,7 +66,7 @@ interface RepositoryLookup {
      * @param <ID> the type of the projection's primary key, or Void if the projection specifies no primary key.
      * @return the repository for the given projection type.
      */
-    fun <T, ID: Any> projection(type: KClass<T>): ProjectionRepository<T, ID> where T : Projection<ID>
+    fun <T, ID : Any> projection(type: KClass<T>): ProjectionRepository<T, ID> where T : Projection<ID>
 
     /**
      * Returns a proxy for the repository of the given type.
@@ -588,11 +584,11 @@ inline fun <reified T : Data> RepositoryLookup.findAll(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.findAll(predicate: PredicateBuilder<T, T, *>): List<T> =
+inline fun <reified T : Data> RepositoryLookup.findAll(predicate: PredicateBuilder<T, *, *>): List<T> =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, Entity<*>, *>).resultList as List<T>
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, *, *>).resultList as List<T>
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, Projection<*>, *>).resultList as List<T>
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, *, *>).resultList as List<T>
 
 /**
  * Creates a query builder to select records of type [T].
@@ -618,11 +614,11 @@ inline fun <reified T : Data> RepositoryLookup.findAllRef(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.findAllRef(predicate: PredicateBuilder<T, T, *>): List<Ref<T>> =
+inline fun <reified T : Data> RepositoryLookup.findAllRef(predicate: PredicateBuilder<T, *, *>): List<Ref<T>> =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, Entity<*>, *>).resultList as List<Ref<T>>
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, *, *>).resultList as List<Ref<T>>
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, Projection<*>, *>).resultList as List<Ref<T>>
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, *, *>).resultList as List<Ref<T>>
 
 /**
  * Creates a query builder to select records of type [T].
@@ -648,11 +644,11 @@ inline fun <reified T : Data> RepositoryLookup.find(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.find(predicate: PredicateBuilder<T, T, *>): T? =
+inline fun <reified T : Data> RepositoryLookup.find(predicate: PredicateBuilder<T, *, *>): T? =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, Entity<*>, *>).optionalResult as T?
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, *, *>).optionalResult as T?
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, Projection<*>, *>).optionalResult as T?
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, *, *>).optionalResult as T?
 
 /**
  * Creates a query builder to select records of type [T].
@@ -678,11 +674,11 @@ inline fun <reified T : Data> RepositoryLookup.findRef(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.findRef(predicate: PredicateBuilder<T, T, *>): Ref<T> =
+inline fun <reified T : Data> RepositoryLookup.findRef(predicate: PredicateBuilder<T, *, *>): Ref<T>? =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, Entity<*>, *>).singleResult as Ref<T>
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, *, *>).optionalResult as Ref<T>?
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, Projection<*>, *>).singleResult as Ref<T>
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, *, *>).optionalResult as Ref<T>?
 
 /**
  * Creates a query builder to select records of type [T].
@@ -708,11 +704,11 @@ inline fun <reified T : Data> RepositoryLookup.get(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.get(predicate: PredicateBuilder<T, T, *>): T =
+inline fun <reified T : Data> RepositoryLookup.get(predicate: PredicateBuilder<T, *, *>): T =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, Entity<*>, *>).singleResult as T
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, *, *>).singleResult as T
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, Projection<*>, *>).singleResult as T
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, *, *>).singleResult as T
 
 /**
  * Creates a query builder to select records of type [T].
@@ -738,11 +734,11 @@ inline fun <reified T : Data> RepositoryLookup.getRef(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.getRef(predicate: PredicateBuilder<T, Ref<T>, *>): Ref<T> =
+inline fun <reified T : Data> RepositoryLookup.getRef(predicate: PredicateBuilder<T, *, *>): Ref<T> =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, Ref<Entity<*>>, *>).singleResult as Ref<T>
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, *, *>).singleResult as Ref<T>
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, Ref<Projection<*>>, *>).singleResult as Ref<T>
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, *, *>).singleResult as Ref<T>
 
 /**
  * Creates a query builder to select records of type [T].
@@ -768,11 +764,11 @@ inline fun <reified T : Data> RepositoryLookup.select(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.select(predicate: PredicateBuilder<T, T, *>): Flow<T> =
+inline fun <reified T : Data> RepositoryLookup.select(predicate: PredicateBuilder<T, *, *>): Flow<T> =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, Entity<*>, *>).resultFlow as Flow<T>
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).select().where(predicate as PredicateBuilder<Entity<*>, *, *>).resultFlow as Flow<T>
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, Projection<*>, *>).resultFlow as Flow<T>
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).select().where(predicate as PredicateBuilder<Projection<*>, *, *>).resultFlow as Flow<T>
 
 /**
  * Creates a query builder to select records of type [T].
@@ -798,11 +794,11 @@ inline fun <reified T : Data> RepositoryLookup.selectRef(
  * @return A [QueryBuilder] for selecting records of type [T].
  */
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T : Data> RepositoryLookup.selectRef(predicate: PredicateBuilder<T, Ref<T>, *>): Flow<Ref<T>> =
+inline fun <reified T : Data> RepositoryLookup.selectRef(predicate: PredicateBuilder<T, *, *>): Flow<Ref<T>> =
     if (T::class.isSubclassOf(Entity::class))
-        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, Ref<Entity<*>>, *>).resultFlow as Flow<Ref<T>>
+        (entity(T::class as KClass<Entity<Any>>) as EntityRepository<Entity<*>, *>).selectRef().where(predicate as PredicateBuilder<Entity<*>, *, *>).resultFlow as Flow<Ref<T>>
     else
-        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, Ref<Projection<*>>, *>).resultFlow as Flow<Ref<T>>
+        (projection(T::class as KClass<Projection<Any>>) as ProjectionRepository<Projection<*>, *>).selectRef().where(predicate as PredicateBuilder<Projection<*>, *, *>).resultFlow as Flow<Ref<T>>
 
 /**
  * Creates a query builder to select records of type [T].
@@ -1121,7 +1117,7 @@ inline fun <reified T : Entity<*>> RepositoryLookup.deleteAll() =
  * @param value the ID value to match against.
  * @return the number of entities deleted (0 or 1).
  */
-inline fun <reified T : Entity<ID>, ID> RepositoryLookup.deleteBy(field: Metamodel<T, ID>, value: ID): Int =
+inline fun <reified T : Entity<ID>, ID : Any> RepositoryLookup.deleteBy(field: Metamodel<T, ID>, value: ID): Int =
     entity<T>().delete().where(field, EQUALS, value).executeUpdate()
 
 /**

storm-kotlin/src/main/kotlin/st/orm/template/PredicateBuilder.kt

@@ -54,11 +54,11 @@ interface PredicateBuilder<T : Data, R, ID> {
      * This method combines the specified predicate with existing predicates using an AND operation, ensuring
      * that all added conditions must be true.
      *
-     * @param builder the predicate builder to add.
+     * @param template the predicate builder to add.
      * @return the predicate builder.
      */
-    fun and(builder: TemplateBuilder) : PredicateBuilder<T, R, ID> {
-        return and(builder.build())
+    fun and(template: TemplateBuilder) : PredicateBuilder<T, R, ID> {
+        return and(template.build())
     }
 
     /**
@@ -102,11 +102,11 @@ interface PredicateBuilder<T : Data, R, ID> {
      * This method combines the specified predicate with existing predicates using an OR operation, ensuring
      * that all added conditions must be true.
      *
-     * @param builder the predicate builder to add.
+     * @param template the predicate builder to add.
      * @return the predicate builder.
      */
-    fun or(builder: TemplateBuilder) : PredicateBuilder<T, R, ID> {
-        return or(builder.build())
+    fun or(template: TemplateBuilder) : PredicateBuilder<T, R, ID> {
+        return or(template.build())
     }
 
     /**

storm-kotlin/src/main/kotlin/st/orm/template/Query.kt

@@ -15,7 +15,6 @@
  */
 package st.orm.template
 
-import jakarta.annotation.Nonnull
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.stream.consumeAsFlow
 import st.orm.Data
@@ -326,7 +325,7 @@ interface Query {
      * @param <T> the type of the result.
      * @throws NonUniqueResultException if more than one result.
      */
-    private fun <T> optionalResult(@Nonnull stream: Stream<T>): T? {
+    private fun <T> optionalResult(stream: Stream<T>): T? {
         stream.use {
             return stream
                 .reduce { _, _ ->

storm-kotlin/src/main/kotlin/st/orm/template/SubqueryTemplate.kt

@@ -62,8 +62,8 @@ interface SubqueryTemplate {
      * @return the subquery builder.
      * @param <T> the table type to select from.
      */
-    fun <T : Data> subquery(fromType: KClass<T>, builder: TemplateBuilder): QueryBuilder<T, *, *> {
-        return subquery(fromType, builder.build())
+    fun <T : Data> subquery(fromType: KClass<T>, template: TemplateBuilder): QueryBuilder<T, *, *> {
+        return subquery(fromType, template.build())
     }
 
     /**

storm-kotlin/src/main/kotlin/st/orm/template/TemplateString.kt

@@ -24,24 +24,20 @@ sealed interface TemplateString {
         /**
          * Create a new template string from the given [TemplateBuilder].
          */
-        @JvmStatic
         fun raw(builder: TemplateBuilder): TemplateString = builder.build()
 
         /**
          * Create a new template string from the given [TemplateBuilder].
          */
-        @JvmStatic
         fun raw(str: String): TemplateString =
             TemplateStringHolder(st.orm.core.template.TemplateString.of(str))
 
         /**
          * Create a new template string from the given [TemplateBuilder].
          */
-        @JvmStatic
         fun wrap(value: Any?): TemplateString =
             TemplateStringHolder(st.orm.core.template.TemplateString.wrap(value))
 
-        @JvmStatic
         fun combine(vararg templates: TemplateString): TemplateString =
             TemplateStringHolder(st.orm.core.template.TemplateString.combine(*templates.map { it.unwrap }.toTypedArray()))
     }