public async Task ExplicitModel()
{
await using var database = await sqlInstance.Build();
var dbContext = database.Context;
await AddData(dbContext);
var services = BuildServiceCollection();
services.AddSingleton <DependencySchema>();
EfGraphQLConventions.RegisterInContainer(
services,
userContext => ((UserContextSingleDb <DependencyDbContext>)userContext).DbContext,
sqlInstance.Model);
await using var provider = services.BuildServiceProvider();
using var schema = provider.GetRequiredService <DependencySchema>();
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
UserContext = new UserContextSingleDb <DependencyDbContext>(dbContext),
Inputs = null
};
await ExecutionResultData(executionOptions);
}
public static async Task <object> ExecuteQuery <TDbContext>(
string query,
ServiceCollection services,
TDbContext dbContext,
Inputs inputs,
GlobalFilters filters)
where TDbContext : DbContext
{
query = query.Replace("'", "\"");
EfGraphQLConventions.RegisterInContainer(
services,
dbContext,
userContext => (TDbContext)userContext,
filters);
using (var provider = services.BuildServiceProvider())
using (var schema = new Schema(new FuncDependencyResolver(provider.GetRequiredService)))
{
var documentExecuter = new EfDocumentExecuter();
#region ExecutionOptionsWithFixIdTypeRule
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
UserContext = dbContext,
Inputs = inputs,
ValidationRules = FixIdTypeRule.CoreRulesWithIdFix
};
#endregion
var executionResult = await documentExecuter.ExecuteWithErrorCheck(executionOptions);
return(executionResult.Data);
}
}
public async Task TransientDbContext()
{
await using var database = await sqlInstance.Build();
var dbContext = database.Context;
await AddData(dbContext);
var services = BuildServiceCollection();
services.AddTransient(_ => database.Context);
EfGraphQLConventions.RegisterInContainer(
services,
userContext => ((UserContextSingleDb <DependencyDbContext>)userContext).DbContext);
await using var provider = services.BuildServiceProvider();
using var schema = new DependencySchema(provider);
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
UserContext = new UserContextSingleDb <DependencyDbContext>(dbContext),
Inputs = null
};
await ExecutionResultData(executionOptions);
}
public async Task Resolve()
{
await using var database = await sqlInstance.Build();
var parent = new MappingParent();
var child = new MappingChild
{
Parent = parent
};
await database.AddDataUntracked(child, parent);
var services = new ServiceCollection();
services.AddSingleton <MappingQuery>();
EfGraphQLConventions.RegisterInContainer(services, _ => database.NewDbContext(), model: sqlInstance.Model);
await using var provider = services.BuildServiceProvider();
var mappingQuery = provider.GetRequiredService <MappingQuery>();
var resolve = await(Task <IEnumerable <MappingChild> >) mappingQuery.Fields
.Single(x => x.Name == "children")
.Resolver !
.Resolve(new ResolveFieldContext()) !;
await Verify(resolve);
}
public async Task ExplicitModel()
{
using (var database = await sqlInstance.Build())
{
var dbContext = database.Context;
await AddData(dbContext);
var services = BuildServiceCollection();
EfGraphQLConventions.RegisterInContainer(
services,
userContext => (DependencyDbContext)userContext,
ModelBuilder.Instance);
using (var provider = services.BuildServiceProvider())
using (var schema = new DependencySchema(provider))
{
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
UserContext = dbContext,
Inputs = null
};
await ExecutionResultData(executionOptions);
}
}
}
public static async Task <object> ExecuteQuery <TDbContext>(
string query,
ServiceCollection services,
TDbContext data,
Inputs?inputs,
Filters?filters)
where TDbContext : DbContext
{
query = query.Replace("'", "\"");
EfGraphQLConventions.RegisterInContainer(
services,
userContext => data,
data.Model,
userContext => filters);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
await using var provider = services.BuildServiceProvider();
using var schema = new Schema(provider);
var documentExecuter = new EfDocumentExecuter();
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
UserContext = new UserContextSingleDb <TDbContext>(data),
Inputs = inputs,
};
var executionResult = await documentExecuter.ExecuteWithErrorCheck(executionOptions);
return(executionResult.Data);
}
public static async Task <object> ExecuteQuery <TDbContext>(
string query,
ServiceCollection services,
TDbContext dbContext,
Inputs?inputs,
Filters?filters)
where TDbContext : DbContext
{
query = query.Replace("'", "\"");
EfGraphQLConventions.RegisterInContainer(
services,
userContext => (TDbContext)((Dictionary <string, object>)userContext)[typeof(TDbContext).Name],
dbContext.Model,
userContext => filters);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
await using var provider = services.BuildServiceProvider();
using var schema = new Schema(provider);
var documentExecuter = new EfDocumentExecuter();
#region ExecutionOptionsWithFixIdTypeRule
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
Inputs = inputs,
ValidationRules = FixIdTypeRule.CoreRulesWithIdFix
};
executionOptions.UserContext.Add(typeof(TDbContext).Name, dbContext);
#endregion
var executionResult = await documentExecuter.ExecuteWithErrorCheck(executionOptions);
return(executionResult.Data);
}
public async Task ScopedDbContext()
{
using var database = await sqlInstance.Build();
var dbContext = database.Context;
await AddData(dbContext);
var services = BuildServiceCollection();
services.AddScoped(x => { return(database.Context); });
EfGraphQLConventions.RegisterInContainer(
services,
userContext => (DependencyDbContext)userContext);
using var provider = services.BuildServiceProvider();
using var schema = new DependencySchema(provider);
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
UserContext = dbContext,
Inputs = null
};
await ExecutionResultData(executionOptions);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//services.AddDbContext<BlogDbContext>(options =>
// options.UseSqlServer(Configuration.GetConnectionString("MainDatabase")));
services.AddSingleton(_ => { return(BlogDbContextEfFactory.CreateDbContext(Configuration)); });
EfGraphQLConventions.RegisterInContainer(
services,
userContext => { return(BlogDbContextEfFactory.CreateDbContext(Configuration)); });
services.AddGraphQL(options => options.ExposeExceptions = true);
services.AddSingleton <MainSchema>();
services.AddSingleton <MainQuery>();
services.AddSingleton <CountryGraph>();
services.AddSingleton <AddressGraph>();
services.AddSingleton <UserGraph>();
services.AddSingleton <PostGraph>();
GraphTypeTypeRegistry.Register <Country, CountryGraph>();
GraphTypeTypeRegistry.Register <Address, AddressGraph>();
GraphTypeTypeRegistry.Register <User, UserGraph>();
GraphTypeTypeRegistry.Register <Post, PostGraph>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.Configure <KestrelServerOptions>(o => { o.AllowSynchronousIO = true; });
services.Configure <IISServerOptions>(o => { o.AllowSynchronousIO = true; });
}
public void ConfigureServices(IServiceCollection services)
{
GraphTypeTypeRegistry.Register <Employee, EmployeeGraph>();
GraphTypeTypeRegistry.Register <EmployeeSummary, EmployeeSummaryGraph>();
GraphTypeTypeRegistry.Register <Company, CompanyGraph>();
services.AddScoped(_ => DbContextBuilder.BuildDbContext());
EfGraphQLConventions.RegisterInContainer <GraphQlEfSampleDbContext>(
services,
model: GraphQlEfSampleDbContext.StaticModel);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
var graphQl = services.AddGraphQL(
options => options.ExposeExceptions = true);
graphQl.AddWebSockets();
services.AddSingleton <ContextFactory>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc(option => option.EnableEndpointRouting = false);
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvc.AddNewtonsoftJson();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddDbContext <AppDbContext>(
bd =>
{
bd.UseMySql("fake");
}
);
/**
* GraphQL schema
*/
// nahradit neskor tymto https://github.com/SimonCropp/GraphQL.EntityFramework/blob/master/doco/configuration.md#connection-types
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
services.AddSingleton <Query>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDocumentWriter, DocumentWriter>();
services.AddSingleton <ISchema, GraphQLSchema>();
services.AddSingleton <IDependencyResolver>(x =>
new FuncDependencyResolver(type => x.GetRequiredService(type)));
}
public async Task ScopedDbContext()
{
await using var database = await sqlInstance.Build();
var dbContext = database.Context;
await AddData(dbContext);
var services = BuildServiceCollection();
services.AddScoped(x => database.Context);
EfGraphQLConventions.RegisterInContainer(
services,
userContext => (DependencyDbContext)((Dictionary <string, object>)userContext)["dbContext"]);
await using var provider = services.BuildServiceProvider();
using var schema = new DependencySchema(provider);
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query,
Inputs = null
};
executionOptions.UserContext.Add("dbContext", dbContext);
await ExecutionResultData(executionOptions);
}
public void ConfigureServices(IServiceCollection services)
{
GraphTypeTypeRegistry.Register <Employee, EmployeeGraph>();
GraphTypeTypeRegistry.Register <EmployeeSummary, EmployeeSummaryGraph>();
GraphTypeTypeRegistry.Register <Company, CompanyGraph>();
EfGraphQLConventions.RegisterInContainer <SampleDbContext>(
services,
model: SampleDbContext.StaticModel);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
//TODO: re add for subscriptions
//var graphQl = services.AddGraphQL(
// options => options.ExposeExceptions = true);
//graphQl.AddWebSockets();
var dbContextBuilder = new DbContextBuilder();
services.AddSingleton <IHostedService>(dbContextBuilder);
services.AddSingleton <Func <SampleDbContext> >(_ => dbContextBuilder.BuildDbContext);
services.AddScoped(_ => dbContextBuilder.BuildDbContext());
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc(option => option.EnableEndpointRouting = false);
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvc.AddNewtonsoftJson();
}
public async Task SchemaPrint()
{
await using var database = await sqlInstance.Build();
var dbContext = database.Context;
var services = new ServiceCollection();
services.AddSingleton <Query>();
services.AddSingleton <Mutation>();
services.AddSingleton(database.Context);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
EfGraphQLConventions.RegisterInContainer(services, _ => dbContext, dbContext.Model);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
await using var provider = services.BuildServiceProvider();
using var schema = new Schema(provider);
var printer = new SchemaPrinter(schema);
var print = printer.Print();
await Verify(print);
}
public static async Task <object> ExecuteQuery(string queryString, ServiceCollection services, DbContext dataContext, Inputs inputs)
{
queryString = queryString.Replace("'", "\"");
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
EfGraphQLConventions.RegisterInContainer(services, dataContext);
using (var provider = services.BuildServiceProvider())
using (var schema = new Schema(new FuncDependencyResolver(provider.GetRequiredService)))
{
var documentExecuter = new DocumentExecuter();
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = queryString,
UserContext = dataContext,
Inputs = inputs
};
var executionResult = await documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (executionResult.Errors != null && executionResult.Errors.Count > 0)
{
if (executionResult.Errors.Count == 1)
{
throw executionResult.Errors.First();
}
throw new AggregateException(executionResult.Errors);
}
return(executionResult.Data);
}
}
public void ConfigureServices(IServiceCollection services)
{
GraphTypeTypeRegistry.Register <Employee, EmployeeGraph>();
GraphTypeTypeRegistry.Register <EmployeeSummary, EmployeeSummaryGraph>();
GraphTypeTypeRegistry.Register <Company, CompanyGraph>();
services.AddScoped(provider => DataContextBuilder.BuildDataContext());
EfGraphQLConventions.RegisterInContainer(services, DataContextBuilder.Model);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
services.AddGraphQL(options => options.ExposeExceptions = true).AddWebSockets();
services.AddSingleton <ContextFactory>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc();
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
}
public static async Task <string> ExecuteQuery <TDbContext>(
string query,
ServiceCollection services,
TDbContext data,
Inputs?inputs,
Filters?filters,
bool disableTracking)
where TDbContext : DbContext
{
query = query.Replace("'", "\"");
EfGraphQLConventions.RegisterInContainer(
services,
_ => data,
data.Model,
_ => filters,
disableTracking);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
await using var provider = services.BuildServiceProvider();
using Schema schema = new(provider);
EfDocumentExecuter executer = new();
ExecutionOptions options = new()
{
Schema = schema,
Query = query,
UserContext = new UserContextSingleDb <TDbContext>(data),
Inputs = inputs,
};
var result = await executer.ExecuteWithErrorCheck(options);
return(await result.Serialize());
}
void RegisterInContainerServiceCollectionUsage(IServiceCollection serviceCollection)
{
#region RegisterInContainerServiceCollectionUsage
EfGraphQLConventions.RegisterInContainer(serviceCollection, MyDataContext.DataModel);
#endregion
}
void RegisterInContainerViaServiceProviderUsage(IServiceCollection serviceCollection)
{
#region RegisterInContainerViaServiceProviderUsage
EfGraphQLConventions.RegisterInContainer(
serviceCollection,
userContext => (MyDbContext)userContext);
#endregion
}
void RegisterInContainerExplicit(IServiceCollection serviceCollection)
{
#region RegisterInContainer
EfGraphQLConventions.RegisterInContainer <MyDbContext>(
serviceCollection,
model: ModelBuilder.GetInstance());
#endregion
}
public void Add(ServiceCollection services)
{
#region add-filter
var filters = new Filters();
filters.Add <MyEntity>(
(userContext, item) => item.Property != "Ignore");
EfGraphQLConventions.RegisterInContainer <MyDbContext>(
services,
resolveFilters: x => filters);
#endregion
}
public void Add(ServiceCollection services, IModel model)
{
#region add-filter
var filters = new GlobalFilters();
filters.Add <MyEntity>(
(userContext, item) =>
{
return(item.Property != "Ignore");
});
EfGraphQLConventions.RegisterInContainer(services, model, filters);
#endregion
}
public async Task SchemaPrint()
{
ServiceCollection services = new();
EfGraphQLConventions.RegisterInContainer <MappingContext>(services, model: sqlInstance.Model);
services.AddSingleton <MappingChildGraph>();
services.AddSingleton <MappingParentGraph>();
services.AddSingleton <MappingSchema>();
await using var provider = services.BuildServiceProvider();
var mappingSchema = provider.GetRequiredService <MappingSchema>();
SchemaPrinter printer = new(mappingSchema);
var print = printer.Print();
await Verifier.Verify(print);
}
public async Task SchemaPrint()
{
var graphQlService = new EfGraphQLService <MappingContext>(sqlInstance.Model, _ => null !);
ServiceCollection services = new();
EfGraphQLConventions.RegisterInContainer <MappingContext>(services);
services.AddSingleton(new MappingChildGraph(graphQlService));
services.AddSingleton(new MappingParentGraph(graphQlService));
await using var provider = services.BuildServiceProvider();
var mappingSchema = new MappingSchema(graphQlService, provider);
var printer = new SchemaPrinter(mappingSchema);
var print = printer.Print();
await Verifier.Verify(print);
}
void RegisterInContainerServiceCollectionUsage(IServiceCollection serviceCollection)
{
#region RegisterInContainerServiceCollectionUsage
var builder = new DbContextOptionsBuilder();
builder.UseSqlServer("fake");
using (var context = new MyDbContext(builder.Options))
{
EfGraphQLConventions.RegisterInContainer(
serviceCollection,
dbContext: context,
dbContextFromUserContext: userContext => (MyDbContext)userContext);
}
#endregion
}
private void ConfigureGraphQLInfrastructure(IServiceCollection services, string connectionString)
{
using (var context = new NorthwindContext(connectionString))
{
EfGraphQLConventions.RegisterInContainer(services, context);
}
foreach (var t in GetGraphQlTypes())
{
services.AddSingleton(t);
}
services.AddSingleton <IDocumentExecuter, DocumentExecuter>();
services.AddSingleton <IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetRequiredService));
services.AddSingleton <ISchema, Infrastructure.Schema>();
services.AddSingleton(typeof(Infrastructure.Strategies.IMutationStrategy <>), typeof(Infrastructure.Strategies.MutationStrategy <>));
}
public void ConfigureServices(IServiceCollection services)
{
GraphTypeTypeRegistry.Register <Employee, EmployeeGraph>();
GraphTypeTypeRegistry.Register <EmployeeSummary, EmployeeSummaryGraph>();
GraphTypeTypeRegistry.Register <Company, CompanyGraph>();
//services.AddScoped(provider => DbContextBuilder.BuildDbContext());
//EfGraphQLConventions.RegisterInContainer(
// services,
// DbContextBuilder.BuildDbContext(),
// userContext => (GraphQlEfSampleDbContext) userContext);
services.AddDbContext <TestContext>(options => options.UseSqlServer("Data Source=VASIC;Initial Catalog=GraphQLEntityFrameworkSample;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"));
var optionsBuilder = new DbContextOptionsBuilder <TestContext>();
optionsBuilder.UseSqlServer("Data Source=VASIC;Initial Catalog=GraphQLEntityFrameworkSample;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False");
using (var context = new TestContext(optionsBuilder.Options))
{
EfGraphQLConventions.RegisterInContainer(
services,
context,
userContext => (TestContext)userContext);
}
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
services.AddGraphQL(options => options.ExposeExceptions = true).AddWebSockets();
services.AddSingleton <ContextFactory>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc();
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <BlogContext>(options =>
options.UseNpgsql(Configuration.GetSection("Database:ConnectionString").Value));
services.AddSingleton <IBlogContext, BlogContext>();
// GraphQL
GraphTypeTypeRegistry.Register <Post, PostGraph>();
GraphTypeTypeRegistry.Register <User, UserGraph>();
EfGraphQLConventions.RegisterInContainer(services, (context) => (context as GraphQLUserContext)?.Context);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <ISchema, GraphQLSchema>();
// Import also all the other created Graphs
foreach (Type type in GetGraphQlTypes())
{
services.AddScoped(type);
}
services.AddMvc(option => option.EnableEndpointRouting = false);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <Data.TaskContext>(opt => opt.UseSqlServer("Server=(localdb)\\MSSQLLocalDB;Database=Tasks;Trusted_Connection=True;MultipleActiveResultSets=true"));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
var serviceProvider = services.BuildServiceProvider();
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
using (var scope = serviceProvider.CreateScope())
EfGraphQLConventions.RegisterInContainer(services, serviceProvider.GetService <Data.TaskContext>());
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
services.AddSingleton <IDocumentExecuter, DocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService)
);
services.AddSingleton <ISchema, Schema>();
}
public void ConfigureServices(IServiceCollection services)
{
services.AddScoped(provider => DataContextBuilder.BuildDataContext());
using (var myDataContext = DataContextBuilder.BuildDataContext())
{
EfGraphQLConventions.RegisterInContainer(services, myDataContext);
}
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
services.AddSingleton <IDocumentExecuter, DocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc();
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
}
