Skip to content

Open-source social media scheduler built for AI agents and the teams behind them. Create, schedule and publish posts to every network through MCP or the REST API, or write them yourself in a composer your team will love.

8.2 KB
Raw Blame
<?php

declare(strict_types=1);

namespace App\Http\Middleware\App;

use App\Actions\AccessToken\HasConnectedMcpClient;
use App\Actions\Analytics\ShowPostingStreak;
use App\Actions\Changelog\BuildChangelogProps;
use App\Enums\Auth\SocialAuthProvider;
use App\Enums\Media\Source as MediaSource;
use App\Enums\Media\Type as MediaType;
use App\Enums\PostPlatform\ContentType;
use App\Enums\SocialAccount\Platform as SocialPlatform;
use App\Enums\User\Locale;
use App\Enums\User\ReferralSource;
use App\Http\Resources\App\HandleInertiaRequests\AuthAccountResource;
use App\Http\Resources\App\HandleInertiaRequests\AuthPlanResource;
use App\Http\Resources\App\HandleInertiaRequests\AuthUserResource;
use App\Http\Resources\App\HandleInertiaRequests\AuthWorkspaceResource;
use App\Http\Resources\App\HandleInertiaRequests\ComposerResource;
use App\Http\Resources\App\HandleInertiaRequests\SidebarChannelResource;
use App\Http\Resources\App\PlanResource;
use App\Models\Account;
use App\Models\Plan;
use App\Models\User;
use App\Models\Workspace;
use App\Support\HeicConverter;
use App\Support\LinkTlds;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;
use Inertia\Inertia;
use Inertia\Middleware;

class HandleInertiaRequests extends Middleware
{
    protected $rootView = 'app';

    public function version(Request $request): ?string
    {
        return parent::version($request);
    }

    /**
     * @return array<string, mixed>
     */
    public function share(Request $request): array
    {
        $user = $request->user();
        $account = $user?->account;
        $isSelfHosted = (bool) config('trypost.self_hosted');

        return [
            ...parent::share($request),
            'name' => config('app.name'),
            'auth' => fn (): array => [
                'user' => $user ? AuthUserResource::make($user) : null,
                'currentWorkspace' => $user?->currentWorkspace
                    ? AuthWorkspaceResource::make($user->currentWorkspace->loadMissing('media'), $user)
                    : null,
                'workspaces' => $user
                    ? $user->workspaces()->with('media')->get()->map(fn (Workspace $workspace): array => AuthWorkspaceResource::summary($workspace))
                    : [],
                'account' => $account ? AuthAccountResource::make($account) : null,
                'plan' => $account && $account->plan ? AuthPlanResource::make($account, $account->plan) : null,
                'hasActiveSubscription' => $account ? $account->hasActiveSubscription() : false,
                'subscriptionPastDue' => $account ? $account->isPastDue() : false,
            ],
            'postingStreak' => fn (): ?array => ShowPostingStreak::forSidebar($user),
            'channels' => fn (): array => $user?->currentWorkspace
                ? SidebarChannelResource::collection($user->currentWorkspace)
                : [],
            'referralSources' => fn (): ?array => $this->showsReferralSources($user, $account, $isSelfHosted)
                    ? array_map(fn (ReferralSource $source): string => $source->value, ReferralSource::cases())
                    : null,
            'mcpPrompt' => fn (): ?array => $this->mcpPrompt($user),
            'usage' => fn (): ?array => $account && ! $isSelfHosted ? $account->usage() : null,
            'features' => fn (): ?array => $account && ! $isSelfHosted ? $account->featureLimits() : null,
            ...($user ? BuildChangelogProps::execute($user) : []),
            'flash' => Inertia::always(fn (): array => $request->session()->get('flash', [])),
            'applicationUrl' => config('app.url'),
            'env' => config('app.env'),
            'locale' => app()->getLocale(),
            'selfHosted' => $isSelfHosted,
        ];
    }

    /**
     * @return array<string, callable>
     */
    public function shareOnce(Request $request): array
    {
        $user = $request->user();
        $workspace = $user?->currentWorkspace;

        return [
            ...parent::shareOnce($request),
            'connectablePlatforms' => fn (): array => SocialPlatform::connectableOptions(),
            'contentTypeMediaRules' => fn (): array => ContentType::mediaRulesForFrontend(),
            'defaultCropPresets' => fn (): array => ContentType::defaultCropPresets(),
            'plans' => function (): array {
                if (config('trypost.self_hosted') || blank(auth()->user()?->account)) {
                    return [];
                }

                return PlanResource::collection(
                    Plan::active()->orderBy('sort')->get()
                )->resolve();
            },
            'legal' => fn (): array => [
                'terms' => config('trypost.legal.terms_url'),
                'privacy' => config('trypost.legal.privacy_url'),
            ],
            'languages' => fn (): array => Locale::options(),
            'aiEnabled' => fn (): bool => filled(config('ai.providers.'.config('ai.default').'.key')),
            'googleAuthEnabled' => fn (): bool => SocialAuthProvider::Google->isEnabled(),
            'githubAuthEnabled' => fn (): bool => SocialAuthProvider::GitHub->isEnabled(),
            'toursEnabled' => fn (): bool => (bool) config('trypost.tours.enabled'),
            ...(filled($user) ? [
                'mediaSources' => fn (): array => ['menu' => MediaSource::menu()],
                'mediaUploadLimits' => fn (): array => [
                    'max_bytes' => [
                        MediaType::Image->value => MediaType::Image->maxSizeInBytes(),
                        MediaType::Video->value => MediaType::Video->maxSizeInBytes(),
                        MediaType::Document->value => MediaType::Document->maxSizeInBytes(),
                    ],
                    'extensions' => [
                        MediaType::Image->value => MediaType::Image->extensions(),
                        MediaType::Video->value => MediaType::Video->extensions(),
                        MediaType::Document->value => MediaType::Document->extensions(),
                    ],
                    'upload_retention_hours' => (int) config('trypost.media.upload_retention_hours'),
                    'heic' => HeicConverter::available(),
                ],
            ] : []),
            ...(filled($workspace) ? ['composer' => ComposerResource::once($workspace)] : []),
            ...(filled($user) && config('trypost.platforms.x.defuse_links') ? ['xLinkTlds' => fn (): array => LinkTlds::all()] : []),
        ];
    }

    public static function referralSourcesCacheKey(User $user): string
    {
        return "referral-sources.{$user->id}";
    }

    public static function mcpPromptCacheKey(User $user, Workspace $workspace): string
    {
        return "mcp-connected.{$user->id}.{$workspace->id}";
    }

    /**
     * The card inviting the user to connect an AI, with the MCP URL its steps
     * show, while their workspace can use the app and has no AI of theirs
     * connected; null otherwise. Only the connection is cached, so the card shows
     * as soon as the account gets app access, and a connection made from the card
     * forgets the cache. Dismissing the card is kept in the browser.
     *
     * @return array{mcp_url: string}|null
     */
    private function mcpPrompt(?User $user): ?array
    {
        $workspace = $user?->currentWorkspace;

        if (blank($workspace) || $workspace->account?->hasAppAccess() !== true) {
            return null;
        }

        $connected = Cache::remember(
            self::mcpPromptCacheKey($user, $workspace),
            now()->addMinutes(5),
            fn (): bool => HasConnectedMcpClient::execute($user, $workspace),
        );

        if ($connected) {
            return null;
        }

        return ['mcp_url' => route('mcp.trypost')];
    }

    private function showsReferralSources(?User $user, ?Account $account, bool $isSelfHosted): bool
    {
        if (blank($user) || $isSelfHosted || $account?->hasAppAccess() !== true) {
            return false;
        }

        return Cache::remember(
            self::referralSourcesCacheKey($user),
            now()->addMinutes(5),
            fn (): bool => blank($user->getRawOriginal('referral_source'))
                && $user->created_at?->lte(now()->subHour()) === true,
        );
    }
}