FEATURE: Command to delete stale workspaces

Neos.ContentRepository.Core/Classes/SharedModel/Workspace/WorkspaceNames.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Neos\ContentRepository\Core\SharedModel\Workspace;
+
+/**
+ * @implements \IteratorAggregate<int,WorkspaceName>
+ * @api
+ */
+final readonly class WorkspaceNames implements \IteratorAggregate, \Countable
+{
+    /** @param array<string,WorkspaceName> $items */
+    private function __construct(
+        private array $items
+    ) {
+    }
+
+    public static function create(
+        WorkspaceName ...$items
+    ): self {
+        $indexed = [];
+        foreach ($items as $item) {
+            $indexed[$item->value] = $item;
+        }
+        return new self(
+            $indexed
+        );
+    }
+
+    public static function fromWorkspaces(Workspaces $workspaces): self
+    {
+        return WorkspaceNames::create(...$workspaces->map(fn (Workspace $workspace) => $workspace->workspaceName));
+    }
+
+    public function contain(WorkspaceName $workspaceName): bool
+    {
+        return array_key_exists($workspaceName->value, $this->items);
+    }
+
+    /** @return list<string> */
+    public function toStringArray(): array
+    {
+        return array_keys($this->items);
+    }
+
+    public function getIterator(): \Traversable
+    {
+        yield from array_values($this->items);
+    }
+
+    public function count(): int
+    {
+        return count($this->items);
+    }
+}

Neos.ContentRepository.Core/Tests/Unit/SharedModel/Workspace/WorkspaceNamesTest.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Neos\ContentRepository\Core\Tests\Unit\SharedModel\Workspace;
+
+use Neos\ContentRepository\Core\SharedModel\Workspace\ContentStreamId;
+use Neos\ContentRepository\Core\SharedModel\Workspace\Workspace;
+use Neos\ContentRepository\Core\SharedModel\Workspace\WorkspaceName;
+use Neos\ContentRepository\Core\SharedModel\Workspace\WorkspaceNames;
+use Neos\ContentRepository\Core\SharedModel\Workspace\Workspaces;
+use Neos\ContentRepository\Core\SharedModel\Workspace\WorkspaceStatus;
+use PHPUnit\Framework\TestCase;
+
+class WorkspaceNamesTest extends TestCase
+{
+    /**
+     * @test
+     */
+    public function contain()
+    {
+        $workspaceNames = WorkspaceNames::create(
+            $nameInstance = WorkspaceName::fromString('foo'),
+            WorkspaceName::fromString('bar'),
+        );
+
+        self::assertTrue($workspaceNames->contain($nameInstance));
+        self::assertTrue($workspaceNames->contain(WorkspaceName::fromString('foo')));
+        self::assertFalse($workspaceNames->contain(WorkspaceName::fromString('not-included')));
+    }
+
+    /**
+     * @test
+     */
+    public function fromWorkspaces()
+    {
+        $workspaces = Workspaces::fromArray([
+            self::workspace('root', null),
+            self::workspace('regular', 'root'),
+            self::workspace('other-root', null),
+        ]);
+
+        self::assertEquals(
+            WorkspaceNames::create(
+                WorkspaceName::fromString('root'),
+                WorkspaceName::fromString('regular'),
+                WorkspaceName::fromString('other-root'),
+            ),
+            WorkspaceNames::fromWorkspaces($workspaces)
+        );
+    }
+
+    private static function workspace(string $name): Workspace
+    {
+        return Workspace::create(
+            WorkspaceName::fromString($name),
+            null,
+            ContentStreamId::create(),
+            WorkspaceStatus::UP_TO_DATE,
+            false
+        );
+    }
+}

Neos.ContentRepository.TestSuite/Classes/Behavior/Features/Bootstrap/CRTestSuiteTrait.php

@@ -136,16 +136,24 @@ public function iExpectTheFollowingWorkspaces(TableNode $payloadTable): void
     {
         $actualComparableHash = [];
         $workspaces = $this->currentContentRepository->findWorkspaces();
+
+        // if not specified, ignore
+        $compareContentStream = in_array('content stream', $payloadTable->getRow(0), true);
+
         foreach ($workspaces as $workspace) {
             $actualComparableHash[] = array_map(json_encode(...), [
                 'name' => $workspace->workspaceName,
                 'base workspace' => $workspace->baseWorkspaceName,
                 'status' => $workspace->status,
-                'content stream' => $workspace->currentContentStreamId,
-                'publishable changes' => $workspace->hasPublishableChanges()
+                ...($compareContentStream ? ['content stream' => $workspace->currentContentStreamId] : []),
+                ...['publishable changes' => $workspace->hasPublishableChanges()]
             ]);
         }
-        Assert::assertSame($payloadTable->getHash(), $actualComparableHash);
+        // ensure the check result does not depend on the workspace ordering
+        $expected = $payloadTable->getHash();
+        usort($expected, fn($a, $b) => $a['name'] <=> $b['name']);
+        usort($actualComparableHash, fn($a, $b) => $a['name'] <=> $b['name']);
+        Assert::assertSame($expected, $actualComparableHash);
     }
 
     /**

Neos.Neos/Classes/Command/WorkspaceCommandController.php

@@ -15,6 +15,7 @@
 namespace Neos\Neos\Command;
 
 use Neos\ContentRepository\Core\Feature\WorkspaceCreation\Exception\WorkspaceAlreadyExists;
+use Neos\ContentRepository\Core\Feature\WorkspaceModification\Command\DeleteWorkspace;
 use Neos\ContentRepository\Core\Feature\WorkspaceRebase\Dto\RebaseErrorHandlingStrategy;
 use Neos\ContentRepository\Core\Feature\WorkspaceRebase\Exception\WorkspaceRebaseFailed;
 use Neos\ContentRepository\Core\Service\WorkspaceMaintenanceServiceFactory;
@@ -26,6 +27,7 @@
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Cli\CommandController;
 use Neos\Flow\Cli\Exception\StopCommandException;
+use Neos\Flow\Utility\Now;
 use Neos\Neos\Domain\Model\WorkspaceClassification;
 use Neos\Neos\Domain\Model\WorkspaceDescription;
 use Neos\Neos\Domain\Model\WorkspaceRole;
@@ -56,6 +58,9 @@ class WorkspaceCommandController extends CommandController
     #[Flow\Inject]
     protected WorkspaceService $workspaceService;
 
+    #[Flow\Inject]
+    protected Now $now;
+
     /**
      * Publish changes of a workspace
      *
@@ -524,6 +529,38 @@ public function showCommand(string $workspace, string $contentRepository = 'defa
         ]);
     }
 
+    /**
+     * Removes all stale personal workspaces.
+     *
+     * A personal workspace is considered stale if it has no pending changes, no other workspace uses it as a base
+     * workspace and the owner of the workspace did not log in for the time specified.
+     *
+     * @param string $contentRepository The name of the content repository. (Default: 'default')
+     * @param string $dateInterval The time interval a user had to be inactive for its workspaces to be considered stale. (Default: '7 days')
+     */
+    public function removeStaleCommand(string $contentRepository = 'default', string $dateInterval = '7 days'): void
+    {
+        $contentRepositoryId = ContentRepositoryId::fromString($contentRepository);
+        $contentRepositoryInstance = $this->contentRepositoryRegistry->get($contentRepositoryId);
+
+        $interval = \DateInterval::createFromDateString($dateInterval);
+        if ($interval === false) {
+            $this->outputLine('Unable to parse date interval "%s".', [$dateInterval]);
+            $this->quit();
+        }
+
+        $ownerUserNotLoggedInAfter = $this->now->sub($interval);
+        if ($this->now <= $ownerUserNotLoggedInAfter) {
+            $this->outputLine('Date interval must not be negative or zero "%s".', [$dateInterval]);
+            $this->quit();
+        }
+
+        $staleWorkspaceNames = $this->workspaceService->getStalePersonalWorkspaceNames($contentRepositoryId, $ownerUserNotLoggedInAfter);
+        $this->outputLine('Found %d stale workspaces for users not logged in after %s.', [count($staleWorkspaceNames), $ownerUserNotLoggedInAfter->format('Y-m-d')]);
+
+        $this->workspaceService->deleteStalePersonalWorkspaces($contentRepositoryId, $staleWorkspaceNames);
+    }
+
     // -----------------------
 
     private function buildWorkspaceRoleSubject(WorkspaceRoleSubjectType $subjectType, string $usernameOrRoleIdentifier): WorkspaceRoleSubject

Neos.Neos/Classes/Domain/Model/UserIds.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Neos\Neos\Domain\Model;
+
+/**
+ * @implements \IteratorAggregate<int,UserId>
+ */
+final readonly class UserIds implements \IteratorAggregate
+{
+    /** @param array<string,UserId> $items */
+    private function __construct(
+        private array $items
+    ) {
+    }
+
+    public static function create(
+        UserId ...$items
+    ): self {
+        $indexed = [];
+        foreach ($items as $item) {
+            $indexed[$item->value] = $item;
+        }
+        return new self(
+            $indexed
+        );
+    }
+
+    public function contain(UserId $userId): bool
+    {
+        return array_key_exists($userId->value, $this->items);
+    }
+
+    /** @return list<string> */
+    public function toStringArray(): array
+    {
+        return array_keys($this->items);
+    }
+
+    public function getIterator(): \Traversable
+    {
+        yield from array_values($this->items);
+    }
+}

Neos.Neos/Classes/Domain/Repository/WorkspaceMetadataAndRoleRepository.php

@@ -385,6 +385,30 @@ classification = :personalWorkspaceClassification
         }
     }
 
+    /**
+     * @return \Traversable<UserId,WorkspaceName>
+     */
+    public function findAllPersonalWorkspaceNamesByContentRepositoryId(ContentRepositoryId $contentRepositoryId): \Traversable
+    {
+        $tableMetadata = self::TABLE_NAME_WORKSPACE_METADATA;
+        $query = <<<SQL
+            SELECT
+                owner_user_id, content_repository_id, workspace_name
+            FROM
+                {$tableMetadata}
+            WHERE
+                classification = :personalWorkspaceClassification
+                AND content_repository_id = :contentRepositoryId
+        SQL;
+        $rows = $this->dbal->fetchAllAssociative($query, [
+            'personalWorkspaceClassification' => WorkspaceClassification::PERSONAL->value,
+            'contentRepositoryId' => $contentRepositoryId->value,
+        ]);
+        foreach ($rows as $row) {
+            yield UserId::fromString($row['owner_user_id']) => WorkspaceName::fromString($row['workspace_name']);
+        }
+    }
+
     /**
      * @param \Closure(): void $fn
      * @return void

Neos.Neos/Classes/Domain/Service/UserService.php

@@ -39,6 +39,7 @@
 use Neos\Neos\Domain\Exception;
 use Neos\Neos\Domain\Model\User;
 use Neos\Neos\Domain\Model\UserId;
+use Neos\Neos\Domain\Model\UserIds;
 use Neos\Neos\Domain\Repository\UserRepository;
 use Neos\Neos\Domain\Repository\WorkspaceMetadataAndRoleRepository;
 use Neos\Party\Domain\Model\AbstractParty;
@@ -775,6 +776,28 @@ public function getAllRoles(User $user): array
         return $roles;
     }
 
+    public function findUserIdsNotLoggedInAfter(\DateTimeInterface $dateTime): UserIds
+    {
+        $userIds = [];
+        /** @var User $user */
+        foreach ($this->getUsers() as $user) {
+            $accounts = $user->getAccounts();
+            $loggedIn = false;
+            foreach ($accounts as $account) {
+                $lastSuccessfulAuthenticationDate = $account->getLastSuccessfulAuthenticationDate();
+                if ($lastSuccessfulAuthenticationDate != null && $lastSuccessfulAuthenticationDate > $dateTime) {
+                    $loggedIn = true;
+                    break;
+                }
+            }
+
+            if (!$loggedIn) {
+                $userIds[] = $user->getId();
+            }
+        }
+        return UserIds::create(...$userIds);
+    }
+
     /**
      * @param User $user
      * @param bool $keepCurrentSession