.NET SDK (beta)

using PowerSync.Common.DB.Schema;
using PowerSync.Common.DB.Schema.Attributes;

[Table("todos"), Index("list", ["list_id"])]
public class Todo
{
    [Column("id")]
    public string TodoId { get; set; }

    [Column("list_id")]
    public string ListId { get; set; }

    [Column("created_at")]
    public string CreatedAt { get; set; }

    [Column("completed")]
    public bool Completed { get; set; }
    // ... other columns
}

public static Schema PowerSyncSchema = new Schema(typeof(Todo));

// The same Todo class is used for queries:
var todos = await db.GetAll<Todo>("SELECT * FROM todos");

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using PowerSync.Common.Client;
using PowerSync.Common.Client.Connection;
using PowerSync.Common.DB.Crud;

public class MyConnector : IPowerSyncBackendConnector
{
    private readonly HttpClient _httpClient;
    
    // User credentials for the current session
    public string UserId { get; private set; }
    
    // Service endpoints
    private readonly string _backendUrl;
    private readonly string _powerSyncUrl;
    private string? _clientId;

    public MyConnector()
    {
        _httpClient = new HttpClient();
        
        // In a real app, this would come from your authentication system
        UserId = "user-123"; 
        
        // Configure your service endpoints
        _backendUrl = "[Your backend API URL]";
        _powerSyncUrl = "https://your-powersync-instance.powersync.journeyapps.com";
    }

    public async Task<PowerSyncCredentials?> FetchCredentials()
    {
        try {
            // Implement fetchCredentials to obtain a JWT from your authentication service. 
            // See https://docs.powersync.com/configuration/auth/overview

            var authToken = "your-auth-token"; // Use a development token (see Authentication Setup https://docs.powersync.com/configuration/auth/development-tokens) to get up and running quickly

            // Return credentials with PowerSync endpoint and JWT token
            return new PowerSyncCredentials(_powerSyncUrl, authToken);
            
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error fetching credentials: {ex.Message}");
            throw;
        }
    }

    public async Task UploadData(IPowerSyncDatabase database)
    {
        // Get the next transaction to upload
        CrudTransaction? transaction;
        try
        {
            transaction = await database.GetNextCrudTransaction();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"UploadData Error: {ex.Message}");
            return;
        }

        // If there's no transaction, there's nothing to upload
        if (transaction == null)
        {
            return;
        }

        // Get client ID if not already retrieved
        _clientId ??= await database.GetClientId();

        try
        {
            // Convert PowerSync operations to your backend format
            var batch = new List<object>();
            foreach (var operation in transaction.Crud)
            {
                batch.Add(new
                {
                    op = operation.Op.ToString(),  // INSERT, UPDATE, DELETE
                    table = operation.Table,
                    id = operation.Id,
                    data = operation.OpData
                });
            }

            // Send the operations to your backend
            var payload = JsonSerializer.Serialize(new { batch });
            var content = new StringContent(payload, Encoding.UTF8, "application/json");

            HttpResponseMessage response = await _httpClient.PostAsync($"{_backendUrl}/api/data", content);
            response.EnsureSuccessStatusCode();

            // Mark the transaction as completed
            await transaction.Complete();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"UploadData Error: {ex.Message}");
            throw;
        }
    }
}

await db.Connect(new MyConnector());
await db.WaitForFirstSync(); // Optional, to wait for a complete snapshot of data to be available

// Subscribe to a stream with parameters
var sub = await db.SyncStream("list_todos", new() { ["list_id"] = "abc123" }).Subscribe();

// Wait for the initial data to sync
await sub.WaitForFirstSync();

// The stream's rows are now in the local SQLite database.
// TODO: Read the todos for this list with a local query.

// When the data is no longer needed
sub.Unsubscribe();

// Define a result type with properties matching the schema columns (some columns omitted here for brevity)
// public class ListResult { public string id; public string name; public string owner_id; ... }

var list = await db.Get<ListResult>("SELECT * FROM lists WHERE id = ?", [listId]);

// Define a result type with properties matching the schema columns (some columns omitted here for brevity)
// public class ListResult { public string id; public string name; public string owner_id; ... }

var lists = await db.GetAll<ListResult>("SELECT * FROM lists");

// Define a result type with properties matching the schema columns (some columns omitted here for brevity)
// public class ListResult { public string id; public string name; public string owner_id; ... }

// Optional cancellation token to stop watching
var cts = new CancellationTokenSource();

// Register listener synchronously on the calling thread...
var listener = db.Watch<ListResult>(
    "SELECT * FROM lists WHERE owner_id = ?",
    [ownerId],
    new SQLWatchOptions { Signal = cts.Token }
);

// ...then listen to changes on another thread (or await foreach directly if already in an async context)
_ = Task.Run(async () =>
{
    await foreach (var results in listener)
    {
        Console.WriteLine("Lists: ");
        foreach (var result in results)
        {
            Console.WriteLine($"{result.id}: {result.name}");
        }
    }
}, cts.Token);

// To stop watching, cancel the token: cts.Cancel();

// And db.Execute for inserts, updates and deletes:
await db.Execute(
  "INSERT INTO lists (id, name, owner_id, created_at) VALUES (uuid(), 'New list', ?, datetime())",
  [connector.UserId]
);

using Microsoft.Extensions.Logging;
using PowerSync.Common.Client;

// Create a logger factory
ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddConsole();             // Enable console logging
    builder.SetMinimumLevel(LogLevel.Information);  // Set minimum log level
});

var logger = loggerFactory.CreateLogger("PowerSyncLogger");

var db = new PowerSyncDatabase(new PowerSyncDatabaseOptions
{
    Database = new SQLOpenOptions { DbFilename = "powersync.db" },
    Schema = AppSchema.PowerSyncSchema,
    Logger = logger
});