Use a FieldBuilder type to define fields

[rspeele]

Right now fields are defined like:

typeBuilder.AddField("friends", u => u.Friends)

Or, with arguments, like:

typeBuilder
  .AddField("friends", new { friendId = 0 },
    args => (db, u) => u.Friends.Where(f => f.Id == args.friendId))

Adding a FieldBuilder would allow throwing more options on the fields without having a crazy method signature. Ideally, either of the current approaches would work to start the builder. Then users could add on other fluent calls to define security constraints, complexity, or additional optional arguments. Here's a hypothetical example of how a pretend astronaut in the distant future might use this:

typeBuilder
  .AddField("friends", u => u.Friends) // if you used args here, those args would be *required*
  .WithComplexity(10, 100) // we estimate a typical user will have between 10 and 100 friends
  .WithArguments(new { id = 0 }, // optional filtering argument
    args => (db, friends) => friends.Where(f => f.Id == args.id), 1) // modifies complexity to 1
  .WithArguments(new { name = "" }, // optional filtering argument
    args => (db, friends) => friends.Where(f => f.Name == args.name))
  .WithSecurityFilter((db, friends) => friends.Where(f => idk(db, friends)) // filter query
  .WithSecurityAssertion(fs => fs.All(SecurityManager.HasPermissionToView)) // in-memory predicate

[chkimes]

Due to problems with type inference, the base API will need to be changed to support this. We'll need to add an AddListField method for adding fields that return lists of objects and only use AddField for fields that return a single object. This is necessary so that we can know the type of TField at compile time.

Other suggested changes are that WithArguments should expose a filter method on the type itself rather than on the list of types. For example:

.WithArguments(new { id = 0 }, args => (db, friend) => friend.Id == args.Id, 1)

Also complexity modifications should be more fleshed out with options to modify the complexity by multiplication, or by setting a max value. The complexity modification could be based on the args as well. Possible API:

.WithArguments(new { id = 0 }, /* filter */, ComplexityMod.Max(1))
.WithArguments(new { contains = "" }, /* filter */,
    args => ComplexityMod.Multiply(1.0 / args.contains.Length))