Central routes without Route::domain(), configurable tenant/central routes by default for domain/subdomain identification, allow accessing central routes in early identification for path & request data middleware (#3)

* Update url binding bootstrapper test * Fix parent::temporarySignedRoute() call * Add universal route tests for all identification types * Improve determineContextFromRequest() * Add setting `TenancyUrlGenerator::$prefixRouteNames` to true in TSP stub * Delete seemingly redundant test (making one route universal won't make all routes universal in any case) * Use collection syntax in ReregisterUniversalRoutes * Improve comments * Add domain identification MW annotation * Update condition in GloballyUsable * Set `tenancy.bootstrappers` instead of adding the bootstrappers using `tenancy.bootstrappers.x`, move test * Revert GloballyUsable condition change * Delete assigning bootstrappers to tenancy.bootstrappers.x * Exclude cache prefixing bootstrapper from the initial configuration * Fix test * Unset bypass parameter * Set static kernel identification-related properties in TestCase * Update bootstrapper name in annotation * Move unset() into a condition * Update TenancyUrlGenerator condition * Set static properties without instantiating Tenancy * Fix unsetting bypass parameter * formatting changes * add a comment * improve docblock * add docblock to TenancyUrlGenerator [ci skip] * docblock changes [ci skip] * Update TenancyUrlGenerator (rename variable, allow bypassing prefixing temporarySignedRoute name) * Improve determineContextFromRequest * Only return the new url generator instance when extending 'url' in UrlBindingBootstrapper * Check route's MW groups for the path ID MW * Remove extra imports from config * Rename MiddlewareContext to Context, add condition for skipping ID MW * Set only the needed bootstrappers in TestCase * Fix code style (php-cs-fixer) * Remove condition * Use correct return type * Fix PHPStan issue * Update comment * Check for tenant parameter instead of prefix * Update shouldBeSkipped condition for universal routes * Don't remove the 'universal' MW group after route re-registration, update test * Fix code style (php-cs-fixer) * Fix typo * Add test for mixing placement of access prevention and identification MW * Add test for mixing placement of access prevention and identification MW * Update docblock * Add setting the session and key resolvers in UrlBindingBootstrapper (required with LW file uploads) * Update stub * Update variable name in route reregistering action * Add trailing comma * Fix code style (php-cs-fixer) * Require routes using path identification to be flagged as tenant in order to be recognized as tenant routes * Add tenant flag while re-registering routes * Update determineContextFromRequest condition (wip) * Fix code style (php-cs-fixer) * Update the middleware context logic so that universal routes have to be flagged as tenant instead of just having ID MW * Update path identification condition * Fix re-registering the LW localized route (add 'tenant' MW) * Update docblock * Simplify LW route re-registration * Add comment * Update comment * Simplify determineContextFromRequest, add comment * Improve stub * Add skipRoute method + test * Fix typo * Update assets/TenancyServiceProvider.stub.php * Update src/Concerns/DealsWithEarlyIdentification.php * Fix typo Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com> * Improve comment * Update test structure * Restructure Fortify test * code style * Fix typo * Update ReregisterUniversalRoutes annotation * Only prefix route name if it wasn't already prefixed * Add todo@docs * Delete `Tenancy::$kernelAccessPreventionSkipped` and related logic * Delete test tenant cleanup * Test MW group unpacking, restructure and improve test * Test that tenancy isn't initialized after visiting a central route with the tenant parameter * Delete "in both central and tenant contexts" from test names * Test that re-registering works with controllers too * Set misc route properties during re-registering * Determine context instead of guessing, update universal route tests * Use randomly generated tenant ID instead of hardcoding `acme` * Remove setting route validators * Rename and update determine context method, add comments * Update ForgetTenantParameter annotation * Add comment * Delete comment, delete variable assignment * Update early domain identification test * Improve domain identification tests (test defaulting accurately) * Improve readability * Simplify domain early ID test * Use randomly generated tenant instead of 'acme' * Simplify request data ID test, use random tenant instead of 'acme' * Simplify defaulting domain identification test * Use RouteFacade alias for the Route facade, improve test code * Add defaulting to the request data and path ID tests * Merge path identification tenant parameter removal tests, clean up * Correct wording Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com> * Delete debugging things from UniversalRouteTest * Update annotation * Add `// Creates a matrix` * Improve comment wording * Add MiddlewareUsableWithUniversalRoutes, refactor code accordingly * Fix code style (php-cs-fixer) * Delete debugging leftovers * Delete unused import * Update universal route GloballyUsable condition * Don't implement the universal route interface in access prevention MW * Check if request host is in the central domains in domain ID MW * Test universal routes with domain identification without access prevent MW * Test that universal routes work only with identification MW implementing the universal route interface * Fix code style (php-cs-fixer) * Rename GloballyUsable to UsableWithEarlyIdentification * Fix annotation * Update requestHasTenant annotations * Update comment * Add `with()` comments * Add with() comments where missing * Rename interface, update/add comments * Rename exception, update its default message * Fix code style (php-cs-fixer) * Fix interface name * Delete redundant code from subdomain ID MW * Change domainOrSubdomain ID MW so that instead of passing the identification to other MWs, it happens in the domainOrSubdomain MW * Test domainOrSubdomain identification with universal routes * Fix code style (php-cs-fixer) * Rename universal routes interface * Fix code style (php-cs-fixer) * Try explaining forgetting the tenant parameter better * update interface name reference * uncouple example from query parameters * Update ForgetTenantParameter.php * Update ForgetTenantParameter annotation * Check both routeHasMiddleware and routeHasIdentificationMiddleware in the route MW detection test * Hardcode tenant subdomain * Delete redundant event listening code * Delete unused imports * Delete misuse of `tenancy()->getMiddlewareContext()` from conditions * Delete unused variable * Update comment * Correct request data identification test (defaulting) * Fix defaulting in path id test * Move default route context configuration in domian id test * Rename and update the tenant parameter test * Delete extra tenant parameter test * Use `tenant-domain.test` instead of `127.0.0.2` * Add `default_to_universal_routes` config key * Deal with defaulting to universal routes in the reregistering action * Update logic to make defaulting to universal routes possible * Test defaulting to universal routes * Fix code style (php-cs-fixer) * Delete extra tests * Delete "without access prevention" from datasets * Add defaulting to universal routes to datasets * Override universal flag by central/tenant flag * Add universal flag overriding test * Update "a route can be universal in both route modes" so that the name corresponds with the tested thing * Ignore the PHPStan error * Reset `InitializeTenancyByPath::$onFail` in PathIdentificationTest * Simplify expression * Use 'Tenancy (not) initialized.' in instead of `tenant()?->getTenantKey()` for better assertions * Properly test removing tenant parameter * Reset static properties in tests * Correct comments in EarlyIdentificationTest * Add comment * Add detail to annotation * Throw exception if payload isn't string or null in request data ID MW * Fix code style (php-cs-fixer) * Delete static `$kernelIdentificationSkipped` property, use `$request->attributes` instead * Use 'default_route_mode' instead of 'default_to_tenant/universal_routes' * Fix code style (php-cs-fixer) * Make path identification MW, tenantParameterName and tenantRouteNamePrefix configurable in ReregisterUniversalRoutes * Delete unused import * Add `$passTenantParameterToRoute` to TenancyUrlGenerator * Use `$passTenantParameterToRoute` in BootstrapperTest * Bypass tenant parameter passing * Improve TenancyUrlGenerator so that both ID methods work * Fix code style (php-cs-fixer) * Improve TenancyUrlGenerator readability * Add modifyBehavior() to TenancyUrlGenerator * Fix code style (php-cs-fixer) * Improve comment * Toggle route name prefixing in path/request data ID MW (route-level identification) * Fix code style (php-cs-fixer) * Add path identification MW config key, add `getTenantParameterName()` to ForgetTenantParameter * Fix code style (php-cs-fixer) * Fix modifyBehavior and routeBehaviorModificationBypassed * Add type to `$parameters` parameter * Split modifyBehavior into two methods, don't pass name and parameters by reference * Update UrlBindingBootstrapper annotation * Correct naming in tests (request data -> query string identification) * Add info to annotation * Pass arrays to the behavior modification methods instead of `mixed` * Fix default value of static property in Fortify bootstrapper * Fix code style (php-cs-fixer) * Correct annotation * Enable prefixing routes directly using path identification MW * Test re-registration of routes with path ID MW * Prefix names of routes directly using path ID MW * Fix code style (php-cs-fixer) * Add Livewire v3 integration example to TSP stub * Prefix route name only if it's not prefixed already * Rename ReregisterUniversalRoutes to ReregisterRoutesAsTenant * Fix code style (php-cs-fixer) * Improve ReregisterRoutesAsTenant * Add/update TenancyUrlGenerator docblocks * Update action name in comments/test names * Update reregister action annotation * Delete unused imports * Improve comments * Make method protected * Improve TenancyUrlGenerator code * Test bypass parameter removal * Fix comment * Update annotation * Improve shouldReregisterRoute * Fix typo, delete redundant comment * Improve skipRoute * Improve shouldBeSkipped * Add and test `$passTenantParameterToRoutes` * add a comment * Fix typo in comment * Pass array as $parameters in prepareRouteInputs * Make path_identification_middleware an array * Fix code style (php-cs-fixer) * Fix ReregisterRouteAsTenant * Move tenantParameterName and tenantRouteNamePrefix getting to PathIdentificationManager * Make PathIdentificationManager properties `Closure|null` * Fix code style (php-cs-fixer) * Fix PathIdentificationManager * Update comments * Use foreach for dataset definition * Extract repetitive inGlobalStack and routeHasMiddleware calls * Refactor PathIdentificationManager * Update TenancyUrlGenerator annotation * Add $skippedRoutes, refactor ReregisterRoutesAsTenant * Improve reregisterRoute * Update re-register action annotation * update test name * Make PathIdentificationManager methods static again, update comments * Add test comment * Update ForgetTenantParameter annotation * Improve route re-registration condition, add comment * Change "re-register" to "clone" * minor code improvements --------- Co-authored-by: lukinovec <lukinovec@gmail.com> Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com> Co-authored-by: PHP CS Fixer <phpcsfixer@example.com>
2025-12-13 21:04:03 +00:00 · 2023-08-03 03:23:26 +05:00 · 2023-08-03 03:23:26 +05:00 · 1d0ca27bc8
commit 1d0ca27bc8
parent bd9bbe8b41
53 changed files with 2668 additions and 271 deletions
--- a/src/Actions/CloneRoutesAsTenant.php
+++ b/src/Actions/CloneRoutesAsTenant.php
@ -0,0 +1,171 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Actions;
+
+use Closure;
+use Illuminate\Config\Repository;
+use Illuminate\Routing\Route;
+use Illuminate\Routing\Router;
+use Illuminate\Support\Collection;
+use Stancl\Tenancy\PathIdentificationManager;
+use Stancl\Tenancy\RouteMode;
+
+/**
+ * The CloneRoutesAsTenant action clones
+ * routes flagged with the 'universal' middleware,
+ * all routes without a flag if the default route mode is universal,
+ * and routes that directly use the InitializeTenancyByPath middleware.
+ *
+ * The main purpose of this action is to make the integration
+ * of packages (e.g., Jetstream or Livewire) easier with path-based tenant identification.
+ *
+ * By default, universal routes are cloned as tenant routes (= they get flagged with the 'tenant' middleware)
+ * and prefixed with the '/{tenant}' path prefix. Their name also gets prefixed with the tenant name prefix.
+ *
+ * Routes with the path identification middleware get cloned similarly, but only if they're not universal at the same time.
+ * Unlike universal routes, these routes don't get the tenant flag,
+ * because they don't need it (they're not universal, and they have the identification MW, so they're already considered tenant).
+ *
+ * You can use the `cloneUsing()` hook to customize the route definitions,
+ * and the `skipRoute()` method to skip cloning of specific routes.
+ * You can also use the $tenantParameterName and $tenantRouteNamePrefix
+ * static properties to customize the tenant parameter name or the route name prefix.
+ *
+ * Note that routes already containing the tenant parameter or prefix won't be cloned.
+ */
+class CloneRoutesAsTenant
+{
+    protected array $cloneRouteUsing = [];
+    protected array $skippedRoutes = [];
+
+    public function __construct(
+        protected Router $router,
+        protected Repository $config,
+    ) {
+    }
+
+    public function handle(): void
+    {
+        $tenantParameterName = PathIdentificationManager::getTenantParameterName();
+        $routePrefix = '/{' . $tenantParameterName . '}';
+
+        /** @var Collection<Route> $routesToClone Only clone non-skipped routes without the tenant parameter. */
+        $routesToClone = collect($this->router->getRoutes()->get())->filter(function (Route $route) use ($tenantParameterName) {
+            return ! (in_array($tenantParameterName, $route->parameterNames()) || in_array($route->getName(), $this->skippedRoutes));
+        });
+
+        if ($this->config->get('tenancy.default_route_mode') !== RouteMode::UNIVERSAL) {
+            // Only clone routes with route-level path identification and universal routes
+            $routesToClone = $routesToClone->where(function (Route $route) {
+                $routeIsUniversal = tenancy()->routeHasMiddleware($route, 'universal');
+
+                return PathIdentificationManager::pathIdentificationOnRoute($route) || $routeIsUniversal;
+            });
+        }
+
+        $this->router->prefix($routePrefix)->group(fn () => $routesToClone->each(fn (Route $route) => $this->cloneRoute($route)));
+    }
+
+    /**
+     * Make the action clone a specific route using the provided callback instead of the default one.
+     */
+    public function cloneUsing(string $routeName, Closure $callback): static
+    {
+        $this->cloneRouteUsing[$routeName] = $callback;
+
+        return $this;
+    }
+
+    /**
+     * Skip a route's cloning.
+     */
+    public function skipRoute(string $routeName): static
+    {
+        $this->skippedRoutes[] = $routeName;
+
+        return $this;
+    }
+
+    /**
+     * Clone a route using a callback specified in the $cloneRouteUsing property (using the cloneUsing method).
+     * If there's no callback specified for the route, use the default way of cloning routes.
+     */
+    protected function cloneRoute(Route $route): void
+    {
+        $routeName = $route->getName();
+
+        // If the route's cloning callback exists
+        // Use the callback to clone the route instead of the default way of cloning routes
+        if ($routeName && $customRouteCallback = data_get($this->cloneRouteUsing, $routeName)) {
+            $customRouteCallback($route);
+
+            return;
+        }
+
+        $routesAreUniversalByDefault = $this->config->get('tenancy.default_route_mode') === RouteMode::UNIVERSAL;
+        $routeHasIdentificationMiddleware = tenancy()->routeHasIdentificationMiddleware($route);
+        $routeHasPathIdentification = PathIdentificationManager::pathIdentificationOnRoute($route);
+        $pathIdentificationMiddlewareInGlobalStack = PathIdentificationManager::pathIdentificationInGlobalStack();
+
+        // Determine if the passed route should get cloned
+        // The route should be cloned if it has path identification middleware
+        // Or if the route doesn't have identification middleware and path identification middleware
+        // Is not used globally or the routes are universal by default
+        $shouldCloneRoute = $routeHasPathIdentification ||
+            (! $routeHasIdentificationMiddleware && ($routesAreUniversalByDefault || $pathIdentificationMiddlewareInGlobalStack));
+
+        if ($shouldCloneRoute) {
+            $newRoute = $this->createNewRoute($route);
+            $routeIsUniversal = tenancy()->routeHasMiddleware($newRoute, 'universal');
+
+            // Add the 'tenant' flag to the new route if the route is universal
+            // Or if it isn't universal and it doesn't have the identification middlware (= it isn't "flagged" as tenant by having the MW)
+            if ((! $routeHasPathIdentification && ! $routeIsUniversal) || $routeIsUniversal || $routesAreUniversalByDefault) {
+                $newRoute->middleware('tenant');
+            }
+
+            $this->copyMiscRouteProperties($route, $newRoute);
+        }
+    }
+
+    protected function createNewRoute(Route $route): Route
+    {
+        $method = strtolower($route->methods()[0]);
+        $routeName = $route->getName();
+        $tenantRouteNamePrefix = PathIdentificationManager::getTenantRouteNamePrefix();
+
+        /** @var Route $newRoute */
+        $newRoute = $this->router->$method($route->uri(), $route->action);
+
+        // Delete middleware from the new route and
+        // Add original route middleware to ensure there's no duplicate middleware
+        unset($newRoute->action['middleware']);
+
+        $newRoute->middleware(tenancy()->getRouteMiddleware($route));
+
+        if ($routeName && ! $route->named($tenantRouteNamePrefix . '*')) {
+            // Clear the route name so that `name()` sets the route name instead of suffixing it
+            unset($newRoute->action['as']);
+
+            $newRoute->name($tenantRouteNamePrefix . $routeName);
+        }
+
+        return $newRoute;
+    }
+
+    /**
+     * Copy misc properties of the original route to the new route.
+     */
+    protected function copyMiscRouteProperties(Route $originalRoute, Route $newRoute): void
+    {
+        $newRoute
+            ->setBindingFields($originalRoute->bindingFields())
+            ->setFallback($originalRoute->isFallback)
+            ->setWheres($originalRoute->wheres)
+            ->block($originalRoute->locksFor(), $originalRoute->waitsFor())
+            ->withTrashed($originalRoute->allowsTrashedBindings())
+            ->setDefaults($originalRoute->defaults);
+    }
+}
--- a/src/Actions/CreateStorageSymlinksAction.php
+++ b/src/Actions/CreateStorageSymlinksAction.php
@ -16,19 +16,19 @@ class CreateStorageSymlinksAction
 {
    use DealsWithTenantSymlinks;

-    public static function handle(Tenant|Collection|LazyCollection $tenants, bool $relativeLink = false, bool $force = false): void
+    public function __invoke(Tenant|Collection|LazyCollection $tenants, bool $relativeLink = false, bool $force = false): void
    {
        $tenants = $tenants instanceof Tenant ? collect([$tenants]) : $tenants;

        /** @var Tenant $tenant */
        foreach ($tenants as $tenant) {
-            foreach (static::possibleTenantSymlinks($tenant) as $publicPath => $storagePath) {
-                static::createLink($publicPath, $storagePath, $tenant, $relativeLink, $force);
+            foreach ($this->possibleTenantSymlinks($tenant) as $publicPath => $storagePath) {
+                $this->createLink($publicPath, $storagePath, $tenant, $relativeLink, $force);
            }
        }
    }

-    protected static function createLink(string $publicPath, string $storagePath, Tenant $tenant, bool $relativeLink, bool $force): void
+    protected function createLink(string $publicPath, string $storagePath, Tenant $tenant, bool $relativeLink, bool $force): void
    {
        event(new CreatingStorageSymlink($tenant));

--- a/src/Actions/RemoveStorageSymlinksAction.php
+++ b/src/Actions/RemoveStorageSymlinksAction.php
@ -15,21 +15,21 @@ class RemoveStorageSymlinksAction
 {
    use DealsWithTenantSymlinks;

-    public static function handle(Tenant|Collection|LazyCollection $tenants): void
+    public function __invoke(Tenant|Collection|LazyCollection $tenants): void
    {
        $tenants = $tenants instanceof Tenant ? collect([$tenants]) : $tenants;

        /** @var Tenant $tenant */
        foreach ($tenants as $tenant) {
-            foreach (static::possibleTenantSymlinks($tenant) as $publicPath => $storagePath) {
-                static::removeLink($publicPath, $tenant);
+            foreach ($this->possibleTenantSymlinks($tenant) as $publicPath => $storagePath) {
+                $this->removeLink($publicPath, $tenant);
            }
        }
    }

-    protected static function removeLink(string $publicPath, Tenant $tenant): void
+    protected function removeLink(string $publicPath, Tenant $tenant): void
    {
-        if (static::symlinkExists($publicPath)) {
+        if ($this->symlinkExists($publicPath)) {
            event(new RemovingStorageSymlink($tenant));

            app()->make('files')->delete($publicPath);