Fauna v10 .NET/C# client driver (current)

var client = new Client("FAUNA_SECRET");

// Scoped key that impersonates an `admin` key for
// the `childDB` child database.
fn...:childDB:admin

var client = new Client("fn...:childDB:admin");

// Create a native var
var collectionName = "Product";

// Pass the var to an FQL query
var query = FQL($@"
    let collection = Collection({collectionName})
    collection.byName('cups').first() {{ price }}"
);

client.QueryAsync(query);

// Create a reusable query fragment.
var product = FQL($@"Product.byName(""pizza"").first()");

// Use the fragment in another FQL query.
var query = FQL($@"
    let product = {product}
    product {{
        name,
        price
    }}
");

client.QueryAsync(query);

using Fauna.Mapping;

class Category
{
    // Property names are automatically converted to camelCase.
    [Id]
    public string? Id { get; set; }

    // Manually specify a name by providing a string.
    [Field("name")]
    public string? CatName { get; set; }
}

class Product
{
    [Id]
    public string? Id { get; set; }

    public string? Name { get; set; }

    public string? Description { get; set; }

    public int Price { get; set; }

    // Reference to document
    public Ref<Category> Category { get; set; }
}

var query = FQL($@"Product.sortedByPriceLowToHigh()");
var products = client.PaginateAsync<Product>(query).FlattenAsync();

await foreach (var p in products)
{
    Console.WriteLine($"{p.Name} {p.Description} {p.Price}");
}

var product = new Product {
    Id = "12345",
    Name = "limes",
    Description = "Organic, 2 ct",
    Price = 95
};

client.QueryAsync(FQL($@"Product.create({product})"));

class CustomerDb : DataContext
{
    public class CustomerCollection : Collection<Customer>
    {
        public Index<Customer> ByEmail(string email) => Index().Call(email);
        public Index<Customer> ByName(string name) => Index().Call(name);
    }

    public CustomerCollection Customer { get => GetCollection<CustomerCollection>(); }
}

var db = client.DataContext<CustomerDb>

var result = db.QueryAsync(FQL($"Customer.all().first()"));
var customer = (Customer)result.Data!;

Console.WriteLine(customer.name);

var query = FQL($"Customer.all()");
await foreach (var page in client.PaginateAsync<Customer>(query))
{
    // handle each page
}

await foreach (var item in client.PaginateAsync<Customer>(query).FlattenAsync())
{
    // handle each item
}

class MyResult
{
    [Field("customers")]
    public Page<Customer>? Customers { get; set; }
}

var query = FQL($"{{customers: Customer.all()}}");
var result = await client.QueryAsync<MyResult>(query);

await foreach (var page in client.PaginateAsync(result.Data.Customers!))
{
    // handle each page
}

await foreach (var item in client.PaginateAsync(result.Data.Customers!).FlattenAsync())
{
    // handle each item
}

try
{
    var client = new Client("FAUNA_SECRET");

    var query = FQL($@"'Hello world'");
    var response = await client.QueryAsync<string>(query);

    Console.WriteLine(response.Stats.ToString());
}
catch (FaunaException e)
{
  if (e is ServiceException serviceException)
  {
    Console.WriteLine(serviceException.Stats.ToString());
    Console.WriteLine(e);
  }
  else {
    Console.WriteLine(e);
  }
}

export FAUNA_SECRET=FAUNA_SECRET
export FAUNA_ENDPOINT=https://db.fauna.com/

var client = new Client();

var config = new Configuration("FAUNA_SECRET")
{
    RetryConfiguration = new RetryConfiguration(3, TimeSpan.FromSeconds(20))
};

var client = new Client(config);

// Get an event source from a supported Set
EventSource eventSource = await client.QueryAsync<EventSource>(FQL($"Product.all().eventSource()"));

var feed = await client.EventFeedAsync<Product>(eventSource);

var feed = await client.EventFeedAsync<Product>(FQL($"Product.all().eventSource()"));

await foreach (var page in feed)
{
    foreach (var evt in page.Events)
    {
        Console.WriteLine($"Event Type: {evt.Type}");
        Product product = evt.Data;
        Console.WriteLine($"Product Name: {product.Name}");
    }
}

try
{
    await foreach (var page in feed)
    {
        try
        {
            foreach (var evt in page.Events)
            {
                Console.WriteLine($"Event Type: {evt.Type}");
                Product product = evt.Data;
                Console.WriteLine($"Product Name: {product.Name}");
            }
        }
        // `EventException` is thrown for event processing errors.
        catch (EventException eventError)
        {
            Console.WriteLine($"Feed event error: {eventError}");
        }
    }
}
catch (Exception error)
{
    Console.WriteLine($"Non-retryable error: {error}");
}

var feedOptions = new FeedOptions(
    startTs: 1710968002310000,
    pageSize: 10,
    cursor: "gsGabc456"
);

var feed = await client.EventFeedAsync<Product>(FQL($"Product.all().eventSource()"), feedOptions);

var query = fql($@"
  let set = Customer.all()

  {{
    initialPage: set.pageSize(10),
    eventSource: set.eventSource()
  }}
");

var response = await client.QueryAsync(query);
var eventSource = response["eventSource"].ToString();

await using var stream = client.SubscribeStream<Customer>(eventSource);
await foreach (var evt in stream)
{
    Console.WriteLine($"Received Event Type: {evt.Type}");
    if (evt.Data != null) // Status events won't have Data
    {
        Customer customer = evt.Data;
        Console.WriteLine($"Name: {customer.Name} - Email: {customer.Email}");
    }
}

var stream = await client.EventStreamAsync<Customer>(FQL($"Customer.all().eventSource()"));
await foreach (var evt in stream)
{
    Console.WriteLine($"Received Event Type: {evt.Type}");
    if (evt.Data != null)
    {
        Customer customer = evt.Data;
        Console.WriteLine($"Name: {customer.Name} - Email: {customer.Email}");
    }
}

var options = new StreamOptions(
    token: "<EVENT_SOURCE>",
    cursor: "gsGghu789"
);

var stream = await client.EventStreamAsync<Customer>(
    query: FQL("Product.all().eventSource()"),
    streamOptions: options
);

await foreach (var evt in stream)
{
    Console.WriteLine($"Received Event Type: {evt.Type}");
    if (evt.Data != null)
    {
        Customer customer = evt.Data;
        Console.WriteLine($"Name: {customer.Name} - Email: {customer.Email}");
    }
}

dotnet add package Serilog
dotnet add package Serilog.Extensions.Logging
dotnet add package Serilog.Sinks.Console
dotnet add package Serilog.Sinks.File

using Fauna;
using Microsoft.Extensions.Logging;
using Serilog;
using static Fauna.Query;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Verbose()
    .WriteTo.Console()
    .WriteTo.File("log.txt",
        rollingInterval: RollingInterval.Day,
        rollOnFileSizeLimit: true)
    .CreateLogger();

var logFactory = new LoggerFactory().AddSerilog(Log.Logger);

var config = new Configuration("mysecret", logger: logFactory.CreateLogger("myapp"));

var client = new Client(config);

await client.QueryAsync(FQL($"1+1"));

// You should see LogLevel.Debug messages in both the Console and the "log{date}.txt" file