opencode-skills-collection 4.1.14 → 4.1.16

package/bundled-skills/azure-resource-manager-cosmosdb-dotnet/references/account-management.md

@@ -0,0 +1,279 @@
+# Account Management
+
+Detailed patterns for managing Cosmos DB accounts via Azure Resource Manager.
+
+## Create Account with Full Configuration
+
+```csharp
+using Azure.ResourceManager.CosmosDB;
+using Azure.ResourceManager.CosmosDB.Models;
+using Azure.Core;
+
+var accountData = new CosmosDBAccountCreateOrUpdateContent(
+    location: AzureLocation.EastUS,
+    locations: new[]
+    {
+        new CosmosDBAccountLocation
+        {
+            LocationName = AzureLocation.EastUS,
+            FailoverPriority = 0,
+            IsZoneRedundant = true
+        },
+        new CosmosDBAccountLocation
+        {
+            LocationName = AzureLocation.WestUS,
+            FailoverPriority = 1,
+            IsZoneRedundant = false
+        }
+    })
+{
+    Kind = CosmosDBAccountKind.GlobalDocumentDB,
+
+    // Consistency
+    ConsistencyPolicy = new ConsistencyPolicy(DefaultConsistencyLevel.BoundedStaleness)
+    {
+        MaxStalenessPrefix = 100000,
+        MaxIntervalInSeconds = 300
+    },
+
+    // High availability
+    EnableAutomaticFailover = true,
+    EnableMultipleWriteLocations = false,
+
+    // Backup
+    BackupPolicy = new ContinuousModeBackupPolicy
+    {
+        ContinuousModeTier = ContinuousModeTier.Continuous7Days
+    },
+
+    // Networking
+    PublicNetworkAccess = CosmosDBPublicNetworkAccess.Enabled,
+    IsVirtualNetworkFilterEnabled = false,
+
+    // Features
+    EnableFreeTier = false,
+    EnableAnalyticalStorage = true,
+    AnalyticalStorageSchemaType = AnalyticalStorageSchemaType.WellDefined,
+
+    // Tags
+    Tags =
+    {
+        ["Environment"] = "Production",
+        ["CostCenter"] = "Engineering"
+    }
+};
+
+var operation = await accountCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-cosmos-account",
+    accountData);
+```
+
+## Get Existing Account
+
+```csharp
+// By name from resource group
+var account = await resourceGroup.GetCosmosDBAccountAsync("my-cosmos-account");
+
+// By resource ID
+var accountId = CosmosDBAccountResource.CreateResourceIdentifier(
+    subscriptionId, resourceGroupName, accountName);
+var account = armClient.GetCosmosDBAccountResource(accountId);
+await account.GetAsync(); // Fetch latest data
+```
+
+## Update Account
+
+```csharp
+// Get current account
+var account = await resourceGroup.GetCosmosDBAccountAsync("my-cosmos-account");
+
+// Create patch data
+var patchData = new CosmosDBAccountPatch
+{
+    EnableAutomaticFailover = true,
+    ConsistencyPolicy = new ConsistencyPolicy(DefaultConsistencyLevel.Session)
+};
+patchData.Tags.Add("UpdatedBy", "Automation");
+
+// Apply update
+var operation = await account.Value.UpdateAsync(WaitUntil.Completed, patchData);
+```
+
+## Delete Account
+
+```csharp
+var account = await resourceGroup.GetCosmosDBAccountAsync("my-cosmos-account");
+await account.Value.DeleteAsync(WaitUntil.Completed);
+```
+
+## List Accounts
+
+```csharp
+// In resource group
+await foreach (var account in resourceGroup.GetCosmosDBAccounts())
+{
+    Console.WriteLine($"Account: {account.Data.Name}");
+    Console.WriteLine($"  Location: {account.Data.Location}");
+    Console.WriteLine($"  Kind: {account.Data.Kind}");
+}
+
+// In subscription
+await foreach (var account in subscription.GetCosmosDBAccountsAsync())
+{
+    Console.WriteLine($"{account.Data.Name} in {account.Data.ResourceGroupName}");
+}
+```
+
+## Get Keys and Connection Strings
+
+```csharp
+// Get keys
+var keys = await account.GetKeysAsync();
+Console.WriteLine($"Primary Key: {keys.Value.PrimaryMasterKey}");
+Console.WriteLine($"Secondary Key: {keys.Value.SecondaryMasterKey}");
+Console.WriteLine($"Primary Read-Only: {keys.Value.PrimaryReadonlyMasterKey}");
+Console.WriteLine($"Secondary Read-Only: {keys.Value.SecondaryReadonlyMasterKey}");
+
+// Get connection strings
+var connectionStrings = await account.GetConnectionStringsAsync();
+foreach (var cs in connectionStrings.Value.ConnectionStrings)
+{
+    Console.WriteLine($"{cs.Description}:");
+    Console.WriteLine($"  {cs.ConnectionString}");
+}
+
+// Regenerate key
+await account.RegenerateKeyAsync(
+    WaitUntil.Completed,
+    new CosmosDBAccountRegenerateKeyContent(CosmosDBAccountKeyKind.Primary));
+```
+
+## Failover Operations
+
+```csharp
+// Manual failover (for testing)
+var failoverContent = new CosmosDBFailoverPolicies(new[]
+{
+    new CosmosDBFailoverPolicy
+    {
+        LocationName = AzureLocation.WestUS,
+        FailoverPriority = 0
+    },
+    new CosmosDBFailoverPolicy
+    {
+        LocationName = AzureLocation.EastUS,
+        FailoverPriority = 1
+    }
+});
+
+await account.FailoverPriorityChangeAsync(WaitUntil.Completed, failoverContent);
+```
+
+## Network Configuration
+
+### Private Endpoint
+
+```csharp
+// Note: Private endpoints are typically created via Azure.ResourceManager.Network
+// The Cosmos account needs to be configured to accept private endpoint connections
+
+var accountData = new CosmosDBAccountCreateOrUpdateContent(location, locations)
+{
+    PublicNetworkAccess = CosmosDBPublicNetworkAccess.Disabled,
+    IsVirtualNetworkFilterEnabled = true
+};
+```
+
+### IP Firewall Rules
+
+```csharp
+var accountData = new CosmosDBAccountCreateOrUpdateContent(location, locations)
+{
+    IPRules =
+    {
+        new CosmosDBIPAddressOrRange { IPAddressOrRange = "104.42.195.92" },
+        new CosmosDBIPAddressOrRange { IPAddressOrRange = "40.76.54.131" },
+        new CosmosDBIPAddressOrRange { IPAddressOrRange = "52.176.6.30/32" }
+    }
+};
+```
+
+### Virtual Network Rules
+
+```csharp
+var accountData = new CosmosDBAccountCreateOrUpdateContent(location, locations)
+{
+    IsVirtualNetworkFilterEnabled = true,
+    VirtualNetworkRules =
+    {
+        new CosmosDBVirtualNetworkRule
+        {
+            Id = new ResourceIdentifier(
+                "/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/virtualNetworks/{vnet}/subnets/{subnet}"),
+            IgnoreMissingVnetServiceEndpoint = false
+        }
+    }
+};
+```
+
+## Consistency Levels
+
+| Level | Description | Use Case |
+|-------|-------------|----------|
+| `Strong` | Linearizable reads | Financial transactions |
+| `BoundedStaleness` | Reads lag by K versions or T time | Gaming leaderboards |
+| `Session` | Read your own writes | User sessions (default) |
+| `ConsistentPrefix` | Reads never see out-of-order writes | Social feeds |
+| `Eventual` | No ordering guarantee | Analytics, non-critical reads |
+
+```csharp
+// Bounded Staleness example
+ConsistencyPolicy = new ConsistencyPolicy(DefaultConsistencyLevel.BoundedStaleness)
+{
+    MaxStalenessPrefix = 100000,  // Max versions behind
+    MaxIntervalInSeconds = 300    // Max time behind (5 min)
+}
+```
+
+## Backup Policies
+
+### Periodic Backup
+
+```csharp
+BackupPolicy = new PeriodicModeBackupPolicy
+{
+    PeriodicModeProperties = new PeriodicModeProperties
+    {
+        BackupIntervalInMinutes = 240,  // 4 hours
+        BackupRetentionIntervalInHours = 720,  // 30 days
+        BackupStorageRedundancy = BackupStorageRedundancy.Geo
+    }
+}
+```
+
+### Continuous Backup
+
+```csharp
+BackupPolicy = new ContinuousModeBackupPolicy
+{
+    ContinuousModeTier = ContinuousModeTier.Continuous30Days
+}
+```
+
+## Account Kinds
+
+| Kind | API | Description |
+|------|-----|-------------|
+| `GlobalDocumentDB` | SQL (Core) | Default, most common |
+| `MongoDB` | MongoDB | MongoDB wire protocol |
+| `Parse` | SQL | Parse Server compatibility |
+
+```csharp
+// MongoDB account
+var accountData = new CosmosDBAccountCreateOrUpdateContent(location, locations)
+{
+    Kind = CosmosDBAccountKind.MongoDB,
+    ApiServerVersion = CosmosDBServerVersion.V4_2
+};
+```

package/bundled-skills/azure-resource-manager-cosmosdb-dotnet/references/sql-resources.md

@@ -0,0 +1,373 @@
+# SQL API Resources
+
+Patterns for managing SQL (Core) API databases, containers, and programmability objects.
+
+## SQL Database Operations
+
+### Create Database
+
+```csharp
+using Azure.ResourceManager.CosmosDB;
+using Azure.ResourceManager.CosmosDB.Models;
+
+var databaseData = new CosmosDBSqlDatabaseCreateOrUpdateContent(
+    new CosmosDBSqlDatabaseResourceInfo("my-database"));
+
+var databaseCollection = account.GetCosmosDBSqlDatabases();
+var operation = await databaseCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-database",
+    databaseData);
+
+CosmosDBSqlDatabaseResource database = operation.Value;
+```
+
+### Create Database with Shared Throughput
+
+```csharp
+var databaseData = new CosmosDBSqlDatabaseCreateOrUpdateContent(
+    new CosmosDBSqlDatabaseResourceInfo("my-database"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        Throughput = 400  // Shared across containers
+    }
+};
+
+// Or with autoscale
+var databaseData = new CosmosDBSqlDatabaseCreateOrUpdateContent(
+    new CosmosDBSqlDatabaseResourceInfo("my-database"))
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        AutoscaleSettings = new AutoscaleSettings
+        {
+            MaxThroughput = 4000
+        }
+    }
+};
+```
+
+### List Databases
+
+```csharp
+await foreach (var db in account.GetCosmosDBSqlDatabases())
+{
+    Console.WriteLine($"Database: {db.Data.Name}");
+    Console.WriteLine($"  Resource ID: {db.Data.Resource.DatabaseName}");
+}
+```
+
+### Delete Database
+
+```csharp
+var database = await account.GetCosmosDBSqlDatabaseAsync("my-database");
+await database.Value.DeleteAsync(WaitUntil.Completed);
+```
+
+## SQL Container Operations
+
+### Create Container with Partition Key
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/tenantId" },
+            Kind = CosmosDBPartitionKind.Hash,
+            Version = 2  // Use V2 for hierarchical partition keys
+        }
+    });
+
+var containerCollection = database.GetCosmosDBSqlContainers();
+var operation = await containerCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "my-container",
+    containerData);
+```
+
+### Hierarchical Partition Key (V2)
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/tenantId", "/userId", "/sessionId" },
+            Kind = CosmosDBPartitionKind.MultiHash,
+            Version = 2
+        }
+    });
+```
+
+### Create Container with Indexing Policy
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/partitionKey" },
+            Kind = CosmosDBPartitionKind.Hash
+        },
+        IndexingPolicy = new CosmosDBIndexingPolicy
+        {
+            Automatic = true,
+            IndexingMode = CosmosDBIndexingMode.Consistent,
+
+            // Include paths
+            IncludedPaths =
+            {
+                new CosmosDBIncludedPath { Path = "/*" }
+            },
+
+            // Exclude paths
+            ExcludedPaths =
+            {
+                new CosmosDBExcludedPath { Path = "/largeTextField/*" },
+                new CosmosDBExcludedPath { Path = "/_etag/?" }
+            },
+
+            // Composite indexes for ORDER BY on multiple fields
+            CompositeIndexes =
+            {
+                new CosmosDBCompositePath[]
+                {
+                    new() { Path = "/name", Order = CompositePathSortOrder.Ascending },
+                    new() { Path = "/timestamp", Order = CompositePathSortOrder.Descending }
+                }
+            },
+
+            // Spatial indexes
+            SpatialIndexes =
+            {
+                new SpatialSpec
+                {
+                    Path = "/location/*",
+                    Types = { SpatialType.Point, SpatialType.Polygon }
+                }
+            }
+        }
+    });
+```
+
+### Create Container with TTL
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/partitionKey" },
+            Kind = CosmosDBPartitionKind.Hash
+        },
+        // Default TTL in seconds (-1 = off, 0 = on but no default, >0 = default seconds)
+        DefaultTtl = 86400  // 24 hours
+    });
+```
+
+### Create Container with Unique Keys
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/tenantId" },
+            Kind = CosmosDBPartitionKind.Hash
+        },
+        UniqueKeys = new CosmosDBUniqueKeyPolicy
+        {
+            UniqueKeys =
+            {
+                new CosmosDBUniqueKey
+                {
+                    Paths = { "/email" }
+                },
+                new CosmosDBUniqueKey
+                {
+                    Paths = { "/department", "/employeeId" }
+                }
+            }
+        }
+    });
+```
+
+### Create Container with Dedicated Throughput
+
+```csharp
+var containerData = new CosmosDBSqlContainerCreateOrUpdateContent(
+    new CosmosDBSqlContainerResourceInfo("my-container")
+    {
+        PartitionKey = new CosmosDBContainerPartitionKey
+        {
+            Paths = { "/partitionKey" },
+            Kind = CosmosDBPartitionKind.Hash
+        }
+    })
+{
+    Options = new CosmosDBCreateUpdateConfig
+    {
+        Throughput = 1000  // Dedicated to this container
+    }
+};
+```
+
+### List Containers
+
+```csharp
+await foreach (var container in database.GetCosmosDBSqlContainers())
+{
+    Console.WriteLine($"Container: {container.Data.Name}");
+    Console.WriteLine($"  Partition Key: {string.Join(", ", container.Data.Resource.PartitionKey.Paths)}");
+    Console.WriteLine($"  Default TTL: {container.Data.Resource.DefaultTtl}");
+}
+```
+
+### Delete Container
+
+```csharp
+var container = await database.GetCosmosDBSqlContainerAsync("my-container");
+await container.Value.DeleteAsync(WaitUntil.Completed);
+```
+
+## Stored Procedures
+
+### Create Stored Procedure
+
+```csharp
+var sprocData = new CosmosDBSqlStoredProcedureCreateOrUpdateContent(
+    new CosmosDBSqlStoredProcedureResourceInfo("bulkDelete")
+    {
+        Body = @"
+function bulkDelete(query) {
+    var context = getContext();
+    var container = context.getCollection();
+    var response = context.getResponse();
+    var deleted = 0;
+
+    var accepted = container.queryDocuments(
+        container.getSelfLink(),
+        query,
+        function(err, docs) {
+            if (err) throw err;
+            docs.forEach(function(doc) {
+                container.deleteDocument(doc._self);
+                deleted++;
+            });
+            response.setBody({ deleted: deleted });
+        }
+    );
+
+    if (!accepted) {
+        response.setBody({ deleted: deleted, continuation: true });
+    }
+}"
+    });
+
+var sprocCollection = container.GetCosmosDBSqlStoredProcedures();
+await sprocCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "bulkDelete",
+    sprocData);
+```
+
+### List Stored Procedures
+
+```csharp
+await foreach (var sproc in container.GetCosmosDBSqlStoredProcedures())
+{
+    Console.WriteLine($"Stored Procedure: {sproc.Data.Name}");
+}
+```
+
+## Triggers
+
+### Create Trigger
+
+```csharp
+var triggerData = new CosmosDBSqlTriggerCreateOrUpdateContent(
+    new CosmosDBSqlTriggerResourceInfo("validateDocument")
+    {
+        Body = @"
+function validateDocument() {
+    var context = getContext();
+    var request = context.getRequest();
+    var doc = request.getBody();
+
+    if (!doc.createdAt) {
+        doc.createdAt = new Date().toISOString();
+    }
+
+    request.setBody(doc);
+}",
+        TriggerType = CosmosDBSqlTriggerType.Pre,
+        TriggerOperation = CosmosDBSqlTriggerOperation.Create
+    });
+
+var triggerCollection = container.GetCosmosDBSqlTriggers();
+await triggerCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "validateDocument",
+    triggerData);
+```
+
+### Trigger Types
+
+| Type | When |
+|------|------|
+| `Pre` | Before the operation |
+| `Post` | After the operation |
+
+### Trigger Operations
+
+| Operation | Applies To |
+|-----------|------------|
+| `All` | All operations |
+| `Create` | Document creation |
+| `Update` | Document updates |
+| `Delete` | Document deletion |
+| `Replace` | Document replacement |
+
+## User Defined Functions (UDFs)
+
+### Create UDF
+
+```csharp
+var udfData = new CosmosDBSqlUserDefinedFunctionCreateOrUpdateContent(
+    new CosmosDBSqlUserDefinedFunctionResourceInfo("formatCurrency")
+    {
+        Body = @"
+function formatCurrency(amount, currency) {
+    return currency + ' ' + amount.toFixed(2);
+}"
+    });
+
+var udfCollection = container.GetCosmosDBSqlUserDefinedFunctions();
+await udfCollection.CreateOrUpdateAsync(
+    WaitUntil.Completed,
+    "formatCurrency",
+    udfData);
+```
+
+## Partition Key Strategies
+
+| Strategy | Path Example | Use Case |
+|----------|--------------|----------|
+| Single property | `/tenantId` | Multi-tenant apps |
+| Synthetic key | `/partitionKey` | Computed from multiple fields |
+| Hierarchical | `/tenantId`, `/userId` | Large tenants with sub-partitioning |
+| ID-based | `/id` | Even distribution, no cross-partition queries |
+
+### Choosing Partition Key
+
+1. **High cardinality** — Many distinct values
+2. **Even distribution** — No hot partitions
+3. **Query alignment** — Most queries include partition key
+4. **Immutable** — Cannot change after document creation