we need to register exporter builder components.

There was a hope that we would only need one (global) extension. It is clear now that we need two: one global, one for per-database things.
So here we simplify and document that state of affairs, so that it is clear for posterity what is going on and why things are safe.

Author: lassewesth

core-write/src/main/java/org/neo4j/gds/core/write/AbstractExportBuildersExtension.java

@@ -1,6 +1,13 @@
 # The OpenGDS extension to Neo4j
 
-Here lives the entrypoint for OpenGDS into Neo4j. We use the extension mechanism to register a [single injectable component](../facade/README.md) with Neo4j.
+Here live the entrypoints for OpenGDS into Neo4j. We use the extension mechanism to register an [injectable facade component](../facade/README.md) with Neo4j.
+We also register per-database components.
+
+The paradigm is, we have the facade holding functionality, accessed via a single component, registered via a global extension.
+And we need per-database components as well, for example for exporter builders. That goes via a database scoped extension.
+
+But, importantly, we only _need_ two extensions, one global, one database scoped. Important because it makes code grokable,
+you have one place to go read some hopefully declarative-ish code, so that you can grok what an edition comprises.
 
 This module initialises plugin state and constructs the facade. It is here we make edition specific choices.
 

open-write-services/src/main/java/org/neo4j/gds/OpenGdsExportBuildersExtension.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.extension;
+
+import org.neo4j.annotations.service.ServiceProvider;
+import org.neo4j.gds.core.write.NativeExportBuildersProvider;
+import org.neo4j.gds.procedures.integration.ExporterBuildersComponentRegistration;
+import org.neo4j.kernel.api.procedure.GlobalProcedures;
+import org.neo4j.kernel.extension.ExtensionFactory;
+import org.neo4j.kernel.extension.ExtensionType;
+import org.neo4j.kernel.extension.context.ExtensionContext;
+import org.neo4j.kernel.lifecycle.Lifecycle;
+import org.neo4j.kernel.lifecycle.LifecycleAdapter;
+
+/**
+ * Life in OpenGDS is very simple, we just register native exporter builders as components.
+ * They are database mode independent.
+ * We need exporter builders as components since they are @Context injected into e.g. Pregel code.
+ * Note that this is a database level extension.
+ * It needs to be one because exporter builders can be database mode dependent.
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+@ServiceProvider
+public class OpenGdsExportBuildersExtension extends ExtensionFactory<OpenGdsExportBuildersExtension.Dependencies> {
+    public OpenGdsExportBuildersExtension() {
+        super(ExtensionType.DATABASE, "gds.open-write-services");
+    }
+
+    @Override
+    public Lifecycle newInstance(ExtensionContext extensionContext, Dependencies dependencies) {
+        var globalProcedures = dependencies.globalProcedures();
+        var exporterBuildersComponentRegistration = new ExporterBuildersComponentRegistration(globalProcedures);
+
+        var exportBuildersProvider = new NativeExportBuildersProvider();
+        exporterBuildersComponentRegistration.registerExporterBuilders(exportBuildersProvider);
+
+        return new LifecycleAdapter(); // do nothing
+    }
+
+    public interface Dependencies {
+        GlobalProcedures globalProcedures();
+    }
+}

procedures/extension/README.md

@@ -1,9 +1,9 @@
 # Procedure Facade
 
-Here we keep the single injectable facade for the GDS procedures.
+Here we keep the injectable facade for the GDS procedures.
 
-All GDS procedures inject this one dependency, and it forms an umbrella over functional areas like graph store catalog or community algorithms. This keeps each sub interface smaller, more coherent and more manageable.
+GDS procedures inject this single dependency, and it forms an umbrella over functional areas like graph store catalog or community algorithms. This keeps each sub interface smaller, more coherent and more manageable.
 
-We also here host the integration services needed to cleanly interface with Neo4j. All Neo4j dependencies should be unstacked and wrapped here, because in the layers below we would want to be Neo4j agnostic.
+We also here host the integration services needed to cleanly interface with Neo4j. All Neo4j dependencies should be unstacked and wrapped here, because in the layers below we would want to be Neo4j agnostic. That makes them reusable.
 
 Code in here mainly uses [the applications procedure facade](../algorithms-facade/README.md) and pipelines. 

procedures/extension/src/main/java/org/neo4j/gds/extension/OpenGdsExportBuildersExtension.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.procedures.integration;
+
+import org.neo4j.gds.core.write.ExportBuildersProvider;
+import org.neo4j.gds.core.write.ExporterContext;
+import org.neo4j.gds.core.write.NodeLabelExporterBuilder;
+import org.neo4j.gds.core.write.NodePropertyExporterBuilder;
+import org.neo4j.gds.core.write.RelationshipExporterBuilder;
+import org.neo4j.gds.core.write.RelationshipPropertiesExporterBuilder;
+import org.neo4j.gds.core.write.RelationshipStreamExporterBuilder;
+import org.neo4j.kernel.api.procedure.GlobalProcedures;
+
+public class ExporterBuildersComponentRegistration {
+    private final GlobalProcedures globalProcedures;
+
+    public ExporterBuildersComponentRegistration(GlobalProcedures globalProcedures) {
+        this.globalProcedures = globalProcedures;
+    }
+
+    public void registerExporterBuilders(ExportBuildersProvider exportBuildersProvider) {
+        globalProcedures.registerComponent(
+            NodePropertyExporterBuilder.class,
+            (ctx) -> exportBuildersProvider.nodePropertyExporterBuilder(
+                new ExporterContext.ProcedureContextWrapper(ctx)
+            ),
+            true
+        );
+
+        globalProcedures.registerComponent(
+            RelationshipStreamExporterBuilder.class,
+            (ctx) -> exportBuildersProvider.relationshipStreamExporterBuilder(
+                new ExporterContext.ProcedureContextWrapper(ctx)
+            ),
+            true
+        );
+
+        globalProcedures.registerComponent(
+            RelationshipExporterBuilder.class,
+            (ctx) -> exportBuildersProvider.relationshipExporterBuilder(
+                new ExporterContext.ProcedureContextWrapper(ctx)
+            ),
+            true
+        );
+
+        globalProcedures.registerComponent(
+            RelationshipPropertiesExporterBuilder.class,
+            (ctx) -> exportBuildersProvider.relationshipPropertiesExporterBuilder(
+                new ExporterContext.ProcedureContextWrapper(ctx)
+            ),
+            true
+        );
+
+        globalProcedures.registerComponent(
+            NodeLabelExporterBuilder.class,
+            (ctx) -> exportBuildersProvider.nodeLabelExporterBuilder(
+                new ExporterContext.ProcedureContextWrapper(ctx)
+            ),
+            true
+        );
+    }
+}