Create Neo4j uniqueness constraints during graph rebuild (#1083)

JeroenDeDauw · claude · web-flow · commit a365910ed25c · 2026-07-19T20:57:57.000+02:00
* Create Neo4j uniqueness constraints during graph rebuild Fixes #874 Neo4jConstraintUpdater::createDefaultConstraints() could create the Page (wiki_id, id) and Subject.id uniqueness constraints but was only ever called from tests, so a real install ran Neo4j without them: duplicate-id nodes were possible and id lookups were unindexed. Wire constraint creation into RebuildGraphDatabases.php -- the production path that (re)builds the graph from the MediaWiki source of truth -- via a new NeoWikiExtension::createGraphDatabaseConstraints() that no-ops when no Neo4j backend is configured (e.g. a SPARQL-only install) and is idempotent (CREATE CONSTRAINT ... IF NOT EXISTS). Creating the constraints before re-projecting means a rebuilt graph always carries them, and an unchanged re-save still succeeds because the projection MERGEs nodes by id. The graph-model.md claim that the constraints are "not created automatically yet" is corrected. The rebuild is the simplest reliable point: it is already the canonical way to establish the graph, it runs with every backend resolved, and its idempotency makes repeated runs safe. A LoadExtensionSchemaUpdates hook was considered but rejected -- NeoWiki registers no SQL schema updater today, and coupling external-Neo4j reachability to update.php is fragile. Relation (edge) ID uniqueness (#351) is not implemented here. Neo4j relationship uniqueness constraints are per relationship type (on this stack, Neo4j 2026.05.0 Enterprise, a type-less "FOR ()-[r]->() REQUIRE r.id IS UNIQUE" is a syntax error), and Relations use an open, user-defined set of relationship types, so no single constraint can enforce global Relation-id uniqueness. A hard pre-save rejection would need a graph read in the deliberately graph-free validation path, which is out of scope here; analysis is posted on issue #351. Tests: - RebuildGraphDatabasesTest::testRebuildCreatesGraphUniquenessConstraints -- after the rebuild runs, SHOW CONSTRAINTS reports both node constraints; a subject page is seeded so the rebuild re-projects real data under the freshly-created constraints. - RebuildGraphDatabasesTest::testEnsuringConstraintsIsSkippedWhenNeo4jIsNotConfigured -- the guard keeps the rebuild safe on a wiki with no Neo4j backend. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * Correct graph-model.md constraint-creation claim The Constraints section implied the uniqueness constraints are always present and that the rebuild is the path that builds the graph. They are in fact created only by running RebuildGraphDatabases.php; the incremental projection on page edits does not create them, so an existing graph gains them only after a rebuild. State this honestly. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * Trim RebuildGraphDatabasesTest to the constraint-wiring fact The test re-asserted Neo4jConstraintUpdaterTest's full constraint shape byte-for-byte, so a constraint-shape change would break two tests. Assert only that the rebuild created both named constraints (the name embeds the properties); their shape and enforcement stay owned by Neo4jConstraintUpdaterTest. Also soften the comment (a single subject cannot collide, so the test does not prove non-violation) and add the missing @Covers for the extension method the rebuild exercises. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * Route graph store initialization through the GraphDatabasePlugin system Constraint creation on rebuild ran through a Neo4j-specific NeoWikiExtension::createGraphDatabaseConstraints() facade method that null-checked the Neo4j plugin and built a Neo4jConstraintUpdater itself. That special-cased one backend on the facade, outside the GraphDatabasePlugin seam every other rebuild step already goes through. Add initialize() to the GraphDatabasePlugin interface: a store prepares its backing store for projection there. Neo4jProjectionStore creates its uniqueness constraints (via a Neo4jConstraintUpdater the Neo4j composition root injects from the write engine it already owns); SparqlProjectionStore is a no-op (no store-level structures to create). RebuildGraphDatabases now calls getGraphDatabasePlugin()->initialize() -- the propagating composite over every configured backend -- before re-projecting, so each backend initializes through the same seam it uses for savePage/deletePage, and a no-backend install is just an empty fan-out. initialize() propagates on the rebuild path like savePage/deletePage; FailureIsolatingGraphDatabasePlugin (hook path only, which never initializes) passes it straight through. The facade method and its Neo4jConstraintUpdater import are removed. Behavior is unchanged: the rebuild creates the same two Neo4j constraints, idempotently, and the incremental per-edit path still does not. extending.md documents the new interface method for extension authors; graph-model.md is unaffected. Tests: - testRebuildCreatesGraphUniquenessConstraints stays as the end-to-end proof the rebuild creates both Neo4j constraints, now through the plugin system (verified failing when Neo4jProjectionStore::initialize is stubbed to a no-op). - testEnsuringConstraintsIsSkippedWhenNeo4jIsNotConfigured becomes testInitializingGraphDatabasesDoesNotThrowWithoutABackend: with no backend configured, the rebuild's initialization step (the composite resolved via the facade) is a no-op. - CompositeGraphDatabasePlugin and FailureIsolatingGraphDatabasePlugin gain initialize() fan-out / delegation and failure-propagation coverage. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
diff --git a/docs/api/graph-model.md b/docs/api/graph-model.md
@@ -107,9 +107,16 @@ When a Subject is deleted but still has incoming relations from other Subjects,
 
 ## Constraints
 
-Two uniqueness constraints are intended for the graph — the `(wiki_id, id)` pair is unique on `:Page` nodes
-([ADR 22](../adr/022-multi-wiki-node-identity.md)), and `Subject.id` is unique. These are **not** created
-automatically yet ([#874](https://github.com/ProfessionalWiki/NeoWiki/issues/874)).
+Two node uniqueness constraints are defined for the graph: the `(wiki_id, id)` pair is unique on `:Page` nodes
+([ADR 22](../adr/022-multi-wiki-node-identity.md)), and `Subject.id` is unique. They are created by running the
+`RebuildGraphDatabases.php` maintenance script, and creation is idempotent (`CREATE CONSTRAINT ... IF NOT EXISTS`),
+so re-running it is safe. The incremental projection that runs on each page edit does not create them, so an
+existing graph gains them only after the rebuild has been run.
+
+Relation (edge) `id` values are not constrained at the graph level: Neo4j relationship uniqueness constraints
+are per relationship type, and Relations use an open, user-defined set of relationship types, so no single
+constraint can enforce global Relation-`id` uniqueness (see
+[#351](https://github.com/ProfessionalWiki/NeoWiki/issues/351)).
 
 ## Related Documentation
 
diff --git a/docs/extending/extending.md b/docs/extending/extending.md
@@ -151,6 +151,10 @@ NeoWiki currently supports Neo4j only, but the graph projection is an extension
 ```php
 class MyGraphDatabasePlugin implements GraphDatabasePlugin {
 
+	public function initialize(): void {
+		// Create any store-level structures your backend needs (e.g. constraints or indexes).
+	}
+
 	public function savePage( Page $page ): void {
 		// Project the page and its subjects into your store.
 	}
@@ -168,6 +172,10 @@ Register with `NeoWikiRegistrar::addGraphDatabasePlugin()`. Example:
 `savePage` hands you the page with all of its Subjects and runs for every revision, so subject edits, undeletions
 and page moves all reach you as a save. `deletePage` gets only the page id.
 
+`initialize` runs once at the start of a `RebuildGraphDatabases` run, before any page is projected — create the
+store-level structures a fresh store needs there (this is how NeoWiki's own Neo4j backend creates its uniqueness
+constraints). Make it idempotent, since every rebuild calls it; it never runs on an individual edit.
+
 **Signal failure by throwing.** On an edit, delete or undelete, NeoWiki logs the failure and lets the user's
 operation commit, so a backend being down never blocks the wiki or starves the other backends — your projection is
 simply out of sync until someone runs `RebuildGraphDatabases`. During that rebuild, failures propagate instead, so
diff --git a/maintenance/RebuildGraphDatabases.php b/maintenance/RebuildGraphDatabases.php
@@ -33,6 +33,8 @@ public function __construct() {
 	}
 
 	public function execute(): void {
+		$this->initializeGraphDatabases();
+
 		$pageIds = $this->getSubjectPageIds();
 
 		$this->outputChanneled( 'Rebuilding graph databases for ' . count( $pageIds ) . ' subject pages...' );
@@ -52,6 +54,17 @@ public function execute(): void {
 		$this->removeDeletedPages();
 	}
 
+	/**
+	 * Initializing the backends before re-projecting guarantees a rebuilt graph carries any store-level
+	 * structures they need (e.g. uniqueness constraints). The rebuild is the production path that
+	 * (re)establishes the graph from the MediaWiki source of truth, so it is the natural, idempotent
+	 * point to ensure those structures exist (#874).
+	 */
+	private function initializeGraphDatabases(): void {
+		$this->outputChanneled( 'Initializing graph databases...' );
+		NeoWikiExtension::getInstance()->getGraphDatabasePlugin()->initialize();
+	}
+
 	/**
 	 * Re-saving the pages that still exist cannot undo a projection delete that failed, so a page deleted
 	 * while a backend was unreachable would otherwise stay in the graph for good, its Subjects still
diff --git a/src/Domain/GraphDatabase/CompositeGraphDatabasePlugin.php b/src/Domain/GraphDatabase/CompositeGraphDatabasePlugin.php
@@ -27,6 +27,12 @@ public function __construct( GraphDatabasePlugin ...$plugins ) {
 		$this->plugins = $plugins;
 	}
 
+	public function initialize(): void {
+		foreach ( $this->plugins as $plugin ) {
+			$plugin->initialize();
+		}
+	}
+
 	public function savePage( Page $page ): void {
 		foreach ( $this->plugins as $plugin ) {
 			$plugin->savePage( $page );
diff --git a/src/Domain/GraphDatabase/FailureIsolatingGraphDatabasePlugin.php b/src/Domain/GraphDatabase/FailureIsolatingGraphDatabasePlugin.php
@@ -42,6 +42,15 @@ public function __construct(
 	) {
 	}
 
+	/**
+	 * Passed straight through without isolation: this decorator wraps plugins only on the hook-facing
+	 * write path, and that path never initializes — initialize() runs solely on the propagating
+	 * rebuild path (see GraphDatabasePlugin), where a failure must surface rather than be swallowed.
+	 */
+	public function initialize(): void {
+		$this->plugin->initialize();
+	}
+
 	public function savePage( Page $page ): void {
 		try {
 			$this->plugin->savePage( $page );
diff --git a/src/Domain/GraphDatabase/GraphDatabasePlugin.php b/src/Domain/GraphDatabase/GraphDatabasePlugin.php
@@ -17,10 +17,20 @@
  *   each plugin (via FailureIsolatingGraphDatabasePlugin), so a throw does not abort the triggering
  *   user operation and one failing backend does not starve the others.
  * - On maintenance rebuilds (RebuildGraphDatabases), the wiring propagates failures so they are
- *   reported truthfully per page instead of being silently swallowed.
+ *   reported truthfully per page instead of being silently swallowed. The rebuild is also the only
+ *   path that calls initialize(), so an initialize() failure propagates like any other rebuild
+ *   failure; the hook path never initializes.
  */
 interface GraphDatabasePlugin {
 
+	/**
+	 * Prepares the backing store for projections by creating the store-level structures the backend
+	 * needs — such as uniqueness constraints — where it supports them. Idempotent, so the rebuild can
+	 * run it every time. The RebuildGraphDatabases maintenance path calls this before bulk re-projection
+	 * so a rebuilt graph carries those structures; the incremental per-edit path does not.
+	 */
+	public function initialize(): void;
+
 	public function savePage( Page $page ): void;
 
 	public function deletePage( PageId $pageId ): void;
diff --git a/src/GraphDatabasePlugins/Neo4j/Neo4jPlugin.php b/src/GraphDatabasePlugins/Neo4j/Neo4jPlugin.php
@@ -15,6 +15,7 @@
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Application\Neo4jReadQueryEngine;
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\EntryPoints\ParserFunction\CypherRawParserFunction;
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jClientReadQueryEngine;
+use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jConstraintUpdater;
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jProjectionStore;
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jResultNormalizer;
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jSubjectUpdaterFactory;
@@ -42,6 +43,7 @@ public function __construct(
 		LoggerInterface $logger,
 		string $wikiId,
 	) {
+		$this->writeQueryEngine = new Neo4jWriteQueryEngine( $client );
 		$this->projectionStore = new Neo4jProjectionStore(
 			client: $client,
 			subjectUpdaterFactory: new Neo4jSubjectUpdaterFactory(
@@ -50,10 +52,11 @@ public function __construct(
 				logger: $logger,
 				wikiId: $wikiId,
 			),
+			// Reuse the write engine the plugin already owns so initialize() creates constraints through it.
+			constraintUpdater: new Neo4jConstraintUpdater( $this->writeQueryEngine ),
 			wikiId: $wikiId,
 		);
 		$this->readQueryEngine = new Neo4jClientReadQueryEngine( $readOnlyClient );
-		$this->writeQueryEngine = new Neo4jWriteQueryEngine( $client );
 		$this->readOnlyClient = $readOnlyClient;
 	}
 
diff --git a/src/GraphDatabasePlugins/Neo4j/Persistence/Neo4jProjectionStore.php b/src/GraphDatabasePlugins/Neo4j/Persistence/Neo4jProjectionStore.php
@@ -21,10 +21,15 @@
 	public function __construct(
 		private ClientInterface $client,
 		private Neo4jSubjectUpdaterFactory $subjectUpdaterFactory,
+		private Neo4jConstraintUpdater $constraintUpdater,
 		private string $wikiId,
 	) {
 	}
 
+	public function initialize(): void {
+		$this->constraintUpdater->createDefaultConstraints();
+	}
+
 	public function savePage( Page $page ): void {
 		$this->client->writeTransaction( function ( TransactionInterface $transaction ) use ( $page ): void {
 			$properties = $page->getProperties()->asArray();
diff --git a/src/GraphDatabasePlugins/Sparql/Persistence/SparqlProjectionStore.php b/src/GraphDatabasePlugins/Sparql/Persistence/SparqlProjectionStore.php
@@ -45,6 +45,11 @@ public function __construct(
 	) {
 	}
 
+	public function initialize(): void {
+		// Nothing to prepare: a SPARQL graph store has no store-level structures (e.g. uniqueness
+		// constraints) to create up front, unlike Neo4j.
+	}
+
 	public function savePage( Page $page ): void {
 		$projector = $this->resolveProjector();
 		$graph = $this->namespaces->graph( $this->projectionName, $page->getId() );
diff --git a/tests/RedHerb/src/RedHerbGraphDatabasePlugin.php b/tests/RedHerb/src/RedHerbGraphDatabasePlugin.php
@@ -21,6 +21,11 @@ class RedHerbGraphDatabasePlugin implements GraphDatabasePlugin {
 	/** @var PageId[] */
 	public array $deletedPageIds = [];
 
+	public function initialize(): void {
+		// A real backend would create its store-level structures (e.g. uniqueness constraints) here.
+		// This example store needs none, so initialization is a no-op.
+	}
+
 	public function savePage( Page $page ): void {
 		$this->savedPages[] = $page;
 	}
diff --git a/tests/phpunit/Domain/GraphDatabase/CompositeGraphDatabasePluginTest.php b/tests/phpunit/Domain/GraphDatabase/CompositeGraphDatabasePluginTest.php
@@ -22,12 +22,24 @@ class CompositeGraphDatabasePluginTest extends TestCase {
 	public function testEmptyCompositeDoesNotThrow(): void {
 		$composite = new CompositeGraphDatabasePlugin();
 
+		$composite->initialize();
 		$composite->savePage( TestPage::build() );
 		$composite->deletePage( new PageId( 1 ) );
 
 		$this->addToAssertionCount( 1 );
 	}
 
+	public function testInitializeDispatchesToAllPlugins(): void {
+		$spy1 = new SpyGraphDatabasePlugin();
+		$spy2 = new SpyGraphDatabasePlugin();
+		$composite = new CompositeGraphDatabasePlugin( $spy1, $spy2 );
+
+		$composite->initialize();
+
+		$this->assertSame( 1, $spy1->initializeCount );
+		$this->assertSame( 1, $spy2->initializeCount );
+	}
+
 	public function testSavePageDispatchesToAllPlugins(): void {
 		$spy1 = new SpyGraphDatabasePlugin();
 		$spy2 = new SpyGraphDatabasePlugin();
@@ -66,6 +78,14 @@ public function testSinglePluginReceivesAllCalls(): void {
 		$this->assertCount( 1, $spy->deletedPageIds );
 	}
 
+	public function testInitializePropagatesAPluginFailure(): void {
+		$composite = new CompositeGraphDatabasePlugin( new ThrowingGraphDatabasePlugin() );
+
+		$this->expectExceptionMessage( ThrowingGraphDatabasePlugin::FAILURE_MESSAGE );
+
+		$composite->initialize();
+	}
+
 	public function testSavePagePropagatesAPluginFailure(): void {
 		$composite = new CompositeGraphDatabasePlugin( new ThrowingGraphDatabasePlugin() );
 
diff --git a/tests/phpunit/Domain/GraphDatabase/FailureIsolatingGraphDatabasePluginTest.php b/tests/phpunit/Domain/GraphDatabase/FailureIsolatingGraphDatabasePluginTest.php
@@ -51,6 +51,14 @@ public function testDeletePageIsDelegatedToTheWrappedPlugin(): void {
 		$this->assertSame( [ $pageId ], $spy->deletedPageIds );
 	}
 
+	public function testInitializeIsDelegatedToTheWrappedPlugin(): void {
+		$spy = new SpyGraphDatabasePlugin();
+
+		$this->newDecorator( $spy )->initialize();
+
+		$this->assertSame( 1, $spy->initializeCount );
+	}
+
 	public function testSucceedingProjectionLogsNothing(): void {
 		$this->newDecorator( new SpyGraphDatabasePlugin() )->savePage( TestPage::build( id: 42 ) );
 
@@ -98,6 +106,19 @@ public function testDatabaseErrorIsReThrownRatherThanSwallowed(): void {
 		$decorator->deletePage( new PageId( 1 ) );
 	}
 
+	/**
+	 * initialize() runs only on the propagating rebuild path, never the isolated hook path, so this
+	 * decorator passes it straight through: a failure surfaces rather than being swallowed and logged
+	 * the way a save or delete failure is.
+	 */
+	public function testInitializeFailureIsNotSwallowed(): void {
+		$decorator = $this->newDecorator( new ThrowingGraphDatabasePlugin() );
+
+		$this->expectExceptionMessage( ThrowingGraphDatabasePlugin::FAILURE_MESSAGE );
+
+		$decorator->initialize();
+	}
+
 	private function pluginThrowing( Throwable $error ): GraphDatabasePlugin {
 		return new class( $error ) implements GraphDatabasePlugin {
 
@@ -106,6 +127,10 @@ public function __construct(
 			) {
 			}
 
+			public function initialize(): void {
+				throw $this->error;
+			}
+
 			public function savePage( Page $page ): void {
 				throw $this->error;
 			}
diff --git a/tests/phpunit/GraphDatabasePlugins/Neo4j/Persistence/Neo4jProjectionStoreTest.php b/tests/phpunit/GraphDatabasePlugins/Neo4j/Persistence/Neo4jProjectionStoreTest.php
@@ -18,8 +18,10 @@
 use ProfessionalWiki\NeoWiki\Domain\Subject\StatementList;
 use ProfessionalWiki\NeoWiki\Domain\Subject\SubjectMap;
 use ProfessionalWiki\NeoWiki\NeoWikiExtension;
+use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jConstraintUpdater;
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jProjectionStore;
 use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jSubjectUpdaterFactory;
+use ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jWriteQueryEngine;
 use Psr\Log\NullLogger;
 use ProfessionalWiki\NeoWiki\Tests\Data\TestPage;
 use ProfessionalWiki\NeoWiki\Tests\Data\TestRelation;
@@ -73,6 +75,7 @@ private function newProjectionStoreForWiki( string $wikiId ): GraphDatabasePlugi
 				logger: new NullLogger(),
 				wikiId: $wikiId,
 			),
+			constraintUpdater: new Neo4jConstraintUpdater( new Neo4jWriteQueryEngine( $extension->getNeo4jClient() ) ),
 			wikiId: $wikiId,
 		);
 	}
diff --git a/tests/phpunit/Maintenance/RebuildGraphDatabasesTest.php b/tests/phpunit/Maintenance/RebuildGraphDatabasesTest.php
@@ -56,6 +56,45 @@ public function testRebuildRemovesADeletedSubjectPageFromTheGraph(): void {
 		);
 	}
 
+	/**
+	 * @covers \ProfessionalWiki\NeoWiki\GraphDatabasePlugins\Neo4j\Persistence\Neo4jProjectionStore::initialize
+	 */
+	public function testRebuildCreatesGraphUniquenessConstraints(): void {
+		// setUpNeo4j() dropped any pre-existing constraints, so the graph starts without them. A subject
+		// page is present so the rebuild re-projects real data under the freshly created constraints. This
+		// is the end-to-end proof that the rebuild's initialization step (routed through the graph plugin
+		// system) reaches Neo4j: both constraints exist by name. Their shape and enforcement are covered by
+		// Neo4jConstraintUpdaterTest.
+		$this->createPageWithSubjects( 'Page with subject', TestSubject::build() );
+
+		$this->runRebuild();
+
+		$this->assertSame(
+			[
+				[ 'name' => 'Page wiki_id id' ],
+				[ 'name' => 'Subject id' ],
+			],
+			$this->readGraph( 'SHOW CONSTRAINTS YIELD name ORDER BY name' )->toRecursiveArray()
+		);
+	}
+
+	/**
+	 * The rebuild runs on wikis with no graph backend configured (e.g. a SPARQL-only install with no
+	 * store), so its initialization step must be a no-op there rather than throwing.
+	 *
+	 * @covers \ProfessionalWiki\NeoWiki\Domain\GraphDatabase\CompositeGraphDatabasePlugin::initialize
+	 */
+	public function testInitializingGraphDatabasesDoesNotThrowWithoutABackend(): void {
+		$this->runWithoutGraphBackend( function (): void {
+			$extension = NeoWikiExtension::getInstance();
+			$this->assertNull( $extension->getNeo4jPlugin(), 'precondition: no Neo4j backend is configured' );
+
+			// The rebuild's initialization step, resolved through the facade exactly as the script does.
+			// Must not throw despite there being no store to initialize.
+			$extension->getGraphDatabasePlugin()->initialize();
+		} );
+	}
+
 	private function runRebuild(): void {
 		ob_start();
 		try {
diff --git a/tests/phpunit/TestDoubles/SpyGraphDatabasePlugin.php b/tests/phpunit/TestDoubles/SpyGraphDatabasePlugin.php
@@ -10,12 +10,18 @@
 
 class SpyGraphDatabasePlugin implements GraphDatabasePlugin {
 
+	public int $initializeCount = 0;
+
 	/** @var Page[] */
 	public array $savedPages = [];
 
 	/** @var PageId[] */
 	public array $deletedPageIds = [];
 
+	public function initialize(): void {
+		$this->initializeCount++;
+	}
+
 	public function savePage( Page $page ): void {
 		$this->savedPages[] = $page;
 	}
diff --git a/tests/phpunit/TestDoubles/ThrowingGraphDatabasePlugin.php b/tests/phpunit/TestDoubles/ThrowingGraphDatabasePlugin.php
@@ -17,6 +17,10 @@ class ThrowingGraphDatabasePlugin implements GraphDatabasePlugin {
 
 	public const string FAILURE_MESSAGE = 'projection backend unreachable';
 
+	public function initialize(): void {
+		throw new RuntimeException( self::FAILURE_MESSAGE );
+	}
+
 	public function savePage( Page $page ): void {
 		throw new RuntimeException( self::FAILURE_MESSAGE );
 	}
