14140550176

Committed 28 Mar 2025 10:29PM UTC coverage: 80.716% (+1.4%) from 79.334%

Build # 14140550176

Build Type

push

github

Committed by

web-flow

Commit Message

feat(support): support `$default` on array `first` and `last` methods (#1096)

Run Details

11 of 12 new or added lines in 2 files covered. (91.67%)

135 existing lines in 16 files now uncovered.

10941 of 13555 relevant lines covered (80.72%)

100.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.87

/src/Tempest/Database/src/QueryStatements/CreateTableStatement.php

<?php

declare(strict_types=1);

namespace Tempest\Database\QueryStatements;

use BackedEnum;
use Symfony\Component\VarDumper\Cloner\Data;
use Tempest\Database\Builder\ModelDefinition;
use Tempest\Database\Builder\TableDefinition;
use Tempest\Database\Config\DatabaseDialect;
use Tempest\Database\QueryStatement;
use Tempest\Support\Str\ImmutableString;
use UnitEnum;

use function Tempest\Support\arr;
use function Tempest\Support\str;

final class CreateTableStatement implements QueryStatement
{
    public function __construct(
        private readonly string $tableName,
        private array $statements = [],
        private array $indexStatements = [],
    ) {}

    /** @param class-string $modelClass */
    public static function forModel(string $modelClass): self
    {
        return new self(new ModelDefinition($modelClass)->getTableDefinition()->name);
    }

    public function primary(string $name = 'id'): self
    {
        $this->statements[] = new PrimaryKeyStatement($name);

        return $this;
    }

    public function belongsTo(
        string $local,
        string $foreign,
        OnDelete $onDelete = OnDelete::RESTRICT,
        OnUpdate $onUpdate = OnUpdate::NO_ACTION,
        bool $nullable = false,
    ): self {
        [, $localKey] = explode('.', $local);

        $this->integer($localKey, nullable: $nullable);

        $this->statements[] = new BelongsToStatement(
            local: $local,
            foreign: $foreign,
            onDelete: $onDelete,
            onUpdate: $onUpdate,
        );

        return $this;
    }

    public function text(
        string $name,
        bool $nullable = false,
        ?string $default = null,
    ): self {
        $this->statements[] = new TextStatement(
            name: $name,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function varchar(
        string $name,
        int $length = 255,
        bool $nullable = false,
        ?string $default = null,
    ): self {
        $this->statements[] = new VarcharStatement(
            name: $name,
            size: $length,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function char(
        string $name,
        bool $nullable = false,
        ?string $default = null,
    ): self {
        $this->statements[] = new CharStatement(
            name: $name,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function integer(
        string $name,
        bool $unsigned = false,
        bool $nullable = false,
        ?int $default = null,
    ): self {
        $this->statements[] = new IntegerStatement(
            name: $name,
            unsigned: $unsigned,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function float(
        string $name,
        bool $nullable = false,
        ?float $default = null,
    ): self {
        $this->statements[] = new FloatStatement(
            name: $name,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function datetime(
        string $name,
        bool $nullable = false,
        ?string $default = null,
    ): self {
        $this->statements[] = new DatetimeStatement(
            name: $name,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function date(
        string $name,
        bool $nullable = false,
        ?string $default = null,
    ): self {
        $this->statements[] = new DateStatement(
            name: $name,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function boolean(
        string $name,
        bool $nullable = false,
        ?bool $default = null,
    ): self {
        $this->statements[] = new BooleanStatement(
            name: $name,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function json(
        string $name,
        bool $nullable = false,
        ?string $default = null,
    ): self {
        $this->statements[] = new JsonStatement(
            name: $name,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function array(
        string $name,
        bool $nullable = false,
        array $default = [],
    ): self {
        $this->statements[] = new JsonStatement(
            name: $name,
            nullable: $nullable,
            default: json_encode($default),
        );

        return $this;
    }

    public function enum(
        string $name,
        string $enumClass,
        bool $nullable = false,
        null|UnitEnum|BackedEnum $default = null,
    ): self {
        $this->statements[] = new CreateEnumTypeStatement($enumClass);

        $this->statements[] = new EnumStatement(
            name: $name,
            enumClass: $enumClass,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function set(
        string $name,
        array $values,
        bool $nullable = false,
        ?string $default = null,
    ): self {
        $this->statements[] = new SetStatement(
            name: $name,
            values: $values,
            nullable: $nullable,
            default: $default,
        );

        return $this;
    }

    public function unique(string ...$columns): self
    {
        $this->indexStatements[] = new UniqueStatement(
            tableName: $this->tableName,
            columns: $columns,
        );

        return $this;
    }

    public function index(string ...$columns): self
    {
        $this->indexStatements[] = new IndexStatement(
            tableName: $this->tableName,
            columns: $columns,
        );

        return $this;
    }

    public function raw(string $statement): self
    {
        $this->statements[] = new RawStatement($statement);

        return $this;
    }

    public function compile(DatabaseDialect $dialect): string
    {
        $createTable = sprintf(
            'CREATE TABLE %s (%s);',
            new TableDefinition($this->tableName),
            arr($this->statements)
                // Remove BelongsTo for sqlLite as it does not support those queries
                ->filter(fn (QueryStatement $queryStatement) => ! ($dialect === DatabaseDialect::SQLITE && $queryStatement instanceof BelongsToStatement))
                ->map(fn (QueryStatement $queryStatement) => str($queryStatement->compile($dialect))->trim()->replace('  ', ' '))
                ->filter(fn (ImmutableString $str) => $str->isNotEmpty())
                ->implode(', ' . PHP_EOL . '    ')
                ->wrap(before: PHP_EOL . '    ', after: PHP_EOL)
                ->toString(),
        );

        if ($this->indexStatements !== []) {
            $createIndices = PHP_EOL . arr($this->indexStatements)
                ->map(fn (QueryStatement $queryStatement) => str($queryStatement->compile($dialect))->trim()->replace('  ', ' '))
                ->implode(';' . PHP_EOL)
                ->append(';');
        } else {
            $createIndices = '';
        }

        return $createTable . $createIndices;
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Tempest\Database\QueryStatements;
6
7	use BackedEnum;
8	use Symfony\Component\VarDumper\Cloner\Data;
9	use Tempest\Database\Builder\ModelDefinition;
10	use Tempest\Database\Builder\TableDefinition;
11	use Tempest\Database\Config\DatabaseDialect;
12	use Tempest\Database\QueryStatement;
13	use Tempest\Support\Str\ImmutableString;
14	use UnitEnum;
15
16	use function Tempest\Support\arr;
17	use function Tempest\Support\str;
18
19	final class CreateTableStatement implements QueryStatement
20	{
21	public function __construct(	71✔
22	private readonly string $tableName,
23	private array $statements = [],
24	private array $indexStatements = [],
25	) {}	71✔
26
27	/** @param class-string $modelClass */
28	public static function forModel(string $modelClass): self	65✔
29	{
30	return new self(new ModelDefinition($modelClass)->getTableDefinition()->name);	65✔
31	}
32
33	public function primary(string $name = 'id'): self	68✔
34	{
35	$this->statements[] = new PrimaryKeyStatement($name);	68✔
36
37	return $this;	68✔
38	}
39
40	public function belongsTo(	43✔
41	string $local,
42	string $foreign,
43	OnDelete $onDelete = OnDelete::RESTRICT,
44	OnUpdate $onUpdate = OnUpdate::NO_ACTION,
45	bool $nullable = false,
46	): self {
47	[, $localKey] = explode('.', $local);	43✔
48
49	$this->integer($localKey, nullable: $nullable);	43✔
50
51	$this->statements[] = new BelongsToStatement(	43✔
52	local: $local,	43✔
53	foreign: $foreign,	43✔
54	onDelete: $onDelete,	43✔
55	onUpdate: $onUpdate,	43✔
56	);	43✔
57
58	return $this;	43✔
59	}
60
61	public function text(	65✔
62	string $name,
63	bool $nullable = false,
64	?string $default = null,
65	): self {
66	$this->statements[] = new TextStatement(	65✔
67	name: $name,	65✔
68	nullable: $nullable,	65✔
69	default: $default,	65✔
70	);	65✔
71
72	return $this;	65✔
73	}
74
75	public function varchar(	68✔
76	string $name,
77	int $length = 255,
78	bool $nullable = false,
79	?string $default = null,
80	): self {
81	$this->statements[] = new VarcharStatement(	68✔
82	name: $name,	68✔
83	size: $length,	68✔
84	nullable: $nullable,	68✔
85	default: $default,	68✔
86	);	68✔
87
88	return $this;	68✔
89	}
90
91	public function char(	1✔
92	string $name,
93	bool $nullable = false,
94	?string $default = null,
95	): self {
96	$this->statements[] = new CharStatement(	1✔
97	name: $name,	1✔
98	nullable: $nullable,	1✔
99	default: $default,	1✔
100	);	1✔
101
102	return $this;	1✔
103	}
104
105	public function integer(	44✔
106	string $name,
107	bool $unsigned = false,
108	bool $nullable = false,
109	?int $default = null,
110	): self {
111	$this->statements[] = new IntegerStatement(	44✔
112	name: $name,	44✔
113	unsigned: $unsigned,	44✔
114	nullable: $nullable,	44✔
115	default: $default,	44✔
116	);	44✔
117
118	return $this;	44✔
119	}
120
121	public function float(	1✔
122	string $name,
123	bool $nullable = false,
124	?float $default = null,
125	): self {
126	$this->statements[] = new FloatStatement(	1✔
127	name: $name,	1✔
128	nullable: $nullable,	1✔
129	default: $default,	1✔
130	);	1✔
131
132	return $this;	1✔
133	}
134
135	public function datetime(	11✔
136	string $name,
137	bool $nullable = false,
138	?string $default = null,
139	): self {
140	$this->statements[] = new DatetimeStatement(	11✔
141	name: $name,	11✔
142	nullable: $nullable,	11✔
143	default: $default,	11✔
144	);	11✔
145
146	return $this;	11✔
147	}
148
149	public function date(	1✔
150	string $name,
151	bool $nullable = false,
152	?string $default = null,
153	): self {
154	$this->statements[] = new DateStatement(	1✔
155	name: $name,	1✔
156	nullable: $nullable,	1✔
157	default: $default,	1✔
158	);	1✔
159
160	return $this;	1✔
161	}
162
163	public function boolean(	1✔
164	string $name,
165	bool $nullable = false,
166	?bool $default = null,
167	): self {
168	$this->statements[] = new BooleanStatement(	1✔
169	name: $name,	1✔
170	nullable: $nullable,	1✔
171	default: $default,	1✔
172	);	1✔
173
174	return $this;	1✔
175	}
176
177	public function json(	2✔
178	string $name,
179	bool $nullable = false,
180	?string $default = null,
181	): self {
182	$this->statements[] = new JsonStatement(	2✔
183	name: $name,	2✔
184	nullable: $nullable,	2✔
185	default: $default,	2✔
186	);	2✔
187
188	return $this;	2✔
189	}
190
191	public function array(	2✔
192	string $name,
193	bool $nullable = false,
194	array $default = [],
195	): self {
196	$this->statements[] = new JsonStatement(	2✔
197	name: $name,	2✔
198	nullable: $nullable,	2✔
199	default: json_encode($default),	2✔
200	);	2✔
201
202	return $this;	2✔
203	}
204
205	public function enum(	2✔
206	string $name,
207	string $enumClass,
208	bool $nullable = false,
209	null\|UnitEnum\|BackedEnum $default = null,
210	): self {
211	$this->statements[] = new CreateEnumTypeStatement($enumClass);	2✔
212
213	$this->statements[] = new EnumStatement(	2✔
214	name: $name,	2✔
215	enumClass: $enumClass,	2✔
216	nullable: $nullable,	2✔
217	default: $default,	2✔
218	);	2✔
219
220	return $this;	2✔
221	}
222
223	public function set(	2✔
224	string $name,
225	array $values,
226	bool $nullable = false,
227	?string $default = null,
228	): self {
229	$this->statements[] = new SetStatement(	2✔
230	name: $name,	2✔
231	values: $values,	2✔
232	nullable: $nullable,	2✔
233	default: $default,	2✔
234	);	2✔
235
236	return $this;	2✔
237	}
238
239	public function unique(string ...$columns): self	1✔
240	{
241	$this->indexStatements[] = new UniqueStatement(	1✔
242	tableName: $this->tableName,	1✔
243	columns: $columns,	1✔
244	);	1✔
245
246	return $this;	1✔
247	}
248
249	public function index(string ...$columns): self	1✔
250	{
251	$this->indexStatements[] = new IndexStatement(	1✔
252	tableName: $this->tableName,	1✔
253	columns: $columns,	1✔
254	);	1✔
255
256	return $this;	1✔
257	}
258
UNCOV 259	public function raw(string $statement): self	×
260	{
UNCOV 261	$this->statements[] = new RawStatement($statement);	×
262
UNCOV 263	return $this;	×
264	}
265
266	public function compile(DatabaseDialect $dialect): string	71✔
267	{
268	$createTable = sprintf(	71✔
269	'CREATE TABLE %s (%s);',	71✔
270	new TableDefinition($this->tableName),	71✔
271	arr($this->statements)	71✔
272	// Remove BelongsTo for sqlLite as it does not support those queries	71✔
273	->filter(fn (QueryStatement $queryStatement) => ! ($dialect === DatabaseDialect::SQLITE && $queryStatement instanceof BelongsToStatement))	71✔
274	->map(fn (QueryStatement $queryStatement) => str($queryStatement->compile($dialect))->trim()->replace(' ', ' '))	71✔
275	->filter(fn (ImmutableString $str) => $str->isNotEmpty())	71✔
276	->implode(', ' . PHP_EOL . ' ')	71✔
277	->wrap(before: PHP_EOL . ' ', after: PHP_EOL)	71✔
278	->toString(),	71✔
279	);	71✔
280
281	if ($this->indexStatements !== []) {	71✔
282	$createIndices = PHP_EOL . arr($this->indexStatements)	1✔
283	->map(fn (QueryStatement $queryStatement) => str($queryStatement->compile($dialect))->trim()->replace(' ', ' '))	1✔
284	->implode(';' . PHP_EOL)	1✔
285	->append(';');	1✔
286	} else {
287	$createIndices = '';	71✔
288	}
289
290	return $createTable . $createIndices;	71✔
291	}
292	}

tempestphp / tempest-framework / 14140550176

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous