443 lines
15 KiB
PHP
443 lines
15 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Services\FormBuilder;
|
|
|
|
use App\Enums\FormBuilder\FormFieldType;
|
|
use App\Exceptions\FormBuilder\BindingChangeBlockedException;
|
|
use App\Exceptions\FormBuilder\CyclicDependencyException;
|
|
use App\Exceptions\FormBuilder\DestructiveConfirmationRequiredException;
|
|
use App\Exceptions\FormBuilder\FrozenSchemaException;
|
|
use App\Jobs\FormBuilder\BackfillFormValueIndexedJob;
|
|
use App\Models\FormBuilder\FormField;
|
|
use App\Models\FormBuilder\FormFieldLibrary;
|
|
use App\Models\FormBuilder\FormSchema;
|
|
use App\Models\FormBuilder\FormSchemaSection;
|
|
use App\Models\FormBuilder\FormSubmission;
|
|
use App\Models\FormBuilder\FormValue;
|
|
use Illuminate\Support\Facades\DB;
|
|
|
|
/**
|
|
* FormField CRUD + reorder + library insertion + binding safety
|
|
* (ARCH §4.2, §6.5, §8, §4.8.1, §7.2).
|
|
*/
|
|
final class FormFieldService
|
|
{
|
|
public function __construct(
|
|
private readonly FormSchemaService $schemaService,
|
|
private readonly FormFieldBindingService $bindingService,
|
|
private readonly FormFieldValidationRuleService $validationRuleService,
|
|
private readonly FormFieldConfigService $configService,
|
|
) {}
|
|
|
|
public function create(FormSchema $schema, array $data): FormField
|
|
{
|
|
$this->assertNotFrozen($schema);
|
|
|
|
$data['form_schema_id'] = $schema->id;
|
|
$data['sort_order'] ??= $this->nextSortOrder($schema);
|
|
|
|
$bindingSpec = $this->extractBindingSpec($data);
|
|
$validationRuleSpecs = $this->extractValidationRuleSpecs($data);
|
|
|
|
$this->assertNoConditionalCycle($schema, null, $data['conditional_logic'] ?? null, $data['slug'] ?? null);
|
|
|
|
/** @var FormField $field */
|
|
$field = FormField::create($data);
|
|
|
|
if ($bindingSpec !== null) {
|
|
$this->bindingService->replaceBindings($field, [$bindingSpec]);
|
|
}
|
|
|
|
if ($validationRuleSpecs !== null) {
|
|
$this->validationRuleService->replaceRules($field, $validationRuleSpecs);
|
|
}
|
|
|
|
$this->schemaService->bumpVersion($schema);
|
|
$field->logFieldChange('field.created');
|
|
|
|
if ($field->is_filterable) {
|
|
BackfillFormValueIndexedJob::dispatch($field->id)->onQueue('default');
|
|
}
|
|
|
|
return $field->refresh();
|
|
}
|
|
|
|
public function update(FormField $field, array $data, bool $forceBindingChange = false): FormField
|
|
{
|
|
$schema = $field->schema;
|
|
$this->assertNotFrozenForStructural($schema, $data);
|
|
|
|
$bindingProvided = array_key_exists('binding', $data);
|
|
$rawBinding = $bindingProvided ? $data['binding'] : null;
|
|
$bindingSpec = $bindingProvided ? $this->extractBindingSpec($data) : null;
|
|
|
|
$validationRulesProvided = array_key_exists('validation_rules', $data);
|
|
$validationRuleSpecs = $validationRulesProvided ? $this->extractValidationRuleSpecs($data) : null;
|
|
|
|
$currentBindingShape = $this->bindingService->toJsonShape($field->bindings()->first());
|
|
|
|
if ($bindingProvided && $this->bindingChanged($currentBindingShape, $rawBinding)) {
|
|
$this->assertBindingChangeAllowed($field, $forceBindingChange);
|
|
}
|
|
|
|
if (array_key_exists('conditional_logic', $data)) {
|
|
$this->assertNoConditionalCycle($schema, $field, $data['conditional_logic'], $data['slug'] ?? $field->slug);
|
|
}
|
|
|
|
$before = [
|
|
'binding' => $currentBindingShape,
|
|
'is_filterable' => $field->is_filterable,
|
|
'is_pii' => $field->is_pii,
|
|
'field_type' => $field->field_type,
|
|
];
|
|
|
|
$field->fill($data);
|
|
$field->save();
|
|
|
|
if ($bindingProvided) {
|
|
$this->bindingService->replaceBindings($field, $bindingSpec === null ? [] : [$bindingSpec]);
|
|
}
|
|
|
|
if ($validationRulesProvided) {
|
|
$this->validationRuleService->replaceRules($field, $validationRuleSpecs ?? []);
|
|
}
|
|
|
|
$this->schemaService->bumpVersion($schema);
|
|
|
|
$field->logFieldChange('field.updated', [
|
|
'old' => $before,
|
|
'new' => [
|
|
'binding' => $this->bindingService->toJsonShape($field->bindings()->first()),
|
|
'is_filterable' => $field->is_filterable,
|
|
'is_pii' => $field->is_pii,
|
|
'field_type' => $field->field_type,
|
|
],
|
|
]);
|
|
|
|
if ($before['is_filterable'] !== $field->is_filterable) {
|
|
BackfillFormValueIndexedJob::dispatch($field->id)->onQueue('default');
|
|
}
|
|
|
|
return $field->refresh();
|
|
}
|
|
|
|
/**
|
|
* Extract the `validation_rules` key from the request data array and
|
|
* return it as the service-layer spec list. The JSON column is no
|
|
* longer written (WS-5b commit 3) — writes go through
|
|
* `FormFieldValidationRuleService::replaceRules` after the FormField
|
|
* row is created/updated.
|
|
*
|
|
* Returns `null` when the key was absent (no change requested), or an
|
|
* empty list when the caller explicitly cleared rules. Callers
|
|
* distinguish via `array_key_exists('validation_rules', $data)`
|
|
* BEFORE invoking this helper.
|
|
*
|
|
* @param array<string, mixed> $data
|
|
* @return list<array<string, mixed>>|null
|
|
*/
|
|
private function extractValidationRuleSpecs(array &$data): ?array
|
|
{
|
|
if (! array_key_exists('validation_rules', $data)) {
|
|
return null;
|
|
}
|
|
$raw = $data['validation_rules'];
|
|
unset($data['validation_rules']);
|
|
if (! is_array($raw)) {
|
|
return [];
|
|
}
|
|
|
|
/** @var list<array<string, mixed>> $raw */
|
|
return array_values($raw);
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $data
|
|
* @return array{target_entity:string,target_attribute:string,mode:string,sync_direction?:?string}|null
|
|
*/
|
|
private function extractBindingSpec(array &$data): ?array
|
|
{
|
|
if (! array_key_exists('binding', $data)) {
|
|
return null;
|
|
}
|
|
$raw = $data['binding'];
|
|
unset($data['binding']);
|
|
if (! is_array($raw) || $raw === []) {
|
|
return null;
|
|
}
|
|
|
|
return [
|
|
'target_entity' => (string) ($raw['entity'] ?? ''),
|
|
'target_attribute' => (string) ($raw['column'] ?? ''),
|
|
'mode' => (string) ($raw['mode'] ?? ''),
|
|
'sync_direction' => isset($raw['sync_direction']) ? (string) $raw['sync_direction'] : null,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed>|null $current Pre-WS-5a ARCH §6.3 shape
|
|
* @param array<string, mixed>|null $next
|
|
*/
|
|
private function bindingChanged(?array $current, ?array $next): bool
|
|
{
|
|
$normalise = static function (?array $value): array {
|
|
if ($value === null || $value === []) {
|
|
return [];
|
|
}
|
|
|
|
return [
|
|
'mode' => (string) ($value['mode'] ?? ''),
|
|
'entity' => (string) ($value['entity'] ?? ''),
|
|
'column' => (string) ($value['column'] ?? ''),
|
|
'sync_direction' => (string) ($value['sync_direction'] ?? ''),
|
|
];
|
|
};
|
|
|
|
return $normalise($current) !== $normalise($next);
|
|
}
|
|
|
|
public function delete(FormField $field, ?string $confirmedName = null): void
|
|
{
|
|
$schema = $field->schema;
|
|
$this->assertNotFrozen($schema);
|
|
|
|
$hasValues = FormValue::query()->where('form_field_id', $field->id)->exists();
|
|
if ($hasValues && $confirmedName !== $field->label) {
|
|
throw DestructiveConfirmationRequiredException::forName($field->label);
|
|
}
|
|
|
|
DB::transaction(function () use ($field, $schema): void {
|
|
$field->logFieldChange('field.deleted');
|
|
$field->delete();
|
|
$this->schemaService->bumpVersion($schema);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param array<int, string> $orderedFieldIds
|
|
*/
|
|
public function reorder(FormSchema $schema, array $orderedFieldIds): void
|
|
{
|
|
DB::transaction(function () use ($schema, $orderedFieldIds): void {
|
|
foreach ($orderedFieldIds as $index => $fieldId) {
|
|
FormField::query()
|
|
->where('form_schema_id', $schema->id)
|
|
->whereKey($fieldId)
|
|
->update(['sort_order' => $index]);
|
|
}
|
|
$this->schemaService->bumpVersion($schema);
|
|
});
|
|
}
|
|
|
|
public function insertFromLibrary(FormSchema $schema, FormFieldLibrary $library, array $overrides = []): FormField
|
|
{
|
|
$this->assertNotFrozen($schema);
|
|
|
|
$data = array_merge([
|
|
'form_schema_id' => $schema->id,
|
|
'library_field_id' => $library->id,
|
|
'field_type' => $library->field_type,
|
|
'slug' => $this->ensureUniqueSlug($schema, $library->slug),
|
|
'label' => $library->label,
|
|
'help_text' => $library->help_text,
|
|
'options' => $library->options,
|
|
'is_required' => (bool) $library->default_is_required,
|
|
'is_filterable' => (bool) $library->default_is_filterable,
|
|
'translations' => $library->translations,
|
|
'sort_order' => $this->nextSortOrder($schema),
|
|
], $overrides);
|
|
|
|
if (! isset($data['slug']) || $data['slug'] === '') {
|
|
$data['slug'] = $this->ensureUniqueSlug($schema, $library->slug);
|
|
} else {
|
|
$data['slug'] = $this->ensureUniqueSlug($schema, $data['slug']);
|
|
}
|
|
|
|
/** @var FormField $field */
|
|
$field = FormField::create($data);
|
|
|
|
$this->bindingService->copyBindings($library, $field);
|
|
$this->validationRuleService->copyRules($library, $field);
|
|
$this->configService->copyConfigs($library, $field);
|
|
|
|
FormFieldLibrary::query()->whereKey($library->id)->increment('usage_count');
|
|
|
|
$this->schemaService->bumpVersion($schema);
|
|
$field->logFieldChange('field.inserted_from_library', ['library_field_id' => $library->id]);
|
|
|
|
if ($field->is_filterable) {
|
|
BackfillFormValueIndexedJob::dispatch($field->id)->onQueue('default');
|
|
}
|
|
|
|
return $field->refresh();
|
|
}
|
|
|
|
private function assertBindingChangeAllowed(FormField $field, bool $forceBindingChange): void
|
|
{
|
|
$submittedCount = FormSubmission::query()
|
|
->where('form_schema_id', $field->form_schema_id)
|
|
->where('status', 'submitted')
|
|
->count();
|
|
|
|
if ($submittedCount > 0 && ! $forceBindingChange) {
|
|
throw BindingChangeBlockedException::forField($field->id, $submittedCount);
|
|
}
|
|
}
|
|
|
|
private function assertNotFrozen(FormSchema $schema): void
|
|
{
|
|
if ($schema->freeze_on_submit && $this->schemaService->hasSubmittedSubmissions($schema)) {
|
|
throw FrozenSchemaException::forSchema($schema->id);
|
|
}
|
|
}
|
|
|
|
private function assertNotFrozenForStructural(FormSchema $schema, array $data): void
|
|
{
|
|
$structuralKeys = ['field_type', 'binding', 'options', 'validation_rules', 'is_required', 'slug'];
|
|
foreach ($structuralKeys as $key) {
|
|
if (array_key_exists($key, $data)) {
|
|
$this->assertNotFrozen($schema);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private function assertNoConditionalCycle(FormSchema $schema, ?FormField $subject, mixed $conditionalLogic, ?string $subjectSlug): void
|
|
{
|
|
if ($conditionalLogic === null || $subjectSlug === null) {
|
|
return;
|
|
}
|
|
|
|
$dependsOn = $this->extractConditionSlugs($conditionalLogic);
|
|
if ($dependsOn === []) {
|
|
return;
|
|
}
|
|
|
|
$adjacency = $this->buildConditionalAdjacency($schema, $subject, $subjectSlug, $dependsOn);
|
|
|
|
$visiting = [];
|
|
$visited = [];
|
|
$walk = function (string $node) use (&$walk, &$adjacency, &$visiting, &$visited, $subjectSlug): void {
|
|
if (isset($visited[$node])) {
|
|
return;
|
|
}
|
|
if (isset($visiting[$node])) {
|
|
throw CyclicDependencyException::forField($subjectSlug);
|
|
}
|
|
$visiting[$node] = true;
|
|
foreach ($adjacency[$node] ?? [] as $next) {
|
|
$walk($next);
|
|
}
|
|
unset($visiting[$node]);
|
|
$visited[$node] = true;
|
|
};
|
|
|
|
$walk($subjectSlug);
|
|
}
|
|
|
|
/**
|
|
* @return array<int, string>
|
|
*/
|
|
private function extractConditionSlugs(mixed $logic): array
|
|
{
|
|
if (! is_array($logic)) {
|
|
return [];
|
|
}
|
|
$slugs = [];
|
|
$walk = function ($node) use (&$walk, &$slugs): void {
|
|
if (! is_array($node)) {
|
|
return;
|
|
}
|
|
if (isset($node['field_slug'])) {
|
|
$slugs[] = (string) $node['field_slug'];
|
|
}
|
|
foreach ($node as $child) {
|
|
if (is_array($child)) {
|
|
$walk($child);
|
|
}
|
|
}
|
|
};
|
|
$walk($logic);
|
|
|
|
return array_values(array_unique($slugs));
|
|
}
|
|
|
|
/**
|
|
* @param array<int, string> $seedDeps
|
|
* @return array<string, array<int, string>>
|
|
*/
|
|
private function buildConditionalAdjacency(FormSchema $schema, ?FormField $subject, string $subjectSlug, array $seedDeps): array
|
|
{
|
|
$fields = FormField::query()
|
|
->where('form_schema_id', $schema->id)
|
|
->get(['id', 'slug', 'conditional_logic']);
|
|
|
|
$adjacency = [];
|
|
foreach ($fields as $f) {
|
|
if ($subject !== null && $f->id === $subject->id) {
|
|
continue;
|
|
}
|
|
$deps = $this->extractConditionSlugs($f->conditional_logic);
|
|
if ($deps !== []) {
|
|
$adjacency[$f->slug] = $deps;
|
|
}
|
|
}
|
|
$adjacency[$subjectSlug] = $seedDeps;
|
|
|
|
return $adjacency;
|
|
}
|
|
|
|
/**
|
|
* @return array<int, string>
|
|
*/
|
|
public function detectSectionCycle(FormSchema $schema, FormSchemaSection $section, ?string $dependsOnId): void
|
|
{
|
|
if ($dependsOnId === null) {
|
|
return;
|
|
}
|
|
|
|
$chain = [];
|
|
$current = $dependsOnId;
|
|
$safety = 100;
|
|
while ($current !== null && $safety-- > 0) {
|
|
if ($current === $section->id) {
|
|
throw CyclicDependencyException::forSection($section->id);
|
|
}
|
|
$chain[] = $current;
|
|
$parent = FormSchemaSection::query()
|
|
->whereKey($current)
|
|
->value('depends_on_section_id');
|
|
$current = $parent !== null ? (string) $parent : null;
|
|
}
|
|
}
|
|
|
|
private function nextSortOrder(FormSchema $schema): int
|
|
{
|
|
$max = (int) FormField::query()
|
|
->where('form_schema_id', $schema->id)
|
|
->max('sort_order');
|
|
|
|
return $max + 1;
|
|
}
|
|
|
|
private function ensureUniqueSlug(FormSchema $schema, string $slug): string
|
|
{
|
|
$base = \Illuminate\Support\Str::slug($slug) ?: 'veld';
|
|
$candidate = $base;
|
|
$i = 2;
|
|
while (FormField::query()
|
|
->where('form_schema_id', $schema->id)
|
|
->where('slug', $candidate)
|
|
->exists()
|
|
) {
|
|
$candidate = $base.'-'.$i;
|
|
$i++;
|
|
}
|
|
|
|
return $candidate;
|
|
}
|
|
}
|