IClient.cs

Go to the documentation of this file.

using System.Runtime.CompilerServices;
using Fauna.Core;
using Fauna.Exceptions;
using Fauna.Mapping;
using Fauna.Serialization;
using Fauna.Types;
using static Fauna.Query;
 
namespace Fauna;
 
public interface IClient
{
    public Task<QuerySuccess<T>> QueryAsync<T>(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
        where T : notnull;
 
    public Task<QuerySuccess<object?>> QueryAsync(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public Task<QuerySuccess<T>> QueryAsync<T>(
        Query query,
        ISerializer<T> serializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public Task<QuerySuccess<object?>> QueryAsync(
        Query query,
        ISerializer serializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
        where T : notnull;
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Page<T> page,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
        where T : notnull;
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Page<object?> page,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Query query,
        ISerializer<T> elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Page<T> page,
        ISerializer<T> elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Query query,
        ISerializer elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Page<object?> page,
        ISerializer elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default);
 
    public Task<T> LoadRefAsync<T>(
        BaseRef<T> reference,
        CancellationToken cancel = default)
        where T : notnull;
}
 
public abstract class BaseClient : IClient
{
    internal BaseClient()
    {
    }
 
    internal abstract MappingContext MappingCtx { get; }
 
    internal abstract Task<QuerySuccess<T>> QueryAsyncInternal<T>(
        Query query,
        ISerializer<T> serializer,
        MappingContext ctx,
        QueryOptions? queryOptions,
        CancellationToken cancel
    );
 
    #region IClient
 
    public Task<QuerySuccess<T>> QueryAsync<T>(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
        where T : notnull =>
        QueryAsync<T>(query, Serializer.Generate<T>(MappingCtx), queryOptions, cancel);
 
    public Task<QuerySuccess<object?>> QueryAsync(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default) =>
        QueryAsync<object?>(query, Serializer.Dynamic, queryOptions, cancel);
 
    public Task<QuerySuccess<T>> QueryAsync<T>(
        Query query,
        ISerializer<T> serializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default) =>
        QueryAsyncInternal(query, serializer, MappingCtx, queryOptions, cancel);
 
    public Task<QuerySuccess<object?>> QueryAsync(
        Query query,
        ISerializer serializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default) =>
        QueryAsync<object?>(query, (ISerializer<object?>)serializer, queryOptions, cancel);
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
        where T : notnull =>
        PaginateAsync(query, Serializer.Generate<T>(MappingCtx), queryOptions, cancel);
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Page<T> page,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
        where T : notnull =>
        PaginateAsync(page, Serializer.Generate<T>(MappingCtx), queryOptions, cancel);
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Query query,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default) =>
        PaginateAsync(query, Serializer.Dynamic, queryOptions, cancel);
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Page<object?> page,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default) =>
        PaginateAsync(page, Serializer.Dynamic, queryOptions, cancel);
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Query query,
        ISerializer<T> elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
    {
        var serializer = new PageSerializer<T>(elemSerializer);
        return PaginateAsyncInternal(query, serializer, queryOptions, cancel);
    }
 
    public IAsyncEnumerable<Page<T>> PaginateAsync<T>(
        Page<T> page,
        ISerializer<T> elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
    {
        var serializer = new PageSerializer<T>(elemSerializer);
        return PaginateAsyncInternal(page, serializer, queryOptions, cancel);
    }
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Query query,
        ISerializer elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
    {
        var elemObjSer = (ISerializer<object?>)elemSerializer;
        var serializer = new PageSerializer<object?>(elemObjSer);
        return PaginateAsyncInternal(query, serializer, queryOptions, cancel);
    }
 
    public IAsyncEnumerable<Page<object?>> PaginateAsync(
        Page<object?> page,
        ISerializer elemSerializer,
        QueryOptions? queryOptions = null,
        CancellationToken cancel = default)
    {
        var elemObjSer = (ISerializer<object?>)elemSerializer;
        var serializer = new PageSerializer<object?>(elemObjSer);
        return PaginateAsyncInternal(page, serializer, queryOptions, cancel);
    }
 
    public async Task<T> LoadRefAsync<T>(
        BaseRef<T> reference,
        CancellationToken cancel = default) where T : notnull
    {
        if (reference.IsLoaded)
        {
            return reference.Get();
        }
 
        var q = FQL($"{reference}");
        var res = await QueryAsync(q, Serializer.Generate<BaseRef<T>>(MappingCtx), null, cancel);
        return res.Data.Get();
    }
 
    #endregion
 
    // Internally accessible for QuerySource use
    internal async IAsyncEnumerable<Page<T>> PaginateAsyncInternal<T>(
        Query query,
        PageSerializer<T> serializer,
        QueryOptions? queryOptions,
        [EnumeratorCancellation] CancellationToken cancel = default)
    {
        var p = await QueryAsyncInternal(query,
            serializer,
            MappingCtx,
            queryOptions,
            cancel);
 
        await foreach (var page in PaginateAsyncInternal(p.Data, serializer, queryOptions, cancel))
        {
            yield return page;
        }
    }
 
    private async IAsyncEnumerable<Page<T>> PaginateAsyncInternal<T>(
        Page<T> page,
        PageSerializer<T> serializer,
        QueryOptions? queryOptions,
        [EnumeratorCancellation] CancellationToken cancel = default)
    {
        yield return page;
 
        while (page.After is not null)
        {
            var q = new QueryExpr(new QueryLiteral($"Set.paginate('{page.After}')"));
 
            var response = await QueryAsyncInternal(q,
                serializer,
                MappingCtx,
                queryOptions,
                cancel);
 
            page = response.Data;
            yield return page;
        }
    }
 
    #region Streaming
 
    internal abstract IAsyncEnumerator<Event<T>> SubscribeStreamInternal<T>(
        EventSource eventSource,
        MappingContext ctx,
        CancellationToken cancel = default) where T : notnull;
 
    public async Task<StreamEnumerable<T>> EventStreamAsync<T>(
        Query query,
        QueryOptions? queryOptions = null,
        StreamOptions? streamOptions = null,
        CancellationToken cancellationToken = default) where T : notnull
    {
        EventSource eventSource = streamOptions?.Token != null
            ? new EventSource(streamOptions.Token) { Options = streamOptions }
            : await GetEventSourceFromQueryAsync(query, queryOptions, cancellationToken);
 
        return new StreamEnumerable<T>(this, eventSource, cancellationToken);
    }
 
    public async Task<StreamEnumerable<T>> EventStreamAsync<T>(
        EventSource eventSource,
        CancellationToken cancellationToken = default) where T : notnull
    {
        await Task.CompletedTask;
 
        return new StreamEnumerable<T>(this, eventSource, cancellationToken);
    }
 
 
    internal abstract IAsyncEnumerator<FeedPage<T>> SubscribeFeedInternal<T>(
        EventSource eventSource,
        MappingContext ctx,
        CancellationToken cancel = default) where T : notnull;
 
    public async Task<FeedEnumerable<T>> EventFeedAsync<T>(
        EventSource eventSource,
        FeedOptions? feedOptions = null,
        CancellationToken cancellationToken = default) where T : notnull
    {
        await Task.CompletedTask;
 
        if (feedOptions != null) eventSource.Options = feedOptions;
 
        return new FeedEnumerable<T>(this, eventSource, cancellationToken);
    }
 
    public async Task<FeedEnumerable<T>> EventFeedAsync<T>(
        Query query,
        FeedOptions? feedOptions = null,
        CancellationToken cancellationToken = default) where T : notnull
    {
        EventSource eventSource = await GetEventSourceFromQueryAsync(query, null, cancellationToken);
        if (feedOptions != null) eventSource.Options = feedOptions;
 
        return new FeedEnumerable<T>(this, eventSource, cancellationToken);
    }
 
    private async Task<EventSource> GetEventSourceFromQueryAsync(
        Query query,
        QueryOptions? queryOptions,
        CancellationToken cancellationToken)
    {
        try
        {
            var response = await QueryAsync<EventSource>(
                query,
                queryOptions,
                cancellationToken);
            return response.Data;
        }
        catch (SerializationException ex)
        {
            throw new InvalidOperationException("Query must return an EventSource.", ex);
        }
    }
 
    public IAsyncEnumerator<Event<T>> SubscribeStream<T>(
        EventSource eventSource,
        MappingContext ctx,
        CancellationToken cancel = default) where T : notnull
    {
        return SubscribeStreamInternal<T>(eventSource, ctx, cancel);
    }
 
    public IAsyncEnumerator<FeedPage<T>> SubscribeFeed<T>(
        EventSource eventSource,
        MappingContext ctx,
        CancellationToken cancel = default) where T : notnull
    {
        return SubscribeFeedInternal<T>(eventSource, ctx, cancel);
    }
 
    #endregion
}