Registration & Onboarding

final class RegisterUser
{
    public function __construct(
        private readonly CreateTenant $createTenant,
    ) {}

    public function execute(RegisterUserData $data): array
    {
        return DB::transaction(function () use ($data): array {
            $user = User::create([
                'name' => $data->name,
                'email' => $data->email,
                'password' => $data->password,
            ]);

            $tenantName = $data->tenantName ?? $user->name."'s Organization";

            $tenant = $this->createTenant->execute(
                new CreateTenantData(
                    name: $tenantName,
                    slug: $data->tenantSlug,
                ),
                $user,
            );

            return [
                'user' => $user->load('tenants'),
                'tenant' => $tenant,
            ];
        });
    }
}

final class StartOnboarding
{
    public function __construct(
        private readonly RegisterUser $registerUser,
        private readonly PaymentGatewayInterface $gateway,
    ) {}

    public function execute(StartOnboardingData $data): OnboardingResult
    {
        $plan = Plan::where('slug', $data->planSlug)->firstOrFail();
        $planPrice = $plan->getPriceForCurrency($data->currency);

        if ($planPrice === null) {
            throw new PlanNotAvailableInCurrencyException(
                $data->planSlug, $data->currency,
                $plan->getAvailableCurrencies(),
            );
        }

        // Register user + tenant in a single transaction
        ['user' => $user, 'tenant' => $tenant] = DB::transaction(function () use ($data): array {
            $result = $this->registerUser->execute(new RegisterUserData(
                name: $data->name,
                email: $data->email,
                password: $data->password,
                tenantName: $data->tenantName,
            ));

            $result['tenant']->update([
                'preferred_currency' => $data->currency,
                'billing_email' => $data->email,
            ]);

            return $result;
        });

        // External calls — intentionally outside the DB transaction
        $this->gateway->ensureCustomer($tenant);

        if ($planPrice->price_cents === 0) {
            return $this->handleFreePlan($data, $plan, $planPrice, $user, $tenant);
        }

        return $this->handlePaidPlan($data, $plan, $planPrice, $user, $tenant);
    }
}

private function handleFreePlan(...): OnboardingResult
{
    $stripeSubscription = $this->gateway->createSubscription(
        $customerId,
        $planPrice->stripe_price_id,
        [
            'quantity' => $data->quantity,
            'metadata' => ['tenant_id' => $tenant->id, 'plan_id' => $plan->id],
        ],
    );

    Subscription::create([
        'tenant_id' => $tenant->id,
        'plan_id' => $plan->id,
        'stripe_subscription_id' => $stripeSubscription['id'],
        'status' => StripeStatusMapper::map($stripeSubscription['status']),
        'currency' => $data->currency,
        'price_cents' => 0,
        // ... period dates, quantity
    ]);

    $tenant->markOnboardingComplete();

    return new OnboardingResult(user: $user, tenant: $tenant, checkoutUrl: null);
}

private function handlePaidPlan(...): OnboardingResult
{
    $frontendUrl = rtrim(config('app.frontend_url'), '/');
    $successUrl = $frontendUrl . config('billing.onboarding.checkout_success_path');
    $cancelUrl = $frontendUrl . config('billing.onboarding.checkout_cancel_path');

    $checkoutSession = $this->gateway->createCheckoutSession(new CreateCheckoutData(
        tenant: $tenant,
        planPrice: $planPrice,
        successUrl: $successUrl,
        cancelUrl: $cancelUrl,
        quantity: $data->quantity,
        trialDays: $plan->trial_days > 0 ? $plan->trial_days : null,
    ));

    return new OnboardingResult(
        user: $user, tenant: $tenant, checkoutUrl: $checkoutSession->url,
    );
}

$isStateful = EnsureFrontendRequestsAreStateful::fromFrontend($request);

if ($isStateful) {
    // SPA (cookie mode): establish session so the cookie survives the Stripe redirect
    Auth::guard('web')->login($result->user);
    $request->session()->regenerate();
} else {
    // API (token mode): generate token pair for stateless clients
    $tokens = $refreshAction->createTokenPair($result->user);
    $response['accessToken'] = $tokens['accessToken'];
    $response['refreshToken'] = $tokens['refreshToken'];
}

<script setup lang="ts">
const MAX_POLLS = 15
const POLL_INTERVAL_MS = 2_000

let pollCount = 0
const intervalId = setInterval(async () => {
  pollCount++
  const status = await onboardingApi.getOnboardingStatus()

  if (status.hasSubscription) {
    clearInterval(intervalId)
    emit('subscription-confirmed', status)
    return
  }

  if (pollCount >= MAX_POLLS) {
    clearInterval(intervalId)
    showTimeoutError.value = true
  }
}, POLL_INTERVAL_MS)
</script>

final class CompleteOnboarding
{
    public function execute(CompleteOnboardingData $data): Tenant
    {
        return DB::transaction(function () use ($data): Tenant {
            $subscription = Subscription::query()
                ->where('tenant_id', $data->tenant->id)
                ->whereIn('status', [SubscriptionStatus::Active, SubscriptionStatus::Trialing])
                ->latest('created_at')
                ->first();

            if ($subscription === null) {
                throw new OnboardingPaymentRequiredException;
            }

            $billingFields = array_filter([
                'legal_name' => $data->legalName,
                'address' => $data->address,
                // ... city, postal_code, country, vat_number, billing_email
            ], fn (mixed $value): bool => $value !== null);

            if ($billingFields !== []) {
                $data->tenant->update($billingFields);
            }

            $data->tenant->markOnboardingComplete();

            return $data->tenant->refresh();
        });
    }
}

const { status, statusPending, isLoading, error, start, retryCheckout, completeSetup, refreshStatus }
  = useOnboarding()

// Start onboarding (signup page)
const result = await start({
  name: 'Jane Smith',
  email: 'jane@example.com',
  password: 'securepassword',
  passwordConfirmation: 'securepassword',
  planSlug: 'pro',
  currency: 'usd',
})

if (result.checkoutUrl) {
  window.location.href = result.checkoutUrl // Redirect to Stripe
}

// After Stripe redirect — check status
await refreshStatus()

// Complete onboarding with billing info
await completeSetup({
  legalName: 'Acme Inc.',
  country: 'US',
  billingEmail: 'billing@acme.com',
})

$query = Tenant::query()
    ->whereNull('onboarding_completed_at')
    ->where('created_at', '<', $cutoff);

$query->chunkById(100, function ($tenants) use (&$tenantsDeleted, &$usersDeleted): void {
    foreach ($tenants as $tenant) {
        DB::transaction(function () use ($tenant, &$tenantsDeleted, &$usersDeleted): void {
            $owner = $tenant->owner;
            $tenant->delete();
            $tenantsDeleted++;

            if ($owner !== null && $owner->tenants()->count() === 0) {
                $owner->tokens()->delete();
                $owner->refreshTokens()->delete();
                $owner->delete();
                $usersDeleted++;
            }
        });
    }
});