Add from, range, filter functions to QueryBuilder

Signed-off-by: davidarendsen <davidarendsen@hey.com>

src/Function/Filter.php

@@ -2,21 +2,23 @@
 
 namespace Arendsen\FluxQueryBuilder\Function;
 
+use Arendsen\FluxQueryBuilder\Expression\KeyValue;
+
 class Filter extends Base {
 
     /**
-     * @var array $settings
+     * @var KeyValue $keyValue
      */
-    private $settings;
+    private $keyValue;
 
-    public function __construct(array $settings)
+    public function __construct(KeyValue $keyValue)
     {
-        $this->settings = $settings;
+        $this->keyValue = $keyValue;
     }
 
     public function __toString()
     {
-        return '|> filter(fn: (r) => ' . implode(' ', $this->settings) . ') ';
+        return '|> filter(fn: (r) => ' . $this->keyValue . ') ';
     }
 
 }

src/Function/Range.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Arendsen\FluxQueryBuilder\Function;
+
+class Range extends Base {
+
+    /**
+     * @var array $settings
+     */
+    private $settings;
+
+    public function __construct(array $settings)
+    {
+        $this->settings = $settings;
+    }
+
+    public function __toString()
+    {
+        return '|> range(' . implode(', ', $this->format($this->settings)) . ') ';
+    }
+
+    protected function format(array $settings)
+    {
+        array_walk($settings, function(&$value, $key) {
+			$value = $key . ': ' . (is_string($value) ? '"' . $value . '"' : $value);
+		});
+
+        return $settings;
+    }
+
+}

src/QueryBuilder.php

@@ -2,8 +2,23 @@
 
 namespace Arendsen\FluxQueryBuilder;
 
+use Arendsen\FluxQueryBuilder\Expression\KeyValue;
+use Arendsen\FluxQueryBuilder\Function\Filter;
+use Arendsen\FluxQueryBuilder\Function\From;
+use Arendsen\FluxQueryBuilder\Function\Range;
+use Exception;
+
 class QueryBuilder {
 
+    const FLUX_PART_FROM = 'from';
+    const FLUX_PART_RANGE = 'range';
+    const FLUX_PART_FILTERS = 'filters';
+
+    /**
+     * @var array $fluxQuery
+     */
+    private $fluxQueryParts = [];
+
     /**
      * @var array $from
      */
@@ -22,36 +37,96 @@ class QueryBuilder {
     public function from(array $from): QueryBuilder
     {
         $this->from = $from;
+        $this->addToQuery(
+            self::FLUX_PART_FROM,
+            new From($this->from)
+        );
         return $this;
     }
 
     public function fromBucket(string $bucket): QueryBuilder {
-        $this->from = ['bucket' => $bucket];
+        $this->from(['bucket' => $bucket]);
         return $this;
     }
 
     public function fromMeasurement(string $measurement): QueryBuilder
     {
         $this->measurement = $measurement;
+        $this->addToQueryArray(
+            self::FLUX_PART_FILTERS,
+            new Filter(KeyValue::set('_measurement', $measurement))
+        );
         return $this;
     }
 
     public function addRange(array $range): QueryBuilder
     {
         $this->range = $range;
+        $this->addToQuery(
+            self::FLUX_PART_RANGE,
+            new Range($range)
+        );
         return $this;
     }
 
     public function addRangeStart(string $rangeStart): QueryBuilder
     {
-        $this->range = ['start' => $rangeStart];
+        $this->addRange(['start' => $rangeStart]);
         return $this;
     }
 
+    protected function addToQuery($key, $query)
+    {
+        $this->fluxQueryParts[$key] = $query;
+    }
+
+    protected function addToQueryArray($key, $query)
+    {
+        $this->fluxQueryParts[$key][] = $query;
+    }
+
     public function build(): string
     {
+        $this->checkRequired();
+
+        $query = '';
+
+        if(isset($this->fluxQueryParts[self::FLUX_PART_FROM])) {
+            $query .= $this->fluxQueryParts[self::FLUX_PART_FROM];
+        }
+
+        if(isset($this->fluxQueryParts[self::FLUX_PART_RANGE])) {
+            $query .= $this->fluxQueryParts[self::FLUX_PART_RANGE];
+        }
+
+        if(isset($this->fluxQueryParts[self::FLUX_PART_FILTERS])) {
+            foreach($this->fluxQueryParts[self::FLUX_PART_FILTERS] as $filter) {
+                $query .= $filter;
+            }
+        }
+
+        return $query;
+
         //TODO: build the query dynamically here
-        return 'from(bucket: "test_bucket", host: "host", org: "example-org", token: "token") |> ';
+        return 'from(bucket: "test_bucket") |> ';
+    }
+
+    protected function checkRequired()
+    {
+        if(!$this->from)
+        {
+            throw new Exception('You need to define the from part of the query!');
+        }
+
+        if(!$this->measurement)
+        {
+            throw new Exception('You need to define the measurement of the query!');
+        }
+
+        if(!$this->range)
+        {
+            throw new Exception('You need to define the range part of the query!');
+        }
     }
 
 }

tests/Function/FilterFunctionTest.php

@@ -9,12 +9,11 @@ final class FilterFunctionTest extends TestCase {
 
     public function testSimpleFilter()
     {
-        $expression = new Filter([
-            KeyValue::set('_measurement', 'test_measurement')
-                ->and('_field', 'user')
-                ->or('_field', 'field2')
-                ->and('user', 'my_username'),
-        ]);
+        $expression = new Filter(KeyValue::set('_measurement', 'test_measurement')
+            ->and('_field', 'user')
+            ->or('_field', 'field2')
+            ->and('user', 'my_username')
+        );
 
         $query = '|> filter(fn: (r) => r._measurement == "test_measurement" and r._field == "user" or ' . 
             'r._field == "field2" and r.user == "my_username") ';

tests/QueryBuilderTest.php

@@ -7,31 +7,65 @@ use Arendsen\FluxQueryBuilder\QueryBuilder;
 final class QueryBuilderTest extends TestCase {
 
     /**
-     * @dataProvider somethingProvider
+     * @dataProvider simpleQueryProvider
      */
-    public function testSomething($bucket, $measurement, $range, $expectedQuery)
+    public function testSimpleQuery($bucket, $measurement, $range, $expectedQuery)
     {
         $queryBuilder = new QueryBuilder();
         $queryBuilder->from($bucket)
             ->fromMeasurement($measurement)
 			->addRangeStart($range);
 
-        $this->assertEquals($queryBuilder->build(), $expectedQuery);
+        $this->assertEquals($expectedQuery, $queryBuilder->build());
     }
 
-    public function somethingProvider(): array
+    public function simpleQueryProvider(): array
     {
         return [
             'case 1' => [
                 [
-                    'bucket' => 'example-bucket', 
-                    'host' => 'host', 
-                    'org' => 'example-org', 
-                    'token' => 'token'
+                    'bucket' => 'example_bucket',
                 ],
                 'test_measurement',
                 '-360h',
-                'from(bucket: "test_bucket", host: "host", org: "example-org", token: "token") |> '
+                'from(bucket: "example_bucket") |> range(start: "-360h") |> filter(fn: (r) => r._measurement == "test_measurement") '
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider throwsExceptionWithoutRequiredDataProvider
+     */
+    public function testThrowsExceptionWithoutRequiredData($from, $measurement, $range)
+    {
+        $this->expectException(Exception::class);
+
+        $queryBuilder = new QueryBuilder();
+
+        if($from) {
+            $queryBuilder->from($from);
+        }
+        if($measurement) {
+            $queryBuilder->fromMeasurement($measurement);
+        }
+        if($range) {
+            $queryBuilder->addRange($range);
+        }
+
+        $queryBuilder->build();
+    }
+
+    public function throwsExceptionWithoutRequiredDataProvider(): array
+    {
+        return [
+            'without from data' => [
+                null, 'test_measurement', ['start' => '-360h'],
+            ],
+            'without measurement data' => [
+                ['from' => 'test_bucket'], null, ['start' => '-360h'],
+            ],
+            'without range data' => [
+                ['from' => 'test_bucket'], 'test_measurement', null,
             ],
         ];
     }