Allow property directly on node

Author: marijnvanwezel

composer.json

@@ -35,7 +35,8 @@
   },
   "require": {
     "php": ">=7.4",
-    "ext-ctype": "*"
+    "ext-ctype": "*",
+    "ext-openssl": "*"
   },
   "require-dev": {
     "phpunit/phpunit": "~9.0",

src/Patterns/Node.php

@@ -22,8 +22,10 @@
 namespace WikibaseSolutions\CypherDSL\Patterns;
 
 use InvalidArgumentException;
+use WikibaseSolutions\CypherDSL\Property;
 use WikibaseSolutions\CypherDSL\PropertyMap;
 use WikibaseSolutions\CypherDSL\Traits\EscapeTrait;
+use WikibaseSolutions\CypherDSL\Traits\IdentifierGenerationTrait;
 use WikibaseSolutions\CypherDSL\Traits\NodeTypeTrait;
 use WikibaseSolutions\CypherDSL\Types\AnyType;
 use WikibaseSolutions\CypherDSL\Types\CompositeTypes\MapType;
@@ -39,6 +41,7 @@ class Node implements NodeType
 {
     use EscapeTrait;
     use NodeTypeTrait;
+    use IdentifierGenerationTrait;
 
     /**
      * @var string[]
@@ -154,7 +157,6 @@ public function getName(): ?Variable
      * @param $variable
      * @return $this
      * @see Node::named()
-     *
      */
     public function setName($variable): self
     {
@@ -171,6 +173,18 @@ public function hasName(): bool
         return isset($this->variable);
     }
 
+    /**
+     * Returns the property of the given name for this expression. For instance, if this expression is the
+     * variable "foo", a function call like $expression->property("bar") would yield "foo.bar".
+     *
+     * @param string $property
+     * @return Property
+     */
+    public function property(string $property): Property
+    {
+        return new Property($this->variableIfNode($this), $property);
+    }
+
     /**
      * Returns the string representation of this relationship that can be used directly
      * in a query.

src/Query.php

@@ -45,6 +45,7 @@
 use WikibaseSolutions\CypherDSL\Patterns\Node;
 use WikibaseSolutions\CypherDSL\Patterns\Path;
 use WikibaseSolutions\CypherDSL\Traits\EscapeTrait;
+use WikibaseSolutions\CypherDSL\Traits\IdentifierGenerationTrait;
 use WikibaseSolutions\CypherDSL\Types\AnyType;
 use WikibaseSolutions\CypherDSL\Types\CompositeTypes\ListType;
 use WikibaseSolutions\CypherDSL\Types\CompositeTypes\MapType;
@@ -61,6 +62,7 @@
 class Query implements QueryConvertable
 {
     use EscapeTrait;
+    use IdentifierGenerationTrait;
 
     // A reference to the Literal class
     const literal = Literal::class;
@@ -270,19 +272,8 @@ public function returning($expressions, bool $distinct = false): self
                 throw new TypeError("\$expressions should only consist of AnyType objects");
             }
 
-
-            // check if expression is node, then replace with variable
-            if ($expression instanceof Node) {
-                // check if Node has Name setted
-                if (!$expression->hasName()) {
-                    $expression->setName(uniqid());
-                }
-
-                $expression = $expression->getName();
-            }
-
             $alias = is_integer($maybeAlias) ? "" : $maybeAlias;
-            $returnClause->addColumn($expression, $alias);
+            $returnClause->addColumn($this->variableIfNode($expression), $alias);
         }
 
         $returnClause->setDistinct($distinct);
@@ -575,8 +566,8 @@ public function where(AnyType $expression): self
     /**
      * Creates the WITH clause.
      *
-     * @param AnyType[]|AnyType $expressions The entries to add; if the array-key is
-     *                                             non-numerical, it is used as the alias
+     * @param AnyType[]|AnyType $expressions The entries to add; if the array-key is non-numerical, it is used as the alias
+     *
      *
      * @return Query
      * @see https://neo4j.com/docs/cypher-manual/current/clauses/with/
@@ -595,17 +586,8 @@ public function with($expressions): self
                 throw new TypeError("\$expressions should only consist of AnyType objects");
             }
 
-            // check if expression is node, then replace with variable
-            if ($expression instanceof Node) {
-                // check if Node has Name setted
-                if (!$expression->hasName()) {
-                    $expression->named(uniqid());
-                }
-                $expression = $expression->getName();
-            }
-
             $alias = is_integer($maybeAlias) ? "" : $maybeAlias;
-            $withClause->addEntry($expression, $alias);
+            $withClause->addEntry($this->variableIfNode($expression), $alias);
         }
 
         $this->clauses[] = $withClause;

src/Traits/IdentifierGenerationTrait.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace WikibaseSolutions\CypherDSL\Traits;
+
+use WikibaseSolutions\CypherDSL\Patterns\Node;
+
+trait IdentifierGenerationTrait
+{
+    /**
+     * Cast the given value to a Variable if it is a node.
+     *
+     * @param mixed $value
+     * @return mixed
+     */
+    public function variableIfNode($value)
+    {
+        if (!($value instanceof Node)) {
+            return $value;
+        }
+
+        if (!$value->hasName()) {
+            $value->setName($this->generateUUID());
+        }
+
+        return $value->getName();
+    }
+
+    /**
+     * Generates a unique random identifier.
+     *
+     * @note It is not entirely guaranteed that this function gives a truly unique identifier. However, because the
+     * number of possible IDs is so huge, it should not be a problem.
+     *
+     * @param int $length
+     * @return string
+     */
+    private function generateUUID(int $length = 32): string
+    {
+        return substr(bin2hex(openssl_random_pseudo_bytes(ceil($length / 2))), 0, $length);
+    }
+}

tests/Unit/Patterns/NodeTest.php

@@ -192,6 +192,21 @@ public function testAddingProperties()
         $this->assertSame("({foo: 'baz', baz: 'bar', qux: 'baz'})", $node->toQuery());
     }
 
+    public function testPropertyWithName()
+    {
+        $node = new Node();
+        $node->named('example');
+
+        $this->assertSame('example.foo', $node->property('foo')->toQuery());
+    }
+
+    public function testPropertyWithoutName()
+    {
+        $node = new Node();
+
+        $this->assertMatchesRegularExpression("/^[0-9a-f]+\.foo$/", $node->property('foo')->toQuery());
+    }
+
     public function provideOnlyLabelData(): array
     {
         return [

tests/Unit/QueryTest.php

@@ -230,11 +230,18 @@ public function testReturning()
 
     public function testReturningWithNode()
     {
-        $node = Query::node("(m)");
+        $node = Query::node("m");
 
         $statement = (new Query())->returning($node)->build();
 
-        $this->assertMatchesRegularExpression("/(RETURN [0-Z])\w+/", $statement);
+        $this->assertMatchesRegularExpression("/(RETURN [0-9a-f]+)/", $statement);
+
+        $node = Query::node("m");
+        $node->named('example');
+
+        $statement = (new Query())->returning($node)->build();
+
+        $this->assertSame('RETURN example', $statement);
     }
 
     public function testCreate()
@@ -388,6 +395,22 @@ public function testWith()
         $this->assertSame("WITH a < b AS foobar", $statement);
     }
 
+    public function testWithWithNode()
+    {
+        $node = Query::node('m');
+
+        $statement = (new Query())->with($node)->build();
+
+        $this->assertMatchesRegularExpression("/(WITH [0-9a-f]+)/", $statement);
+
+        $node = Query::node("m");
+        $node->named('example');
+
+        $statement = (new Query())->with($node)->build();
+
+        $this->assertSame('WITH example', $statement);
+    }
+
     public function testCallProcedure()
     {
         $procedure = "apoc.json";