Skip to content

An open-source, self-hostable PaaS alternative to Vercel, Heroku & Netlify that lets you easily deploy static sites, databases, full-stack applications and 360+ one-click services on your own servers.

feat: add ClickHouse backups and cloud ops tools

Andras Bacsai2719d6604244
diff --git a/app/Jobs/SyncStripeSubscriptionsJob.php b/app/Actions/Stripe/SyncStripeSubscriptions.php
similarity index 61%
rename from app/Jobs/SyncStripeSubscriptionsJob.php
rename to app/Actions/Stripe/SyncStripeSubscriptions.php
index 572d6e78c8..977007961e 100644
--- a/app/Jobs/SyncStripeSubscriptionsJob.php
+++ b/app/Actions/Stripe/SyncStripeSubscriptions.php
@@ -1,30 +1,18 @@
<?php
-namespace App\Jobs;
+namespace App\Actions\Stripe;
use App\Models\Subscription;
-use Illuminate\Bus\Queueable;
-use Illuminate\Contracts\Queue\ShouldBeEncrypted;
-use Illuminate\Contracts\Queue\ShouldQueue;
-use Illuminate\Foundation\Bus\Dispatchable;
-use Illuminate\Queue\InteractsWithQueue;
-use Illuminate\Queue\SerializesModels;
+use Lorisleiva\Actions\Concerns\AsAction;
use Stripe\StripeClient;
-class SyncStripeSubscriptionsJob implements ShouldBeEncrypted, ShouldQueue
+class SyncStripeSubscriptions
{
- use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+ use AsAction;
- public int $tries = 1;
+ private const VALID_STRIPE_STATUSES = ['active', 'past_due'];
- public int $timeout = 1800; // 30 minutes max
-
- public function __construct(public bool $fix = false)
- {
- $this->onQueue('high');
- }
-
- public function handle(?\Closure $onProgress = null): array
+ public function handle(bool $fix = false, ?\Closure $onProgress = null): array
{
if (! isCloud() || ! isStripe()) {
return ['error' => 'Not running on Cloud or Stripe not configured'];
@@ -34,7 +22,9 @@ class SyncStripeSubscriptionsJob implements ShouldBeEncrypted, ShouldQueue
->where('stripe_invoice_paid', true)
->get();
- $stripe = app(StripeClient::class);
+ $stripe = app()->bound(StripeClient::class)
+ ? app(StripeClient::class)
+ : new StripeClient(config('subscription.stripe_api_key'));
// Bulk fetch all valid subscription IDs from Stripe (active + past_due)
$validStripeIds = $this->fetchValidStripeSubscriptionIds($stripe, $onProgress);
@@ -43,13 +33,20 @@ class SyncStripeSubscriptionsJob implements ShouldBeEncrypted, ShouldQueue
$staleSubscriptions = $subscriptions->filter(
fn (Subscription $sub) => ! in_array($sub->stripe_subscription_id, $validStripeIds)
);
+ $staleSubscriptionCount = $staleSubscriptions->count();
+
+ $onProgress?->__invoke('checking', 0, $staleSubscriptionCount);
// For each stale subscription, get the exact Stripe status and check for resubscriptions
$discrepancies = [];
$resubscribed = [];
$errors = [];
+ $fixedCount = 0;
+ $manualReviewCount = 0;
+
+ foreach ($staleSubscriptions->values() as $index => $subscription) {
+ $onProgress?->__invoke('checking', $index + 1, $staleSubscriptionCount);
- foreach ($staleSubscriptions as $subscription) {
try {
$stripeSubscription = $stripe->subscriptions->retrieve(
$subscription->stripe_subscription_id
@@ -66,8 +63,18 @@ class SyncStripeSubscriptionsJob implements ShouldBeEncrypted, ShouldQueue
continue;
}
- // Check if this user resubscribed under a different customer/subscription
+ if (in_array($stripeStatus, self::VALID_STRIPE_STATUSES, true)) {
+ continue;
+ }
+
$activeSub = $this->findActiveSubscriptionByEmail($stripe, $stripeSubscription->customer);
+ $validReplacement = Subscription::query()
+ ->where('team_id', $subscription->team_id)
+ ->where('id', '!=', $subscription->id)
+ ->where('stripe_invoice_paid', true)
+ ->whereIn('stripe_subscription_id', $validStripeIds)
+ ->first();
+
if ($activeSub) {
$resubscribed[] = [
'subscription_id' => $subscription->id,
@@ -78,33 +85,69 @@ class SyncStripeSubscriptionsJob implements ShouldBeEncrypted, ShouldQueue
'new_stripe_subscription_id' => $activeSub['subscription_id'],
'new_stripe_customer_id' => $activeSub['customer_id'],
'new_status' => $activeSub['status'],
+ 'linked_to_team' => $validReplacement?->stripe_subscription_id === $activeSub['subscription_id'],
];
+ }
- continue;
+ $inactiveSubscription = null;
+ if (! $validReplacement && ! $activeSub) {
+ $inactiveSubscription = Subscription::query()
+ ->where('team_id', $subscription->team_id)
+ ->where('id', '!=', $subscription->id)
+ ->where('stripe_invoice_paid', false)
+ ->first();
}
+ $resolution = match (true) {
+ (bool) $validReplacement => 'delete_stale',
+ (bool) $activeSub => 'manual_review',
+ (bool) $inactiveSubscription => 'delete_stale',
+ default => 'end_subscription',
+ };
+
$discrepancies[] = [
'subscription_id' => $subscription->id,
'team_id' => $subscription->team_id,
'stripe_subscription_id' => $subscription->stripe_subscription_id,
'stripe_status' => $stripeStatus,
+ 'resolution' => $resolution,
];
- if ($this->fix) {
- $subscription->update([
- 'stripe_invoice_paid' => false,
- 'stripe_past_due' => false,
- ]);
+ if ($fix) {
+ $team = $subscription->team;
+
+ if ($resolution === 'manual_review') {
+ $manualReviewCount++;
+
+ continue;
+ }
+
+ if ($resolution === 'delete_stale') {
+ if (! $validReplacement && $inactiveSubscription && $team) {
+ $team->subscriptionEnded($inactiveSubscription);
+ }
+
+ $subscription->delete();
+ $fixedCount++;
+
+ continue;
+ }
- if ($stripeStatus === 'canceled') {
- $subscription->team?->subscriptionEnded();
+ if ($team) {
+ $team->subscriptionEnded($subscription);
+ } else {
+ $subscription->update([
+ 'stripe_invoice_paid' => false,
+ 'stripe_past_due' => false,
+ ]);
}
+ $fixedCount++;
}
}
- if ($this->fix && count($discrepancies) > 0) {
+ if ($fix && $fixedCount > 0) {
send_internal_notification(
- 'SyncStripeSubscriptionsJob: Fixed '.count($discrepancies)." discrepancies:\n".
+ "SyncStripeSubscriptions: Fixed {$fixedCount} discrepancies:\n".
json_encode($discrepancies, JSON_PRETTY_PRINT)
);
}
@@ -114,7 +157,9 @@ class SyncStripeSubscriptionsJob implements ShouldBeEncrypted, ShouldQueue
'discrepancies' => $discrepancies,
'resubscribed' => $resubscribed,
'errors' => $errors,
- 'fixed' => $this->fix,
+ 'fixed' => $fix,
+ 'fixed_count' => $fixedCount,
+ 'manual_review_count' => $manualReviewCount,
];
}
@@ -183,13 +228,13 @@ class SyncStripeSubscriptionsJob implements ShouldBeEncrypted, ShouldQueue
$validIds = [];
$fetched = 0;
- foreach (['active', 'past_due'] as $status) {
+ foreach (self::VALID_STRIPE_STATUSES as $status) {
foreach ($stripe->subscriptions->all(['status' => $status, 'limit' => 100])->autoPagingIterator() as $sub) {
$validIds[] = $sub->id;
$fetched++;
if ($onProgress) {
- $onProgress($fetched);
+ $onProgress('fetching', $fetched, null);
}
}
}
diff --git a/app/Console/Commands/Cloud/CleanupUnverifiedUsers.php b/app/Console/Commands/Cloud/CleanupUnverifiedUsers.php
new file mode 100644
index 0000000000..bf63edce56
--- /dev/null
+++ b/app/Console/Commands/Cloud/CleanupUnverifiedUsers.php
@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Console\Commands\Cloud;
+
+use App\Models\User;
+use Illuminate\Console\Command;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Str;
+
+class CleanupUnverifiedUsers extends Command
+{
+ protected $signature = 'cloud:cleanup-unverified-users
+ {--yes : Delete eligible users instead of running a dry run}';
+
+ protected $description = 'Delete unverified users without Stripe subscriptions or defined resources';
+
+ public function handle(): int
+ {
+ if (! isCloud()) {
+ $this->error('This command can only be run on Coolify Cloud.');
+
+ return self::FAILURE;
+ }
+
+ $eligibleUsers = $this->eligibleUsers();
+ $eligibleCount = $eligibleUsers->count();
+
+ $this->info("Found {$eligibleCount} ".Str::plural('unverified user', $eligibleCount).' eligible for deletion.');
+ $shouldDelete = (bool) $this->option('yes');
+
+ if (! $shouldDelete) {
+ $this->warn('Dry run only. Use --yes to delete eligible users.');
+ }
+
+ $deletedCount = 0;
+
+ if ($eligibleCount > 0) {
+ $progressAction = $shouldDelete ? 'Deleting' : 'Checking';
+ $progressBar = $this->output->createProgressBar($eligibleCount);
+ $progressBar->setFormat("{$progressAction} eligible users: %current%/%max% [%bar%] %percent:3s%%");
+ $progressBar->start();
+
+ foreach ($eligibleUsers->lazyById(100) as $user) {
+ if ($shouldDelete && $user->delete()) {
+ $deletedCount++;
+ }
+
+ $progressBar->advance();
+ }
+
+ $progressBar->finish();
+ $this->newLine(2);
+ }
+
+ if ($shouldDelete) {
+ $this->info("Deleted {$deletedCount} ".Str::plural('unverified user', $deletedCount).'.');
+ }
+
+ return self::SUCCESS;
+ }
+
+ private function eligibleUsers(): Builder
+ {
+ return User::query()
+ ->where('id', '!=', 0)
+ ->whereNull('email_verified_at')
+ ->whereDoesntHave('teams', fn (Builder $query) => $query->whereKey(0))
+ ->whereDoesntHave('teams.subscription')
+ ->whereDoesntHave('teams.servers')
+ ->whereDoesntHave('teams', function (Builder $query) {
+ $query->whereHas('projects.applications')
+ ->orWhereHas('projects.postgresqls')
+ ->orWhereHas('projects.redis')
+ ->orWhereHas('projects.mongodbs')
+ ->orWhereHas('projects.mysqls')
+ ->orWhereHas('projects.mariadbs')
+ ->orWhereHas('projects.keydbs')
+ ->orWhereHas('projects.dragonflies')
+ ->orWhereHas('projects.clickhouses')
+ ->orWhereHas('projects.services');
+ });
+ }
+}
diff --git a/app/Console/Commands/Cloud/ExportUsers.php b/app/Console/Commands/Cloud/ExportUsers.php
new file mode 100644
index 0000000000..5e383c4ce8
--- /dev/null
+++ b/app/Console/Commands/Cloud/ExportUsers.php
@@ -0,0 +1,127 @@
+<?php
+
+namespace App\Console\Commands\Cloud;
+
+use App\Models\User;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Storage;
+use RuntimeException;
+use Throwable;
+
+class ExportUsers extends Command
+{
+ protected $signature = 'cloud:export-users';
+
+ protected $description = 'Export subscribed and unsubscribed verified Coolify Cloud users to separate CSV files';
+
+ public function handle(): int
+ {
+ if (! isCloud()) {
+ $this->error('This command can only be run on Coolify Cloud.');
+
+ return self::FAILURE;
+ }
+
+ $backups = Storage::disk('backups');
+ $backups->delete('cloud-users.csv');
+
+ $subscribedPath = $backups->path('cloud-users-subscribed.csv');
+ $unsubscribedPath = $backups->path('cloud-users-unsubscribed.csv');
+ $subscribedOutput = fopen($subscribedPath, 'wb');
+
+ if ($subscribedOutput === false) {
+ $this->error("Unable to open {$subscribedPath} for writing.");
+
+ return self::FAILURE;
+ }
+
+ $unsubscribedOutput = fopen($unsubscribedPath, 'wb');
+
+ if ($unsubscribedOutput === false) {
+ fclose($subscribedOutput);
+ $this->error("Unable to open {$unsubscribedPath} for writing.");
+
+ return self::FAILURE;
+ }
+
+ $subscribedCount = 0;
+ $unsubscribedCount = 0;
+
+ try {
+ $header = [
+ 'email',
+ 'first_name',
+ 'last_name',
+ 'lifetime_value_currency',
+ 'lifetime_value_amount',
+ 'utm_campaign',
+ 'utm_source',
+ 'utm_medium',
+ 'utm_content',
+ 'utm_term',
+ 'phone',
+ ];
+
+ $this->writeCsvRow($subscribedOutput, $header);
+ $this->writeCsvRow($unsubscribedOutput, $header);
+
+ foreach (User::query()
+ ->select(['id', 'email', 'name'])
+ ->where('id', '!=', 0)
+ ->whereNotNull('email_verified_at')
+ ->withExists([
+ 'teams as is_subscribed' => fn ($query) => $query
+ ->whereRelation('subscription', 'stripe_invoice_paid', true),
+ ])
+ ->lazyById(500) as $user) {
+ $nameParts = preg_split('/\s+/u', trim((string) $user->name), 2) ?: [];
+ [$firstName, $lastName] = array_pad($nameParts, 2, '');
+
+ $row = [
+ $user->email,
+ $firstName,
+ $lastName,
+ '',
+ '',
+ '',
+ '',
+ '',
+ '',
+ '',
+ '',
+ ];
+
+ if ($user->is_subscribed) {
+ $this->writeCsvRow($subscribedOutput, $row);
+ $subscribedCount++;
+ } else {
+ $this->writeCsvRow($unsubscribedOutput, $row);
+ $unsubscribedCount++;
+ }
+ }
+ } catch (Throwable $exception) {
+ $this->error("Unable to export users: {$exception->getMessage()}");
+
+ return self::FAILURE;
+ } finally {
+ fclose($subscribedOutput);
+ fclose($unsubscribedOutput);
+ }
+
+ $this->info("Exported {$subscribedCount} subscribed verified users to {$subscribedPath}");
+ $this->info("Exported {$unsubscribedCount} unsubscribed verified users to {$unsubscribedPath}");
+
+ return self::SUCCESS;
+ }
+
+ /**
+ * @param resource $output
+ * @param array<int, mixed> $fields
+ */
+ private function writeCsvRow($output, array $fields): void
+ {
+ if (fputcsv($output, $fields, ',', '"', '') === false) {
+ throw new RuntimeException('Unable to write the CSV file.');
+ }
+ }
+}
diff --git a/app/Console/Commands/Cloud/SyncStripeSubscriptions.php b/app/Console/Commands/Cloud/SyncStripeSubscriptions.php
index 46f6b4edd5..cedacfbeb5 100644
--- a/app/Console/Commands/Cloud/SyncStripeSubscriptions.php
+++ b/app/Console/Commands/Cloud/SyncStripeSubscriptions.php
@@ -2,7 +2,7 @@
namespace App\Console\Commands\Cloud;
-use App\Jobs\SyncStripeSubscriptionsJob;
+use App\Actions\Stripe\SyncStripeSubscriptions as SyncStripeSubscriptionsAction;
use Illuminate\Console\Command;
class SyncStripeSubscriptions extends Command
@@ -35,14 +35,18 @@ class SyncStripeSubscriptions extends Command
$this->newLine();
- $job = new SyncStripeSubscriptionsJob($fix);
- $fetched = 0;
- $result = $job->handle(function (int $count) use (&$fetched): void {
- $fetched = $count;
- $this->output->write("\r Fetching subscriptions from Stripe... {$fetched}");
+ $progressShown = false;
+ $result = SyncStripeSubscriptionsAction::run($fix, function (string $stage, int $current, ?int $total) use (&$progressShown): void {
+ $progressShown = true;
+ $message = match ($stage) {
+ 'checking' => " Checking stale subscriptions against Stripe... {$current}/{$total}",
+ default => " Fetching valid subscriptions from Stripe... {$current}",
+ };
+
+ $this->output->write("\r".str_pad($message, 80));
});
- if ($fetched > 0) {
- $this->output->write("\r".str_repeat(' ', 60)."\r");
+ if ($progressShown) {
+ $this->output->write("\r".str_repeat(' ', 80)."\r");
}
if (isset($result['error'])) {
@@ -63,13 +67,22 @@ class SyncStripeSubscriptions extends Command
$this->line(" Team ID: {$discrepancy['team_id']}");
$this->line(" Stripe ID: {$discrepancy['stripe_subscription_id']}");
$this->line(" Stripe Status: {$discrepancy['stripe_status']}");
+ $resolution = match ($discrepancy['resolution']) {
+ 'delete_stale' => 'Delete stale local row',
+ 'manual_review' => 'Manual review required',
+ default => 'End local subscription',
+ };
+ $this->line(" Resolution: {$resolution}");
$this->newLine();
}
if ($fix) {
- $this->info('All discrepancies have been fixed.');
+ $this->info("Automatic corrections applied: {$result['fixed_count']}");
+ if ($result['manual_review_count'] > 0) {
+ $this->warn("Skipped for manual review: {$result['manual_review_count']}");
+ }
} else {
- $this->comment('Run with --fix to correct these discrepancies.');
+ $this->comment('Run with --fix to apply automatic corrections.');
}
} else {
$this->info('No discrepancies found. All subscriptions are in sync.');
@@ -84,6 +97,7 @@ class SyncStripeSubscriptions extends Command
$this->line(" - Team ID: {$resub['team_id']} | Email: {$resub['email']}");
$this->line(" Old: {$resub['old_stripe_subscription_id']} (cus: {$resub['old_stripe_customer_id']})");
$this->line(" New: {$resub['new_stripe_subscription_id']} (cus: {$resub['new_stripe_customer_id']}) [{$resub['new_status']}]");
+ $this->line(' Linked to this team: '.($resub['linked_to_team'] ? 'Yes' : 'No'));
$this->newLine();
}
}
diff --git a/app/Http/Controllers/Api/DatabasesController.php b/app/Http/Controllers/Api/DatabasesController.php
index 3761effd72..d06e2eac5c 100644
--- a/app/Http/Controllers/Api/DatabasesController.php
+++ b/app/Http/Controllers/Api/DatabasesController.php
@@ -850,6 +850,12 @@ class DatabasesController extends Controller
$this->authorize('manageBackups', $database);
+ if (! $database->isBackupSolutionAvailable()) {
+ return response()->json([
+ 'message' => 'Scheduled backups are not supported for this database type.',
+ ], 422);
+ }
+
// Validate frequency is a valid cron expression
$isValid = validate_cron_expression($request->frequency);
if (! $isValid) {
@@ -915,6 +921,8 @@ class DatabasesController extends Controller
$backupData['databases_to_backup'] = $database->mysql_database;
} elseif ($database->type() === 'standalone-mariadb') {
$backupData['databases_to_backup'] = $database->mariadb_database;
+ } elseif ($database->type() === 'standalone-clickhouse') {
+ $backupData['databases_to_backup'] = $database->clickhouse_db;
}
}
@@ -3016,7 +3024,7 @@ class DatabasesController extends Controller
),
]
)]
- public function move_by_uuid(Request $request): \Illuminate\Http\JsonResponse
+ public function move_by_uuid(Request $request): JsonResponse
{
$teamId = getTeamIdFromToken();
if (is_null($teamId)) {
diff --git a/app/Jobs/DatabaseBackupJob.php b/app/Jobs/DatabaseBackupJob.php
index e9e1f91050..f25158d34a 100644
--- a/app/Jobs/DatabaseBackupJob.php
+++ b/app/Jobs/DatabaseBackupJob.php
@@ -8,6 +8,7 @@ use App\Models\ScheduledDatabaseBackup;
use App\Models\ScheduledDatabaseBackupExecution;
use App\Models\Server;
use App\Models\ServiceDatabase;
+use App\Models\StandaloneClickhouse;
use App\Models\StandaloneMariadb;
use App\Models\StandaloneMongodb;
use App\Models\StandaloneMysql;
@@ -17,6 +18,7 @@ use App\Notifications\Database\BackupFailed;
use App\Notifications\Database\BackupSuccess;
use App\Notifications\Database\BackupSuccessWithS3Warning;
use App\Rules\SafeWebhookUrl;
+use App\Support\ClickhouseBackupCommand;
use Carbon\Carbon;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeEncrypted;
@@ -39,7 +41,7 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
public Server $server;
- public StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|ServiceDatabase $database;
+ public StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneClickhouse|ServiceDatabase $database;
public ?string $container_name = null;
@@ -271,6 +273,8 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
$databasesToBackup = [$this->database->mysql_database];
} elseif (str($databaseType)->contains('mariadb')) {
$databasesToBackup = [$this->database->mariadb_database];
+ } elseif ($this->database instanceof StandaloneClickhouse) {
+ $databasesToBackup = [$this->database->clickhouse_db];
} else {
return;
}
@@ -294,6 +298,10 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
// Format: db1,db2,db3
$databasesToBackup = explode(',', $databasesToBackup);
$databasesToBackup = array_map('trim', $databasesToBackup);
+ } elseif ($this->database instanceof StandaloneClickhouse) {
+ // Format: db1,db2,db3
+ $databasesToBackup = explode(',', $databasesToBackup);
+ $databasesToBackup = array_map('trim', $databasesToBackup);
} else {
return;
}
@@ -386,6 +394,17 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
'local_storage_deleted' => false,
]);
$this->backup_standalone_mariadb($database);
+ } elseif ($this->database instanceof StandaloneClickhouse) {
+ $this->backup_file = '/clickhouse-backup-'.Carbon::now()->timestamp."-{$this->backup_log_uuid}.zip";
+ $this->backup_location = $this->backup_dir.$this->backup_file;
+ $this->backup_log = ScheduledDatabaseBackupExecution::create([
+ 'uuid' => $this->backup_log_uuid,
+ 'database_name' => $database,
+ 'filename' => $this->backup_location,
+ 'scheduled_database_backup_id' => $this->backup->id,
+ 'local_storage_deleted' => false,
+ ]);
+ $this->backup_standalone_clickhouse($database);
} else {
throw new \Exception('Unsupported database type');
}
@@ -400,6 +419,9 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
}
} catch (Throwable $e) {
// Local backup failed
+ if ($this->database instanceof StandaloneClickhouse) {
+ deleteBackupsLocally($this->backup_location, $this->server);
+ }
if ($this->backup_log) {
$this->backup_log->update([
'status' => 'failed',
@@ -642,6 +664,32 @@ class DatabaseBackupJob implements ShouldBeEncrypted, ShouldQueue
}
}
+ private function backup_standalone_clickhouse(string $database): void
+ {
+ $archiveName = ltrim($this->backup_file, '/');
+
+ try {
+ $commands = ClickhouseBackupCommand::make(
+ containerName: $this->container_name,
+ database: $database,
+ archiveName: $archiveName,
+ backupDirectory: $this->backup_dir,
+ );
+
+ $this->backup_output = instant_remote_process($commands, $this->server, true, false, $this->timeout, disableMultiplexing: true);
+ $this->backup_output = trim($this->backup_output);
+ if ($this->backup_output === '') {
+ $this->backup_output = null;
+ }
+ } catch (Throwable $e) {
+ $this->add_to_error_output($e->getMessage());
+ throw $e;
+ } finally {
+ $cleanupCommand = ClickhouseBackupCommand::cleanup($this->container_name, $archiveName);
+ instant_remote_process([$cleanupCommand], $this->server, false, false, null, disableMultiplexing: true);
+ }
+ }
+
private function add_to_backup_output($output): void
{
if ($this->backup_output) {
diff --git a/app/Livewire/Project/Database/Backup/Index.php b/app/Livewire/Project/Database/Backup/Index.php
index 2df32ec7bf..71380754fb 100644
--- a/app/Livewire/Project/Database/Backup/Index.php
+++ b/app/Livewire/Project/Database/Backup/Index.php
@@ -22,13 +22,7 @@ class Index extends Component
if (! $database) {
return redirect()->route('dashboard');
}
- // No backups
- if (
- $database->getMorphClass() === \App\Models\StandaloneRedis::class ||
- $database->getMorphClass() === \App\Models\StandaloneKeydb::class ||
- $database->getMorphClass() === \App\Models\StandaloneDragonfly::class ||
- $database->getMorphClass() === \App\Models\StandaloneClickhouse::class
- ) {
+ if (! $database->isBackupSolutionAvailable()) {
return redirect()->route('project.database.configuration', [
'project_uuid' => $project->uuid,
'environment_uuid' => $environment->uuid,
diff --git a/app/Livewire/Project/Database/CreateScheduledBackup.php b/app/Livewire/Project/Database/CreateScheduledBackup.php
index 7384adcff4..49065711b2 100644
--- a/app/Livewire/Project/Database/CreateScheduledBackup.php
+++ b/app/Livewire/Project/Database/CreateScheduledBackup.php
@@ -48,6 +48,12 @@ class CreateScheduledBackup extends Component
try {
$this->authorize('manageBackups', $this->database);
+ if (! $this->database->isBackupSolutionAvailable()) {
+ $this->dispatch('error', 'Scheduled backups are not supported for this database type.');
+
+ return;
+ }
+
$this->validate();
if ($this->saveToS3) {
@@ -87,6 +93,8 @@ class CreateScheduledBackup extends Component
$payload['databases_to_backup'] = $this->database->mysql_database;
} elseif ($this->database->type() === 'standalone-mariadb') {
$payload['databases_to_backup'] = $this->database->mariadb_database;
+ } elseif ($this->database->type() === 'standalone-clickhouse') {
+ $payload['databases_to_backup'] = $this->database->clickhouse_db;
}
$databaseBackup = ScheduledDatabaseBackup::create($payload);
diff --git a/app/Models/StandaloneClickhouse.php b/app/Models/StandaloneClickhouse.php
index 9db5f21b78..7ca45cc3b7 100644
--- a/app/Models/StandaloneClickhouse.php
+++ b/app/Models/StandaloneClickhouse.php
@@ -370,6 +370,6 @@ class StandaloneClickhouse extends BaseModel
public function isBackupSolutionAvailable()
{
- return false;
+ return true;
}
}
diff --git a/app/Models/Team.php b/app/Models/Team.php
index a979b44fbd..2b468bf4cc 100644
--- a/app/Models/Team.php
+++ b/app/Models/Team.php
@@ -219,13 +219,15 @@ class Team extends Model implements SendsDiscord, SendsEmail, SendsPushover, Sen
$this->getNotificationSettings('webhook')?->isEnabled();
}
- public function subscriptionEnded()
+ public function subscriptionEnded(?Subscription $subscription = null): void
{
- if (! $this->subscription) {
+ $subscription ??= $this->subscription;
+
+ if (! $subscription) {
return;
}
- $this->subscription->update([
+ $subscription->update([
'stripe_subscription_id' => null,
'stripe_cancel_at_period_end' => false,
'stripe_invoice_paid' => false,
diff --git a/app/Support/ClickhouseBackupCommand.php b/app/Support/ClickhouseBackupCommand.php
new file mode 100644
index 0000000000..69e93d5c30
--- /dev/null
+++ b/app/Support/ClickhouseBackupCommand.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Support;
+
+final class ClickhouseBackupCommand
+{
+ /** @return array<int, string> */
+ public static function make(
+ string $containerName,
+ string $database,
+ string $archiveName,
+ string $backupDirectory,
+ ): array {
+ validateShellSafePath($database, 'database name');
+ validateFilenameSafe($archiveName, 'ClickHouse backup archive');
+
+ $backupDirectory = rtrim($backupDirectory, '/');
+ $containerBackupPath = '/var/lib/clickhouse/backups/'.$archiveName;
+ $backupLocation = $backupDirectory.'/'.$archiveName;
+ $query = "BACKUP DATABASE `{$database}` TO File('{$archiveName}')";
+
+ return [
+ 'mkdir -p '.escapeshellarg($backupDirectory),
+ 'docker exec '.escapeshellarg($containerName).' clickhouse-client --query '.escapeshellarg($query),
+ 'docker cp '.escapeshellarg($containerName.':'.$containerBackupPath).' '.escapeshellarg($backupLocation),
+ ];
+ }
+
+ public static function cleanup(string $containerName, string $archiveName): string
+ {
+ validateFilenameSafe($archiveName, 'ClickHouse backup archive');
+
+ $containerBackupPath = '/var/lib/clickhouse/backups/'.$archiveName;
+
+ return 'docker exec '.escapeshellarg($containerName).' rm -f '.escapeshellarg($containerBackupPath);
+ }
+}
diff --git a/resources/views/livewire/admin/index.blade.php b/resources/views/livewire/admin/index.blade.php
index acba3accea..8abb924133 100644
--- a/resources/views/livewire/admin/index.blade.php
+++ b/resources/views/livewire/admin/index.blade.php
@@ -22,7 +22,7 @@
<div class="box-title">{{ $user->name }}</div>
<div class="box-description">{{ $user->email }}</div>
<div class="box-description">Active:
- {{ $user->teams()->whereRelation('subscription', 'stripe_subscription_id', '!=', null)->exists() ? 'Yes' : 'No' }}
+ {{ $user->teams()->whereRelation('subscription', 'stripe_invoice_paid', true)->exists() ? 'Yes' : 'No' }}
</div>
</div>
</div>
diff --git a/resources/views/livewire/project/database/backup-edit.blade.php b/resources/views/livewire/project/database/backup-edit.blade.php
index 4f810d755b..515241364b 100644
--- a/resources/views/livewire/project/database/backup-edit.blade.php
+++ b/resources/views/livewire/project/database/backup-edit.blade.php
@@ -97,6 +97,10 @@
helper="Comma separated list of databases to backup. Empty will include the default one."
id="databasesToBackup" />
@endif
+ @elseif($backup->database_type === 'App\Models\StandaloneClickhouse')
+ <x-forms.input label="Databases To Backup"
+ helper="Comma separated list of databases to backup. Empty will include the default one."
+ id="databasesToBackup" />
@endif
</div>
<div class="grid grid-cols-1 gap-2 md:grid-cols-3">
diff --git a/resources/views/livewire/project/database/heading.blade.php b/resources/views/livewire/project/database/heading.blade.php
index ca4fcf1eab..66af4895f4 100644
--- a/resources/views/livewire/project/database/heading.blade.php
+++ b/resources/views/livewire/project/database/heading.blade.php
@@ -8,12 +8,7 @@
'label' => 'Backups',
'route' => 'project.database.backup.index',
'active' => request()->routeIs('project.database.backup.index', 'project.database.backup.execution'),
- 'visible' => in_array($database->getMorphClass(), [
- 'App\Models\StandalonePostgresql',
- 'App\Models\StandaloneMongodb',
- 'App\Models\StandaloneMysql',
- 'App\Models\StandaloneMariadb',
- ]),
+ 'visible' => $database->isBackupSolutionAvailable(),
],
];
@@ -200,11 +195,7 @@
Terminal
</a>
@endcan
- @if (
- $database->getMorphClass() === 'App\Models\StandalonePostgresql' ||
- $database->getMorphClass() === 'App\Models\StandaloneMongodb' ||
- $database->getMorphClass() === 'App\Models\StandaloneMysql' ||
- $database->getMorphClass() === 'App\Models\StandaloneMariadb')
+ @if ($database->isBackupSolutionAvailable())
<a class="shrink-0 {{ request()->routeIs('project.database.backup.index') ? 'dark:text-white' : '' }}" {{ wireNavigate() }}
href="{{ route('project.database.backup.index', $parameters) }}">
Backups
diff --git a/tests/Feature/AdminSubscriptionStatusTest.php b/tests/Feature/AdminSubscriptionStatusTest.php
new file mode 100644
index 0000000000..94e1609354
--- /dev/null
+++ b/tests/Feature/AdminSubscriptionStatusTest.php
@@ -0,0 +1,47 @@
+<?php
+
+use App\Livewire\Admin\Index as AdminIndex;
+use App\Models\InstanceSettings;
+use App\Models\Subscription;
+use App\Models\Team;
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Livewire\Livewire;
+
+uses(RefreshDatabase::class);
+
+test('admin search only shows users with paid subscriptions as active', function () {
+ config()->set('cache.default', 'array');
+ config()->set('constants.coolify.self_hosted', false);
+
+ InstanceSettings::unguarded(
+ fn () => InstanceSettings::query()->firstOrCreate(['id' => 0])
+ );
+
+ $rootTeam = Team::find(0) ?? Team::factory()->create(['id' => 0]);
+ $rootUser = User::find(0) ?? User::factory()->create(['id' => 0]);
+ $rootTeam->members()->syncWithoutDetaching([
+ $rootUser->id => ['role' => 'admin'],
+ ]);
+
+ $inactiveUser = User::factory()->create(['email' => '[email protected]']);
+ $inactiveTeam = Team::factory()->create();
+ $inactiveTeam->members()->attach($inactiveUser->id, ['role' => 'owner']);
+ Subscription::create([
+ 'team_id' => $inactiveTeam->id,
+ 'stripe_subscription_id' => 'sub_stale',
+ 'stripe_invoice_paid' => false,
+ ]);
+
+ $this->actingAs($rootUser);
+ session(['currentTeam' => ['id' => $rootTeam->id]]);
+
+ Livewire::test(AdminIndex::class)
+ ->set([
+ 'foundUsers' => collect(),
+ 'search' => '[email protected]',
+ ])
+ ->call('submitSearch')
+ ->assertSee('No')
+ ->assertDontSee('Yes');
+});
diff --git a/tests/Feature/Api/DatabaseBackupCreationApiTest.php b/tests/Feature/Api/DatabaseBackupCreationApiTest.php
index 8882fec39c..cb0c5cf737 100644
--- a/tests/Feature/Api/DatabaseBackupCreationApiTest.php
+++ b/tests/Feature/Api/DatabaseBackupCreationApiTest.php
@@ -5,8 +5,10 @@ use App\Models\Project;
use App\Models\S3Storage;
use App\Models\ScheduledDatabaseBackup;
use App\Models\Server;
+use App\Models\StandaloneClickhouse;
use App\Models\StandaloneDocker;
use App\Models\StandalonePostgresql;
+use App\Models\StandaloneRedis;
use App\Models\Team;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
@@ -15,7 +17,7 @@ use Illuminate\Support\Str;
uses(RefreshDatabase::class);
beforeEach(function () {
- InstanceSettings::updateOrCreate(['id' => 0]);
+ InstanceSettings::forceCreate(['id' => 0, 'is_api_enabled' => true]);
$this->team = Team::factory()->create();
$this->user = User::factory()->create();
@@ -77,6 +79,56 @@ function backupHeaders(): array
}
describe('POST /api/v1/databases/{uuid}/backups', function () {
+ test('rejects backup configurations for unsupported database types', function () {
+ $database = StandaloneRedis::create([
+ 'uuid' => (string) Str::uuid(),
+ 'name' => 'Redis DB',
+ 'status' => 'running',
+ 'environment_id' => $this->environment->id,
+ 'destination_id' => $this->destination->id,
+ 'destination_type' => $this->destination->getMorphClass(),
+ ]);
+
+ $response = $this->withHeaders(backupHeaders())
+ ->postJson("/api/v1/databases/{$database->uuid}/backups", [
+ 'frequency' => 'daily',
+ ]);
+
+ $response->assertUnprocessable()
+ ->assertJson([
+ 'message' => 'Scheduled backups are not supported for this database type.',
+ ]);
+
+ expect(ScheduledDatabaseBackup::count())->toBe(0);
+ });
+
+ test('defaults clickhouse backups to its configured database', function () {
+ $database = StandaloneClickhouse::create([
+ 'uuid' => (string) Str::uuid(),
+ 'name' => 'ClickHouse DB',
+ 'clickhouse_admin_user' => 'default',
+ 'clickhouse_admin_password' => 'password',
+ 'clickhouse_db' => 'analytics',
+ 'image' => 'clickhouse/clickhouse-server:25.11',
+ 'status' => 'running',
+ 'environment_id' => $this->environment->id,
+ 'destination_id' => $this->destination->id,
+ 'destination_type' => $this->destination->getMorphClass(),
+ ]);
+
+ $response = $this->withHeaders(backupHeaders())
+ ->postJson("/api/v1/databases/{$database->uuid}/backups", [
+ 'frequency' => 'daily',
+ ]);
+
+ $response->assertCreated();
+
+ $backup = ScheduledDatabaseBackup::where('uuid', $response->json('uuid'))->firstOrFail();
+
+ expect($backup->databases_to_backup)->toBe('analytics')
+ ->and($backup->database_type)->toBe(StandaloneClickhouse::class);
+ });
+
test('creates backup configuration with valid frequency', function () {
$response = $this->withHeaders(backupHeaders())
->postJson("/api/v1/databases/{$this->database->uuid}/backups", [
diff --git a/tests/Feature/CleanupUnverifiedUsersCommandTest.php b/tests/Feature/CleanupUnverifiedUsersCommandTest.php
new file mode 100644
index 0000000000..39d5c67bab
--- /dev/null
+++ b/tests/Feature/CleanupUnverifiedUsersCommandTest.php
@@ -0,0 +1,154 @@
+<?php
+
+use App\Models\Application;
+use App\Models\Environment;
+use App\Models\Project;
+use App\Models\Server;
+use App\Models\Subscription;
+use App\Models\Team;
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Artisan;
+
+uses(RefreshDatabase::class);
+
+beforeEach(function () {
+ config()->set('constants.coolify.self_hosted', false);
+});
+
+test('it previews eligible unverified users without deleting them', function () {
+ $user = User::factory()->unverified()->create([
+ 'email' => '[email protected]',
+ ]);
+
+ $this->artisan('cloud:cleanup-unverified-users')
+ ->expectsOutput('Found 1 unverified user eligible for deletion.')
+ ->expectsOutput('Dry run only. Use --yes to delete eligible users.')
+ ->assertSuccessful();
+
+ $this->assertModelExists($user);
+});
+
+test('it reports dry run progress', function () {
+ $users = User::factory()->unverified()->count(2)->create();
+
+ $exitCode = Artisan::call('cloud:cleanup-unverified-users');
+
+ expect($exitCode)->toBe(0)
+ ->and(Artisan::output())->toContain('Checking eligible users: 2/2');
+
+ $users->each(fn (User $user) => $this->assertModelExists($user));
+});
+
+test('it deletes eligible unverified users with the yes option', function () {
+ $user = User::factory()->unverified()->create([
+ 'email' => '[email protected]',
+ ]);
+
+ $this->artisan('cloud:cleanup-unverified-users', ['--yes' => true])
+ ->expectsOutput('Deleted 1 unverified user.')
+ ->assertSuccessful();
+
+ $this->assertModelMissing($user);
+});
+
+test('it reports deletion progress', function () {
+ User::factory()->unverified()->count(2)->create();
+
+ $exitCode = Artisan::call('cloud:cleanup-unverified-users', ['--yes' => true]);
+
+ expect($exitCode)->toBe(0)
+ ->and(Artisan::output())->toContain('Deleting eligible users: 2/2');
+});
+
+test('it keeps verified users', function () {
+ $user = User::factory()->create([
+ 'email' => '[email protected]',
+ ]);
+
+ $this->artisan('cloud:cleanup-unverified-users', ['--yes' => true])
+ ->expectsOutput('Deleted 0 unverified users.')
+ ->assertSuccessful();
+
+ $this->assertModelExists($user);
+});
+
+test('it keeps unverified users with a Stripe subscription record', function () {
+ $user = User::factory()->unverified()->create([
+ 'email' => '[email protected]',
+ ]);
+
+ Subscription::create([
+ 'team_id' => $user->teams()->firstOrFail()->id,
+ 'stripe_invoice_paid' => false,
+ ]);
+
+ $this->artisan('cloud:cleanup-unverified-users', ['--yes' => true])
+ ->expectsOutput('Deleted 0 unverified users.')
+ ->assertSuccessful();
+
+ $this->assertModelExists($user);
+});
+
+test('it keeps unverified users with defined resources', function () {
+ $user = User::factory()->unverified()->create([
+ 'email' => '[email protected]',
+ ]);
+
+ $project = Project::factory()->create([
+ 'team_id' => $user->teams()->firstOrFail()->id,
+ ]);
+ $environment = Environment::factory()->create([
+ 'project_id' => $project->id,
+ ]);
+ Application::factory()->create([
+ 'environment_id' => $environment->id,
+ ]);
+
+ $this->artisan('cloud:cleanup-unverified-users', ['--yes' => true])
+ ->expectsOutput('Deleted 0 unverified users.')
+ ->assertSuccessful();
+
+ $this->assertModelExists($user);
+});
+
+test('it keeps unverified users with servers', function () {
+ $user = User::factory()->unverified()->create([
+ 'email' => '[email protected]',
+ ]);
+
+ Server::factory()->create([
+ 'team_id' => $user->teams()->firstOrFail()->id,
+ ]);
+
+ $this->artisan('cloud:cleanup-unverified-users', ['--yes' => true])
+ ->expectsOutput('Deleted 0 unverified users.')
+ ->assertSuccessful();
+
+ $this->assertModelExists($user);
+});
+
+test('it keeps unverified root team members', function () {
+ $user = User::factory()->unverified()->create([
+ 'email' => '[email protected]',
+ ]);
+ $rootTeam = Team::factory()->create([
+ 'id' => 0,
+ 'name' => 'Root Team',
+ ]);
+ $rootTeam->members()->attach($user->id, ['role' => 'admin']);
+
+ $this->artisan('cloud:cleanup-unverified-users', ['--yes' => true])
+ ->expectsOutput('Deleted 0 unverified users.')
+ ->assertSuccessful();
+
+ $this->assertModelExists($user);
+});
+
+test('it only runs on Coolify Cloud', function () {
+ config()->set('constants.coolify.self_hosted', true);
+
+ $this->artisan('cloud:cleanup-unverified-users')
+ ->expectsOutput('This command can only be run on Coolify Cloud.')
+ ->assertFailed();
+});
diff --git a/tests/Feature/CloudExportUsersCommandTest.php b/tests/Feature/CloudExportUsersCommandTest.php
new file mode 100644
index 0000000000..45dda49591
--- /dev/null
+++ b/tests/Feature/CloudExportUsersCommandTest.php
@@ -0,0 +1,101 @@
+<?php
+
+use App\Models\Subscription;
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Storage;
+
+uses(RefreshDatabase::class);
+
+beforeEach(function () {
+ Storage::fake('backups');
+ config()->set('constants.coolify.self_hosted', false);
+});
+
+test('it exports subscribed and unsubscribed verified users to separate files without tags', function () {
+ User::factory()->create([
+ 'id' => 0,
+ 'name' => 'Root User',
+ 'email' => '[email protected]',
+ ]);
+
+ $subscribedUser = User::factory()->create([
+ 'name' => 'Ada Lovelace',
+ 'email' => '[email protected]',
+ ]);
+
+ Subscription::create([
+ 'team_id' => $subscribedUser->teams()->firstOrFail()->id,
+ 'stripe_invoice_paid' => true,
+ 'stripe_subscription_id' => 'sub_active',
+ ]);
+
+ User::factory()->create([
+ 'name' => 'Grace',
+ 'email' => '[email protected]',
+ ]);
+
+ User::factory()->unverified()->create([
+ 'name' => 'Unverified User',
+ 'email' => '[email protected]',
+ ]);
+
+ Storage::disk('backups')->put('cloud-users.csv', 'old export');
+
+ $this->artisan('cloud:export-users')->assertSuccessful();
+
+ Storage::disk('backups')->assertExists([
+ 'cloud-users-subscribed.csv',
+ 'cloud-users-unsubscribed.csv',
+ ]);
+ Storage::disk('backups')->assertMissing('cloud-users.csv');
+
+ $readCsv = function (string $filename): array {
+ $output = fopen(Storage::disk('backups')->path($filename), 'rb');
+ $rows = [];
+
+ while (($row = fgetcsv($output, null, ',', '"', '')) !== false) {
+ $rows[] = $row;
+ }
+
+ fclose($output);
+
+ return $rows;
+ };
+
+ $header = [
+ 'email',
+ 'first_name',
+ 'last_name',
+ 'lifetime_value_currency',
+ 'lifetime_value_amount',
+ 'utm_campaign',
+ 'utm_source',
+ 'utm_medium',
+ 'utm_content',
+ 'utm_term',
+ 'phone',
+ ];
+
+ expect($readCsv('cloud-users-subscribed.csv'))->toBe([
+ $header,
+ ['[email protected]', 'Ada', 'Lovelace', '', '', '', '', '', '', '', ''],
+ ])->and($readCsv('cloud-users-unsubscribed.csv'))->toBe([
+ $header,
+ ['[email protected]', 'Grace', '', '', '', '', '', '', '', '', ''],
+ ]);
+});
+
+test('it only runs on Coolify Cloud', function () {
+ config()->set('constants.coolify.self_hosted', true);
+
+ $this->artisan('cloud:export-users')
+ ->expectsOutput('This command can only be run on Coolify Cloud.')
+ ->assertFailed();
+
+ Storage::disk('backups')->assertMissing([
+ 'cloud-users.csv',
+ 'cloud-users-subscribed.csv',
+ 'cloud-users-unsubscribed.csv',
+ ]);
+});
diff --git a/tests/Feature/CreateScheduledBackupValidationTest.php b/tests/Feature/CreateScheduledBackupValidationTest.php
index 4b5eec24c8..56a4cf479f 100644
--- a/tests/Feature/CreateScheduledBackupValidationTest.php
+++ b/tests/Feature/CreateScheduledBackupValidationTest.php
@@ -6,8 +6,10 @@ use App\Models\Project;
use App\Models\S3Storage;
use App\Models\ScheduledDatabaseBackup;
use App\Models\Server;
+use App\Models\StandaloneClickhouse;
use App\Models\StandaloneDocker;
use App\Models\StandalonePostgresql;
+use App\Models\StandaloneRedis;
use App\Models\Team;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
@@ -136,3 +138,49 @@ it('creates a scheduled backup with a valid team-owned S3 storage', function ()
expect($backup->save_s3)->toBeTruthy();
expect($backup->s3_storage_id)->toBe($s3->id);
});
+
+it('creates a clickhouse backup for its configured database', function () {
+ $server = Server::factory()->create(['team_id' => $this->team->id]);
+ $destination = StandaloneDocker::where('server_id', $server->id)->firstOrFail();
+ $project = Project::factory()->create(['team_id' => $this->team->id]);
+ $environment = Environment::factory()->create(['project_id' => $project->id]);
+ $database = StandaloneClickhouse::create([
+ 'name' => 'clickhouse-scheduled-backup',
+ 'clickhouse_admin_user' => 'default',
+ 'clickhouse_admin_password' => 'password',
+ 'clickhouse_db' => 'analytics',
+ 'environment_id' => $environment->id,
+ 'destination_id' => $destination->id,
+ 'destination_type' => $destination->getMorphClass(),
+ ]);
+
+ Livewire::test(CreateScheduledBackup::class, ['database' => $database])
+ ->set('frequency', 'daily')
+ ->call('submit')
+ ->assertDispatched('refreshScheduledBackups');
+
+ $backup = ScheduledDatabaseBackup::firstOrFail();
+
+ expect($backup->database_type)->toBe(StandaloneClickhouse::class)
+ ->and($backup->databases_to_backup)->toBe('analytics');
+});
+
+it('rejects scheduled backups for unsupported database types', function () {
+ $server = Server::factory()->create(['team_id' => $this->team->id]);
+ $destination = StandaloneDocker::where('server_id', $server->id)->firstOrFail();
+ $project = Project::factory()->create(['team_id' => $this->team->id]);
+ $environment = Environment::factory()->create(['project_id' => $project->id]);
+ $database = StandaloneRedis::create([
+ 'name' => 'redis-without-backups',
+ 'environment_id' => $environment->id,
+ 'destination_id' => $destination->id,
+ 'destination_type' => $destination->getMorphClass(),
+ ]);
+
+ Livewire::test(CreateScheduledBackup::class, ['database' => $database])
+ ->set('frequency', 'daily')
+ ->call('submit')
+ ->assertDispatched('error');
+
+ expect(ScheduledDatabaseBackup::count())->toBe(0);
+});
diff --git a/tests/Feature/ScheduleOnOneServerTest.php b/tests/Feature/ScheduleOnOneServerTest.php
index 167d16bfa2..49d5926892 100644
--- a/tests/Feature/ScheduleOnOneServerTest.php
+++ b/tests/Feature/ScheduleOnOneServerTest.php
@@ -48,3 +48,13 @@ it('schedules every production job with onOneServer', function () {
);
});
});
+
+it('does not schedule Stripe subscription reconciliation automatically', function () {
+ $schedule = app(Schedule::class);
+
+ $event = collect($schedule->events())->first(
+ fn ($event) => str_contains((string) $event->description, 'SyncStripeSubscriptions')
+ );
+
+ expect($event)->toBeNull();
+});
diff --git a/tests/Feature/Subscription/SyncStripeSubscriptionsActionTest.php b/tests/Feature/Subscription/SyncStripeSubscriptionsActionTest.php
new file mode 100644
index 0000000000..31070053d6
--- /dev/null
+++ b/tests/Feature/Subscription/SyncStripeSubscriptionsActionTest.php
@@ -0,0 +1,296 @@
+<?php
+
+use App\Actions\Stripe\SyncStripeSubscriptions;
+use App\Models\Server;
+use App\Models\Subscription;
+use App\Models\Team;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Stripe\Collection as StripeCollection;
+use Stripe\Service\CustomerService;
+use Stripe\Service\SubscriptionService;
+use Stripe\StripeClient;
+
+uses(RefreshDatabase::class);
+
+beforeEach(function () {
+ config()->set('constants.coolify.self_hosted', false);
+ config()->set('subscription.provider', 'stripe');
+
+ $this->team = Team::factory()->create();
+ $this->subscription = Subscription::create([
+ 'team_id' => $this->team->id,
+ 'stripe_subscription_id' => 'sub_stale',
+ 'stripe_customer_id' => 'cus_stale',
+ 'stripe_invoice_paid' => true,
+ ]);
+});
+
+afterEach(function () {
+ SyncStripeSubscriptions::clearFake();
+});
+
+function stripeSubscriptionCollection(array $subscriptions = []): StripeCollection
+{
+ return StripeCollection::constructFrom([
+ 'data' => $subscriptions,
+ 'has_more' => false,
+ 'url' => '/v1/subscriptions',
+ ]);
+}
+
+test('fix mode fully ends a locally active subscription with an invalid Stripe status', function () {
+ $server = Server::factory()->create([
+ 'team_id' => $this->team->id,
+ 'unreachable_count' => 0,
+ 'unreachable_notification_sent' => false,
+ ]);
+
+ $stripe = Mockery::mock(StripeClient::class);
+ $subscriptions = Mockery::mock(SubscriptionService::class);
+ $customers = Mockery::mock(CustomerService::class);
+ $stripe->subscriptions = $subscriptions;
+ $stripe->customers = $customers;
+
+ $subscriptions->shouldReceive('all')->twice()->andReturn(stripeSubscriptionCollection());
+ $subscriptions->shouldReceive('retrieve')->with('sub_stale')->andReturn((object) [
+ 'status' => 'unpaid',
+ 'customer' => 'cus_stale',
+ ]);
+ $customers->shouldReceive('retrieve')->with('cus_stale')->andThrow(new RuntimeException('Customer unavailable'));
+
+ $this->instance(StripeClient::class, $stripe);
+
+ $progress = [];
+
+ SyncStripeSubscriptions::run(
+ fix: true,
+ onProgress: function (string $stage, int $current, ?int $total) use (&$progress): void {
+ $progress[] = [$stage, $current, $total];
+ },
+ );
+
+ $this->subscription->refresh();
+ $server->refresh();
+
+ expect($this->subscription->stripe_invoice_paid)->toBeFalsy()
+ ->and($this->subscription->stripe_subscription_id)->toBeNull()
+ ->and($server->unreachable_count)->toBe(3)
+ ->and($server->unreachable_notification_sent)->toBeTrue()
+ ->and($progress)->toContain(['checking', 0, 1])
+ ->and($progress)->toContain(['checking', 1, 1]);
+});
+
+test('a same-email subscription not linked to the team is left for manual review', function () {
+ $stripe = Mockery::mock(StripeClient::class);
+ $subscriptions = Mockery::mock(SubscriptionService::class);
+ $customers = Mockery::mock(CustomerService::class);
+ $stripe->subscriptions = $subscriptions;
+ $stripe->customers = $customers;
+
+ $subscriptions->shouldReceive('all')
+ ->with(Mockery::on(fn (array $parameters) => isset($parameters['status'])))
+ ->twice()
+ ->andReturn(stripeSubscriptionCollection());
+ $subscriptions->shouldReceive('retrieve')->with('sub_stale')->andReturn((object) [
+ 'status' => 'canceled',
+ 'customer' => 'cus_stale',
+ ]);
+ $customers->shouldReceive('retrieve')->with('cus_stale')->andReturn((object) [
+ 'email' => '[email protected]',
+ ]);
+ $customers->shouldReceive('all')->andReturn((object) [
+ 'data' => [(object) ['id' => 'cus_active']],
+ ]);
+ $subscriptions->shouldReceive('all')->with([
+ 'customer' => 'cus_active',
+ 'limit' => 10,
+ ])->andReturn((object) [
+ 'data' => [(object) [
+ 'id' => 'sub_active_elsewhere',
+ 'status' => 'active',
+ ]],
+ ]);
+
+ $this->instance(StripeClient::class, $stripe);
+
+ $result = SyncStripeSubscriptions::run(fix: true);
+
+ $this->subscription->refresh();
+
+ expect($result['resubscribed'])->toHaveCount(1)
+ ->and($result['discrepancies'])->toHaveCount(1)
+ ->and($result['discrepancies'][0]['resolution'])->toBe('manual_review')
+ ->and($this->subscription->stripe_invoice_paid)->toBeTruthy()
+ ->and($this->subscription->stripe_subscription_id)->toBe('sub_stale');
+});
+
+test('a stale local subscription is deleted when its team has a valid replacement', function () {
+ $replacement = Subscription::create([
+ 'team_id' => $this->team->id,
+ 'stripe_subscription_id' => 'sub_active_elsewhere',
+ 'stripe_customer_id' => 'cus_active',
+ 'stripe_invoice_paid' => true,
+ ]);
+ $server = Server::factory()->create(['team_id' => $this->team->id]);
+ $server->settings->update([
+ 'is_reachable' => true,
+ 'is_usable' => true,
+ ]);
+
+ $stripe = Mockery::mock(StripeClient::class);
+ $subscriptions = Mockery::mock(SubscriptionService::class);
+ $customers = Mockery::mock(CustomerService::class);
+ $stripe->subscriptions = $subscriptions;
+ $stripe->customers = $customers;
+
+ $subscriptions->shouldReceive('all')
+ ->with(['status' => 'active', 'limit' => 100])
+ ->andReturn(stripeSubscriptionCollection([
+ ['id' => 'sub_active_elsewhere'],
+ ]));
+ $subscriptions->shouldReceive('all')
+ ->with(['status' => 'past_due', 'limit' => 100])
+ ->andReturn(stripeSubscriptionCollection());
+ $subscriptions->shouldReceive('retrieve')->with('sub_stale')->andReturn((object) [
+ 'status' => 'canceled',
+ 'customer' => 'cus_stale',
+ ]);
+ $customers->shouldReceive('retrieve')->with('cus_stale')->andReturn((object) [
+ 'email' => '[email protected]',
+ ]);
+ $customers->shouldReceive('all')->andReturn((object) [
+ 'data' => [(object) ['id' => 'cus_active']],
+ ]);
+ $subscriptions->shouldReceive('all')->with([
+ 'customer' => 'cus_active',
+ 'limit' => 10,
+ ])->andReturn((object) [
+ 'data' => [(object) [
+ 'id' => 'sub_active_elsewhere',
+ 'status' => 'active',
+ ]],
+ ]);
+
+ $this->instance(StripeClient::class, $stripe);
+
+ $result = SyncStripeSubscriptions::run(fix: true);
+
+ expect($result['discrepancies'][0]['resolution'])->toBe('delete_stale')
+ ->and($this->subscription->fresh())->toBeNull()
+ ->and($replacement->fresh())->not->toBeNull()
+ ->and($replacement->fresh()->stripe_invoice_paid)->toBeTruthy()
+ ->and($server->settings->fresh()->is_reachable)->toBeTruthy()
+ ->and($server->settings->fresh()->is_usable)->toBeTruthy();
+});
+
+test('a stale duplicate is deleted when its team already has an inactive subscription row', function () {
+ $inactiveSubscription = Subscription::create([
+ 'team_id' => $this->team->id,
+ 'stripe_customer_id' => 'cus_stale',
+ 'stripe_invoice_paid' => false,
+ ]);
+ $server = Server::factory()->create(['team_id' => $this->team->id]);
+ $server->settings->update([
+ 'is_reachable' => true,
+ 'is_usable' => true,
+ ]);
+
+ $stripe = Mockery::mock(StripeClient::class);
+ $subscriptions = Mockery::mock(SubscriptionService::class);
+ $customers = Mockery::mock(CustomerService::class);
+ $stripe->subscriptions = $subscriptions;
+ $stripe->customers = $customers;
+
+ $subscriptions->shouldReceive('all')->twice()->andReturn(stripeSubscriptionCollection());
+ $subscriptions->shouldReceive('retrieve')->with('sub_stale')->andReturn((object) [
+ 'status' => 'canceled',
+ 'customer' => 'cus_stale',
+ ]);
+ $customers->shouldReceive('retrieve')->with('cus_stale')->andThrow(new RuntimeException('Customer unavailable'));
+
+ $this->instance(StripeClient::class, $stripe);
+
+ $result = SyncStripeSubscriptions::run(fix: true);
+
+ expect($result['discrepancies'][0]['resolution'])->toBe('delete_stale')
+ ->and($this->subscription->fresh())->toBeNull()
+ ->and($inactiveSubscription->fresh())->not->toBeNull()
+ ->and($server->settings->fresh()->is_reachable)->toBeFalsy()
+ ->and($server->settings->fresh()->is_usable)->toBeFalsy();
+});
+
+test('valid Stripe subscriptions remain active', function (string $status) {
+ $stripe = Mockery::mock(StripeClient::class);
+ $subscriptions = Mockery::mock(SubscriptionService::class);
+ $stripe->subscriptions = $subscriptions;
+
+ $subscriptions->shouldReceive('all')
+ ->with(['status' => $status, 'limit' => 100])
+ ->andReturn(stripeSubscriptionCollection([
+ ['id' => 'sub_stale'],
+ ]));
+ $subscriptions->shouldReceive('all')
+ ->with(['status' => $status === 'active' ? 'past_due' : 'active', 'limit' => 100])
+ ->andReturn(stripeSubscriptionCollection());
+ $subscriptions->shouldNotReceive('retrieve');
+
+ $this->instance(StripeClient::class, $stripe);
+
+ $result = SyncStripeSubscriptions::run(fix: true);
+
+ $this->subscription->refresh();
+
+ expect($result['discrepancies'])->toBeEmpty()
+ ->and($this->subscription->stripe_invoice_paid)->toBeTruthy()
+ ->and($this->subscription->stripe_subscription_id)->toBe('sub_stale');
+})->with(['active', 'past_due']);
+
+test('the terminal command runs the reconciliation action synchronously', function () {
+ SyncStripeSubscriptions::shouldRun()
+ ->once()
+ ->withArgs(fn (bool $fix, ?Closure $onProgress) => $fix === false && $onProgress instanceof Closure)
+ ->andReturnUsing(function (bool $fix, Closure $onProgress): array {
+ $onProgress('checking', 2, 10);
+
+ return [
+ 'total_checked' => 0,
+ 'discrepancies' => [],
+ 'resubscribed' => [],
+ 'errors' => [],
+ 'fixed' => false,
+ ];
+ });
+
+ $this->artisan('cloud:sync-stripe-subscriptions')
+ ->expectsOutputToContain('Checking stale subscriptions against Stripe... 2/10')
+ ->expectsOutput('Total subscriptions checked: 0')
+ ->assertSuccessful();
+});
+
+test('the terminal command passes the fix option to the reconciliation action', function () {
+ SyncStripeSubscriptions::shouldRun()
+ ->once()
+ ->withArgs(fn (bool $fix, ?Closure $onProgress) => $fix === true && $onProgress instanceof Closure)
+ ->andReturn([
+ 'total_checked' => 1,
+ 'discrepancies' => [[
+ 'subscription_id' => 1,
+ 'team_id' => 2,
+ 'stripe_subscription_id' => 'sub_stale',
+ 'stripe_status' => 'canceled',
+ 'resolution' => 'manual_review',
+ ]],
+ 'resubscribed' => [],
+ 'errors' => [],
+ 'fixed' => true,
+ 'fixed_count' => 0,
+ 'manual_review_count' => 1,
+ ]);
+
+ $this->artisan('cloud:sync-stripe-subscriptions', ['--fix' => true])
+ ->expectsOutput('Total subscriptions checked: 1')
+ ->expectsOutput(' Resolution: Manual review required')
+ ->expectsOutput('Automatic corrections applied: 0')
+ ->expectsOutput('Skipped for manual review: 1')
+ ->assertSuccessful();
+});
diff --git a/tests/Feature/Subscription/TeamSubscriptionEndedTest.php b/tests/Feature/Subscription/TeamSubscriptionEndedTest.php
index 55d59e0e69..bc0f0a6f22 100644
--- a/tests/Feature/Subscription/TeamSubscriptionEndedTest.php
+++ b/tests/Feature/Subscription/TeamSubscriptionEndedTest.php
@@ -1,5 +1,6 @@
<?php
+use App\Models\Subscription;
use App\Models\Team;
use Illuminate\Foundation\Testing\RefreshDatabase;
@@ -14,3 +15,24 @@ test('subscriptionEnded does not throw when team has no subscription', function
// If we reach here, no exception was thrown
expect(true)->toBeTrue();
});
+
+test('subscriptionEnded updates the exact subscription when duplicate rows exist', function () {
+ $team = Team::factory()->create();
+ $otherSubscription = Subscription::create([
+ 'team_id' => $team->id,
+ 'stripe_subscription_id' => 'sub_other',
+ 'stripe_invoice_paid' => true,
+ ]);
+ $subscriptionToEnd = Subscription::create([
+ 'team_id' => $team->id,
+ 'stripe_subscription_id' => 'sub_stale',
+ 'stripe_invoice_paid' => true,
+ ]);
+
+ $team->subscriptionEnded($subscriptionToEnd);
+
+ expect($subscriptionToEnd->fresh()->stripe_subscription_id)->toBeNull()
+ ->and($subscriptionToEnd->fresh()->stripe_invoice_paid)->toBeFalsy()
+ ->and($otherSubscription->fresh()->stripe_subscription_id)->toBe('sub_other')
+ ->and($otherSubscription->fresh()->stripe_invoice_paid)->toBeTruthy();
+});
diff --git a/tests/Unit/ClickhouseBackupCommandTest.php b/tests/Unit/ClickhouseBackupCommandTest.php
new file mode 100644
index 0000000000..0130a9dd62
--- /dev/null
+++ b/tests/Unit/ClickhouseBackupCommandTest.php
@@ -0,0 +1,36 @@
+<?php
+
+use App\Models\StandaloneClickhouse;
+use App\Support\ClickhouseBackupCommand;
+
+test('clickhouse exposes scheduled backups', function () {
+ expect((new StandaloneClickhouse)->isBackupSolutionAvailable())->toBeTrue();
+});
+
+test('builds a native clickhouse backup command using container credentials', function () {
+ $commands = ClickhouseBackupCommand::make(
+ containerName: 'clickhouse-uuid',
+ database: 'analytics',
+ archiveName: 'backup-uuid.zip',
+ backupDirectory: '/data/coolify/backups/clickhouse',
+ );
+
+ expect($commands)->toHaveCount(3)
+ ->and($commands[0])->toBe("mkdir -p '/data/coolify/backups/clickhouse'")
+ ->and($commands[1])->toContain("docker exec 'clickhouse-uuid' clickhouse-client")
+ ->and($commands[1])->not->toContain('--password')
+ ->and($commands[1])->toContain("BACKUP DATABASE `analytics` TO File('")
+ ->and($commands[1])->toContain('backup-uuid.zip')
+ ->and($commands[2])->toBe("docker cp 'clickhouse-uuid:/var/lib/clickhouse/backups/backup-uuid.zip' '/data/coolify/backups/clickhouse/backup-uuid.zip'")
+ ->and(ClickhouseBackupCommand::cleanup('clickhouse-uuid', 'backup-uuid.zip'))
+ ->toBe("docker exec 'clickhouse-uuid' rm -f '/var/lib/clickhouse/backups/backup-uuid.zip'");
+});
+
+test('rejects unsafe clickhouse database names', function () {
+ expect(fn () => ClickhouseBackupCommand::make(
+ containerName: 'clickhouse-uuid',
+ database: 'analytics`; DROP DATABASE default; --',
+ archiveName: 'backup-uuid.zip',
+ backupDirectory: '/data/coolify/backups/clickhouse',
+ ))->toThrow(Exception::class);
+});