IndexedDb

@inject Bit.Butil.IndexedDb indexedDb

if (await indexedDb.IsSupported())
{
    // safe to open databases
}

private IndexedDbHandle db = default!;

db = await indexedDb.Open("butil-docs-notes", version: 2, stores:
[
    new IndexedDbStoreSchema
    {
        Name = "notes",
        KeyPath = "id",
        Indexes =
        [
            new IndexedDbIndexSchema { Name = "by-category", KeyPath = "category" },
        ],
    },
    new IndexedDbStoreSchema { Name = "blobs" },   // out-of-line keys
],
onVersionChange: () => Console.WriteLine("another tab is upgrading; this handle was closed"),
onClose: () => Console.WriteLine("connection died - storage evicted?"));

if (db.WasUpgraded)
{
    // Runs after the upgrade transaction commits, so keep any backfill idempotent.
    Console.WriteLine($"migrated v{db.OldVersion} -> v{db.NewVersion}");
}

@code {
    // The handle from "Open a database" above; every call below goes through it.
    private IndexedDbHandle db = default!;

    // The record type. Property names are camel-cased on the way across, so "id" is the KeyPath the
    // store was created with.
    public class Note
    {
        public int Id { get; set; }
        public string Text { get; set; } = "";
        public string Category { get; set; } = "general";
    }

    private async Task Write()
    {
        var key = await db.Add("notes", new Note { Id = 1, Text = "Hello IndexedDB", Category = "intro" });

        await db.Put("notes", new Note { Id = 1, Text = "Hello again", Category = "intro" }); // upsert
    }
}

@code {
    private IndexedDbHandle db = default!;   // from "Open a database"

    private async Task Read()
    {
        var one = await db.Get<Note>("notes", 1);         // null when absent

        var all = await db.GetAll<Note>("notes");          // Note[]

        var keys = await db.GetAllKeys("notes");           // JsonElement[]

        var count = await db.Count("notes");               // int
    }
}

@code {
    private IndexedDbHandle db = default!;   // from "Open a database"

    private async Task Query()
    {
        // IndexedDbKeyRange.Bound(10, 20);                   // 10 <= key <= 20
        // IndexedDbKeyRange.Bound(10, 20, lowerOpen: true);  // 10 <  key <= 20
        // IndexedDbKeyRange.LowerBound(10);                  // key >= 10
        // IndexedDbKeyRange.UpperBound(20, open: true);      // key <  20
        // IndexedDbKeyRange.Only(15);                        // key == 15

        var range = IndexedDbKeyRange.Bound(10, 20);

        var notes = await db.GetAll<Note>("notes", range);
        var keys = await db.GetAllKeys("notes", range);
        var howMany = await db.Count("notes", range);

        await db.Delete("notes", range);                   // removes the whole interval
    }
}

@code {
    private IndexedDbHandle db = default!;   // from "Open a database"

    private async Task Paginate()
    {
        var page = await db.GetPage<Note>("notes", skip: 20, take: 10);

        foreach (var record in page)
        {
            Console.WriteLine($"{record.PrimaryKey}: {record.Value!.Text}");
        }

        // newest first
        var latest = await db.GetPage<Note>("notes", direction: IndexedDbCursorDirection.Previous, take: 5);

        // keys only, restricted to a range
        var keys = await db.GetKeyPage("notes", IndexedDbKeyRange.LowerBound(10), take: 3);
    }
}

@code {
    // The index has to exist in the schema the database was opened with - "by-category" is the one
    // declared on the notes store above.
    private IndexedDbHandle db = default!;

    private async Task ByIndex()
    {
        var first = await db.GetByIndex<Note>("notes", "by-category", "intro");

        var matches = await db.GetAllByIndex<Note>("notes", "by-category", "intro");

        var keys = await db.GetAllKeysByIndex("notes", "by-category", "intro");

        var howMany = await db.CountByIndex("notes", "by-category", "intro");

        var removed = await db.DeleteByIndex("notes", "by-category", "intro");   // returns the count

        // every distinct category, once each
        var distinct = await db.GetKeyPageByIndex("notes", "by-category",
            direction: IndexedDbCursorDirection.NextUnique);
    }
}

@code {
    private IndexedDbHandle db = default!;   // from "Open a database"

    private async Task Batch()
    {
        var keys = await db.Transact(
        [
            IndexedDbOperation.Put("notes", new Note { Id = 10, Text = "first", Category = "batch" }),
            IndexedDbOperation.Put("notes", new Note { Id = 11, Text = "second", Category = "batch" }),
            IndexedDbOperation.Delete("notes", 1),
        ],
        durability: IndexedDbDurability.Relaxed);

        // An Add on a key that already exists aborts the batch - none of the writes above it survive.
    }
}

@code {
    // "blobs" is the out-of-line store from the schema above, so the key is passed rather than read
    // off the value.
    private IndexedDbHandle db = default!;

    private async Task Binary(byte[] png)
    {
        await db.PutBytes("blobs", png, key: "logo");

        var bytes = await db.GetBytes("blobs", "logo");   // byte[]? - null when absent or not binary
    }
}

@inject Bit.Butil.IndexedDb indexedDb

@code {
    private IndexedDbHandle db = default!;   // from "Open a database"

    private async Task Inspect()
    {
        var info = await db.GetInfo();          // name, version, store names
        var store = await db.GetStoreInfo("notes");   // keypath, autoIncrement, index names
        var index = await db.GetIndexInfo("notes", "by-category");   // keypath, unique, multiEntry

        // These two are on the service rather than a connection: they answer about the origin.
        var all = await indexedDb.Databases();  // IndexedDbDatabaseInfo[]

        var order = await indexedDb.Compare(1, 2);   // negative: 1 sorts before 2
    }
}

@code {
    private IndexedDbHandle db = default!;   // from "Open a database"

    private async Task Remove()
    {
        await db.Delete("notes", 1);

        await db.Clear("notes");
    }
}

@implements IAsyncDisposable
@inject Bit.Butil.IndexedDb indexedDb

@code {
    private IndexedDbHandle? db;

    // A deleteDatabase request blocks for as long as any connection is still open - including this
    // page's own - so the handle is closed first.
    private async Task Drop()
    {
        if (db is not null) await db.DisposeAsync();
        db = null;

        await indexedDb.DeleteDatabase("butil-docs-notes");
    }

    public async ValueTask DisposeAsync()
    {
        if (db is not null) await db.DisposeAsync();
    }
}