CosmosLibraryStore.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Microsoft.Azure.Cosmos;
using ServerlessLibrary.Models;

namespace ServerlessLibrary
{
    /// <summary>
    /// Cosmos db Library store
    /// </summary>
    public class CosmosLibraryStore : ILibraryStore
    {
        public CosmosLibraryStore()
        {
            CosmosDBRepository<LibraryItem>.Initialize();
        }

        public async Task Add(LibraryItem libraryItem)
        {
            await CosmosDBRepository<LibraryItem>.CreateItemAsync(libraryItem);
        }

        async public Task<IList<LibraryItem>> GetAllItems()
        {
            IEnumerable<LibraryItem> libraryItems = await CosmosDBRepository<LibraryItem>.GetAllItemsAsync();
            return libraryItems.ToList();
        }
    }

    /// <summary>
    /// Cosmos db APIs
    /// </summary>
    /// <typeparam name="T"></typeparam>
    static class CosmosDBRepository<T> where T : class
    {
        private static readonly string DatabaseId = ServerlessLibrarySettings.Database;
        private static readonly string CollectionId = ServerlessLibrarySettings.Collection;
        private static Container container;

        public static async Task<T> GetItemAsync(string id)
        {
            try
            {
                ItemResponse<T> response = await container.ReadItemAsync<T>(id, PartitionKey.None);
                return response.Resource;
            }
            catch (CosmosException e)
            {
                if (e.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    return null;
                }
                else
                {
                    throw;
                }
            }
        }

        public static async Task<List<T>> GetAllItemsAsync()
        {
            FeedIterator<T> query = container.GetItemQueryIterator<T>(
                queryDefinition: null,
                requestOptions: new QueryRequestOptions() { MaxItemCount = -1 }); // NOTE: FeedOptions.EnableCrossPartitionQuery is removed in SDK v3 (https://docs.microsoft.com/en-us/azure/cosmos-db/sql/migrate-dotnet-v3?tabs=dotnet-v3#changes-to-feedoptions-queryrequestoptions-in-v30-sdk)

            List<T> results = new List<T>();
            using (query)
            {
                while (query.HasMoreResults)
                {
                    results.AddRange(await query.ReadNextAsync());
                }
            }

            return results;
        }

        public static async Task<T> CreateItemAsync(T item)
        {
            ItemResponse<T> response = await container.CreateItemAsync(item, PartitionKey.None);
            return response.Resource;
        }

        public static async Task<T> UpdateItemAsync(string id, T item)
        {
            ItemResponse<T> response = await container.UpsertItemAsync(item, PartitionKey.None);
            return response.Resource;
        }

        public static async Task DeleteItemAsync(string id)
        {
            await container.DeleteItemAsync<T>(id, PartitionKey.None);
        }

        public static void Initialize()
        {
            if (container == null)
            {
                CosmosClient client;

                // Use DefaultAzureCredential as the default authentication method (recommended for Azure workloads)
                if (!string.IsNullOrEmpty(ServerlessLibrarySettings.CosmosEndpoint))
                {
                    try
                    {
                        // Create DefaultAzureCredential with basic options compatible with .NET Core 2.1
                        TokenCredential credential = new DefaultAzureCredential();
                        client = new CosmosClient(ServerlessLibrarySettings.CosmosEndpoint, credential);
                    }
                    catch
                    {
                        // Fallback to connection string authentication if DefaultAzureCredential fails
                        if (!string.IsNullOrEmpty(ServerlessLibrarySettings.CosmosAuthkey))
                        {
                            client = new CosmosClient(
                                ServerlessLibrarySettings.CosmosEndpoint,
                                ServerlessLibrarySettings.CosmosAuthkey);
                        }
                        else
                        {
                            throw new System.InvalidOperationException(
                                "Unable to authenticate with Cosmos DB. Ensure either managed identity is configured or CosmosAuthkey is provided.");
                        }
                    }
                }
                else
                {
                    throw new System.InvalidOperationException("CosmosEndpoint must be configured.");
                }

                DatabaseResponse databaseResponse = client.CreateDatabaseIfNotExistsAsync(DatabaseId).Result;
                Database database = databaseResponse;

                ContainerResponse containerResponse = database.CreateContainerIfNotExistsAsync(id: CollectionId, partitionKeyPath: "/_partitionKey", throughput: 400).Result;
                container = containerResponse;
            }
        }
    }
}