You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sling.apache.org by ra...@apache.org on 2020/10/09 13:57:53 UTC
[sling-org-apache-sling-graphql-core] branch issue/SLING-9796
created (now 9e3de63)
This is an automated email from the ASF dual-hosted git repository.
radu pushed a change to branch issue/SLING-9796
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-graphql-core.git.
at 9e3de63 SLING-9796 - Add support for using Unions
This branch includes the following new commits:
new 9e3de63 SLING-9796 - Add support for using Unions
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[sling-org-apache-sling-graphql-core] 01/01: SLING-9796 - Add
support for using Unions
Posted by ra...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
radu pushed a commit to branch issue/SLING-9796
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-graphql-core.git
commit 9e3de633e58df6d98f46a155f81db0ae37957e04
Author: Radu Cotescu <ra...@apache.org>
AuthorDate: Fri Oct 9 15:52:43 2020 +0200
SLING-9796 - Add support for using Unions
Co-authored-by: Radu Cotescu <ra...@apache.org>
Co-authored-by: Adrian Kozma <ko...@adobe.com>
---
README.md | 30 ++++-
.../sling/graphql/api/SlingTypeResolver.java | 41 ++++++
.../graphql/api/SlingTypeResolverEnvironment.java | 65 +++++++++
.../graphql/core/engine/DefaultQueryExecutor.java | 67 ++++++++--
.../core/engine/SlingTypeResolverSelector.java | 145 +++++++++++++++++++++
.../core/engine/SlingTypeResolverWrapper.java | 54 ++++++++
.../engine/TypeResolverEnvironmentWrapper.java | 73 +++++++++++
.../example/resolvers/DoNothingTypeResolver.java | 36 +++++
.../core/engine/DefaultQueryExecutorTest.java | 43 +++++-
.../core/engine/IntrospectionQueryTest.java | 24 +++-
.../graphql/core/engine/ResourceQueryTestBase.java | 1 +
.../SlingTypeResolverNameValidationTest.java | 65 +++++++++
.../core/engine/SlingTypeResolverSelectorTest.java | 85 ++++++++++++
.../graphql/core/mocks/DummyTypeResolver.java | 32 +++++
.../apache/sling/graphql/core/mocks/TestUtil.java | 13 ++
.../graphql/core/mocks/TypeSlingResourceDTO.java | 37 ++++++
.../sling/graphql/core/mocks/TypeTestDTO.java | 50 +++++++
.../UnionTypeResolver.java} | 33 ++---
.../core/schema/SchemaDescriptionsTest.java | 5 +
...{test-schema.txt => failing-fetcher-schema.txt} | 33 +----
...schema.txt => failing-type-resolver-schema.txt} | 33 +----
src/test/resources/test-schema.txt | 20 ++-
22 files changed, 894 insertions(+), 91 deletions(-)
diff --git a/README.md b/README.md
index ef2f229..32bb24d 100644
--- a/README.md
+++ b/README.md
@@ -100,7 +100,7 @@ The names of those `SlingDataFetcher` services are in the form
<namespace>/<name>
The `sling/` namespace is reserved for `SlingDataFetcher` services
-which hava Java package names that start with `org.apache.sling`.
+which have Java package names that start with `org.apache.sling`.
The `<options>` and `<source>` arguments of the directive can be used by the
`SlingDataFetcher` services to influence their behavior.
@@ -130,6 +130,34 @@ The data fetcher provider then looks for a script that handles the `graphql/fetc
In that test, the `/graphql/fetchers/scripted/example/fetcher.js` shown above resolves with those requirements, it is executed to retrieve the requested data. That execution happens with a context consisting of the current `SlingDataFetcherEnvironment` under the `environment` key, and the current Sling Resource under the `resource` key, both used in this test script.
+## SlingTypeResolver selection with Schema Directives
+
+The GraphQL schemas used by this module can be enhanced using
+[schema directives](http://spec.graphql.org/June2018/#sec-Language.Directives)
+(see also the [Apollo docs](https://www.apollographql.com/docs/graphql-tools/schema-directives/) for how those work)
+that select specific `SlingTypeResolver` services to return the appropriate GraphQL object type using Unions.
+
+Here's a simple example, the test code has more:
+
+ # This directive maps the corresponding type resolver to a given Union
+ directive @resolver(
+ name: String,
+ options: String = "",
+ source: String = ""
+ ) on UNION
+
+ union TestUnion @resolver(name : "test/resolver", source : "TestUnion") = Type_1 | Type_2 | Type_3 | Type_4
+
+The names of those `SlingTypeResolver` services are in the form
+
+ <namespace>/<name>
+
+The `sling/` namespace is reserved for `SlingTypeResolver` services
+which have Java package names that start with `org.apache.sling`.
+
+The `<options>` and `<source>` arguments of the directive can be used by the
+`SlingTypeResolver` services to influence their behavior.
+
## Caching: Persisted queries API
No matter how you decide to create your Sling GraphQL endpoints, you have the option to allow GraphQL clients to use persisted queries.
diff --git a/src/main/java/org/apache/sling/graphql/api/SlingTypeResolver.java b/src/main/java/org/apache/sling/graphql/api/SlingTypeResolver.java
new file mode 100644
index 0000000..19dbc94
--- /dev/null
+++ b/src/main/java/org/apache/sling/graphql/api/SlingTypeResolver.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.graphql.api;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.osgi.annotation.versioning.ConsumerType;
+
+/**
+ * Resolves the GraphQL object type of a given result item. Services must be registered with a {@link #NAME_SERVICE_PROPERTY} property
+ * with a unique value that's matched with the corresponding {@code @directive} in the GraphQL Schema.
+ */
+@ConsumerType
+public interface SlingTypeResolver<T> {
+
+ /**
+ * Defines the service registration property with which all {@link SlingTypeResolver} services have to be registered. The value should
+ * be namespaced, with namespaces being delimited by the "/" character.
+ */
+ String NAME_SERVICE_PROPERTY = "name";
+
+ @Nullable
+ T getType(@NotNull SlingTypeResolverEnvironment e);
+}
diff --git a/src/main/java/org/apache/sling/graphql/api/SlingTypeResolverEnvironment.java b/src/main/java/org/apache/sling/graphql/api/SlingTypeResolverEnvironment.java
new file mode 100644
index 0000000..9c52196
--- /dev/null
+++ b/src/main/java/org/apache/sling/graphql/api/SlingTypeResolverEnvironment.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.graphql.api;
+
+import org.apache.sling.api.resource.Resource;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.osgi.annotation.versioning.ProviderType;
+
+/**
+ * Provides contextual information to the {@link SlingTypeResolver}
+ */
+@SuppressWarnings("TypeParameterUnusedInFormals")
+
+@ProviderType
+public interface SlingTypeResolverEnvironment<T> {
+
+ /**
+ * @return the current Sling resource
+ */
+ @Nullable
+ Resource getCurrentResource();
+
+ /**
+ * @return the options, if set by the schema directive
+ */
+ @Nullable
+ String getResolverOptions();
+
+ /**
+ * @return the source, if set by the schema directive
+ */
+ @Nullable
+ String getResolverSource();
+
+ /**
+ * @return the GraphQL result item
+ */
+ @Nullable
+ Object getObject();
+
+ /**
+ * @param name the type name
+ * @return the GraphQL Object Type
+ */
+ @Nullable
+ T getObjectType(@NotNull String name);
+}
diff --git a/src/main/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutor.java b/src/main/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutor.java
index 2b87dab..93d472d 100644
--- a/src/main/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutor.java
+++ b/src/main/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutor.java
@@ -25,11 +25,14 @@ import javax.json.Json;
import javax.json.JsonObject;
import javax.script.ScriptException;
+import graphql.language.UnionTypeDefinition;
+import graphql.schema.TypeResolver;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.graphql.api.SchemaProvider;
import org.apache.sling.graphql.api.SlingDataFetcher;
import org.apache.sling.graphql.api.SlingGraphQLException;
import org.apache.sling.graphql.api.engine.QueryExecutor;
+import org.apache.sling.graphql.api.SlingTypeResolver;
import org.apache.sling.graphql.core.scalars.SlingScalarsProvider;
import org.apache.sling.graphql.core.schema.RankedSchemaProviders;
import org.jetbrains.annotations.NotNull;
@@ -69,6 +72,11 @@ public class DefaultQueryExecutor implements QueryExecutor {
public static final String FETCHER_OPTIONS = "options";
public static final String FETCHER_SOURCE = "source";
+ public static final String RESOLVER_DIRECTIVE = "resolver";
+ public static final String RESOLVER_NAME = "name";
+ public static final String RESOLVER_OPTIONS = "options";
+ public static final String RESOLVER_SOURCE = "source";
+
@Reference
private RankedSchemaProviders schemaProvider;
@@ -76,6 +84,9 @@ public class DefaultQueryExecutor implements QueryExecutor {
private SlingDataFetcherSelector dataFetcherSelector;
@Reference
+ private SlingTypeResolverSelector typeResolverSelector;
+
+ @Reference
private SlingScalarsProvider scalarsProvider;
@Override
@@ -84,8 +95,7 @@ public class DefaultQueryExecutor implements QueryExecutor {
try {
String schemaDef = prepareSchemaDefinition(schemaProvider, queryResource, selectors);
LOGGER.debug("Resource {} maps to GQL schema {}", queryResource.getPath(), schemaDef);
- final GraphQLSchema schema =
- buildSchema(schemaDef, dataFetcherSelector, scalarsProvider, queryResource);
+ final GraphQLSchema schema = buildSchema(schemaDef, queryResource);
ExecutionInput executionInput = ExecutionInput.newExecutionInput()
.query(query)
.variables(variables)
@@ -104,7 +114,7 @@ public class DefaultQueryExecutor implements QueryExecutor {
try {
schemaDef = prepareSchemaDefinition(schemaProvider, queryResource, selectors);
LOGGER.debug("Resource {} maps to GQL schema {}", queryResource.getPath(), schemaDef);
- final GraphQLSchema schema = buildSchema(schemaDef, dataFetcherSelector, scalarsProvider, queryResource);
+ final GraphQLSchema schema = buildSchema(schemaDef, queryResource);
final GraphQL graphQL = GraphQL.newGraphQL(schema).build();
LOGGER.debug("Executing query\n[{}]\nat [{}] with variables [{}]", query, queryResource.getPath(), variables);
ExecutionInput ei = ExecutionInput.newExecutionInput()
@@ -131,24 +141,22 @@ public class DefaultQueryExecutor implements QueryExecutor {
}
}
- private GraphQLSchema buildSchema(String sdl, SlingDataFetcherSelector fetchers, SlingScalarsProvider scalarsProvider,
- Resource currentResource) {
+ private GraphQLSchema buildSchema(String sdl, Resource currentResource) {
TypeDefinitionRegistry typeRegistry = new SchemaParser().parse(sdl);
Iterable<GraphQLScalarType> scalars = scalarsProvider.getCustomScalars(typeRegistry.scalars());
- RuntimeWiring runtimeWiring = buildWiring(typeRegistry, fetchers, scalars, currentResource);
+ RuntimeWiring runtimeWiring = buildWiring(typeRegistry, scalars, currentResource);
SchemaGenerator schemaGenerator = new SchemaGenerator();
return schemaGenerator.makeExecutableSchema(typeRegistry, runtimeWiring);
}
- private RuntimeWiring buildWiring(TypeDefinitionRegistry typeRegistry, SlingDataFetcherSelector fetchers,
- Iterable<GraphQLScalarType> scalars, Resource r) {
+ private RuntimeWiring buildWiring(TypeDefinitionRegistry typeRegistry, Iterable<GraphQLScalarType> scalars, Resource r) {
List<ObjectTypeDefinition> types = typeRegistry.getTypes(ObjectTypeDefinition.class);
RuntimeWiring.Builder builder = RuntimeWiring.newRuntimeWiring();
for (ObjectTypeDefinition type : types) {
builder.type(type.getName(), typeWiring -> {
for (FieldDefinition field : type.getFieldDefinitions()) {
try {
- DataFetcher<Object> fetcher = getDataFetcher(field, fetchers, r);
+ DataFetcher<Object> fetcher = getDataFetcher(field, r);
if (fetcher != null) {
typeWiring.dataFetcher(field.getName(), fetcher);
}
@@ -162,6 +170,20 @@ public class DefaultQueryExecutor implements QueryExecutor {
});
}
scalars.forEach(builder::scalar);
+
+ List<UnionTypeDefinition> unionTypes = typeRegistry.getTypes(UnionTypeDefinition.class);
+ for (UnionTypeDefinition type : unionTypes) {
+ try {
+ TypeResolver resolver = getTypeResolver(type, r);
+ if (resolver != null) {
+ builder.type(type.getName(), typeWriting -> typeWriting.typeResolver(resolver));
+ }
+ } catch (SlingGraphQLException e) {
+ throw e;
+ } catch(Exception e) {
+ throw new SlingGraphQLException("Exception while building wiring.", e);
+ }
+ }
return builder.build();
}
@@ -181,7 +203,15 @@ public class DefaultQueryExecutor implements QueryExecutor {
name, SlingDataFetcherSelector.FETCHER_NAME_PATTERN));
}
- private DataFetcher<Object> getDataFetcher(FieldDefinition field, SlingDataFetcherSelector fetchers, Resource currentResource)
+ private @NotNull String validateResolverName(String name) {
+ if (SlingTypeResolverSelector.nameMatchesPattern(name)) {
+ return name;
+ }
+ throw new SlingGraphQLException(String.format("Invalid type resolver name %s, does not match %s",
+ name, SlingTypeResolverSelector.RESOLVER_NAME_PATTERN));
+ }
+
+ private DataFetcher<Object> getDataFetcher(FieldDefinition field, Resource currentResource)
{
DataFetcher<Object> result = null;
final Directive d =field.getDirective(FETCHER_DIRECTIVE);
@@ -189,7 +219,7 @@ public class DefaultQueryExecutor implements QueryExecutor {
final String name = validateFetcherName(getDirectiveArgumentValue(d, FETCHER_NAME));
final String options = getDirectiveArgumentValue(d, FETCHER_OPTIONS);
final String source = getDirectiveArgumentValue(d, FETCHER_SOURCE);
- SlingDataFetcher<Object> f = fetchers.getSlingFetcher(name);
+ SlingDataFetcher<Object> f = dataFetcherSelector.getSlingFetcher(name);
if(f != null) {
result = new SlingDataFetcherWrapper<>(f, currentResource, options, source);
}
@@ -197,6 +227,21 @@ public class DefaultQueryExecutor implements QueryExecutor {
return result;
}
+ private TypeResolver getTypeResolver(UnionTypeDefinition typeDefinition, Resource currentResource) {
+ TypeResolver resolver = null;
+ final Directive d = typeDefinition.getDirective(RESOLVER_DIRECTIVE);
+ if(d != null) {
+ final String name = validateResolverName(getDirectiveArgumentValue(d, RESOLVER_NAME));
+ final String options = getDirectiveArgumentValue(d, RESOLVER_OPTIONS);
+ final String source = getDirectiveArgumentValue(d, RESOLVER_SOURCE);
+ SlingTypeResolver<Object> r = typeResolverSelector.getSlingTypeResolver(name);
+ if(r != null) {
+ resolver = new SlingTypeResolverWrapper(r, currentResource, options, source);
+ }
+ }
+ return resolver;
+ }
+
private @Nullable String prepareSchemaDefinition(@NotNull SchemaProvider schemaProvider,
@NotNull org.apache.sling.api.resource.Resource resource,
@NotNull String[] selectors) throws ScriptException {
diff --git a/src/main/java/org/apache/sling/graphql/core/engine/SlingTypeResolverSelector.java b/src/main/java/org/apache/sling/graphql/core/engine/SlingTypeResolverSelector.java
new file mode 100644
index 0000000..3cd7524
--- /dev/null
+++ b/src/main/java/org/apache/sling/graphql/core/engine/SlingTypeResolverSelector.java
@@ -0,0 +1,145 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.graphql.core.engine;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.TreeSet;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.sling.commons.osgi.PropertiesUtil;
+import org.apache.sling.graphql.api.SlingDataFetcher;
+import org.apache.sling.graphql.api.SlingTypeResolver;
+import org.apache.sling.graphql.core.osgi.ServiceReferenceObjectTuple;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.osgi.framework.ServiceReference;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferenceCardinality;
+import org.osgi.service.component.annotations.ReferencePolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Selects a SlingTypeProvider used to get the corresponding object type,
+ * based on a name specified by a GraphQL schema directive.
+ */
+@Component(service = SlingTypeResolverSelector.class)
+public class SlingTypeResolverSelector {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(SlingTypeResolverSelector.class);
+ static final Pattern RESOLVER_NAME_PATTERN = Pattern.compile("\\w+(/\\w+)+");
+
+ private final Map<String, TreeSet<ServiceReferenceObjectTuple<SlingTypeResolver<Object>>>> typeResolvers = new HashMap<>();
+
+ /**
+ * Resolvers which have a name starting with this prefix must be
+ * under the {#link RESERVED_PACKAGE_PREFIX} package.
+ */
+ public static final String RESERVED_NAME_PREFIX = "sling/";
+
+ /**
+ * Package name prefix for resolvers which have names starting
+ * with the {#link RESERVED_NAME_PREFIX}.
+ */
+ public static final String RESERVED_PACKAGE_PREFIX = "org.apache.sling.";
+
+ /**
+ * @return a SlingTypeResolver, or null if none available. First tries to get an
+ * OSGi SlingTypeResolver service, and if not found tries to find a scripted SlingTypeResolver.
+ */
+ @Nullable
+ public SlingTypeResolver<Object> getSlingTypeResolver(@NotNull String name) {
+ TreeSet<ServiceReferenceObjectTuple<SlingTypeResolver<Object>>> resolvers = typeResolvers.get(name);
+ if (resolvers != null && !resolvers.isEmpty()) {
+ return resolvers.last().getServiceObject();
+ }
+ return null;
+ }
+
+ private boolean hasValidName(@NotNull ServiceReference<SlingTypeResolver<Object>> serviceReference,
+ @NotNull SlingTypeResolver<Object> slingTypeResolver) {
+ String name = PropertiesUtil.toString(serviceReference.getProperty(SlingTypeResolver.NAME_SERVICE_PROPERTY), null);
+ if (StringUtils.isNotEmpty(name)) {
+ if (!nameMatchesPattern(name)) {
+ LOGGER.error("Invalid SlingTypeResolver {}: type resolver name is not namespaced (e.g. ns/myTypeResolver)",
+ slingTypeResolver.getClass().getName());
+ return false;
+ }
+ if (name.startsWith(RESERVED_NAME_PREFIX)) {
+ final String className = slingTypeResolver.getClass().getName();
+ if (!slingTypeResolver.getClass().getName().startsWith(RESERVED_PACKAGE_PREFIX)) {
+ LOGGER.error(
+ "Invalid SlingDataFetcher {}: fetcher names starting with '{}' are reserved for Apache Sling Java packages",
+ className, RESERVED_NAME_PREFIX);
+ return false;
+ }
+ }
+ } else {
+ LOGGER.error("Invalid {} implementation: fetcher {} is missing the mandatory value for its {} service property.",
+ SlingDataFetcher.class.getName(), slingTypeResolver.getClass().getName(), SlingDataFetcher.NAME_SERVICE_PROPERTY);
+ return false;
+ }
+ return true;
+ }
+
+ static boolean nameMatchesPattern(String name) {
+ if (StringUtils.isNotEmpty(name)) {
+ return RESOLVER_NAME_PATTERN.matcher(name).matches();
+ }
+ return false;
+ }
+
+ @Reference(
+ service = SlingTypeResolver.class,
+ cardinality = ReferenceCardinality.MULTIPLE,
+ policy = ReferencePolicy.DYNAMIC
+ )
+ private void bindSlingTypeResolver(ServiceReference<SlingTypeResolver<Object>> reference, SlingTypeResolver<Object> slingTypeResolver) {
+ if (hasValidName(reference, slingTypeResolver)) {
+ synchronized (typeResolvers) {
+ String name = (String) reference.getProperty(SlingTypeResolver.NAME_SERVICE_PROPERTY);
+ TreeSet<ServiceReferenceObjectTuple<SlingTypeResolver<Object>>> resolvers = typeResolvers.computeIfAbsent(name,
+ key -> new TreeSet<>());
+ resolvers.add(new ServiceReferenceObjectTuple<>(reference, slingTypeResolver));
+ }
+ }
+ }
+
+ @SuppressWarnings("unused")
+ private void unbindSlingTypeResolver(ServiceReference<SlingTypeResolver<Object>> reference) {
+ String name = (String) reference.getProperty(SlingTypeResolver.NAME_SERVICE_PROPERTY);
+ if (StringUtils.isNotEmpty(name)) {
+ synchronized (typeResolvers) {
+ TreeSet<ServiceReferenceObjectTuple<SlingTypeResolver<Object>>> resolvers = typeResolvers.get(name);
+ if (resolvers != null) {
+ Optional<ServiceReferenceObjectTuple<SlingTypeResolver<Object>>> tupleToRemove =
+ resolvers.stream().filter(tuple -> reference.equals(tuple.getServiceReference())).findFirst();
+ tupleToRemove.ifPresent(resolvers::remove);
+ }
+ }
+ }
+ }
+
+}
diff --git a/src/main/java/org/apache/sling/graphql/core/engine/SlingTypeResolverWrapper.java b/src/main/java/org/apache/sling/graphql/core/engine/SlingTypeResolverWrapper.java
new file mode 100644
index 0000000..a9976c6
--- /dev/null
+++ b/src/main/java/org/apache/sling/graphql/core/engine/SlingTypeResolverWrapper.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.graphql.core.engine;
+
+import graphql.TypeResolutionEnvironment;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.TypeResolver;
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.graphql.api.SlingTypeResolver;
+
+/**
+ * Wraps a SlingTypeResolver to make it usable by graphql-java
+ */
+class SlingTypeResolverWrapper implements TypeResolver {
+
+ private final SlingTypeResolver<Object> resolver;
+ private final Resource currentResource;
+ private final String options;
+ private final String source;
+
+ SlingTypeResolverWrapper(SlingTypeResolver<Object> resolver, Resource currentResource, String options,
+ String source) {
+ this.resolver = resolver;
+ this.currentResource = currentResource;
+ this.options = options;
+ this.source = source;
+ }
+
+ @Override
+ public GraphQLObjectType getType(TypeResolutionEnvironment environment) {
+ Object r = resolver.getType(new TypeResolverEnvironmentWrapper(environment, currentResource, options, source));
+ if (r instanceof GraphQLObjectType) {
+ return (GraphQLObjectType) r;
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/org/apache/sling/graphql/core/engine/TypeResolverEnvironmentWrapper.java b/src/main/java/org/apache/sling/graphql/core/engine/TypeResolverEnvironmentWrapper.java
new file mode 100644
index 0000000..a2a8583
--- /dev/null
+++ b/src/main/java/org/apache/sling/graphql/core/engine/TypeResolverEnvironmentWrapper.java
@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.graphql.core.engine;
+
+import graphql.TypeResolutionEnvironment;
+import graphql.schema.GraphQLObjectType;
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.graphql.api.SlingTypeResolverEnvironment;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Wraps the graphql-java TypeResolverEnvironment to provide
+ * our own SlingTypeResolverEnvironment interface. This avoids
+ * having to expose the graphql-java APIs in our own API.
+ */
+class TypeResolverEnvironmentWrapper implements SlingTypeResolverEnvironment<GraphQLObjectType> {
+ private final TypeResolutionEnvironment env;
+ private final Resource currentResource;
+ private final String options;
+ private final String source;
+
+ TypeResolverEnvironmentWrapper(TypeResolutionEnvironment env, Resource currentResource, String options,
+ String source) {
+ this.env = env;
+ this.currentResource = currentResource;
+ this.options = options;
+ this.source = source;
+ }
+
+ @Override
+ public Resource getCurrentResource() {
+ return currentResource;
+ }
+
+ @Override
+ public String getResolverOptions() {
+ return options;
+ }
+
+ @Override
+ public String getResolverSource() {
+ return source;
+ }
+
+ @Override
+ public Object getObject() {
+ return env.getObject();
+ }
+
+ @Override
+ @Nullable
+ public GraphQLObjectType getObjectType(@NotNull String name) {
+ return env.getSchema().getObjectType(name);
+ }
+}
diff --git a/src/test/java/com/example/resolvers/DoNothingTypeResolver.java b/src/test/java/com/example/resolvers/DoNothingTypeResolver.java
new file mode 100644
index 0000000..8aaeafa
--- /dev/null
+++ b/src/test/java/com/example/resolvers/DoNothingTypeResolver.java
@@ -0,0 +1,36 @@
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ Licensed to the Apache Software Foundation (ASF) under one
+ ~ or more contributor license agreements. See the NOTICE file
+ ~ distributed with this work for additional information
+ ~ regarding copyright ownership. The ASF licenses this file
+ ~ to you under the Apache License, Version 2.0 (the
+ ~ "License"); you may not use this file except in compliance
+ ~ with the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing,
+ ~ software distributed under the License is distributed on an
+ ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ ~ KIND, either express or implied. See the License for the
+ ~ specific language governing permissions and limitations
+ ~ under the License.
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+package com.example.resolvers;
+
+import org.apache.sling.graphql.api.SlingTypeResolver;
+import org.apache.sling.graphql.api.SlingTypeResolverEnvironment;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/** SlingTypeResolver used to test the requirement for sling/* fetcher
+ * names to point to classes under the org.apache.sling package
+ */
+public class DoNothingTypeResolver implements SlingTypeResolver<Object> {
+
+ @Nullable
+ @Override
+ public Object getType(@NotNull SlingTypeResolverEnvironment e) {
+ return null;
+ }
+}
diff --git a/src/test/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutorTest.java b/src/test/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutorTest.java
index 41a0e4b..7e567e1 100644
--- a/src/test/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutorTest.java
+++ b/src/test/java/org/apache/sling/graphql/core/engine/DefaultQueryExecutorTest.java
@@ -18,18 +18,24 @@
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
package org.apache.sling.graphql.core.engine;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.Dictionary;
import java.util.Hashtable;
+import java.util.List;
import org.apache.sling.graphql.api.SchemaProvider;
import org.apache.sling.graphql.api.SlingGraphQLException;
import org.apache.sling.graphql.api.engine.QueryExecutor;
import org.apache.sling.graphql.core.mocks.DigestDataFetcher;
+import org.apache.sling.graphql.core.mocks.DummyTypeResolver;
import org.apache.sling.graphql.core.mocks.EchoDataFetcher;
import org.apache.sling.graphql.core.mocks.FailingDataFetcher;
import org.apache.sling.graphql.core.mocks.MockSchemaProvider;
import org.apache.sling.graphql.core.mocks.TestUtil;
+import org.apache.sling.graphql.core.mocks.TypeSlingResourceDTO;
+import org.apache.sling.graphql.core.mocks.TypeTestDTO;
+import org.apache.sling.graphql.core.mocks.UnionTypeResolver;
import org.junit.Test;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceRegistration;
@@ -44,10 +50,19 @@ import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
public class DefaultQueryExecutorTest extends ResourceQueryTestBase {
+
protected void setupAdditionalServices() {
final Dictionary<String, Object> staticData = new Hashtable<>();
staticData.put("test", true);
+ final Dictionary<String, Object> unionData = new Hashtable<>();
+ final List<Object> items = new ArrayList<>();
+ items.add(new TypeTestDTO(true, false, "path/to/resource", "1, 2, 3"));
+ items.add(new TypeSlingResourceDTO(resource.getPath(), resource.getResourceType()));
+ unionData.put("items", items);
+
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "union/resolver", new UnionTypeResolver());
+ TestUtil.registerSlingDataFetcher(context.bundleContext(), "union/fetcher", new EchoDataFetcher(unionData));
TestUtil.registerSlingDataFetcher(context.bundleContext(), "echoNS/echo", new EchoDataFetcher(null));
TestUtil.registerSlingDataFetcher(context.bundleContext(), "failure/fail", new FailingDataFetcher());
TestUtil.registerSlingDataFetcher(context.bundleContext(), "test/static", new EchoDataFetcher(staticData));
@@ -116,14 +131,30 @@ public class DefaultQueryExecutorTest extends ResourceQueryTestBase {
@Test
public void invalidFetcherNamesTest() {
- context.registerService(SchemaProvider.class, new MockSchemaProvider("failing-schema"), Constants.SERVICE_RANKING,
+ context.registerService(SchemaProvider.class, new MockSchemaProvider("failing-fetcher-schema"), Constants.SERVICE_RANKING,
Integer.MAX_VALUE);
final ServiceRegistration<?> reg = TestUtil.registerSlingDataFetcher(context.bundleContext(), "missingSlash", new EchoDataFetcher(42));
try {
queryJSON("{ currentResource { missingSlash } }", new String[] {});
fail("Expected query to fail");
} catch(Exception e) {
- TestUtil.assertNestedException(e, SlingGraphQLException.class, "does not match");
+ TestUtil.assertNestedException(e, SlingGraphQLException.class, "Invalid fetcher name missingSlash");
+ } finally {
+ reg.unregister();
+ }
+ }
+
+ @Test
+ public void invalidTypeResolverNamesTest() {
+ context.registerService(SchemaProvider.class, new MockSchemaProvider("failing-type-resolver-schema"), Constants.SERVICE_RANKING,
+ Integer.MAX_VALUE);
+ final ServiceRegistration<?> reg = TestUtil.registerSlingTypeResolver(context.bundleContext(), "missingSlash",
+ new DummyTypeResolver());
+ try {
+ queryJSON("{ currentResource { missingSlash } }", new String[] {});
+ fail("Expected query to fail");
+ } catch(Exception e) {
+ TestUtil.assertNestedException(e, SlingGraphQLException.class, "Invalid type resolver name missingSlash");
} finally {
reg.unregister();
}
@@ -138,4 +169,12 @@ public class DefaultQueryExecutorTest extends ResourceQueryTestBase {
assertThat(json, hasJsonPath("$.data.scriptedFetcher.resourcePath", equalTo(resource.getPath())));
assertThat(json, hasJsonPath("$.data.scriptedFetcher.testingArgument", equalTo("1, 2, 3")));
}
+
+ @Test
+ public void unionFetcherTest() throws Exception {
+ final String json = queryJSON("{ unionFetcher { items { ... on Test { testingArgument } ... on SlingResource { path }} } }");
+ assertThat(json, hasJsonPath("$.data.unionFetcher"));
+ assertThat(json, hasJsonPath("$.data.unionFetcher.items[0].testingArgument", equalTo("1, 2, 3")));
+ assertThat(json, hasJsonPath("$.data.unionFetcher.items[1].path", equalTo(resource.getPath())));
+ }
}
diff --git a/src/test/java/org/apache/sling/graphql/core/engine/IntrospectionQueryTest.java b/src/test/java/org/apache/sling/graphql/core/engine/IntrospectionQueryTest.java
index 4c4d476..227a49f 100644
--- a/src/test/java/org/apache/sling/graphql/core/engine/IntrospectionQueryTest.java
+++ b/src/test/java/org/apache/sling/graphql/core/engine/IntrospectionQueryTest.java
@@ -18,15 +18,37 @@
*/
package org.apache.sling.graphql.core.engine;
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.List;
+
import static com.jayway.jsonpath.matchers.JsonPathMatchers.hasJsonPath;
import static org.junit.Assert.assertThat;
import static org.hamcrest.Matchers.contains;
+import org.apache.sling.graphql.core.mocks.EchoDataFetcher;
+import org.apache.sling.graphql.core.mocks.TestUtil;
+import org.apache.sling.graphql.core.mocks.TypeSlingResourceDTO;
+import org.apache.sling.graphql.core.mocks.TypeTestDTO;
+import org.apache.sling.graphql.core.mocks.UnionTypeResolver;
import org.junit.Test;
public class IntrospectionQueryTest extends ResourceQueryTestBase {
-
+
+ @Override
+ protected void setupAdditionalServices() {
+ final Dictionary<String, Object> unionData = new Hashtable<>();
+ final List<Object> items = new ArrayList<>();
+ items.add(new TypeTestDTO(true, false, "path/to/resource", "1, 2, 3"));
+ items.add(new TypeSlingResourceDTO(resource.getPath(), resource.getResourceType()));
+ unionData.put("items", items);
+
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "union/resolver", new UnionTypeResolver());
+ TestUtil.registerSlingDataFetcher(context.bundleContext(), "union/fetcher", new EchoDataFetcher(unionData));
+ }
+
@Test
public void schemaIntrospectionTest() throws Exception {
final String json = queryJSON("{ __schema { types { name } directives { description }}}");
diff --git a/src/test/java/org/apache/sling/graphql/core/engine/ResourceQueryTestBase.java b/src/test/java/org/apache/sling/graphql/core/engine/ResourceQueryTestBase.java
index c5b3095..f33340f 100644
--- a/src/test/java/org/apache/sling/graphql/core/engine/ResourceQueryTestBase.java
+++ b/src/test/java/org/apache/sling/graphql/core/engine/ResourceQueryTestBase.java
@@ -66,6 +66,7 @@ public abstract class ResourceQueryTestBase {
context.registerInjectActivateService(new ScriptedDataFetcherProvider());
context.registerInjectActivateService(new SlingDataFetcherSelector());
+ context.registerInjectActivateService(new SlingTypeResolverSelector());
context.registerInjectActivateService(new SlingScalarsProvider());
context.registerInjectActivateService(new RankedSchemaProviders());
context.registerInjectActivateService(new DefaultQueryExecutor());
diff --git a/src/test/java/org/apache/sling/graphql/core/engine/SlingTypeResolverNameValidationTest.java b/src/test/java/org/apache/sling/graphql/core/engine/SlingTypeResolverNameValidationTest.java
new file mode 100644
index 0000000..fbe8273
--- /dev/null
+++ b/src/test/java/org/apache/sling/graphql/core/engine/SlingTypeResolverNameValidationTest.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.graphql.core.engine;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(Parameterized.class)
+public class SlingTypeResolverNameValidationTest {
+
+ @Parameters(name = "{0}")
+ public static Collection<Object[]> data() {
+ final List<Object[]> result = new ArrayList<>();
+ result.add(new Object[]{"with/slash", true});
+ result.add(new Object[]{"missingSlash", false});
+ result.add(new Object[]{"", false});
+ result.add(new Object[]{"one/two/three", true});
+ result.add(new Object[]{"one/two/three/four_and/five_and_451_six_6", true});
+ result.add(new Object[]{"uno/1/x42", true});
+ result.add(new Object[]{"uno_due/tre", true});
+ result.add(new Object[]{"the:colon/bad", false});
+ result.add(new Object[]{"/startingslash", false});
+ result.add(new Object[]{"/starting/ending", false});
+ return result;
+ }
+
+ private final String name;
+ private final boolean expectValid;
+
+ public SlingTypeResolverNameValidationTest(String name, Boolean expectValid) {
+ this.name = name;
+ this.expectValid = expectValid;
+ }
+
+ @Test
+ public void testValidation() {
+ final String msg = String.format("Expecting '%s' to be %s", name, expectValid ? "valid" : "invalid");
+ assertEquals(msg, SlingTypeResolverSelector.nameMatchesPattern(name), expectValid);
+ }
+
+}
diff --git a/src/test/java/org/apache/sling/graphql/core/engine/SlingTypeResolverSelectorTest.java b/src/test/java/org/apache/sling/graphql/core/engine/SlingTypeResolverSelectorTest.java
new file mode 100644
index 0000000..db0f254
--- /dev/null
+++ b/src/test/java/org/apache/sling/graphql/core/engine/SlingTypeResolverSelectorTest.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.graphql.core.engine;
+
+import org.apache.sling.graphql.api.SlingTypeResolver;
+import org.apache.sling.graphql.api.SlingTypeResolverEnvironment;
+import org.apache.sling.graphql.core.mocks.DummyTypeResolver;
+import org.apache.sling.graphql.core.mocks.TestUtil;
+import org.apache.sling.graphql.core.mocks.UnionTypeResolver;
+import org.apache.sling.testing.mock.osgi.junit.OsgiContext;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.example.resolvers.DoNothingTypeResolver;
+
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+public class SlingTypeResolverSelectorTest {
+
+ @Rule
+ public final OsgiContext context = new OsgiContext();
+
+ private SlingTypeResolverSelector selector;
+
+ @Before
+ public void setup() {
+ context.registerInjectActivateService(new SlingTypeResolverSelector());
+ selector = context.getService(SlingTypeResolverSelector.class);
+
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "sling/union", new UnionTypeResolver());
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "sling/shouldFail", new DoNothingTypeResolver());
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "example/ok", new DoNothingTypeResolver());
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "sling/duplicate", 1, new DummyTypeResolver());
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "sling/duplicate", 0, new UnionTypeResolver());
+ }
+
+ @Test
+ public void acceptableName() {
+ final SlingTypeResolver<Object> sdf = selector.getSlingTypeResolver("example/ok");
+ assertThat(sdf, not(nullValue()));
+ }
+
+ @Test
+ public void reservedNameOk() {
+ final SlingTypeResolver<Object> sdf = selector.getSlingTypeResolver("sling/union");
+ assertThat(sdf, not(nullValue()));
+ }
+
+ @Test
+ public void reservedNameError() {
+ assertNull(selector.getSlingTypeResolver("sling/shouldFail"));
+ }
+
+ @Test
+ public void sameNameTypeResolver() {
+ final SlingTypeResolver<Object> str = selector.getSlingTypeResolver("sling/duplicate");
+ assertNotNull(str);
+ assertEquals(DummyTypeResolver.class, str.getClass());
+ assertNull(str.getType(mock(SlingTypeResolverEnvironment.class)));
+ }
+}
diff --git a/src/test/java/org/apache/sling/graphql/core/mocks/DummyTypeResolver.java b/src/test/java/org/apache/sling/graphql/core/mocks/DummyTypeResolver.java
new file mode 100644
index 0000000..ad44668
--- /dev/null
+++ b/src/test/java/org/apache/sling/graphql/core/mocks/DummyTypeResolver.java
@@ -0,0 +1,32 @@
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ Licensed to the Apache Software Foundation (ASF) under one
+ ~ or more contributor license agreements. See the NOTICE file
+ ~ distributed with this work for additional information
+ ~ regarding copyright ownership. The ASF licenses this file
+ ~ to you under the Apache License, Version 2.0 (the
+ ~ "License"); you may not use this file except in compliance
+ ~ with the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing,
+ ~ software distributed under the License is distributed on an
+ ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ ~ KIND, either express or implied. See the License for the
+ ~ specific language governing permissions and limitations
+ ~ under the License.
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+package org.apache.sling.graphql.core.mocks;
+
+import org.apache.sling.graphql.api.SlingTypeResolver;
+import org.apache.sling.graphql.api.SlingTypeResolverEnvironment;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class DummyTypeResolver implements SlingTypeResolver<Object> {
+
+ @Override
+ public @Nullable Object getType(@NotNull SlingTypeResolverEnvironment e) {
+ return null;
+ }
+}
diff --git a/src/test/java/org/apache/sling/graphql/core/mocks/TestUtil.java b/src/test/java/org/apache/sling/graphql/core/mocks/TestUtil.java
index a68d3cb..5a2b415 100644
--- a/src/test/java/org/apache/sling/graphql/core/mocks/TestUtil.java
+++ b/src/test/java/org/apache/sling/graphql/core/mocks/TestUtil.java
@@ -26,6 +26,7 @@ import java.util.Hashtable;
import org.apache.sling.graphql.api.SlingDataFetcher;
import org.apache.sling.graphql.api.SlingScalarConverter;
+import org.apache.sling.graphql.api.SlingTypeResolver;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceRegistration;
@@ -44,6 +45,18 @@ public class TestUtil {
return bc.registerService(SlingDataFetcher.class, f, props);
}
+ public static ServiceRegistration<?> registerSlingTypeResolver(BundleContext bc, String name, SlingTypeResolver<?> tr) {
+ return registerSlingTypeResolver(bc, name, 0, tr);
+ }
+
+ public static ServiceRegistration<?> registerSlingTypeResolver(BundleContext bc, String name, int serviceRanking,
+ SlingTypeResolver<?> tr) {
+ final Dictionary<String, Object> props = new Hashtable<>();
+ props.put(SlingTypeResolver.NAME_SERVICE_PROPERTY, name);
+ props.put(Constants.SERVICE_RANKING, serviceRanking);
+ return bc.registerService(SlingTypeResolver.class, tr, props);
+ }
+
public static ServiceRegistration<?> registerSlingScalarConverter(BundleContext bc, String name, SlingScalarConverter<?,?> c) {
final Dictionary<String, Object> props = new Hashtable<>();
props.put(SlingScalarConverter.NAME_SERVICE_PROPERTY, name);
diff --git a/src/test/java/org/apache/sling/graphql/core/mocks/TypeSlingResourceDTO.java b/src/test/java/org/apache/sling/graphql/core/mocks/TypeSlingResourceDTO.java
new file mode 100644
index 0000000..fa1339f
--- /dev/null
+++ b/src/test/java/org/apache/sling/graphql/core/mocks/TypeSlingResourceDTO.java
@@ -0,0 +1,37 @@
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ Licensed to the Apache Software Foundation (ASF) under one
+ ~ or more contributor license agreements. See the NOTICE file
+ ~ distributed with this work for additional information
+ ~ regarding copyright ownership. The ASF licenses this file
+ ~ to you under the Apache License, Version 2.0 (the
+ ~ "License"); you may not use this file except in compliance
+ ~ with the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing,
+ ~ software distributed under the License is distributed on an
+ ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ ~ KIND, either express or implied. See the License for the
+ ~ specific language governing permissions and limitations
+ ~ under the License.
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+package org.apache.sling.graphql.core.mocks;
+
+public class TypeSlingResourceDTO {
+ private final String path;
+ private final String resourceType;
+
+ public TypeSlingResourceDTO(String path, String resourceType) {
+ this.path = path;
+ this.resourceType = resourceType;
+ }
+
+ public String getPath() {
+ return path;
+ }
+
+ public String getResourceType() {
+ return resourceType;
+ }
+}
diff --git a/src/test/java/org/apache/sling/graphql/core/mocks/TypeTestDTO.java b/src/test/java/org/apache/sling/graphql/core/mocks/TypeTestDTO.java
new file mode 100644
index 0000000..2e087ae
--- /dev/null
+++ b/src/test/java/org/apache/sling/graphql/core/mocks/TypeTestDTO.java
@@ -0,0 +1,50 @@
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ Licensed to the Apache Software Foundation (ASF) under one
+ ~ or more contributor license agreements. See the NOTICE file
+ ~ distributed with this work for additional information
+ ~ regarding copyright ownership. The ASF licenses this file
+ ~ to you under the Apache License, Version 2.0 (the
+ ~ "License"); you may not use this file except in compliance
+ ~ with the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing,
+ ~ software distributed under the License is distributed on an
+ ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ ~ KIND, either express or implied. See the License for the
+ ~ specific language governing permissions and limitations
+ ~ under the License.
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+package org.apache.sling.graphql.core.mocks;
+
+public class TypeTestDTO {
+ private final boolean test;
+ private final boolean boolValue;
+ private final String resourcePath;
+ private final String testingArgument;
+
+ public TypeTestDTO(boolean test, boolean boolValue, String resourcePath, String testingArgument) {
+ this.test = test;
+ this.boolValue = boolValue;
+ this.resourcePath = resourcePath;
+ this.testingArgument = testingArgument;
+ }
+
+ public boolean isTest() {
+ return test;
+ }
+
+ public boolean isBoolValue() {
+ return boolValue;
+ }
+
+ public String getResourcePath() {
+ return resourcePath;
+ }
+
+ public String getTestingArgument() {
+ return testingArgument;
+ }
+
+}
diff --git a/src/test/java/org/apache/sling/graphql/core/engine/IntrospectionQueryTest.java b/src/test/java/org/apache/sling/graphql/core/mocks/UnionTypeResolver.java
similarity index 50%
copy from src/test/java/org/apache/sling/graphql/core/engine/IntrospectionQueryTest.java
copy to src/test/java/org/apache/sling/graphql/core/mocks/UnionTypeResolver.java
index 4c4d476..61ccc0c 100644
--- a/src/test/java/org/apache/sling/graphql/core/engine/IntrospectionQueryTest.java
+++ b/src/test/java/org/apache/sling/graphql/core/mocks/UnionTypeResolver.java
@@ -16,25 +16,26 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.sling.graphql.core.engine;
-import static com.jayway.jsonpath.matchers.JsonPathMatchers.hasJsonPath;
+package org.apache.sling.graphql.core.mocks;
-import static org.junit.Assert.assertThat;
-import static org.hamcrest.Matchers.contains;
+import org.apache.sling.graphql.api.SlingTypeResolver;
+import org.apache.sling.graphql.api.SlingTypeResolverEnvironment;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
-import org.junit.Test;
+public class UnionTypeResolver implements SlingTypeResolver<Object> {
-public class IntrospectionQueryTest extends ResourceQueryTestBase {
-
- @Test
- public void schemaIntrospectionTest() throws Exception {
- final String json = queryJSON("{ __schema { types { name } directives { description }}}");
- assertThat(json, hasJsonPath("$.data.__schema"));
- assertThat(json, hasJsonPath("$.data.__schema.types"));
- assertThat(json, hasJsonPath("$.data.__schema.types..name"));
- assertThat(json, hasJsonPath("$.data.__schema.directives"));
- assertThat(json, hasJsonPath("$.data.__schema.directives..description"));
+ @Nullable
+ @Override
+ public Object getType(@NotNull SlingTypeResolverEnvironment e) {
+ Object resultItem = e.getObject();
+ if (resultItem instanceof TypeTestDTO) {
+ return e.getObjectType("Test");
+ }
+ if (resultItem instanceof TypeSlingResourceDTO) {
+ return e.getObjectType("SlingResource");
+ }
+ return null;
}
-
}
diff --git a/src/test/java/org/apache/sling/graphql/core/schema/SchemaDescriptionsTest.java b/src/test/java/org/apache/sling/graphql/core/schema/SchemaDescriptionsTest.java
index 0b247a2..48500cd 100644
--- a/src/test/java/org/apache/sling/graphql/core/schema/SchemaDescriptionsTest.java
+++ b/src/test/java/org/apache/sling/graphql/core/schema/SchemaDescriptionsTest.java
@@ -30,7 +30,10 @@ import org.apache.sling.graphql.api.engine.QueryExecutor;
import org.apache.sling.graphql.core.engine.DefaultQueryExecutor;
import org.apache.sling.graphql.core.engine.ScriptedDataFetcherProvider;
import org.apache.sling.graphql.core.engine.SlingDataFetcherSelector;
+import org.apache.sling.graphql.core.engine.SlingTypeResolverSelector;
import org.apache.sling.graphql.core.mocks.MockSchemaProvider;
+import org.apache.sling.graphql.core.mocks.TestUtil;
+import org.apache.sling.graphql.core.mocks.UnionTypeResolver;
import org.apache.sling.graphql.core.scalars.SlingScalarsProvider;
import org.apache.sling.testing.mock.osgi.junit.OsgiContext;
import org.hamcrest.CustomMatcher;
@@ -104,6 +107,8 @@ public class SchemaDescriptionsTest {
context.bundleContext().registerService(ServletResolver.class, servletResolver, null);
context.registerInjectActivateService(new ScriptedDataFetcherProvider());
context.registerInjectActivateService(new SlingDataFetcherSelector());
+ context.registerInjectActivateService(new SlingTypeResolverSelector());
+ TestUtil.registerSlingTypeResolver(context.bundleContext(), "union/resolver", new UnionTypeResolver());
context.registerInjectActivateService(new SlingScalarsProvider());
context.registerService(SchemaProvider.class, new MockSchemaProvider("test-schema"));
context.registerInjectActivateService(new RankedSchemaProviders());
diff --git a/src/test/resources/test-schema.txt b/src/test/resources/failing-fetcher-schema.txt
similarity index 54%
copy from src/test/resources/test-schema.txt
copy to src/test/resources/failing-fetcher-schema.txt
index 0bcaa5d..a559d0f 100644
--- a/src/test/resources/test-schema.txt
+++ b/src/test/resources/failing-fetcher-schema.txt
@@ -22,40 +22,11 @@ directive @fetcher(
source : String = ""
) on FIELD_DEFINITION
-# GraphQL Schema used for our tests
+# Schema used to test invalid fetcher names
type Query {
currentResource : SlingResource @fetcher(name:"echoNS/echo")
-
- # Test some static values
- staticContent: Test @fetcher(name:"test/static")
-
- scriptedFetcher (testing : String) : Test @fetcher(name:"scripted/example")
}
-# This should be omitted from the SlingResource type description
-#
-# SlingResource, for our tests
type SlingResource {
- path: String
- resourceType: String
-
- pathMD5: String @fetcher(name:"sling/digest" options:"md5" source:"path")
-
- # SHA256 digest of the path
- pathSHA256: String @fetcher(name:"sling/digest" options:"sha-256" source:"path")
-
- # MD5 digest of the resource type
- resourceTypeMD5: String @fetcher(name:"sling/digest" options:"md5" source:"resourceType")
-
- nullValue: String @fetcher(name:"echoNS/echo" options:"null")
-
- # Failure message
- failure: String @fetcher(name:"failure/fail")
+ missingSlash: String @fetcher(name:"missingSlash")
}
-
-type Test {
- test: Boolean
- boolValue: Boolean
- resourcePath: String
- testingArgument: String
-}
\ No newline at end of file
diff --git a/src/test/resources/test-schema.txt b/src/test/resources/failing-type-resolver-schema.txt
similarity index 61%
copy from src/test/resources/test-schema.txt
copy to src/test/resources/failing-type-resolver-schema.txt
index 0bcaa5d..2e9694d 100644
--- a/src/test/resources/test-schema.txt
+++ b/src/test/resources/failing-type-resolver-schema.txt
@@ -16,11 +16,11 @@
# * under the License.
# This directive maps fields to our Sling data fetchers
-directive @fetcher(
+directive @resolver(
name : String,
options : String = "",
source : String = ""
-) on FIELD_DEFINITION
+) on UNION
# GraphQL Schema used for our tests
type Query {
@@ -30,32 +30,9 @@ type Query {
staticContent: Test @fetcher(name:"test/static")
scriptedFetcher (testing : String) : Test @fetcher(name:"scripted/example")
-}
-
-# This should be omitted from the SlingResource type description
-#
-# SlingResource, for our tests
-type SlingResource {
- path: String
- resourceType: String
-
- pathMD5: String @fetcher(name:"sling/digest" options:"md5" source:"path")
-
- # SHA256 digest of the path
- pathSHA256: String @fetcher(name:"sling/digest" options:"sha-256" source:"path")
-
- # MD5 digest of the resource type
- resourceTypeMD5: String @fetcher(name:"sling/digest" options:"md5" source:"resourceType")
-
- nullValue: String @fetcher(name:"echoNS/echo" options:"null")
- # Failure message
- failure: String @fetcher(name:"failure/fail")
+ # Test union as return type
+ unionFetcher: Test2 @fetcher(name:"union/fetcher")
}
-type Test {
- test: Boolean
- boolValue: Boolean
- resourcePath: String
- testingArgument: String
-}
\ No newline at end of file
+union AllTypes @resolver(name:"missingSlash" source:"AllTypes") = SlingResource | Test
diff --git a/src/test/resources/test-schema.txt b/src/test/resources/test-schema.txt
index 0bcaa5d..2ea0466 100644
--- a/src/test/resources/test-schema.txt
+++ b/src/test/resources/test-schema.txt
@@ -22,6 +22,13 @@ directive @fetcher(
source : String = ""
) on FIELD_DEFINITION
+# This directive to maps types
+directive @resolver(
+ name : String,
+ options : String = "",
+ source : String = ""
+) on UNION
+
# GraphQL Schema used for our tests
type Query {
currentResource : SlingResource @fetcher(name:"echoNS/echo")
@@ -30,8 +37,13 @@ type Query {
staticContent: Test @fetcher(name:"test/static")
scriptedFetcher (testing : String) : Test @fetcher(name:"scripted/example")
+
+ # Test union as return type
+ unionFetcher: Test2 @fetcher(name:"union/fetcher")
}
+union AllTypes @resolver(name:"union/resolver" source:"AllTypes") = SlingResource | Test
+
# This should be omitted from the SlingResource type description
#
# SlingResource, for our tests
@@ -51,6 +63,7 @@ type SlingResource {
# Failure message
failure: String @fetcher(name:"failure/fail")
+
}
type Test {
@@ -58,4 +71,9 @@ type Test {
boolValue: Boolean
resourcePath: String
testingArgument: String
-}
\ No newline at end of file
+}
+
+type Test2 {
+ items: [AllTypes]
+}
+