public void AddSchema()
{
// arrange
StitchingBuilder stitchingBuilder = StitchingBuilder.New();
DocumentNode schema_a = Parser.Default.Parse(
"type A { b: String }");
DocumentNode schema_b = Parser.Default.Parse(
"type B { c: String }");
// act
stitchingBuilder.AddSchema("a", s => schema_a)
.AddSchema("b", s => schema_b);
// assert
var services = new ServiceCollection();
stitchingBuilder.Populate(services);
DocumentNode schema = services.BuildServiceProvider()
.GetRequiredService <StitchingBuilder.StitchingFactory>()
.MergedSchema;
SchemaSyntaxSerializer.Serialize(schema).MatchSnapshot();
}
private static DocumentNode MergeSchemas(
StitchingBuilder builder,
IDictionary <NameString, DocumentNode> schemas)
{
var merger = new SchemaMerger();
foreach (NameString name in schemas.Keys)
{
merger.AddSchema(name, schemas[name]);
}
foreach (MergeTypeRuleFactory handler in builder._mergeRules)
{
merger.AddMergeRule(handler);
}
foreach (IDocumentRewriter rewriter in builder._docRewriters)
{
merger.AddDocumentRewriter(rewriter);
}
foreach (ITypeRewriter rewriter in builder._typeRewriters)
{
merger.AddTypeRewriter(rewriter);
}
return(merger.Merge());
}
private StitchingFactory(
StitchingBuilder builder,
IReadOnlyList <IRemoteExecutorAccessor> executors,
DocumentNode mergedSchema)
{
_builder = builder;
_executors = executors;
MergedSchema = mergedSchema;
}
private StitchingFactory(
StitchingBuilder builder,
IReadOnlyList <IRemoteExecutorAccessor> executors,
DocumentNode mergedSchema)
{
_builder = builder;
_executors = executors;
MergedSchema = mergedSchema;
_options = _builder._options ?? new QueryExecutionOptions();
}
private static void VisitMerged(
StitchingBuilder builder,
DocumentNode schema)
{
if (builder._mergedDocVis.Count > 0)
{
foreach (Action <DocumentNode> visitor in
builder._mergedDocVis)
{
visitor.Invoke(schema);
}
}
}
public void AddSchema_LoadSchemaIsNull_ArgumentNullException()
{
// arrange
StitchingBuilder stitchingBuilder = StitchingBuilder.New();
NameString schemName = "abc";
// act
Action action = () => stitchingBuilder.AddSchema(
schemName, (LoadSchemaDocument)null);
// assert
Assert.Equal("loadSchema",
Assert.Throws <ArgumentNullException>(action).ParamName);
}
public void AddSchema_SchemaNameIsEmpty_ArgumentNullException()
{
// arrange
StitchingBuilder stitchingBuilder = StitchingBuilder.New();
NameString schemName = "abc";
// act
Action action = () => stitchingBuilder.AddSchema(
null, sp => new DocumentNode(new List <IDefinitionNode>()));
// assert
Assert.Equal("name",
Assert.Throws <ArgumentException>(action).ParamName);
}
private static DocumentNode RewriteMerged(
StitchingBuilder builder,
DocumentNode schema)
{
if (builder._mergedDocRws.Count == 0)
{
return(schema);
}
DocumentNode current = schema;
foreach (Func <DocumentNode, DocumentNode> rewriter in
builder._mergedDocRws)
{
current = rewriter.Invoke(current);
}
return(current);
}
public void AddSchema_SchemaAlreadyRegistered_2_ArgumentNullException()
{
// arrange
StitchingBuilder stitchingBuilder = StitchingBuilder.New();
NameString schemName = "abc";
stitchingBuilder.AddQueryExecutor(
schemName,
sp => default(IQueryExecutor));
// act
Action action = () => stitchingBuilder.AddSchema(
schemName,
sp => new DocumentNode(new List <IDefinitionNode>()));
// assert
Assert.Equal("name",
Assert.Throws <ArgumentException>(action).ParamName);
}
public static StitchingFactory Create(
StitchingBuilder builder,
IServiceProvider services)
{
// fetch schemas for createing remote schemas
IDictionary <NameString, DocumentNode> remoteSchemas =
LoadSchemas(builder._schemas, services);
// fetch schema extensions
IReadOnlyList <DocumentNode> extensions =
LoadExtensions(builder._extensions, services);
// add local remote executors
var executors = new List <IRemoteExecutorAccessor>(
services.GetServices <IRemoteExecutorAccessor>());
// create schema map for merge process
var allSchemas = new Dictionary <NameString, DocumentNode>(
remoteSchemas);
// add schemas from local remote schemas for merging them
AddSchemasFromExecutors(allSchemas, executors);
// add remote executors
executors.AddRange(CreateRemoteExecutors(remoteSchemas));
// merge schema
DocumentNode mergedSchema = MergeSchemas(builder, allSchemas);
mergedSchema = AddExtensions(mergedSchema, extensions);
mergedSchema = RewriteMerged(builder, mergedSchema);
mergedSchema = RemoveBuiltInTypes(mergedSchema);
mergedSchema = RemoveDirectives(mergedSchema);
VisitMerged(builder, mergedSchema);
// create factory
return(new StitchingFactory(builder, executors, mergedSchema));
}
