14049246919

Committed 24 Mar 2025 09:42PM UTC coverage: 79.353% (-0.04%) from 79.391%

Build # 14049246919

Build Type

push

github

Committed by

web-flow

Commit Message

feat(support): support array parameters in string manipulations (#1073)

Run Details

48 of 48 new or added lines in 2 files covered. (100.0%)

735 existing lines in 126 files now uncovered.

10492 of 13222 relevant lines covered (79.35%)

90.78 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\TableName;
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<\Tempest\Database\DatabaseModel> $modelClass */
    public static function forModel(string $modelClass): self
    {
        return new self($modelClass::table()->tableName);
    }

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

tempestphp / tempest-framework / 14049246919

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