public GraphQLVisitor(ISchemaProvider schemaProvider, IMethodProvider methodProvider, QueryVariables variables, ClaimsIdentity claims)
{
this.claims = claims;
this.schemaProvider = schemaProvider;
this.methodProvider = methodProvider;
this.variables = variables;
}
public QueryPropertyWalkerVisitorBase(
IServiceProvider serviceProvider,
IMethodProvider methodProvider)
: base(serviceProvider)
{
MethodProvider = methodProvider;
}
public DefaultExpressionVisitor(
IPropertyValueProvider <T> propertyValueProvider = null,
IMethodProvider <T> methodProvider = null)
{
this.propertyValueProvider = propertyValueProvider ?? new ReflectionPropertyValueProvider <T>();
this.methodProvider = methodProvider ?? new ReflectionMethodProvider <T>();
}
public CategoryValidator(ICategoryValidationService categoryValidationService,
IMethodProvider methodProvider)
{
CascadeMode = CascadeMode.Stop;
var methodType = methodProvider.GetMethodUpperName();
RuleFor(r => r.Id)
.NotNull()
.NotEmpty()
.MustAsync(categoryValidationService.CategoryExistsAsync)
.WithMessage("Category with this id doesn't exists.")
.When(dto => methodType == "PUT");
RuleFor(r => r.Id)
.MustAsync(categoryValidationService.CategoryIdNotExistsAsync)
.WithMessage("Category with this id already exists.")
.When(dto => methodType == "POST");
RuleFor(r => r.Name)
.NotNull()
.NotEmpty()
.MaximumLength(50);
RuleFor(r => r.Name)
.MustAsync(categoryValidationService.CategoryNameNotExistsAsync)
.WithMessage("Category with this name already exists.")
.When(dto => methodType == "POST");
RuleFor(r => r.Name)
.MustAsync(async(category, name, cancellation) =>
await categoryValidationService.CategoryNameChangedAndNotExistsAsync(category.Id, name, cancellation))
.WithMessage("Category with this name already exists.")
.When(dto => methodType == "PUT");
}
public QueryGrammerNodeVisitor(Expression expression, ISchemaProvider schemaProvider, IMethodProvider methodProvider, QueryVariables variables)
{
currentContext = (ExpressionResult)expression;
this.schemaProvider = schemaProvider;
this.methodProvider = methodProvider;
this.variables = variables;
}
public override void Enumerate(IMemberCompletionAcceptor acceptor)
{
if (acceptor == null)
{
throw ExceptionBuilder.ArgumentNull("acceptor");
}
// Report all columns accessible by the table ref.
TableRefBinding tableRefBinding = new TableRefBinding(null, _tableBinding, _correlationName);
foreach (ColumnBinding columnBinding in _tableBinding.Columns)
{
ColumnRefBinding columnRefBinding = new ColumnRefBinding(tableRefBinding, columnBinding);
acceptor.AcceptColumnRef(columnRefBinding);
}
// Now contribute any methods accessible by the row type.
IMethodProvider methodProvider = _scope.DataContext.MetadataContext.MethodProviders[_tableBinding.RowType];
if (methodProvider != null)
{
MethodBinding[] methods = methodProvider.GetMethods(_tableBinding.RowType);
foreach (MethodBinding methodBinding in methods)
{
acceptor.AcceptMethod(methodBinding);
}
}
}
/// <summary>
/// ctor
/// </summary>
/// <param name="propertyProvider"></param>
/// <param name="propertyValidator"></param>
/// <param name="methodProvider"></param>
/// <param name="methodValidator"></param>
public ObjectValidator(IPropertyProvider propertyProvider, IPropertyValidator propertyValidator, IMethodProvider methodProvider, IMethodValidator methodValidator)
{
this.propertyProvider = propertyProvider;
this.propertyValidator = propertyValidator;
this.methodProvider = methodProvider;
this.methodValidator = methodValidator;
}
public override void Enumerate(IMemberCompletionAcceptor acceptor)
{
if (acceptor == null)
{
throw ExceptionBuilder.ArgumentNull("acceptor");
}
NamedConstantExpression namedConstantExpression = _expressionBeforeDot as NamedConstantExpression;
ParameterExpression parameterExpression = _expressionBeforeDot as ParameterExpression;
IList <PropertyBinding> properties = null;
if (namedConstantExpression == null && parameterExpression == null)
{
// The properties must be provided by a regular property provider.
IPropertyProvider propertyProvider = _scope.DataContext.MetadataContext.PropertyProviders[_expressionBeforeDot.ExpressionType];
if (propertyProvider != null)
{
properties = propertyProvider.GetProperties(_expressionBeforeDot.ExpressionType);
}
}
else
{
// The expression before the dot is named constant or a parameter. In both cases, the properties
// could be contributed as custom properties.
if (namedConstantExpression != null)
{
properties = namedConstantExpression.Constant.CustomProperties;
}
else
{
properties = parameterExpression.Parameter.CustomProperties;
}
}
if (properties != null)
{
foreach (PropertyBinding propertyBinding in properties)
{
acceptor.AcceptProperty(propertyBinding);
}
}
// Now contribute any methods
IMethodProvider methodProvider = _scope.DataContext.MetadataContext.MethodProviders[_expressionBeforeDot.ExpressionType];
if (methodProvider != null)
{
MethodBinding[] methods = methodProvider.GetMethods(_expressionBeforeDot.ExpressionType);
foreach (MethodBinding methodBinding in methods)
{
acceptor.AcceptMethod(methodBinding);
}
}
}
public QueryPropertyWalkerVisitor(
IServiceProvider serviceProvider,
IPropertyProvider propertyProvider,
IMethodProvider methodProvider)
: base(serviceProvider, methodProvider)
{
_propertyProvider = propertyProvider;
}
public EntityQueryNodeVisitor(Expression expression, ISchemaProvider schemaProvider, IMethodProvider methodProvider, QueryVariables variables, ClaimsIdentity claims)
{
this.claims = claims;
currentContext = (ExpressionResult)expression;
this.schemaProvider = schemaProvider;
this.methodProvider = methodProvider;
this.constantVisitor = new ConstantVisitor(schemaProvider);
}
public QueryFilterPropertyWalkerVisitor(
IServiceProvider serviceProvider,
IMethodProvider methodProvider,
IListProvider listProvider)
: base(serviceProvider)
{
_methodProvider = methodProvider;
_listProvider = listProvider;
}
public RouteFilterBuilder(
IActionContextAccessor actionContextAccessor,
IPropertyProvider propertyProvider,
IMethodProvider methodProvider)
{
_actionContextAccessor = actionContextAccessor;
_propertyProvider = propertyProvider;
_methodProvider = methodProvider;
}
public RouteValidator(
IActionContextAccessor actionContextAccessor,
IPropertyProvider propertyProvider,
IMethodProvider methodProvider)
{
_actionContextAccessor = actionContextAccessor;
_propertyProvider = propertyProvider;
_methodProvider = methodProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodApiClientDecorator{TRequest, TResponse}"/> class.
/// </summary>
/// <param name="apiClient">The instance to decorate</param>
/// <param name="methodProvider"></param>
public MethodApiClientDecorator(
IApiClient <TRequest, TResponse> apiClient,
IMethodProvider <TRequest> methodProvider) : base(apiClient)
{
Argument.NotNull(apiClient, nameof(apiClient));
Argument.NotNull(methodProvider, nameof(methodProvider));
_apiClient = apiClient;
_methodProvider = methodProvider;
}
public JitCompilerHost(string assemblyPath, IMethodProvider methodProvider)
{
_assemblyPath = assemblyPath;
_methodProvider = methodProvider;
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
// ensure methods are jitted before compilation starts to not interfere with actual jitting events
RuntimeHelpers.PrepareMethod(GetType().GetMethod(nameof(PreJITMethods), BindingFlags.Instance | BindingFlags.Public).MethodHandle);
InliningAnalyzerSource.Log.AsyncMethodStart(null);
InliningAnalyzerSource.Log.AsyncMethodStop(null);
}
/// <summary>
/// Returns all methods matching the identifier.
/// </summary>
/// <param name="type">The type to search the methods in.</param>
/// <param name="identifier">The identifier to match the methods.</param>
public MethodBinding[] FindMethod(Type type, Identifier identifier)
{
if (type == null)
{
throw ExceptionBuilder.ArgumentNull("type");
}
if (identifier == null)
{
throw ExceptionBuilder.ArgumentNull("identifier");
}
// Get method provider responsible for the given type.
IMethodProvider methodProvider = _methodProviders[type];
if (methodProvider == null)
{
return(new MethodBinding[0]);
}
// Get properties from the provider.
MethodBinding[] methods;
try
{
methods = methodProvider.GetMethods(type);
}
catch (NQueryException)
{
throw;
}
catch (Exception ex)
{
throw ExceptionBuilder.IMethodProviderGetMethodsFailed(ex);
}
// Return all methods that match the given name.
List <MethodBinding> result = new List <MethodBinding>();
foreach (MethodBinding methodBinding in methods)
{
if (identifier.Matches(methodBinding.Name))
{
result.Add(methodBinding);
}
}
return(result.ToArray());
}
// Method Providers
public DataContext AddMethodProvider(Type type, IMethodProvider provider)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
var newProviders = MethodProviders.Add(type, provider);
return(WithMethodProviders(newProviders));
}
/// <summary>
/// Execute a query using this schema.
/// </summary>
/// <param name="gql">The query</param>
/// <param name="context">The context object. An instance of the context the schema was build from</param>
/// <param name="serviceProvider">A service provider used for looking up dependencies of field selections and mutations</param>
/// <param name="claims">Optional claims to check access for queries</param>
/// <param name="methodProvider"></param>
/// <param name="includeDebugInfo"></param>
/// <typeparam name="TContextType"></typeparam>
/// <returns></returns>
public QueryResult ExecuteQuery(QueryRequest gql, TContextType context, IServiceProvider serviceProvider, ClaimsIdentity claims, IMethodProvider methodProvider = null)
{
if (methodProvider == null)
{
methodProvider = new DefaultMethodProvider();
}
QueryResult result;
try
{
var graphQLCompiler = new GraphQLCompiler(this, methodProvider);
var queryResult = graphQLCompiler.Compile(gql, claims);
result = queryResult.ExecuteQuery(context, serviceProvider, gql.OperationName);
}
catch (Exception ex)
{
// error with the whole query
result = new QueryResult {
Errors = { new GraphQLError(ex.InnerException != null ? ex.InnerException.Message : ex.Message) }
};
}
return(result);
}
public GraphQLCompiler(ISchemaProvider schemaProvider, IMethodProvider methodProvider)
{
_schemaProvider = schemaProvider;
_methodProvider = methodProvider;
}
public GraphQLVisitor(ISchemaProvider schemaProvider, IMethodProvider methodProvider, QueryVariables variables)
{
this.schemaProvider = schemaProvider;
this.methodProvider = methodProvider;
this.variables = variables;
}
public QueryDetailPropertyWalkerVisitorBase(
IServiceProvider serviceProvider,
IMethodProvider methodProvider)
: base(serviceProvider, methodProvider)
{
}
/// <summary>
/// Execute a query using this schema.
/// </summary>
/// <param name="gql">The query</param>
/// <param name="context">The context object. An instance of the context the schema was build from</param>
/// <param name="serviceProvider">A service provider used for looking up dependencies of field selections and mutations</param>
/// <param name="claims">Optional claims to check access for queries</param>
/// <param name="methodProvider"></param>
/// <param name="includeDebugInfo"></param>
/// <typeparam name="TContextType"></typeparam>
/// <returns></returns>
public async Task <QueryResult> ExecuteQueryAsync(QueryRequest gql, TContextType context, IServiceProvider serviceProvider, ClaimsIdentity claims, IMethodProvider methodProvider = null)
{
//== JT
this.User = Security.Worker.CreateUser(claims);
// Clear any previous errors before executing new query
GraphQLValidation.Errors = new List <GraphQLError>();
//==
if (methodProvider == null)
{
methodProvider = new DefaultMethodProvider();
}
QueryResult result;
try
{
var graphQLCompiler = new GraphQLCompiler(this, methodProvider);
var queryResult = graphQLCompiler.Compile(gql, claims);
result = await queryResult.ExecuteQueryAsync(context, serviceProvider, gql.OperationName);
}
catch (Exception ex)
{
// error with the whole query
result = new QueryResult {
Errors = { new GraphQLError(ex.InnerException != null ? ex.InnerException.Message : ex.Message) }
};
}
return(result);
}
public QueryResult ExecuteQuery(QueryRequest gql, TContextType context, IServiceProvider serviceProvider, ClaimsIdentity claims, IMethodProvider methodProvider = null)
{
return(ExecuteQueryAsync(gql, context, serviceProvider, claims, methodProvider).Result);
}
private static ExpressionResult CompileQuery(string query, Expression context, ISchemaProvider schemaProvider, ClaimsIdentity claims, IMethodProvider methodProvider, QueryVariables variables)
{
AntlrInputStream stream = new AntlrInputStream(query);
var lexer = new EntityGraphQLLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new EntityGraphQLParser(tokens)
{
BuildParseTree = true
};
var tree = parser.startRule();
var visitor = new QueryGrammerNodeVisitor(context, schemaProvider, methodProvider, variables, claims);
var expression = visitor.Visit(tree);
return(expression);
}
/// Function that returns the DataContext for the queries. If null _serviceProvider is used
public static IDictionary <string, object> QueryObject <TType>(this TType context, string dataQuery, ISchemaProvider schemaProvider, IRelationHandler relationHandler = null, IMethodProvider methodProvider = null, bool includeDebugInfo = false)
{
if (methodProvider == null)
{
methodProvider = new DefaultMethodProvider();
}
Stopwatch timer = null;
if (includeDebugInfo)
{
timer = new Stopwatch();
timer.Start();
}
var allData = new ConcurrentDictionary <string, object>();
try
{
var objectGraph = new DataApiCompiler(schemaProvider, methodProvider, relationHandler).Compile(dataQuery);
// Parallel.ForEach(objectGraph.Fields, node =>
foreach (var node in objectGraph.Fields)
{
try
{
if (!string.IsNullOrEmpty(node.Error))
{
System.Console.WriteLine(node.Error);
allData[node.Name] = node.Error;
}
else
{
var data = node.AsLambda().Compile().DynamicInvoke(context);
allData[node.Name] = data;
}
}
catch (Exception ex)
{
allData[node.Name] = new { eql_error = ex.Message };
}
}
// );
}
catch (Exception ex)
{
allData["error"] = ex.Message;
}
if (includeDebugInfo && timer != null)
{
timer.Stop();
allData["_debug"] = new { TotalMilliseconds = timer.ElapsedMilliseconds };
}
return(allData);
}
public static CompiledQueryResult CompileWith(string query, Expression context, ISchemaProvider schemaProvider, ClaimsIdentity claims, IMethodProvider methodProvider = null, QueryVariables variables = null)
{
if (methodProvider == null)
{
methodProvider = new DefaultMethodProvider();
}
if (variables == null)
{
variables = new QueryVariables();
}
var expression = CompileQuery(query, context, schemaProvider, claims, methodProvider, variables);
var parameters = expression.Expression.NodeType == ExpressionType.Lambda ? ((LambdaExpression)expression.Expression).Parameters.ToList() : new List <ParameterExpression>();
return(new CompiledQueryResult(expression, parameters));
}
/// <summary>
/// Compile a query.
/// </summary>
/// <param name="query">The query text</param>
/// <param name="schemaProvider"></param>
/// <param name="methodProvider"></param>
/// <returns></returns>
public static CompiledQueryResult Compile(string query, ISchemaProvider schemaProvider, ClaimsIdentity claims, IMethodProvider methodProvider, QueryVariables variables)
{
ParameterExpression contextParam = null;
if (schemaProvider != null)
{
contextParam = Expression.Parameter(schemaProvider.ContextType);
}
var expression = CompileQuery(query, contextParam, schemaProvider, claims, methodProvider, variables);
var contextParams = new List <ParameterExpression>();
if (contextParam != null)
{
contextParams.Add(contextParam);
}
return(new CompiledQueryResult(expression, contextParams));
}
public DataApiVisitor(ISchemaProvider schemaProvider, IMethodProvider methodProvider, IRelationHandler relationHandler)
{
_schemaProvider = schemaProvider;
_methodProvider = methodProvider;
_relationHandler = relationHandler;
}
public static QueryResult CompileWith(string query, Expression context, ISchemaProvider schemaProvider, IMethodProvider methodProvider, QueryVariables variables)
{
var expression = CompileQuery(query, context, schemaProvider, methodProvider, variables);
var parameters = expression.Expression.NodeType == ExpressionType.Lambda ? ((LambdaExpression)expression.Expression).Parameters.ToList() : new List <ParameterExpression>();
if (expression.ConstantParameters != null)
{
parameters.AddRange(expression.ConstantParameters.Keys);
}
return(new QueryResult(expression, parameters, expression.ConstantParameters?.Values));
}
/// <summary>
/// Compile a query.
/// </summary>
/// <param name="query">The query text</param>
/// <param name="schemaProvider"></param>
/// <param name="methodProvider"></param>
/// <returns></returns>
public static QueryResult Compile(string query, ISchemaProvider schemaProvider, IMethodProvider methodProvider, QueryVariables variables)
{
ParameterExpression contextParam = null;
if (schemaProvider != null)
{
contextParam = Expression.Parameter(schemaProvider.ContextType);
}
var expression = CompileQuery(query, contextParam, schemaProvider, methodProvider, variables);
var contextParams = new List <ParameterExpression>();
if (contextParam != null)
{
contextParams.Add(contextParam);
}
if (expression.ConstantParameters.Any())
{
contextParams.AddRange(expression.ConstantParameters.Keys);
}
return(new QueryResult(expression, contextParams, expression.ConstantParameters.Values));
}
