Must implement post functionality for testing client.

Right now only ICollection properties are supported.

CacheCow is a neat implementation of an invisible HTTP caching layer on top of WebApi and HttpClient. Pomona should integrate with CacheCow or implement something similar.

With ASP.NET 5.0 and Web API 2, OData gains support for $select, $expand, and $value. It would be nice if Pomona was as close to fully compatible with OData as possible.

It would be nice if Pomona (perhaps through a separate Pomona.Profiling package) made it easier to profile the queries it sends, so lazy loading in loops and such was easier to detect and remedy.

I'm thinking that when a flag (perhaps HttpContext.IsDebuggingEnabled) is set, the Pomona Client will gather information about all requests being made and when the context (i.e. incoming URI) is the same for a bunch of requests being made within a very short timeframe, a warning should be sent somewhere.

This "somewhere" should probably be pluggable, with plugs like logging an error to log4net or sending an error event to Sentry.

This probably implies a major refactoring of PomonaModule.

Right now IQueryableRepository contains a Post(resource, form) method returning object, although it obviously doesn't belong there.

Pomona needs to support this:

{
    "isSantaReal" : true
}

In addition to this (which is currently supported):

{
    "isSantaReal" : {
        "_type" : "Boolean",
        "value" : "True",
    }
}

When a constructor's parameter type doesn't match the type of its target property, a non-wrapped exception like the following is thrown:

System.ArgumentException: Got an unexpected exception: Expression of type 'PropertyType' cannot be used for constructor parameter of type 'ParameterType'.

It would be nice if this exception was wrapped in an exception with more context and information so it would be easier to debug and fix.

When using IPropertyOptionsBuilder.UsingFormula() to customize the generated value of a property, it would be nice to have access to the HTTP context to be able to generate URIs and similar values that are context dependent.

MockedRepository.Query().OfType() works fine.
This is related to how a repository acts as an IQueryable.

This makes using the testing client more cumbersome.

PomonaModule and PomonaSession is now spaghetti code, sharing a number of responsibilities.

Need to refactor this.

Right now way too much stuff results in an InternalServerError message, which is not very helpful.

It vould be nice if this vould work:

when:

interface ICustomType : IBaseClass

then:

ICustomType result = client.BaseClasses.Post<ICustomType>(BaseClassForm);

and:

ICustomType result = client.Post<ICustomType>(BaseClassForm);

Since query is already supporting this:

client.BaseClasses.Query<ICustomType> ();

is already doing the wanted mapping, if ICustomType inherits IBaseClass

Expanded referenced resources can often appear multiple times in query results.

MessagePack is a light-weight alternative to JSON that it would be nice if Pomona supported.

This will make LINQ the only interface.

Maybe add some simple Get(int id) overloads too.

Filtering by parent id should be default behaviour.

I think I might need to do some custom encoding here, as the url provided by nancy has already been decoded.

See test QueryGalaxyHavingQuestionMarkInName_ReturnsCorrectResource for details.

This should be implemented in LazyProxyBase.OnGet(..).

subscriptions/1/invalidatedstates, should be subscriptions/1/invalidated-states

Right now IPomonaQuery is a useless empty interface, so it is cast to PomonaQuery in a lot of places right now.

This should be cleaned up.

The depenency should be greater or equal.

Pomona should support the Hyper Text Coffee Pot Control Protocol (RFC 2324) so people can use Pomona in a way everyone expects a RESTful API to work by being able to brew a fresh cup of coffee.

What I mean here is posting a form directly to a resource uri, not a repository of resource.

There's a placeholder PostFormToHandledThing_CallsHandlerPostToResourceMethod in ResourceHandlerTests (TODO category).

To be able to compose REST services in a more more modular and dynamic way, it would be awesome to be able to proxy one Pomona API (A) within another (B) and have B's API expose both A and B's functionality both server- and client-side.

Right now an object is patched directly in deserializer.
This makes it impossible to add validation rules for patching, or custom patching behaviour, before applying it.

To change this the deserializer should rather return a Delta, which can be inspected before apply occurs.

This is how ASP.NET web api works, but only supports changing value properties of the entity, not add stuff to collection etc..

When POSTing an abstract class, Pomona throws a NullReferenceException because the type's Constructor is null:

System.NullReferenceException: Object reference not set to an instance of an object.
   at Pomona.Common.TypeSystem.TransformedType.Create[T](IConstructorPropertySource`1 propertySource)
   at Pomona.Common.Serialization.Json.PomonaJsonDeserializer.PropertyValueSource`1.Deserialize()
   at Pomona.Common.Serialization.Json.PomonaJsonDeserializer.DeserializeComplexNode(IDeserializerNode node, Reader reader)
   at Pomona.Common.Serialization.Json.PomonaJsonDeserializer.DeserializeNode(IDeserializerNode node, Reader reader)
   at Pomona.Common.Serialization.Json.PomonaJsonDeserializer.<>c__DisplayClass1.<DeserializeThroughContext>b__0(IDeserializerNode n)
   at Pomona.ServerDeserializationContext.Deserialize(IDeserializerNode node, Action`1 nodeDeserializeAction)
   at Pomona.Common.Serialization.Json.PomonaJsonDeserializer.DeserializeThroughContext(IDeserializerNode node, Reader reader)
   at Pomona.Common.Serialization.Json.PomonaJsonDeserializer.Deserialize(TextReader textReader, TypeSpec expectedBaseType, IDeserializationContext context, Object patchedObject)
   at Pomona.Common.Serialization.Json.PomonaJsonDeserializer.Deserialize(TextReader textReader, DeserializeOptions options)
   at Pomona.PomonaRequest.Deserialize(TransformedType expectedBaseType, Stream body, Object patchedObject)
   at Pomona.PomonaRequest.Bind(TypeSpec type, Object patchedObject)
   at Pomona.RequestProcessing.HandlerRequestProcessor`1.PostToCollection(PomonaRequest request, ResourceCollectionNode collectionNode)
   at Pomona.RequestProcessing.HandlerRequestProcessor`1.ProcessCollectionNode(PomonaRequest request, ResourceCollectionNode collectionNode)
   at Pomona.RequestProcessing.HandlerRequestProcessor`1.Process(PomonaRequest request)
   at Pomona.RequestProcessing.DefaultRequestProcessorPipeline.<>c__DisplayClass3.<Process>b__0(IPomonaRequestProcessor x)
   at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext()
   at System.Linq.Enumerable.FirstOrDefault[TSource](IEnumerable`1 source, Func`2 predicate)
   at Pomona.RequestProcessing.DefaultRequestProcessorPipeline.Process(PomonaRequest request)
   at Pomona.PomonaModule.ProcessRequest()
   at Pomona.PomonaModule.<RegisterRoutesFor>b__27(Object x)
   at CallSite.Target(Closure , CallSite , Func`2 , Object )
   at Pomona.PomonaModule.<>c__DisplayClass1b.<Register>b__1a(Object x)

It would be nice if the exception thrown informed about the class being abstract instead.

Began writing a fix, but not finished.

Ids in url is interpreted as Symbol rather than LiteralString

The following fails:
http://example.com/resources/myid/subresources

This works(but shouldn't):
http://example.com/resources/'myid'/subresources

The pomona client should provide a warning if a certain number of lazy resources, that could be fetched with expand, has been requested from a single parent resource.

Something like:
pomonaClient.AddLazyThresholdWarning(numberOfLazyCalls,(x)=>DoSomething(x))

Need to find out what syntax we want for type literals:

'Edm.Int32', 'Int32' with or without quotes.

Make IClientRepository.Query() obsolete and instead implement IQueryable in IClientRepository itself.

It should be possible to configure each resource to require or not require authentication as well as what type of authentication it requires. Since authentication is configured for the entire module in Nancy, a possible approach could be to create one NancyModule per resource that has a different authentication requirement than its parent.

The c# expression (x => x.Attributes.SafeGet("blah") as string == null) becomes "attributes.blah eq null". Should be "(attributes.blah as t'String') eq null".

This is caused by an optimization that shouldn't have been applied in this case.

Should recognize the following signatures for root resources:

IQueryable QueryFoo();
IQueryable Query();
IQueryable Query();

Should recognize child resources:

IQueryable Query(Parent parent);
IQueryable QueryChildren(Parent parent);

Bonus:
IQueryable Query(PomonaRequest pomonaRequest);

This requires quite a bit of refactoring in node walking and IQuerableResolver related stuff. Basically I think one PomonaRequest might be needed for every part in path. I hope there is some way around this, but I haven't been able to find any clean ways to do this yet.

The serialization is starting to get quite messy, and should be cleaned up a bit.

I believe this is caused by how the ANTLR build task works.