Hybrid Search implementation and find enumerator cleanup (#18)

Co-authored-by: jeffrey-elliott <[email protected]>
Co-authored-by: Steve Hewitt <[email protected]>

Author: a-random-steve

.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+on:
+  push:
+    branches:
+      - main
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Restore dependencies
+        run: dotnet restore ./src/DataStax.AstraDB.DataApi/
+
+      - name: Build
+        run: dotnet build ./src/DataStax.AstraDB.DataApi/ --configuration Release --no-restore

.github/workflows/release.yml

@@ -0,0 +1,52 @@
+name: Release to NuGet
+
+on:
+  push:
+    tags:
+      - "v*.*.*" # Matches stable versions like v1.2.3
+      - "v*.*.*-*" # Matches pre-release versions like v2.0.1-beta
+
+jobs:
+  build-and-release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Extract version from tag
+        id: extract_version
+        run: |
+          TAG=${{ github.ref_name }}
+          VERSION=${TAG#v} # Removes 'v' prefix
+          echo "PACKAGE_VERSION=$VERSION" >> $GITHUB_ENV
+
+      - name: Restore dependencies
+        run: dotnet restore ./src/DataStax.AstraDB.DataApi/
+
+      - name: Build
+        run: dotnet build ./src/DataStax.AstraDB.DataApi/ --configuration Release --no-restore
+
+      - name: Pack
+        run: dotnet pack ./src/DataStax.AstraDB.DataApi/ --configuration Release --no-build --output nupkgs -p:Version=${{ env.PACKAGE_VERSION }}
+
+      # - name: Push to NuGet
+      #   run: dotnet nuget push nupkgs/*.nupkg --api-key $NUGET_API_KEY --source https://api.nuget.org/v3/index.json
+      #   env:
+      #     NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
+
+      - name: Dry-run NuGet push
+        run: |
+          echo "Would run: dotnet nuget push nupkgs/*.nupkg --api-key [REDACTED] --source https://api.nuget.org/v3/index.json"
+
+      - name: Upload NuGet package as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: nuget-package
+          path: nupkgs/*.nupkg
+          retention-days: 1

index.md

@@ -4,7 +4,7 @@ _layout: landing
 
 # Overview
 
-This C# Client Library simplifies using the DataStax Data API to manage and interact with AstraDB instances as well as other DataStax databases.
+This C# Client Library simplifies using the DataStax Data API to manage and interact with Astra DB instances as well as other DataStax databases.
 
 # Installation
 

src/DataStax.AstraDB.DataApi/Admin/AstraDatabasesAdmin.cs

@@ -35,8 +35,6 @@ namespace DataStax.AstraDB.DataApi.Admin;
 /// </example>
 public class AstraDatabasesAdmin
 {
-    private const int WAIT_IN_SECONDS = 600;
-
     private readonly CommandOptions _adminOptions;
     private readonly DataApiClient _client;
 
@@ -360,7 +358,7 @@ internal async Task<IDatabaseAdmin> CreateDatabaseAsync(DatabaseCreationOptions
             if (existingDb.Status == "ACTIVE")
             {
                 Console.WriteLine($"Database {databaseName} already exists and is ACTIVE.");
-                return GetDatabaseAdmin(Guid.Parse(existingDb.Id));
+                return GetDatabaseAdmin(existingDb);
             }
 
             throw new InvalidOperationException($"Database {databaseName} already exists but is in state: {existingDb.Status}");
@@ -403,63 +401,29 @@ internal async Task<IDatabaseAdmin> CreateDatabaseAsync(DatabaseCreationOptions
 
     private void WaitForDatabase(string databaseName)
     {
-        WaitForDatabaseAsync(databaseName, true).ResultSync();
-    }
-
-    private async Task WaitForDatabaseAsync(string databaseName)
-    {
-        await WaitForDatabaseAsync(databaseName, false).ConfigureAwait(false);
+        WaitForDatabaseAsync(databaseName).ResultSync();
     }
 
-    internal async Task WaitForDatabaseAsync(string databaseName, bool runSynchronously)
+    internal async Task WaitForDatabaseAsync(string databaseName)
     {
+        const int MAX_WAIT_IN_SECONDS = 600;
+        const int SLEEP_SECONDS = 5;
         Guard.NotNullOrEmpty(databaseName, nameof(databaseName));
-        if (runSynchronously)
-        {
-            Console.WriteLine($"Waiting {WAIT_IN_SECONDS} seconds synchronously before checking db status...");
-            Thread.Sleep(WAIT_IN_SECONDS * 1000);
-            string status = GetDatabaseStatus(databaseName);
 
-            if (status != "ACTIVE")
-            {
-                throw new Exception($"Database {databaseName} is still {status} after {WAIT_IN_SECONDS} seconds.");
-            }
+        int secondsWaited = 0;
 
-            Console.WriteLine($"Database {databaseName} is ready.");
-            return;
-        }
-
-        const int retry = 30_000; // 30 seconds
-        int waiting = 0;
-
-        while (waiting < WAIT_IN_SECONDS * 1000)
+        while (secondsWaited < MAX_WAIT_IN_SECONDS)
         {
             string status = await GetDatabaseStatusAsync(databaseName).ConfigureAwait(false);
             if (status == "ACTIVE")
             {
-                Console.WriteLine($"Database {databaseName} is ready.");
                 return;
             }
-
-            Console.WriteLine($"Database {databaseName} is {status}... retrying in {retry / 1000} seconds.");
-            await Task.Delay(retry).ConfigureAwait(false);
-            waiting += retry;
-        }
-
-        throw new Exception($"Database {databaseName} did not become ready within {WAIT_IN_SECONDS} seconds.");
-    }
-
-    internal string GetDatabaseStatus(string databaseName)
-    {
-        Guard.NotNullOrEmpty(databaseName, nameof(databaseName));
-        var db = ListDatabases().FirstOrDefault(item => databaseName.Equals(item.Info.Name));
-
-        if (db == null)
-        {
-            throw new Exception($"Database '{databaseName}' not found.");
+            await Task.Delay(SLEEP_SECONDS * 1000).ConfigureAwait(false);
+            secondsWaited += SLEEP_SECONDS;
         }
 
-        return db.Status;
+        throw new Exception($"Database {databaseName} did not become ready within {MAX_WAIT_IN_SECONDS} seconds.");
     }
 
     internal async Task<string> GetDatabaseStatusAsync(string databaseName)
@@ -638,10 +602,19 @@ internal async Task<bool> DropDatabaseAsync(Guid dbGuid, CommandOptions options,
         return false;
     }
 
-    private IDatabaseAdmin GetDatabaseAdmin(Guid dbGuid)
+    private DatabaseAdminAstra GetDatabaseAdmin(DatabaseInfo dbInfo)
     {
-        Guard.NotEmpty(dbGuid, nameof(dbGuid));
-        return new DatabaseAdminAstra(dbGuid, _client, null);
+        var apiEndpoint = $"https://{dbInfo.Id}-{dbInfo.Info.Region}.apps.astra.datastax.com";
+        var database = _client.GetDatabase(apiEndpoint);
+        return new DatabaseAdminAstra(database, _client, null);
+    }
+
+    private DatabaseAdminAstra GetDatabaseAdmin(Guid dbGuid)
+    {
+        var dbInfo = GetDatabaseInfo(dbGuid);
+        var apiEndpoint = $"https://{dbGuid}-{dbInfo.Info.Region}.apps.astra.datastax.com";
+        var database = _client.GetDatabase(apiEndpoint);
+        return new DatabaseAdminAstra(database, _client, null);
     }
 
     /// <summary>