fix: allow to pass expression to query builder column default values

- fixed value functions in query builder
- added optional link to bug.yml template
- added heads up about flow-php/postgresql being in development

Author: norberttech

.github/ISSUE_TEMPLATE/bug.yml

@@ -24,6 +24,14 @@ body:
       render: php
     validations:
       required: true
+  - type: input
+    id: playground-url
+    attributes:
+      label: Playground snippet
+      description: "Share a snippet from the Flow PHP Playground to help us reproduce the issue."
+      placeholder: "https://flow-php.com/playground/?snippet=..."
+    validations:
+      required: false
   - type: textarea
     id: data
     attributes:

documentation/components/libs/postgresql.md

@@ -9,6 +9,9 @@
 
 ## Overview
 
+> **Note:** This library is under active development. If you encounter any issues, especially with the Query Builder,
+> please [report a bug](https://github.com/flow-php/flow/issues/new?template=bug.yml).
+
 PostgreSQL library provides three main capabilities:
 
 1. **SQL Parser** - Parse, analyze, and modify existing PostgreSQL queries using the real PostgreSQL

src/lib/postgresql/src/Flow/PostgreSql/DSL/functions.php

@@ -72,6 +72,7 @@
     Parameter,
     RawExpression,
     RowExpression,
+    SQLValueFunctionExpression,
     Star,
     Subquery,
     TypeCast,
@@ -817,6 +818,51 @@ function data_type_interval() : DataType
     return DataType::interval();
 }
 
+/**
+ * SQL standard CURRENT_TIMESTAMP function.
+ *
+ * Returns the current date and time (at the start of the transaction).
+ * Useful as a column default value or in SELECT queries.
+ *
+ * Example: column('created_at', data_type_timestamp())->default(current_timestamp())
+ * Example: select()->select(current_timestamp()->as('now'))
+ */
+#[DocumentationDSL(module: Module::PG_QUERY, type: DSLType::HELPER)]
+function current_timestamp() : SQLValueFunctionExpression
+{
+    return SQLValueFunctionExpression::currentTimestamp();
+}
+
+/**
+ * SQL standard CURRENT_DATE function.
+ *
+ * Returns the current date (at the start of the transaction).
+ * Useful as a column default value or in SELECT queries.
+ *
+ * Example: column('birth_date', data_type_date())->default(current_date())
+ * Example: select()->select(current_date()->as('today'))
+ */
+#[DocumentationDSL(module: Module::PG_QUERY, type: DSLType::HELPER)]
+function current_date() : SQLValueFunctionExpression
+{
+    return SQLValueFunctionExpression::currentDate();
+}
+
+/**
+ * SQL standard CURRENT_TIME function.
+ *
+ * Returns the current time (at the start of the transaction).
+ * Useful as a column default value or in SELECT queries.
+ *
+ * Example: column('start_time', data_type_time())->default(current_time())
+ * Example: select()->select(current_time()->as('now_time'))
+ */
+#[DocumentationDSL(module: Module::PG_QUERY, type: DSLType::HELPER)]
+function current_time() : SQLValueFunctionExpression
+{
+    return SQLValueFunctionExpression::currentTime();
+}
+
 /**
  * Create a UUID data type.
  */

src/lib/postgresql/src/Flow/PostgreSql/QueryBuilder/Expression/ExpressionFactory.php

@@ -117,6 +117,10 @@ public static function fromAst(Node $node) : Expression
             return ArrayExpression::fromAst($node);
         }
 
+        if ($node->getSqlValueFunction() !== null) {
+            return SQLValueFunctionExpression::fromAst($node);
+        }
+
         throw UnsupportedNodeException::forNodeType('Unknown expression node type');
     }
 }

src/lib/postgresql/src/Flow/PostgreSql/QueryBuilder/Expression/SQLValueFunctionExpression.php

@@ -0,0 +1,126 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\PostgreSql\QueryBuilder\Expression;
+
+use Flow\PostgreSql\Protobuf\AST\{Node, SQLValueFunction, SQLValueFunctionOp};
+use Flow\PostgreSql\QueryBuilder\Exception\{InvalidAstException, UnsupportedNodeException};
+
+/**
+ * Represents SQL standard value functions like CURRENT_TIMESTAMP, CURRENT_DATE, CURRENT_TIME.
+ *
+ * These are special SQL keywords that return values based on the current transaction time.
+ * Unlike regular functions, they don't use parentheses and are represented in PostgreSQL's
+ * AST as SQLValueFunction nodes rather than FuncCall nodes.
+ */
+final readonly class SQLValueFunctionExpression implements Expression
+{
+    private function __construct(
+        private int $op,
+    ) {
+    }
+
+    public static function currentCatalog() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_CURRENT_CATALOG);
+    }
+
+    public static function currentDate() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_CURRENT_DATE);
+    }
+
+    public static function currentRole() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_CURRENT_ROLE);
+    }
+
+    public static function currentSchema() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_CURRENT_SCHEMA);
+    }
+
+    public static function currentTime() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_CURRENT_TIME);
+    }
+
+    public static function currentTimestamp() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_CURRENT_TIMESTAMP);
+    }
+
+    public static function currentUser() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_CURRENT_USER);
+    }
+
+    public static function fromAst(Node $node) : static
+    {
+        $sqlValueFunction = $node->getSqlValueFunction();
+
+        if ($sqlValueFunction === null) {
+            throw InvalidAstException::unexpectedNodeType('SQLValueFunction', 'unknown');
+        }
+
+        $op = $sqlValueFunction->getOp();
+
+        $supported = [
+            SQLValueFunctionOp::SVFOP_CURRENT_DATE,
+            SQLValueFunctionOp::SVFOP_CURRENT_TIME,
+            SQLValueFunctionOp::SVFOP_CURRENT_TIMESTAMP,
+            SQLValueFunctionOp::SVFOP_CURRENT_ROLE,
+            SQLValueFunctionOp::SVFOP_CURRENT_USER,
+            SQLValueFunctionOp::SVFOP_CURRENT_CATALOG,
+            SQLValueFunctionOp::SVFOP_CURRENT_SCHEMA,
+            SQLValueFunctionOp::SVFOP_LOCALTIME,
+            SQLValueFunctionOp::SVFOP_LOCALTIMESTAMP,
+            SQLValueFunctionOp::SVFOP_SESSION_USER,
+            SQLValueFunctionOp::SVFOP_USER,
+        ];
+
+        if (!\in_array($op, $supported, true)) {
+            throw UnsupportedNodeException::forNodeType('SQLValueFunction op=' . $op);
+        }
+
+        return new self($op);
+    }
+
+    public static function localTime() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_LOCALTIME);
+    }
+
+    public static function localTimestamp() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_LOCALTIMESTAMP);
+    }
+
+    public static function sessionUser() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_SESSION_USER);
+    }
+
+    public static function user() : self
+    {
+        return new self(SQLValueFunctionOp::SVFOP_USER);
+    }
+
+    public function as(string $alias) : AliasedExpression
+    {
+        return AliasedExpression::create($this, $alias);
+    }
+
+    public function toAst() : Node
+    {
+        $sqlValueFunction = new SQLValueFunction();
+        $sqlValueFunction->setOp($this->op);
+        $sqlValueFunction->setTypmod(-1);
+
+        $node = new Node();
+        $node->setSqlValueFunction($sqlValueFunction);
+
+        return $node;
+    }
+}

src/lib/postgresql/src/Flow/PostgreSql/QueryBuilder/Schema/ColumnDefinition.php

@@ -8,6 +8,7 @@
 use Flow\PostgreSql\Protobuf\AST\{ColumnDef, ConstrType, Constraint, Node, RangeVar};
 use Flow\PostgreSql\Protobuf\AST\PBString;
 use Flow\PostgreSql\QueryBuilder\Exception\InvalidAstException;
+use Flow\PostgreSql\QueryBuilder\Expression\Expression;
 
 final readonly class ColumnDefinition
 {
@@ -47,13 +48,17 @@ public function check(string $expression) : self
         );
     }
 
-    public function default(bool|float|int|string|null $value) : self
+    public function default(bool|float|int|string|Expression|null $value) : self
     {
+        $node = $value instanceof Expression
+            ? $value->toAst()
+            : $this->createLiteralNode($value);
+
         return new self(
             $this->name,
             $this->type,
             $this->notNull,
-            $this->createLiteralNode($value),
+            $node,
             $this->identity,
             $this->generatedExpression,
             $this->constraints,

src/lib/postgresql/tests/Flow/PostgreSql/Tests/Integration/QueryBuilder/SelectBuilderTest.php

@@ -24,6 +24,9 @@
     cond_not,
     cond_or,
     cte,
+    current_date,
+    current_time,
+    current_timestamp,
     data_type_integer,
     data_type_text,
     derived,
@@ -1225,4 +1228,53 @@ public function test_simple_select_with_where() : void
             'SELECT * FROM users WHERE active = true'
         );
     }
+
+    public function test_sql_value_function_current_date() : void
+    {
+        $query = select()
+            ->select(current_date()->as('today'));
+
+        $this->assertSelectQueryRoundTrip(
+            $query,
+            'SELECT current_date AS today'
+        );
+    }
+
+    public function test_sql_value_function_current_time() : void
+    {
+        $query = select()
+            ->select(current_time()->as('now_time'));
+
+        $this->assertSelectQueryRoundTrip(
+            $query,
+            'SELECT current_time AS now_time'
+        );
+    }
+
+    public function test_sql_value_function_current_timestamp() : void
+    {
+        $query = select()
+            ->select(current_timestamp()->as('now'));
+
+        $this->assertSelectQueryRoundTrip(
+            $query,
+            'SELECT current_timestamp AS now'
+        );
+    }
+
+    public function test_sql_value_functions_with_other_columns() : void
+    {
+        $query = select()
+            ->select(
+                col('id'),
+                col('name'),
+                current_timestamp()->as('created_at')
+            )
+            ->from(table('users'));
+
+        $this->assertSelectQueryRoundTrip(
+            $query,
+            'SELECT id, name, current_timestamp AS created_at FROM users'
+        );
+    }
 }

src/lib/postgresql/tests/Flow/PostgreSql/Tests/Integration/QueryBuilder/TableBuilderTest.php

@@ -10,6 +10,7 @@
     col,
     column,
     create,
+    current_timestamp,
     data_type_boolean,
     data_type_integer,
     data_type_serial,
@@ -328,6 +329,19 @@ public function test_create_table_with_column_default() : void
         );
     }
 
+    public function test_create_table_with_column_default_current_timestamp() : void
+    {
+        $builder = create()->table('audit_log')
+            ->column(column('id', data_type_serial())->primaryKey())
+            ->column(column('message', data_type_text())->notNull())
+            ->column(column('created_at', data_type_timestamp())->notNull()->default(current_timestamp()));
+
+        $this->assertCreateTableQuery(
+            $builder,
+            'CREATE TABLE audit_log (id serial PRIMARY KEY, message pg_catalog.text NOT NULL, created_at timestamp NOT NULL DEFAULT current_timestamp)'
+        );
+    }
+
     public function test_create_table_with_composite_primary_key() : void
     {
         $builder = create()->table('order_items')