static async Task Main(string[] args)
{
var connectionToDb = await File.ReadAllTextAsync("connectionString.txt");
var dbContext = ContextBuilder.BuildContext(connectionToDb);
var jm = new JoinMonsterExecuter(
new QueryToSqlConverter(new DefaultAliasGenerator()),
new SqlCompiler(new SQLiteDialect()),
new Hydrator()
);
var serviceProvider = new FuncServiceProvider(type =>
{
var swQuery = new GenericQuery(dbContext, jm);
if (type == typeof(GenericQuery))
{
return(swQuery);
}
return(Activator.CreateInstance(type));
});
var schema = new TargetDbSchema(serviceProvider);
Console.WriteLine("Built a schema");
var queryToRun = await File.ReadAllTextAsync("query.txt");
Console.WriteLine("Running GraphQL Query");
Console.WriteLine(queryToRun);
await using var connection = new SqlConnection(connectionToDb);
await connection.OpenAsync();
var options = new ExecutionOptions
{
ThrowOnUnhandledException = true,
Schema = schema,
Query = queryToRun,
UserContext = new Dictionary <string, object>
{
{ nameof(IDbConnection), connection }
},
UnhandledExceptionDelegate = (ctx) =>
{
var e = ctx.Exception;
}
};
var result = await new DocumentExecuter().ExecuteAsync(
options
).ConfigureAwait(true);
//data.EnrichWithApolloTracing(start);
Console.WriteLine("Json returned to caller:");
var writer = new DocumentWriter(true);
Console.WriteLine(await writer.WriteToStringAsync(result));
}
public StarWarsQuery(JoinMonsterExecuter joinMonster)
{
Name = "Query";
object Resolve(IResolveFieldContext <object> context) =>
joinMonster.ExecuteAsync(context, async(sql, parameters) =>
{
Console.WriteLine(sql);
Console.WriteLine();
var dbConnection = (IDbConnection)context.UserContext[nameof(IDbConnection)];
await using var command = (DbCommand)dbConnection.CreateCommand();
command.CommandText = sql;
foreach (var(key, value) in parameters)
{
var sqlParameter = command.CreateParameter();
sqlParameter.ParameterName = key;
sqlParameter.Value = value;
command.Parameters.Add(sqlParameter);
}
return(await command.ExecuteReaderAsync());
}, CancellationToken.None);
Field <CharacterInterface>("hero", resolve: Resolve)
.SqlWhere((where, _, __, ___) => where.Column("id", 3));
Field <HumanType>(
"human",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id", Description = "id of the human"
}
),
resolve: Resolve
).SqlWhere((where, args, _, __) => where.Column("id", args["id"]));
Field <ListGraphType <HumanType> >(
"humans",
resolve: Resolve
)
.SqlWhere((where, args, _, __) => where.Column("type", "Human"))
.SqlOrder((order, _, __, ___) => order.By("name"));
Field <DroidType>(
"droid",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id", Description = "id of the droid"
}
),
resolve: Resolve
).SqlWhere((where, args, _, __) => where.Column("id", args["id"]));
Field <ListGraphType <PlanetType> >(
"planets",
resolve: Resolve
);
}
public void Execute_WhenDatabaseCallIsNull_ThrowsException()
{
var sut = new JoinMonsterExecuter(new QueryToSqlConverterStub(), new SqlCompilerStub(), new BatchPlannerStub(), new Hydrator());
Func <Task> action = () => sut.ExecuteAsync(new ResolveFieldContext(), null, CancellationToken.None);
action.Should()
.Throw <ArgumentNullException>()
.Which.ParamName.Should()
.Be("databaseCall");
}
public GenericQuery(DbContext dbContext, JoinMonsterExecuter jm)
{
FieldType BuildEntity(EntityMetadata entityMetadata)
{
var tableType = new EntityType(entityMetadata);
var newListType = new ListGraphType(tableType);
var newField = new FieldType
{
Name = entityMetadata.TableName,
Type = typeof(ListGraphType <Entity>),
ResolvedType = newListType,
Resolver =
new FuncFieldResolver <object, object>(Resolve), //new MyFieldResolver(metaTable, dbContext),
Arguments = new QueryArguments(
tableType.TableArgs
)
};
return(newField);
}
Name = "MyQuery";
object Resolve(IResolveFieldContext <object> context) =>
jm.ExecuteAsync(context, async(sql, parameters) =>
{
Console.WriteLine("SQL sent to DB");
sql = sql.Replace("\"\"", "\"");
Console.WriteLine(sql);
Console.WriteLine();
Console.WriteLine("Parameters:");
parameters.ToList().ForEach(d => Console.Write($"{d.Key}-{d.Value}"));
Console.WriteLine();
var dbConnection = (IDbConnection)context.UserContext[nameof(IDbConnection)];
await using var command = (DbCommand)dbConnection.CreateCommand();
command.CommandText = sql;
foreach (var(key, value) in parameters)
{
var sqlParameter = command.CreateParameter();
sqlParameter.ParameterName = key;
sqlParameter.Value = value;
command.Parameters.Add(sqlParameter);
}
return(await command.ExecuteReaderAsync());
});
var dbMetadata = new DatabaseMetadata(dbContext);
var allEntities = dbMetadata.GetEntityMetadatas().ToList();
EntityType.EntitiesAlreadyCreated = new Dictionary <string, EntityType>();
var feeder = new EntityFeeder(allEntities);
var entityToMap = feeder.GetNextEntity();
do
{
var newField = BuildEntity(entityToMap);
// newField.SqlWhere(ApplyParameters);
// AddField(newField);
entityToMap = feeder.GetNextEntity();
} while (entityToMap != null);
// //do it again
var f = new ReverseEntityFeeder(allEntities);
var e = f.GetNextEntity();
do
{
var newField = BuildEntity(e);
newField.SqlWhere(ApplyParameters);
AddField(newField);
e = f.GetNextEntity();
} while (e != null);
//ResolveOneToManyColumnRelationships();
}
static async Task Main(string[] args)
{
SQLiteConnection.CreateFile("starwars.db");
await using var connection = new SQLiteConnection("Data Source=starwars.db");
await connection.OpenAsync();
await PopulateDatabase(connection);
var compiler = new SqlCompiler(new SQLiteDialect());
var hydrator = new Hydrator();
var joinMonster = new JoinMonsterExecuter(
new QueryToSqlConverter(new DefaultAliasGenerator()),
compiler,
new BatchPlanner(compiler, hydrator),
hydrator
);
var serviceProvider = new FuncServiceProvider(type =>
{
if (type == typeof(StarWarsQuery))
{
return(new StarWarsQuery(joinMonster));
}
return(Activator.CreateInstance(type));
});
var schema = new StarWarsSchema(serviceProvider);
var query = @"
{
human(id: ""1"") {
name
id
homePlanet {
id
name
}
friends {
name
}
}
humans {
name
}
}";
var start = DateTime.UtcNow;
var documentExecuter = new DocumentExecuter();
var data = await documentExecuter.ExecuteAsync(options =>
{
options.Schema = schema;
options.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
options.EnableMetrics = true;
options.Query = query;
options.UserContext = new Dictionary <string, object>
{
{ nameof(IDbConnection), connection }
};
});
// data.EnrichWithApolloTracing(start);
var writer = new DocumentWriter(true);
Console.WriteLine(await writer.WriteToStringAsync(data));
}