fix: 1.3.0 bug reviews — scheduled restore, paths, UI consistency (#362)

- Centralize destination-database-name validation on DatabaseType so
  Firebird/SQLite paths validate consistently across the Restore modal,
  Scheduled Restore modal, and the API.
- Short-circuit SQLite in DatabaseProvider::listDatabasesForServer() so
  the autocomplete suggests configured full paths instead of basenames.
- Require source_database_name on scheduled restores (UI, API, DB
  NOT NULL migration) — SQLite servers expose multiple paths and Redis
  was already filtered out at the source-server picker.
- Reorder scheduled-restore steps (Schedule → Source → Target) and share
  the restore summary partial between both modals.
- Let demo users manage scheduled restores; hide Redis from the source
  picker since Redis can't be restored.
- Share a job-status indicator component and tighten badge styling.
- Use a uniform "—" placeholder in the restore summary instead of
  type-specific "(enter name)".
- Drop the duplicate @error block in _destination-autocomplete (Mary's
  x-input already renders it).
- Docs: README and self-hosting quick start mention scheduled restores
  and align env vars; add DatabaseType per-type rule tests.

Author: David-Crty

README.md

@@ -42,6 +42,7 @@
 - **Automated backups** - Schedule recurring backups on daily or weekly intervals. Flexible retention policies: simple time-based (days) or GFS (grandfather-father-son)
 - **Multiple compression options** - gzip, zstd (20-40% better compression), or encrypted (AES-256 for sensitive data)
 - **Cross-server restore** - Restore snapshots from production to staging, or between any compatible servers
+- **Scheduled restores** - Refresh a target database on a recurring schedule (e.g. nightly prod → staging) by replaying the latest completed snapshot
 - **Built-in data browser** - Open Adminer in-app to inspect MySQL, PostgreSQL, and SQLite servers (admin-enabled, role-gated)
 - **Flexible storage** - Store backups locally, on S3-compatible storage (AWS S3, MinIO, etc.), or remote servers via SFTP/FTP
 - **Real-time monitoring** - Track backup and restore progress with detailed job logs

app/Enums/DatabaseType.php

@@ -149,6 +149,46 @@ public function createPdo(DatabaseServer $server, ?string $database = null, int
         return new \PDO($dsn, $server->username, $server->getDecryptedPassword(), $options);
     }
 
+    /**
+     * Validation rules for a destination database name/path of this type.
+     *
+     * SQLite accepts any non-empty path. Firebird is a path too but with a
+     * restricted character set. All other types use the conservative
+     * identifier charset (letters, numbers, underscores).
+     *
+     * @return array<int, string>
+     */
+    public function databaseNameRules(): array
+    {
+        return match ($this) {
+            self::SQLITE => ['required', 'string', 'max:255'],
+            self::FIREBIRD => ['required', 'string', 'max:255', 'regex:/^[a-zA-Z0-9_\/\\\\.\-: ]+$/'],
+            default => ['required', 'string', 'max:64', 'regex:/^[a-zA-Z0-9_]+$/'],
+        };
+    }
+
+    /**
+     * Validation messages for {@see databaseNameRules()}, keyed by `{field}.{rule}`.
+     *
+     * @return array<string, string>
+     */
+    public function databaseNameMessages(string $field): array
+    {
+        return match ($this) {
+            self::SQLITE => [
+                "{$field}.required" => __('Please enter a database path.'),
+            ],
+            self::FIREBIRD => [
+                "{$field}.required" => __('Please enter a database name or path.'),
+                "{$field}.regex" => __('Database name can only contain letters, numbers, spaces, slashes, dots, dashes, colons, and underscores.'),
+            ],
+            default => [
+                "{$field}.required" => __('Please enter a database name.'),
+                "{$field}.regex" => __('Database name can only contain letters, numbers, and underscores.'),
+            ],
+        };
+    }
+
     /**
      * Get the file extension used for database dumps.
      *

app/Http/Requests/Api/V1/RestoreRequest.php

@@ -2,7 +2,6 @@
 
 namespace App\Http\Requests\Api\V1;
 
-use App\Enums\DatabaseType;
 use App\Models\DatabaseServer;
 use Illuminate\Contracts\Validation\ValidationRule;
 use Illuminate\Foundation\Http\FormRequest;
@@ -26,15 +25,10 @@ public function rules(): array
     {
         /** @var DatabaseServer $server */
         $server = $this->route('database_server');
-        $isSqlite = $server->database_type === DatabaseType::SQLITE;
-
-        $schemaRules = $isSqlite
-            ? ['required', 'string', 'max:255']
-            : ['required', 'string', 'max:64', 'regex:/^[a-zA-Z0-9_]+$/'];
 
         return [
             'snapshot_id' => ['required', 'string', 'exists:snapshots,id'],
-            'schema_name' => $schemaRules,
+            'schema_name' => $server->database_type->databaseNameRules(),
         ];
     }
 
@@ -43,8 +37,9 @@ public function rules(): array
      */
     public function messages(): array
     {
-        return [
-            'schema_name.regex' => 'Database name can only contain letters, numbers, and underscores.',
-        ];
+        /** @var DatabaseServer $server */
+        $server = $this->route('database_server');
+
+        return $server->database_type->databaseNameMessages('schema_name');
     }
 }

app/Http/Requests/Api/V1/SaveScheduledRestoreRequest.php

@@ -16,7 +16,7 @@ public function rules(): array
         return [
             'name' => ['required', 'string', 'max:100'],
             'source_server_id' => ['required', 'string', 'exists:database_servers,id'],
-            'source_database_name' => ['nullable', 'string', 'max:255'],
+            'source_database_name' => ['required', 'string', 'max:255'],
             'target_server_id' => ['required', 'string', 'exists:database_servers,id'],
             'schema_name' => ['required', 'string', 'max:255'],
             'backup_schedule_id' => ['required', 'string', 'exists:backup_schedules,id'],

app/Livewire/Forms/DatabaseServerForm.php

@@ -735,7 +735,7 @@ public function getScheduleOptions(): array
         return $this->getBackupSchedules()
             ->map(fn (BackupSchedule $schedule) => [
                 'id' => $schedule->id,
-                'name' => $schedule->name.' — '.$schedule->expression.' ('.\App\Support\Formatters::cronTranslation($schedule->expression).')',
+                'name' => $schedule->displayLabel(),
             ])
             ->toArray();
     }

app/Livewire/Restore/Modal.php

@@ -239,26 +239,12 @@ public function previousStep(): void
      */
     protected function validateSchemaName(): void
     {
-        $type = $this->targetServer?->database_type;
-
-        if ($type === DatabaseType::SQLITE) {
-            $rules = ['schemaName' => 'required|string|max:255'];
-            $messages = ['schemaName.required' => __('Please enter a database path.')];
-        } elseif ($type === DatabaseType::FIREBIRD) {
-            $rules = ['schemaName' => 'required|string|max:255|regex:/^[a-zA-Z0-9_\/\\\\.\-: ]+$/'];
-            $messages = [
-                'schemaName.required' => __('Please enter a database name or path.'),
-                'schemaName.regex' => __('Database name can only contain letters, numbers, spaces, slashes, dots, dashes, colons, and underscores.'),
-            ];
-        } else {
-            $rules = ['schemaName' => 'required|string|max:64|regex:/^[a-zA-Z0-9_]+$/'];
-            $messages = [
-                'schemaName.required' => __('Please enter a database name.'),
-                'schemaName.regex' => __('Database name can only contain letters, numbers, and underscores.'),
-            ];
-        }
+        $type = $this->targetServer->database_type;
 
-        $this->validate($rules, $messages);
+        $this->validate(
+            ['schemaName' => $type->databaseNameRules()],
+            $type->databaseNameMessages('schemaName'),
+        );
     }
 
     public function restore(BackupJobFactory $backupJobFactory): void

app/Livewire/ScheduledRestore/Index.php

@@ -115,19 +115,6 @@ public function openEdit(string $id): void
         $this->dispatch('open-scheduled-restore-modal', id: $id);
     }
 
-    public function toggleEnabled(string $id): void
-    {
-        $scheduledRestore = ScheduledRestore::findOrFail($id);
-
-        $this->authorize('update', $scheduledRestore);
-
-        $scheduledRestore->update(['enabled' => ! $scheduledRestore->enabled]);
-
-        $this->success($scheduledRestore->enabled
-            ? __('Scheduled restore enabled.')
-            : __('Scheduled restore disabled.'));
-    }
-
     public function runNow(string $id): void
     {
         $scheduledRestore = ScheduledRestore::findOrFail($id);

app/Livewire/ScheduledRestore/Modal.php

@@ -82,14 +82,14 @@ public function updatedTargetServerId(): void
     public function nextStep(): void
     {
         if ($this->currentStep === 1) {
-            $this->validateSourceStep();
+            $this->validateScheduleStep();
             $this->currentStep = 2;
 
             return;
         }
 
         if ($this->currentStep === 2) {
-            $this->validateTargetStep();
+            $this->validateSourceStep();
             $this->currentStep = 3;
         }
     }
@@ -103,14 +103,14 @@ public function previousStep(): void
 
     public function save(): void
     {
+        $this->validateScheduleStep();
         $this->validateSourceStep();
         $this->validateTargetStep();
-        $this->validateScheduleStep();
 
         $payload = [
             'name' => $this->name,
             'source_server_id' => $this->sourceServerId,
-            'source_database_name' => $this->sourceDatabaseName ?: null,
+            'source_database_name' => $this->sourceDatabaseName,
             'target_server_id' => $this->targetServerId,
             'schema_name' => $this->schemaName,
             'backup_schedule_id' => $this->backupScheduleId,
@@ -138,19 +138,10 @@ public function save(): void
 
     protected function validateSourceStep(): void
     {
-        $rules = [
+        $this->validate([
             'sourceServerId' => 'required|exists:database_servers,id',
-        ];
-
-        $sourceServer = $this->sourceServerId
-            ? DatabaseServer::find($this->sourceServerId)
-            : null;
-
-        if ($sourceServer && $this->sourceServerRequiresDatabaseName($sourceServer)) {
-            $rules['sourceDatabaseName'] = 'required|string|max:255';
-        }
-
-        $this->validate($rules, [
+            'sourceDatabaseName' => 'required|string|max:255',
+        ], [
             'sourceServerId.required' => __('Please select a source server.'),
             'sourceDatabaseName.required' => __('Please select the source database.'),
         ]);
@@ -167,22 +158,11 @@ protected function validateTargetStep(): void
         ]);
 
         $target = DatabaseServer::findOrFail($this->targetServerId);
-        $isSqlite = $target->database_type === DatabaseType::SQLITE;
 
-        if ($isSqlite) {
-            $this->validate(
-                ['schemaName' => 'required|string|max:255'],
-                ['schemaName.required' => __('Please enter a database path.')]
-            );
-        } else {
-            $this->validate(
-                ['schemaName' => 'required|string|max:64|regex:/^[a-zA-Z0-9_]+$/'],
-                [
-                    'schemaName.required' => __('Please enter a database name.'),
-                    'schemaName.regex' => __('Database name can only contain letters, numbers, and underscores.'),
-                ]
-            );
-        }
+        $this->validate(
+            ['schemaName' => $target->database_type->databaseNameRules()],
+            $target->database_type->databaseNameMessages('schemaName'),
+        );
 
         if ($target->isAppDatabase($this->schemaName)) {
             $this->addError('schemaName', __('Cannot restore over the application database.'));
@@ -208,18 +188,14 @@ protected function validateScheduleStep(): void
         ]);
     }
 
-    protected function sourceServerRequiresDatabaseName(DatabaseServer $server): bool
-    {
-        return ! in_array($server->database_type, [DatabaseType::REDIS, DatabaseType::SQLITE], true);
-    }
-
     /**
      * @return array<int, array{id: string, name: string}>
      */
     public function getSourceServerOptionsProperty(): array
     {
         return DatabaseServer::query()
             ->whereHas('snapshots', fn ($q) => $q->whereHas('job', fn ($jq) => $jq->whereRaw('status = ?', ['completed'])))
+            ->where('database_type', '!=', DatabaseType::REDIS->value)
             ->orderBy('name')
             ->get(['id', 'name'])
             ->map(fn (DatabaseServer $s) => ['id' => $s->id, 'name' => $s->name])
@@ -277,19 +253,18 @@ public function getBackupScheduleOptionsProperty(): array
         return BackupSchedule::query()
             ->orderBy('name')
             ->get(['id', 'name', 'expression'])
-            ->map(fn (BackupSchedule $s) => ['id' => $s->id, 'name' => "{$s->name} ({$s->expression})"])
+            ->map(fn (BackupSchedule $s) => ['id' => $s->id, 'name' => $s->displayLabel()])
             ->toArray();
     }
 
-    public function getSourceServerRequiresDatabaseProperty(): bool
+    public function getSourceServerProperty(): ?DatabaseServer
     {
-        if (! $this->sourceServerId) {
-            return true;
-        }
-
-        $source = DatabaseServer::find($this->sourceServerId);
+        return $this->sourceServerId ? DatabaseServer::find($this->sourceServerId) : null;
+    }
 
-        return $source ? $this->sourceServerRequiresDatabaseName($source) : true;
+    public function getSelectedScheduleProperty(): ?BackupSchedule
+    {
+        return $this->backupScheduleId ? BackupSchedule::find($this->backupScheduleId) : null;
     }
 
     public function getTargetServerProperty(): ?DatabaseServer

app/Models/BackupSchedule.php

@@ -2,6 +2,7 @@
 
 namespace App\Models;
 
+use App\Support\Formatters;
 use Database\Factories\BackupScheduleFactory;
 use Illuminate\Database\Eloquent\Concerns\HasUlids;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
@@ -21,6 +22,24 @@ class BackupSchedule extends Model
         'expression',
     ];
 
+    /**
+     * Human label combining the schedule name, the raw cron expression, and a
+     * natural-language translation of it. Used wherever a schedule is shown
+     * inline (select options, summaries) so the formatting stays consistent.
+     */
+    public function displayLabel(): string
+    {
+        return $this->name.' — '.$this->expression.' ('.$this->cronTranslation().')';
+    }
+
+    /**
+     * Natural-language translation of the cron expression (e.g. "At 02:00").
+     */
+    public function cronTranslation(): string
+    {
+        return Formatters::cronTranslation($this->expression);
+    }
+
     /**
      * @return HasMany<Backup, BackupSchedule>
      */

app/Policies/RestorePolicy.php

@@ -27,38 +27,38 @@ public function view(User $user, Restore|ScheduledRestore $restore): bool
     }
 
     /**
-     * Determine whether the user can start a new restore (from a context
-     * where the target server is not yet known).
-     * Demo users can trigger restores. Final authorization on the target
-     * server is still checked via DatabaseServerPolicy@restore.
+     * Determine whether the user can start a new restore or schedule one.
+     * Demo users can create both. Final authorization on the target server
+     * is still checked via DatabaseServerPolicy@restore.
      */
     public function create(User $user): bool
     {
         return $user->isDemo() || $user->canPerformActions();
     }
 
     /**
-     * Determine whether the user can update the model.
+     * Determine whether the user can update the scheduled restore.
+     * One-shot Restore records are not editable, so update only applies
+     * to ScheduledRestore.
      */
-    public function update(User $user, Restore|ScheduledRestore $restore): bool
+    public function update(User $user, ScheduledRestore $restore): bool
     {
-        return $user->canPerformActions();
+        return $user->isDemo() || $user->canPerformActions();
     }
 
     /**
-     * Determine whether the user can delete a restore record.
-     * Viewers and demo users cannot delete.
+     * Determine whether the user can delete the model.
      */
     public function delete(User $user, Restore|ScheduledRestore $restore): bool
     {
-        return $user->canPerformActions();
+        return $user->isDemo() || $user->canPerformActions();
     }
 
     /**
      * Determine whether the user can manually run the scheduled restore now.
      */
     public function run(User $user, ScheduledRestore $restore): bool
     {
-        return $user->canPerformActions();
+        return $user->isDemo() || $user->canPerformActions();
     }
 }