- Work done on many-to-many relations - code must still be refactored out of the EntityTrait.

- Fixed Entity::field("propertyname") function to look for name into @Field() annotation and returns it if it exists.
- A lot of bug fixes made into SQL fragments.

src/EntityTrait.php

@@ -3,6 +3,7 @@
 namespace Ulmus;
 
 use Ulmus\Repository,
+    Ulmus\Query,
     Ulmus\Common\EntityResolver,
     Ulmus\Common\EntityField;
 
@@ -35,43 +36,85 @@ trait EntityTrait {
         $entityResolver =  $this->resolveEntity();
         
         # Resolve relations here if one is called
+        
+        # @TODO REFACTOR THIS CODE URGENTLY !
         if ( null !== ( $relation = $entityResolver->searchFieldAnnotation($name, new Relation() ) ) ) {
+            $relationType = strtolower(str_replace(['-', '_'], '', $relation->type));
+            
             $order = $entityResolver->searchFieldAnnotationList($name, new OrderBy() );
             $where = $entityResolver->searchFieldAnnotationList($name, new Where() );
 
-            $baseEntity = $relation->entity();
-            $repository = $baseEntity->repository();
-                                
-            foreach($where as $condition) {
-                $repository->where($condition->field, $condition->value, $condition->operator);
-            }
-            
-            foreach($order as $item) {
-                $repository->orderBy($item->field, $item->order);
-            }
+            if ( $relation->entity ?? false ) {
+                $baseEntity = $relation->entity();
                 
-            $field = $relation->key;
-            
-            if ( method_exists($this, $filterMethod = "filterRelation$name") ) {
-                $this->$filterMethod($repository);
+                $repository = $baseEntity->repository();
+
+                foreach($where as $condition) {
+                    $repository->where($condition->field, $condition->value, $condition->operator);
+                }
+
+                foreach($order as $item) {
+                    $repository->orderBy($item->field, $item->order);
+                }
+
+                $field = $relation->key;
+
+                if ( method_exists($this, $filterMethod = "filterRelation$name") ) {
+                    $this->$filterMethod($repository);
+                }
             }
             
-            switch($relation->type) {
-                case 'oneToMany':
-                    $repository->where( $baseEntity->field($relation->foreignKey), $this->$field); # <<<<<<<<< CHANGE $THIS->ID WITH PROPER NOMENCLATURE
-                    
-                    return $this->$name = $repository->loadAll();
-                   
-                case 'oneToOne':
+            switch( $relationType ) {
+                case 'onetoone':                    
                     $repository->where( $baseEntity->field($relation->foreignKey), $this->$field );
-
-                    $result = $repository->loadAll();
+                    $result = call_user_func([$repository, $relation->function]);
                     
                     if ( count($result) === 0 ) {
                         return $baseEntity;
                     }
                     
                     return $this->$name = $result[0];
+                    
+                case 'onetomany':
+                    $repository->where( $baseEntity->field($relation->foreignKey), $this->$field); # <<<<<<<<< CHANGE $THIS->ID WITH PROPER NOMENCLATURE
+                    
+                    return $this->$name = call_user_func([$repository, $relation->function]);
+                    
+                case 'manytomany':
+                    if ( false === $relation->bridge ?? false ) {
+                        throw new \Exception("Your many-to-many @Relation() from variable `$name` is missing a 'bridge' value.");
+                    }
+                    
+                    $bridgeEntity = Ulmus::resolveEntity($relation->bridge);
+                    $bridgeRelation = $bridgeEntity->searchFieldAnnotation($relation->field, new Relation() );
+                    $relationRelation = $bridgeEntity->searchFieldAnnotation($relation->foreignField, new Relation() );
+                    
+                    $repository = $relationRelation->entity()->repository();
+
+                    $bridgeAlias = uniqid("bridge_");
+                    $relationAlias = uniqid("relation_");
+
+                    $repository->select("{$repository->alias}.*")
+                        ->join(Query\Join::TYPE_INNER, $bridgeEntity->tableName() . " $bridgeAlias", $relation->bridge::field($relationRelation->key, $bridgeAlias), $relationRelation->entity::field($relationRelation->foreignKey))
+                        ->join(Query\Join::TYPE_INNER, $this->resolveEntity()->tableName() . " $relationAlias", $relation->bridge::field($bridgeRelation->key, $bridgeAlias), static::field($bridgeRelation->foreignKey, $relationAlias))
+                        ->where( static::field($bridgeRelation->foreignKey, $relationAlias), $this->{$bridgeRelation->foreignKey} );
+
+                    $this->$name = call_user_func([ $repository, $relationRelation->function ]);
+                    
+                    if ($relation->bridgeField ?? false) {
+                        $repository = $relationRelation->entity::repository();
+                        
+                        $repository->select("$bridgeAlias.*")
+                            ->join(Query\Join::TYPE_INNER, $bridgeEntity->tableName() . " $bridgeAlias", $relation->bridge::field($relationRelation->key, $bridgeAlias), $relationRelation->entity::field($relationRelation->foreignKey))
+                            ->join(Query\Join::TYPE_INNER, $this->resolveEntity()->tableName() . " $relationAlias", $relation->bridge::field($bridgeRelation->key, $bridgeAlias), static::field($bridgeRelation->foreignKey, $relationAlias))
+                            ->where( static::field($bridgeRelation->foreignKey, $relationAlias), $this->{$bridgeRelation->foreignKey} );
+
+                        $bridgeName = $relation->bridgeField;
+                        
+                        $this->$bridgeName = $repository->collectionFromQuery($relation->bridge);
+                    }
+                    
+                    return $this->$name;
             }
             
             return;
@@ -225,16 +268,16 @@ trait EntityTrait {
      */
     public static function field($name, ? string $alias = null) : EntityField
     {
-        return new EntityField(static::class, $name, $alias ?: Repository::DEFAULT_ALIAS);
+        return new EntityField(static::class, $name, $alias ?: Repository::DEFAULT_ALIAS, Ulmus::resolveEntity(static::class));
     }
 
     /**
      * @Ignore
      */
-    public static function fields(...$fields) : string
+    public static function fields(array $fields, ? string $alias = null) : string
     {
-        return implode(', ', array_map(function($name) {
-            return static::field($name);
+        return implode(', ', array_map(function($item) use ($alias){
+            return static::field($item, $alias);
         }, $fields));
     }
 }