public async Task AddClassErrorFilter()
{
// arrange
ISchema schema = Schema.Create("type Query { foo: String }",
c => c.BindResolver(
ctx =>
{
throw new Exception("Foo");
}).To("Query", "foo"));
var options = new QueryExecutionOptions
{
IncludeExceptionDetails = false
};
IQueryExecutor executor = schema.MakeExecutable(builder =>
builder.UseDefaultPipeline(options)
.AddErrorFilter <DummyErrorFilter>());
// act
IExecutionResult result = await executor.ExecuteAsync("{ foo }");
// assert
result.MatchSnapshot();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddScoped <IRepository, InMemoryRepository>();
// this enables you to use DataLoader in your resolvers.
services.AddDataLoaderRegistry();
// Add GraphQL Services
var queryExecutionOptions = new QueryExecutionOptions
{
TracingPreference = TracingPreference.OnDemand
};
if (_environment.IsDevelopment())
{
queryExecutionOptions.TracingPreference = TracingPreference.Always;
queryExecutionOptions.IncludeExceptionDetails = true;
_logger.LogInformation(" *** LogInformation: In DEV Environment");
}
// Create our schema
var schemaDef = File.ReadAllText("schema.graphql");
var schema = Schema.Create(schemaDef, ConfigureSchema);
services.AddGraphQL(schema, queryExecutionOptions);
}
public async Task <List <TModel> > GetAllAsync(QueryExecutionOptions options = null)
{
using (var unitOfWork = ConnectionManager.Connect())
{
return((await unitOfWork.Connection.GetAllAsync <TModel>(ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds)).ToList());
}
}
public List <TModel> GetAll(QueryExecutionOptions options = null)
{
using (var unitOfWork = ConnectionManager.Connect())
{
return(unitOfWork.Connection.GetAll <TModel>(ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds).ToList());
}
}
public virtual async Task <bool> UpdateAsync(TModel model, QueryExecutionOptions options = null)
{
using (var unitOfWork = ConnectionManager.Connect())
{
return(await unitOfWork.Connection.UpdateAsync(model, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds));
}
}
public Task <TModel> GetByIdAsync(TKey id, QueryExecutionOptions options = null)
{
using (var unitOfWork = ConnectionManager.Connect())
{
return(unitOfWork.Connection.GetAsync <TModel>(id, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds));
}
}
public static IServiceCollection AddCustomGraphQl(this IServiceCollection collection)
{
var customOptions = new QueryExecutionOptions
{
ForceSerialExecution = true,
};
return(collection
.AddGraphQL(
provider => SchemaBuilder.New()
.AddAuthorizeDirectiveType()
// To restrict max number of fields in one page
.AddType(new PaginationAmountType(100))
.ModifyOptions(e =>
{
e.DefaultBindingBehavior = BindingBehavior.Explicit;
e.UseXmlDocumentation = true;
})
.BindClrType <Unit, VoidType>()
.BindClrType <TimeSpan, TimeSpanType>()
.AddMutationType <GraphQlMutations>()
.AddQueryType <GraphQlQueries>()
.AddServices(provider)
.Create(),
builder => builder
.Use <CustomGraphQlExceptionHandlingMiddleware>()
.UseDefaultPipeline())
.AddSingleton <IExecutionStrategyOptionsAccessor>(provider => customOptions));
}
public virtual async Task <bool> DeleteAsync(IEnumerable <TKey> ids, QueryExecutionOptions options = null)
{
foreach (var id in ids)
{
await DeleteAsync(id, options);
}
return(true);
}
public virtual bool Delete(IEnumerable <TKey> ids, QueryExecutionOptions options = null)
{
foreach (var id in ids)
{
Delete(id, options);
}
return(true);
}
public virtual async Task <bool> AddAsync(IEnumerable <TModel> models, QueryExecutionOptions options = null)
{
foreach (var model in models)
{
await AddAsync(model, options);
}
return(true);
}
public virtual bool Add(IEnumerable <TModel> models, QueryExecutionOptions options = null)
{
foreach (var model in models)
{
Add(model, options);
}
return(true);
}
private static IQueryExecutionOptionsAccessor CreateOptions()
{
var options = new QueryExecutionOptions();
options.ExecutionTimeout = TimeSpan.FromSeconds(30);
return(options);
}
public override sealed long Add(TModel model, QueryExecutionOptions options = null)
{
using (var unitOfWork = ConnectionManager.Connect())
{
model.Id = unitOfWork.Connection.Insert(model, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds);
return(model.Id);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//services.AddGraphQL(SchemaBuilder.New());
/*
* This is an alternative approach (workaround) to fix this behavior
*/
#region Workaround
Func <IServiceProvider, ISchema> factory = s => SchemaBuilder.New()
.AddServices(s)
.AddType <AuthorType>()
.AddType <BookType>()
.AddQueryType <Query>()
.Create();
var opts = new QueryExecutionOptions {
};
services.AddSingleton(sp =>
{
var d = sp.GetRequiredService <DiagnosticListener>();
var o = sp.GetServices <IDiagnosticObserver>();
BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance;
CultureInfo culture = null;
var instantiatedType = Activator.CreateInstance(typeof(QueryExecutionDiagnostics), flags, null, new object[] { d, o }, culture);
return(instantiatedType as QueryExecutionDiagnostics);
});
QueryExecutionBuilder.New()
.AddDefaultServices(opts)
.UseRequestTimeout()
.UseExceptionHandling()
.UseQueryParser()
.UseNoCachedQueryError()
.UseValidation()
.UseOperationResolver()
.UseMaxComplexity()
.UseOperationExecutor()
.Populate(services);
services.AddSingleton(factory);
services.AddSingleton <IIdSerializer, IdSerializer>()
.AddGraphQLSubscriptions();
services.AddJsonQueryResultSerializer().AddJsonArrayResponseStreamSerializer();
services.AddSingleton <IBatchQueryExecutor, BatchQueryExecutor>();
/* END */
#endregion
services.AddApplicationInsightsTelemetry();
}
public virtual async Task <TKey> AddAsync(TModel model, QueryExecutionOptions options = null)
{
using (var unitOfWork = ConnectionManager.Connect())
{
await unitOfWork.Connection.InsertAsync(model, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds);
return(model.Id);
}
}
private IQueryValidator CreateValidator()
{
var services = new ServiceCollection();
var options = new QueryExecutionOptions();
services.AddQueryValidation(options);
services.AddDefaultValidationRules();
return(services.BuildServiceProvider()
.GetRequiredService <IQueryValidator>());
}
public bool DeleteWhere(Expression <Func <TModel, bool> > where, QueryExecutionOptions options = null)
{
var(whereClauseSql, whereClauseParameters) = WhereClauseCompiler.ToSql(where, language: WhereClauseCompiler.Language.MYSQL);
var parameters = new DynamicParameters(whereClauseParameters);
using (var unitOfWork = ConnectionManager.Connect())
{
var rowsDeleted = unitOfWork.Connection.Execute($"DELETE FROM {TableName} WHERE {whereClauseSql}", parameters, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds);
return(rowsDeleted >= 0);
}
}
public override sealed bool Delete(IEnumerable <long> ids, QueryExecutionOptions options = null)
{
var(whereClauseSql, whereClauseParameters) = WhereClauseCompiler.ToSql <TModel>(x => ids.Contains(x.Id), language: WhereClauseCompiler.Language.MYSQL);
var parameters = new DynamicParameters(whereClauseParameters);
using (var unitOfWork = ConnectionManager.Connect())
{
var deletedRows = unitOfWork.Connection.Execute($"DELETE FROM {TableName} WHERE {whereClauseSql}", parameters, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds);
return(deletedRows >= 0);
}
}
public async Task ExecuteOperationMiddleware_Mutation_ExecutedSerially()
{
// arrange
var state = 0;
var schema = Schema.Create(
FileResource.Open("MutationExecutionSchema.graphql"),
cnf =>
{
cnf.BindResolver(() => state)
.To("Query", "state");
cnf.BindResolver(() => state)
.To("CurrentState", "theNumber");
cnf.BindResolver(
ctx => state = ctx.Argument <int>("newNumber"))
.To("Mutation", "changeTheNumber");
});
DocumentNode query = Parser.Default.Parse(
FileResource.Open("MutationExecutionQuery.graphql"));
OperationDefinitionNode operation = query.Definitions
.OfType <OperationDefinitionNode>()
.FirstOrDefault();
var request = new QueryRequest("{ a }").ToReadOnly();
var services = new DictionaryServiceProvider(
new KeyValuePair <Type, object>(
typeof(IErrorHandler),
ErrorHandler.Default));
var context = new QueryContext(schema, services, request)
{
Document = query,
Operation = operation
};
var options = new QueryExecutionOptions();
var strategyResolver = new ExecutionStrategyResolver(options);
var middleware = new ExecuteOperationMiddleware(
c => Task.CompletedTask,
strategyResolver,
new Cache <DirectiveLookup>(10));
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Result);
context.Result.Snapshot();
}
public virtual bool Update(IEnumerable <TModel> models, QueryExecutionOptions options = null)
{
bool result = true;
foreach (var model in models)
{
if (result)
{
result = result && Update(model, options);
}
}
return(result);
}
public virtual async Task <bool> UpdateAsync(IEnumerable <TModel> models, QueryExecutionOptions options = null)
{
bool result = true;
foreach (var model in models)
{
if (result)
{
result = result && await UpdateAsync(model, options);
}
}
return(result);
}
public virtual async Task <bool> DeleteAsync(TKey id, QueryExecutionOptions options = null)
{
using (var unitOfWork = ConnectionManager.Connect())
{
if (await unitOfWork.Connection.DeleteAsync(new TModel {
Id = id
}, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds))
{
return(true);
}
}
return(false);
}
public async Task FilterOnlyNullRefExceptions()
{
// arrange
ISchema schema = Schema.Create(
"type Query { foo: String bar: String }",
c =>
{
// will be handled by the default filter logic
c.BindResolver(
ctx =>
{
throw new Exception("Foo");
}).To("Query", "foo");
// will be handled by the custom filter logic
c.BindResolver(
ctx =>
{
throw new NullReferenceException("Foo");
}).To("Query", "bar");
});
var options = new QueryExecutionOptions
{
IncludeExceptionDetails = false,
ExecutionTimeout = TimeSpan.FromMinutes(10)
};
IQueryExecutor executor = schema.MakeExecutable(builder =>
builder.UseDefaultPipeline(options)
.AddErrorFilter(error =>
{
if (error.Exception is NullReferenceException)
{
return(error.WithCode("NullRef"));
}
return(error);
}));
// act
IExecutionResult result =
await executor.ExecuteAsync("{ foo bar }");
// assert
result.MatchSnapshot(o =>
o.IgnoreField("Errors[0].Exception")
.IgnoreField("Errors[1].Exception"));
}
public List <TModel> GetWhere(Expression <Func <TModel, bool> > where, QueryExecutionOptions options = null)
{
var limit = options?.ResultLimit;
if (limit.HasValue && limit.Value <= 0)
{
return(new List <TModel>());
}
var(query, parameters) = BuildGetWhereQuery(where, options);
using (var unitOfWork = ConnectionManager.Connect())
{
return(unitOfWork.Connection.Query <TModel>(query, parameters, ConnectionManager.GetCurrentTransaction(), commandTimeout: options?.TimeoutInSeconds).ToList());
}
}
public Startup(IConfiguration configuration, IWebHostEnvironment environment)
{
Configuration = configuration;
Environment = environment;
_queryExecutionOptions = new QueryExecutionOptions
{
MaxExecutionDepth = 32,
MaxOperationComplexity = 256,
IncludeExceptionDetails = Environment.IsDevelopment(),
ExecutionTimeout = new TimeSpan(0, 0, 10),
ForceSerialExecution = true
};
// register API types
_schema = SchemaBuilder.New()
.BindClrType <int, IntType>()
.BindClrType <string, StringType>()
.BindClrType <bool, BooleanType>()
.AddQueryType(x => x.Name("Query"))
.AddMutationType(x => x.Name("Mutation"))
.AddEnumType <AuthorizationErrorCodes>(x => x.BindValuesImplicitly())
.AddEnumType <UserSignUpErrorCode>(x => x.BindValuesImplicitly())
.AddEnumType <UserSignInErrorCode>(x => x.BindValuesImplicitly())
.AddType(new PaginationAmountType(64))
.AddType <MailType>()
.AddType <MailQueryType>()
.AddType <MailMutationType>()
.AddType <MailFilterInputType>()
.AddType <MailCreateInputType>()
.AddType <MailUpdateInputType>()
.AddType <MailDeleteInputType>()
.AddType <UserMutationType>()
.AddType <UserSignUpPayloadType>()
.AddType <UserSignInPayloadType>()
.AddType <MailGroupType>()
.AddType <MailGroupQueryType>()
.AddType <MailGroupMutationType>()
.AddType <MailGroupCreateInputType>()
.AddType <MailGroupUpdateInputType>()
.AddType <MailGroupDeleteInputType>()
.AddType <MailGroupMailType>()
.AddType <MailGroupMailMutationType>()
.ModifyOptions(x => x.DefaultBindingBehavior = BindingBehavior.Explicit)
.Create();
}
public void AddGraphQL_ServicesSchemaConfigOptions()
{
// arrange
var services = new ServiceCollection();
var options = new QueryExecutionOptions();
// act
ServiceCollectionExtensions.AddGraphQL(
services,
c => c.Options.StrictValidation = false,
options);
// assert
services.Select(t => ReflectionUtils.GetTypeName(t.ServiceType))
.OrderBy(t => t, StringComparer.Ordinal)
.ToArray()
.MatchSnapshot();
}
public async Task ExecuteOperationMiddleware_Mutation_ExecutedSerially()
{
// arrange
var state = 0;
var schema = Schema.Create(
FileResource.Open("MutationExecutionSchema.graphql"),
cnf =>
{
cnf.BindResolver(() => state)
.To("Query", "state");
cnf.BindResolver(() => state)
.To("CurrentState", "theNumber");
cnf.BindResolver(
ctx => state = ctx.Argument <int>("newNumber"))
.To("Mutation", "changeTheNumber");
});
DocumentNode query = Parser.Default.Parse(
FileResource.Open("MutationExecutionQuery.graphql"));
OperationDefinitionNode operationNode = query.Definitions
.OfType <OperationDefinitionNode>()
.FirstOrDefault();
var operation = new Operation
(
query,
operationNode,
new VariableValueBuilder(
schema,
operationNode)
.CreateValues(new Dictionary <string, object>()),
schema.MutationType,
null
);
IReadOnlyQueryRequest request = new QueryRequest("{ a }");
var observable = new DiagnosticListener("Foo");
var services = new DictionaryServiceProvider(
new KeyValuePair <Type, object>(
typeof(IErrorHandler),
ErrorHandler.Default),
new KeyValuePair <Type, object>(
typeof(DiagnosticListener),
observable),
new KeyValuePair <Type, object>(
typeof(DiagnosticSource),
observable));
var context = new QueryContext
(
schema,
services.CreateRequestServiceScope(),
request,
fs => fs.Field.Middleware
)
{
Document = query,
Operation = operation
};
var options = new QueryExecutionOptions();
var strategyResolver = new ExecutionStrategyResolver(options);
var diagnostics = new QueryExecutionDiagnostics(
new DiagnosticListener("Foo"),
new IDiagnosticObserver[0],
TracingPreference.Never);
var middleware = new ExecuteOperationMiddleware(
c => Task.CompletedTask,
strategyResolver,
new Cache <DirectiveMiddlewareCompiler>(10),
diagnostics);
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Result);
context.Result.Snapshot();
}
public void ExecuteIntersectionQuery(BoundingBox bounds, FeatureDataTable table, QueryExecutionOptions options)
{
throw new NotImplementedException();
}
public IFeatureDataReader ExecuteIntersectionQuery(BoundingBox bounds, QueryExecutionOptions options)
{
throw new NotImplementedException();
}
public IAsyncResult BeginExecuteIntersectionQuery(BoundingBox bounds, FeatureDataTable table,
QueryExecutionOptions options, AsyncCallback callback,
object asyncState)
{
throw new NotImplementedException();
}
