random-mirrors/cosmos-explorer
1
0
Fork 0
mirror of https://github.com/Azure/cosmos-explorer.git synced 2025-12-22 02:11:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

More tweaks

Browse Source
This commit is contained in:
Steve Faulkner
2020-07-23 18:12:58 -05:00
parent f1812077e9
commit f4f2d00d7f
22 changed files with 2049 additions and 2233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
src/Utils/arm/CassandraResources.ts
View File

@@ -4,164 +4,112 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class CassandraResourcesClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/cassandraKeyspaces`;
/* Lists the Cassandra keyspaces under an existing Azure Cosmos DB database account. */ constructor(
export async function listCassandraKeyspaces ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string
accountName: string ) {}
) : Promise<Types.CassandraKeyspaceListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces`, { method: "get", }).then((response) => response.json())
}
/* Lists the Cassandra keyspaces under an existing Azure Cosmos DB database account. */
async listCassandraKeyspaces(): Promise<Types.CassandraKeyspaceListResult> {
const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Gets the Cassandra keyspaces under an existing Azure Cosmos DB database account with the provided name. */ /* Gets the Cassandra keyspaces under an existing Azure Cosmos DB database account with the provided name. */
export async function getCassandraKeyspace ( async getCassandraKeyspace(keyspaceName: string): Promise<Types.CassandraKeyspaceGetResults> {
subscriptionId: string, const path = `/${keyspaceName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
keyspaceName: string
) : Promise<Types.CassandraKeyspaceGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB Cassandra keyspace */
async createUpdateCassandraKeyspace(
keyspaceName: string,
body: Types.CassandraKeyspaceCreateUpdateParameters
): Promise<Types.CassandraKeyspaceGetResults | void> {
const path = `/${keyspaceName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Create or update an Azure Cosmos DB Cassandra keyspace */ /* Deletes an existing Azure Cosmos DB Cassandra keyspace. */
export async function createUpdateCassandraKeyspace ( async deleteCassandraKeyspace(keyspaceName: string): Promise<void | void> {
subscriptionId: string, const path = `/${keyspaceName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
keyspaceName: string
,body: Types.CassandraKeyspaceCreateUpdateParameters
) : Promise<Types.CassandraKeyspaceGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Lists the Cassandra table under an existing Azure Cosmos DB database account. */
async listCassandraTables(keyspaceName: string): Promise<Types.CassandraTableListResult> {
const path = `/${keyspaceName}/tables`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Deletes an existing Azure Cosmos DB Cassandra keyspace. */ /* Gets the Cassandra table under an existing Azure Cosmos DB database account. */
export async function deleteCassandraKeyspace ( async getCassandraTable(keyspaceName: string, tableName: string): Promise<Types.CassandraTableGetResults> {
subscriptionId: string, const path = `/${keyspaceName}/tables/${tableName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
keyspaceName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}`, { method: "delete", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB Cassandra Table */
async createUpdateCassandraTable(
keyspaceName: string,
tableName: string,
body: Types.CassandraTableCreateUpdateParameters
): Promise<Types.CassandraTableGetResults | void> {
const path = `/${keyspaceName}/tables/${tableName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Gets the RUs per second of the Cassandra Keyspace under an existing Azure Cosmos DB database account with the provided name. */ /* Deletes an existing Azure Cosmos DB Cassandra table. */
export async function getCassandraKeyspaceThroughput ( async deleteCassandraTable(keyspaceName: string, tableName: string): Promise<void | void> {
subscriptionId: string, const path = `/${keyspaceName}/tables/${tableName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
keyspaceName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Gets the RUs per second of the Cassandra table under an existing Azure Cosmos DB database account with the provided name. */
async getCassandraTableThroughput(
keyspaceName: string,
tableName: string
): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${keyspaceName}/tables/${tableName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Update RUs per second of an Azure Cosmos DB Cassandra Keyspace */ /* Update RUs per second of an Azure Cosmos DB Cassandra table */
export async function updateCassandraKeyspaceThroughput ( async updateCassandraTableThroughput(
subscriptionId: string, keyspaceName: string,
resourceGroupName: string, tableName: string,
accountName: string, body: Types.ThroughputSettingsUpdateParameters
keyspaceName: string ): Promise<Types.ThroughputSettingsGetResults | void> {
,body: Types.ThroughputSettingsUpdateParameters const path = `/${keyspaceName}/tables/${tableName}/throughputSettings/default`;
) : Promise<Types.ThroughputSettingsGetResults | void> { return window
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json()) .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
} .then(response => response.json());
}
/* Gets the RUs per second of the Cassandra Keyspace under an existing Azure Cosmos DB database account with the provided name. */
async getCassandraKeyspaceThroughput(keyspaceName: string): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${keyspaceName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Lists the Cassandra table under an existing Azure Cosmos DB database account. */ /* Update RUs per second of an Azure Cosmos DB Cassandra Keyspace */
export async function listCassandraTables ( async updateCassandraKeyspaceThroughput(
subscriptionId: string, keyspaceName: string,
resourceGroupName: string, body: Types.ThroughputSettingsUpdateParameters
accountName: string, ): Promise<Types.ThroughputSettingsGetResults | void> {
keyspaceName: string const path = `/${keyspaceName}/throughputSettings/default`;
return window
) : Promise<Types.CassandraTableListResult> { .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables`, { method: "get", }).then((response) => response.json()) .then(response => response.json());
} }
}
/* Gets the Cassandra table under an existing Azure Cosmos DB database account. */
export async function getCassandraTable (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
keyspaceName: string,
tableName: string
) : Promise<Types.CassandraTableGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables/${tableName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB Cassandra Table */
export async function createUpdateCassandraTable (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
keyspaceName: string,
tableName: string
,body: Types.CassandraTableCreateUpdateParameters
) : Promise<Types.CassandraTableGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables/${tableName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Deletes an existing Azure Cosmos DB Cassandra table. */
export async function deleteCassandraTable (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
keyspaceName: string,
tableName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables/${tableName}`, { method: "delete", }).then((response) => response.json())
}
/* Gets the RUs per second of the Cassandra table under an existing Azure Cosmos DB database account with the provided name. */
export async function getCassandraTableThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
keyspaceName: string,
tableName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables/${tableName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Update RUs per second of an Azure Cosmos DB Cassandra table */
export async function updateCassandraTableThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
keyspaceName: string,
tableName: string
,body: Types.ThroughputSettingsUpdateParameters
) : Promise<Types.ThroughputSettingsGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/cassandraKeyspaces/${keyspaceName}/tables/${tableName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}

65
src/Utils/arm/Collection.ts
View File

@@ -4,46 +4,35 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class CollectionClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/databases/${this.databaseRid}/collections/${this.collectionRid}/`;
/* Retrieves the metrics determined by the given filter for the given database account and collection. */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly databaseRid: string,
databaseRid: string, private readonly collectionRid: string
collectionRid: string ) {}
) : Promise<Types.MetricListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/collections/${collectionRid}/metrics`, { method: "get", }).then((response) => response.json())
}
/* Retrieves metric definitions for the given collection. */
async listMetricDefinitions(): Promise<Types.MetricDefinitionsListResult> {
const path = `metricDefinitions`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Retrieves the usages (most recent storage data) for the given collection. */ /* Retrieves the metrics determined by the given filter for the given database account and collection. */
export async function listUsages ( async listMetrics(): Promise<Types.MetricListResult> {
subscriptionId: string, const path = `metrics`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseRid: string,
collectionRid: string
) : Promise<Types.UsagesResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/collections/${collectionRid}/usages`, { method: "get", }).then((response) => response.json())
}
/* Retrieves the usages (most recent storage data) for the given collection. */
/* Retrieves metric definitions for the given collection. */ async listUsages(): Promise<Types.UsagesResult> {
export async function listMetricDefinitions ( const path = `usages`;
subscriptionId: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
resourceGroupName: string, }
accountName: string, }
databaseRid: string,
collectionRid: string
) : Promise<Types.MetricDefinitionsListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/collections/${collectionRid}/metricDefinitions`, { method: "get", }).then((response) => response.json())
}

47
src/Utils/arm/CollectionPartition.ts
View File

@@ -4,32 +4,29 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class CollectionPartitionClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/databases/${this.databaseRid}/collections/${this.collectionRid}/partitions/`;
/* Retrieves the metrics determined by the given filter for the given collection, split by partition. */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly databaseRid: string,
databaseRid: string, private readonly collectionRid: string
collectionRid: string ) {}
) : Promise<Types.PartitionMetricListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/collections/${collectionRid}/partitions/metrics`, { method: "get", }).then((response) => response.json())
}
/* Retrieves the metrics determined by the given filter for the given collection, split by partition. */
async listMetrics(): Promise<Types.PartitionMetricListResult> {
const path = `metrics`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Retrieves the usages (most recent storage data) for the given collection, split by partition. */ /* Retrieves the usages (most recent storage data) for the given collection, split by partition. */
export async function listUsages ( async listUsages(): Promise<Types.PartitionUsagesResult> {
subscriptionId: string, const path = `usages`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseRid: string, }
collectionRid: string
) : Promise<Types.PartitionUsagesResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/collections/${collectionRid}/partitions/usages`, { method: "get", }).then((response) => response.json())
}

33
src/Utils/arm/CollectionPartitionRegion.ts
View File

@@ -4,19 +4,24 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class CollectionPartitionRegionClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/region/${this.region}/databases/${this.databaseRid}/collections/${this.collectionRid}/partitions/metrics`;
/* Retrieves the metrics determined by the given filter for the given collection and region, split by partition. */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly region: string,
region: string, private readonly databaseRid: string,
databaseRid: string, private readonly collectionRid: string
collectionRid: string ) {}
) : Promise<Types.PartitionMetricListResult> { /* Retrieves the metrics determined by the given filter for the given collection and region, split by partition. */
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/region/${region}/databases/${databaseRid}/collections/${collectionRid}/partitions/metrics`, { method: "get", }).then((response) => response.json()) async listMetrics(): Promise<Types.PartitionMetricListResult> {
} const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
}

33
src/Utils/arm/CollectionRegion.ts
View File

@@ -4,19 +4,24 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class CollectionRegionClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/region/${this.region}/databases/${this.databaseRid}/collections/${this.collectionRid}/metrics`;
/* Retrieves the metrics determined by the given filter for the given database account, collection and region. */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly region: string,
region: string, private readonly databaseRid: string,
databaseRid: string, private readonly collectionRid: string
collectionRid: string ) {}
) : Promise<Types.MetricListResult> { /* Retrieves the metrics determined by the given filter for the given database account, collection and region. */
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/region/${region}/databases/${databaseRid}/collections/${collectionRid}/metrics`, { method: "get", }).then((response) => response.json()) async listMetrics(): Promise<Types.MetricListResult> {
} const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
}

67
src/Utils/arm/Database.ts
View File

@@ -6,47 +6,32 @@
import * as Types from "./types"; import * as Types from "./types";
/* Retrieves the metrics determined by the given filter for the given database account and database. */ export class DatabaseClient {
export async function listMetrics( private readonly baseUrl = "https://management.azure.com";
subscriptionId: string, private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/databases/${this.databaseRid}/`;
resourceGroupName: string,
accountName: string,
databaseRid: string
): Promise<Types.MetricListResult> {
return window
.fetch(
`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/metrics`,
{ method: "get" }
)
.then(response => response.json());
}
/* Retrieves the usages (most recent data) for the given database. */ constructor(
export async function listUsages( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly databaseRid: string
databaseRid: string ) {}
): Promise<Types.UsagesResult> {
return window
.fetch(
`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/usages`,
{ method: "get" }
)
.then(response => response.json());
}
/* Retrieves metric definitions for the given database. */ /* Retrieves metric definitions for the given database. */
export async function listMetricDefinitions( async listMetricDefinitions(): Promise<Types.MetricDefinitionsListResult> {
subscriptionId: string, const path = `metricDefinitions`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseRid: string
): Promise<Types.MetricDefinitionsListResult> { /* Retrieves the metrics determined by the given filter for the given database account and database. */
return window async listMetrics(): Promise<Types.MetricListResult> {
.fetch( const path = `metrics`;
`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/metricDefinitions`, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
{ method: "get" } }
)
.then(response => response.json()); /* Retrieves the usages (most recent data) for the given database. */
async listUsages(): Promise<Types.UsagesResult> {
const path = `usages`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
} }

29
src/Utils/arm/DatabaseAccountRegion.ts
View File

@@ -6,17 +6,20 @@
import * as Types from "./types"; import * as Types from "./types";
/* Retrieves the metrics determined by the given filter for the given database account and region. */ export class DatabaseAccountRegionClient {
export async function listMetrics( private readonly baseUrl = "https://management.azure.com";
subscriptionId: string, private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/region/${this.region}/metrics`;
resourceGroupName: string,
accountName: string, constructor(
region: string private readonly subscriptionId: string,
): Promise<Types.MetricListResult> { private readonly resourceGroupName: string,
return window private readonly accountName: string,
.fetch( private readonly region: string
`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/region/${region}/metrics`, ) {}
{ method: "get" }
) /* Retrieves the metrics determined by the given filter for the given database account and region. */
.then(response => response.json()); async listMetrics(): Promise<Types.MetricListResult> {
const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
} }

365
src/Utils/arm/DatabaseAccounts.ts
View File

@@ -4,215 +4,194 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class DatabaseAccountsClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/`;
/* Retrieves the properties of an existing Azure Cosmos DB database account. */ /* Checks that the Azure Cosmos DB account name already exists. A valid account name may contain only lowercase letters, numbers, and the '-' character, and must be between 3 and 50 characters. */
export async function get ( async checkNameExists(accountName: string): Promise<void | void> {
subscriptionId: string, const path = `providers/Microsoft.DocumentDB/databaseAccountNames/${accountName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "head" }).then(response => response.json());
accountName: string }
) : Promise<Types.DatabaseAccountGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`, { method: "get", }).then((response) => response.json())
}
/* Lists all the Azure Cosmos DB database accounts available under the subscription. */
async list(subscriptionId: string): Promise<Types.DatabaseAccountsListResult> {
const path = `subscriptions/${subscriptionId}/providers/Microsoft.DocumentDB/databaseAccounts`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Updates the properties of an existing Azure Cosmos DB database account. */ /* Lists all the Azure Cosmos DB database accounts available under the given resource group. */
export async function update ( async listByResourceGroup(
subscriptionId: string, subscriptionId: string,
resourceGroupName: string, resourceGroupName: string
accountName: string ): Promise<Types.DatabaseAccountsListResult> {
,body: Types.DatabaseAccountUpdateParameters const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts`;
) : Promise<Types.DatabaseAccountGetResults> { return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`, { method: "patch", body: JSON.stringify(body) }).then((response) => response.json()) }
}
/* Retrieves the properties of an existing Azure Cosmos DB database account. */
async get(
subscriptionId: string,
resourceGroupName: string,
accountName: string
): Promise<Types.DatabaseAccountGetResults> {
const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account. */ /* Updates the properties of an existing Azure Cosmos DB database account. */
export async function createOrUpdate ( async update(
subscriptionId: string, subscriptionId: string,
resourceGroupName: string, resourceGroupName: string,
accountName: string accountName: string,
,body: Types.DatabaseAccountCreateUpdateParameters body: Types.DatabaseAccountUpdateParameters
) : Promise<Types.DatabaseAccountGetResults> { ): Promise<Types.DatabaseAccountGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json()) const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`;
} return window
.fetch(this.baseUrl + this.basePath + path, { method: "patch", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account. */
async createOrUpdate(
subscriptionId: string,
resourceGroupName: string,
accountName: string,
body: Types.DatabaseAccountCreateUpdateParameters
): Promise<Types.DatabaseAccountGetResults> {
const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Deletes an existing Azure Cosmos DB database account. */ /* Deletes an existing Azure Cosmos DB database account. */
export async function delete ( async delete(subscriptionId: string, resourceGroupName: string, accountName: string): Promise<void | void> {
subscriptionId: string, const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string }
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}`, { method: "delete", }).then((response) => response.json())
}
/* Changes the failover priority for the Azure Cosmos DB database account. A failover priority of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover priority values must be unique for each of the regions in which the database account exists. */
async failoverPriorityChange(
subscriptionId: string,
resourceGroupName: string,
accountName: string,
body: Types.FailoverPolicies
): Promise<void | void> {
const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/failoverPriorityChange`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "post", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Changes the failover priority for the Azure Cosmos DB database account. A failover priority of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover priority values must be unique for each of the regions in which the database account exists. */ /* Lists the connection strings for the specified Azure Cosmos DB database account. */
export async function failoverPriorityChange ( async listConnectionStrings(
subscriptionId: string, subscriptionId: string,
resourceGroupName: string, resourceGroupName: string,
accountName: string accountName: string
,body: Types.FailoverPolicies ): Promise<Types.DatabaseAccountListConnectionStringsResult> {
) : Promise<void | void> { const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/listConnectionStrings`;
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/failoverPriorityChange`, { method: "post", body: JSON.stringify(body) }).then((response) => response.json()) return window.fetch(this.baseUrl + this.basePath + path, { method: "post" }).then(response => response.json());
} }
/* Lists the access keys for the specified Azure Cosmos DB database account. */
async listKeys(
subscriptionId: string,
resourceGroupName: string,
accountName: string
): Promise<Types.DatabaseAccountListKeysResult> {
const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/listKeys`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "post" }).then(response => response.json());
}
/* Lists all the Azure Cosmos DB database accounts available under the subscription. */ /* Retrieves metric definitions for the given database account. */
export async function list ( async listMetricDefinitions(
subscriptionId: string subscriptionId: string,
resourceGroupName: string,
) : Promise<Types.DatabaseAccountsListResult> { accountName: string
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/providers/Microsoft.DocumentDB/databaseAccounts`, { method: "get", }).then((response) => response.json()) ): Promise<Types.MetricDefinitionsListResult> {
} const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/metricDefinitions`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Retrieves the metrics determined by the given filter for the given database account. */
async listMetrics(
subscriptionId: string,
resourceGroupName: string,
accountName: string
): Promise<Types.MetricListResult> {
const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/metrics`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Lists all the Azure Cosmos DB database accounts available under the given resource group. */ /* Offline the specified region for the specified Azure Cosmos DB database account. */
export async function listByResourceGroup ( async offlineRegion(
subscriptionId: string, subscriptionId: string,
resourceGroupName: string resourceGroupName: string,
accountName: string,
) : Promise<Types.DatabaseAccountsListResult> { body: Types.RegionForOnlineOffline
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts`, { method: "get", }).then((response) => response.json()) ): Promise<void | void | Types.ErrorResponse> {
} const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/offlineRegion`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "post", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Online the specified region for the specified Azure Cosmos DB database account. */
async onlineRegion(
subscriptionId: string,
resourceGroupName: string,
accountName: string,
body: Types.RegionForOnlineOffline
): Promise<void | void | Types.ErrorResponse> {
const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/onlineRegion`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "post", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Lists the access keys for the specified Azure Cosmos DB database account. */ /* Lists the read-only access keys for the specified Azure Cosmos DB database account. */
export async function listKeys ( async getReadOnlyKeys(
subscriptionId: string, subscriptionId: string,
resourceGroupName: string, resourceGroupName: string,
accountName: string accountName: string
): Promise<Types.DatabaseAccountListReadOnlyKeysResult> {
) : Promise<Types.DatabaseAccountListKeysResult> { const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/readonlykeys`;
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/listKeys`, { method: "post", }).then((response) => response.json()) return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
} }
/* Lists the read-only access keys for the specified Azure Cosmos DB database account. */
async listReadOnlyKeys(
subscriptionId: string,
resourceGroupName: string,
accountName: string
): Promise<Types.DatabaseAccountListReadOnlyKeysResult> {
const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/readonlykeys`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "post" }).then(response => response.json());
}
/* Lists the connection strings for the specified Azure Cosmos DB database account. */ /* Regenerates an access key for the specified Azure Cosmos DB database account. */
export async function listConnectionStrings ( async regenerateKey(
subscriptionId: string, subscriptionId: string,
resourceGroupName: string, resourceGroupName: string,
accountName: string accountName: string,
body: Types.DatabaseAccountRegenerateKeyParameters
) : Promise<Types.DatabaseAccountListConnectionStringsResult> { ): Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/listConnectionStrings`, { method: "post", }).then((response) => response.json()) const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/regenerateKey`;
} return window
.fetch(this.baseUrl + this.basePath + path, { method: "post", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Retrieves the usages (most recent data) for the given database account. */
/* Offline the specified region for the specified Azure Cosmos DB database account. */ async listUsages(
export async function offlineRegion ( subscriptionId: string,
subscriptionId: string, resourceGroupName: string,
resourceGroupName: string, accountName: string
accountName: string ): Promise<Types.UsagesResult> {
,body: Types.RegionForOnlineOffline const path = `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/usages`;
) : Promise<void | void | Types.ErrorResponse> { return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/offlineRegion`, { method: "post", body: JSON.stringify(body) }).then((response) => response.json()) }
} }
/* Online the specified region for the specified Azure Cosmos DB database account. */
export async function onlineRegion (
subscriptionId: string,
resourceGroupName: string,
accountName: string
,body: Types.RegionForOnlineOffline
) : Promise<void | void | Types.ErrorResponse> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/onlineRegion`, { method: "post", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Lists the read-only access keys for the specified Azure Cosmos DB database account. */
export async function getReadOnlyKeys (
subscriptionId: string,
resourceGroupName: string,
accountName: string
) : Promise<Types.DatabaseAccountListReadOnlyKeysResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/readonlykeys`, { method: "get", }).then((response) => response.json())
}
/* Lists the read-only access keys for the specified Azure Cosmos DB database account. */
export async function listReadOnlyKeys (
subscriptionId: string,
resourceGroupName: string,
accountName: string
) : Promise<Types.DatabaseAccountListReadOnlyKeysResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/readonlykeys`, { method: "post", }).then((response) => response.json())
}
/* Regenerates an access key for the specified Azure Cosmos DB database account. */
export async function regenerateKey (
subscriptionId: string,
resourceGroupName: string,
accountName: string
,body: Types.DatabaseAccountRegenerateKeyParameters
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/regenerateKey`, { method: "post", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Checks that the Azure Cosmos DB account name already exists. A valid account name may contain only lowercase letters, numbers, and the '-' character, and must be between 3 and 50 characters. */
export async function checkNameExists (
accountName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/providers/Microsoft.DocumentDB/databaseAccountNames/${accountName}`, { method: "head", }).then((response) => response.json())
}
/* Retrieves the metrics determined by the given filter for the given database account. */
export async function listMetrics (
subscriptionId: string,
resourceGroupName: string,
accountName: string
) : Promise<Types.MetricListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/metrics`, { method: "get", }).then((response) => response.json())
}
/* Retrieves the usages (most recent data) for the given database account. */
export async function listUsages (
subscriptionId: string,
resourceGroupName: string,
accountName: string
) : Promise<Types.UsagesResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/usages`, { method: "get", }).then((response) => response.json())
}
/* Retrieves metric definitions for the given database account. */
export async function listMetricDefinitions (
subscriptionId: string,
resourceGroupName: string,
accountName: string
) : Promise<Types.MetricDefinitionsListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/metricDefinitions`, { method: "get", }).then((response) => response.json())
}

242
src/Utils/arm/GremlinResources.ts
View File

@@ -4,164 +4,112 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class GremlinResourcesClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/gremlinDatabases`;
/* Lists the Gremlin databases under an existing Azure Cosmos DB database account. */ constructor(
export async function listGremlinDatabases ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string
accountName: string ) {}
) : Promise<Types.GremlinDatabaseListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases`, { method: "get", }).then((response) => response.json())
}
/* Lists the Gremlin databases under an existing Azure Cosmos DB database account. */
async listGremlinDatabases(): Promise<Types.GremlinDatabaseListResult> {
const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Gets the Gremlin databases under an existing Azure Cosmos DB database account with the provided name. */ /* Gets the Gremlin databases under an existing Azure Cosmos DB database account with the provided name. */
export async function getGremlinDatabase ( async getGremlinDatabase(databaseName: string): Promise<Types.GremlinDatabaseGetResults> {
subscriptionId: string, const path = `/${databaseName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<Types.GremlinDatabaseGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB Gremlin database */
async createUpdateGremlinDatabase(
databaseName: string,
body: Types.GremlinDatabaseCreateUpdateParameters
): Promise<Types.GremlinDatabaseGetResults | void> {
const path = `/${databaseName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Create or update an Azure Cosmos DB Gremlin database */ /* Deletes an existing Azure Cosmos DB Gremlin database. */
export async function createUpdateGremlinDatabase ( async deleteGremlinDatabase(databaseName: string): Promise<void | void> {
subscriptionId: string, const path = `/${databaseName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
databaseName: string
,body: Types.GremlinDatabaseCreateUpdateParameters
) : Promise<Types.GremlinDatabaseGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Lists the Gremlin graph under an existing Azure Cosmos DB database account. */
async listGremlinGraphs(databaseName: string): Promise<Types.GremlinGraphListResult> {
const path = `/${databaseName}/graphs`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Deletes an existing Azure Cosmos DB Gremlin database. */ /* Gets the Gremlin graph under an existing Azure Cosmos DB database account. */
export async function deleteGremlinDatabase ( async getGremlinGraph(databaseName: string, graphName: string): Promise<Types.GremlinGraphGetResults> {
subscriptionId: string, const path = `/${databaseName}/graphs/${graphName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}`, { method: "delete", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB Gremlin graph */
async createUpdateGremlinGraph(
databaseName: string,
graphName: string,
body: Types.GremlinGraphCreateUpdateParameters
): Promise<Types.GremlinGraphGetResults | void> {
const path = `/${databaseName}/graphs/${graphName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Gets the RUs per second of the Gremlin database under an existing Azure Cosmos DB database account with the provided name. */ /* Deletes an existing Azure Cosmos DB Gremlin graph. */
export async function getGremlinDatabaseThroughput ( async deleteGremlinGraph(databaseName: string, graphName: string): Promise<void | void> {
subscriptionId: string, const path = `/${databaseName}/graphs/${graphName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Gets the Gremlin graph throughput under an existing Azure Cosmos DB database account with the provided name. */
async getGremlinGraphThroughput(
databaseName: string,
graphName: string
): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${databaseName}/graphs/${graphName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Update RUs per second of an Azure Cosmos DB Gremlin database */ /* Update RUs per second of an Azure Cosmos DB Gremlin graph */
export async function updateGremlinDatabaseThroughput ( async updateGremlinGraphThroughput(
subscriptionId: string, databaseName: string,
resourceGroupName: string, graphName: string,
accountName: string, body: Types.ThroughputSettingsUpdateParameters
databaseName: string ): Promise<Types.ThroughputSettingsGetResults | void> {
,body: Types.ThroughputSettingsUpdateParameters const path = `/${databaseName}/graphs/${graphName}/throughputSettings/default`;
) : Promise<Types.ThroughputSettingsGetResults | void> { return window
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json()) .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
} .then(response => response.json());
}
/* Gets the RUs per second of the Gremlin database under an existing Azure Cosmos DB database account with the provided name. */
async getGremlinDatabaseThroughput(databaseName: string): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${databaseName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Lists the Gremlin graph under an existing Azure Cosmos DB database account. */ /* Update RUs per second of an Azure Cosmos DB Gremlin database */
export async function listGremlinGraphs ( async updateGremlinDatabaseThroughput(
subscriptionId: string, databaseName: string,
resourceGroupName: string, body: Types.ThroughputSettingsUpdateParameters
accountName: string, ): Promise<Types.ThroughputSettingsGetResults | void> {
databaseName: string const path = `/${databaseName}/throughputSettings/default`;
return window
) : Promise<Types.GremlinGraphListResult> { .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/graphs`, { method: "get", }).then((response) => response.json()) .then(response => response.json());
} }
}
/* Gets the Gremlin graph under an existing Azure Cosmos DB database account. */
export async function getGremlinGraph (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
graphName: string
) : Promise<Types.GremlinGraphGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/graphs/${graphName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB Gremlin graph */
export async function createUpdateGremlinGraph (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
graphName: string
,body: Types.GremlinGraphCreateUpdateParameters
) : Promise<Types.GremlinGraphGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/graphs/${graphName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Deletes an existing Azure Cosmos DB Gremlin graph. */
export async function deleteGremlinGraph (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
graphName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/graphs/${graphName}`, { method: "delete", }).then((response) => response.json())
}
/* Gets the Gremlin graph throughput under an existing Azure Cosmos DB database account with the provided name. */
export async function getGremlinGraphThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
graphName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/graphs/${graphName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Update RUs per second of an Azure Cosmos DB Gremlin graph */
export async function updateGremlinGraphThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
graphName: string
,body: Types.ThroughputSettingsUpdateParameters
) : Promise<Types.ThroughputSettingsGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/gremlinDatabases/${databaseName}/graphs/${graphName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}

242
src/Utils/arm/MongoDBResources.ts
View File

@@ -4,164 +4,112 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class MongoDBResourcesClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/mongodbDatabases`;
/* Lists the MongoDB databases under an existing Azure Cosmos DB database account. */ constructor(
export async function listMongoDBDatabases ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string
accountName: string ) {}
) : Promise<Types.MongoDBDatabaseListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases`, { method: "get", }).then((response) => response.json())
}
/* Lists the MongoDB databases under an existing Azure Cosmos DB database account. */
async listMongoDBDatabases(): Promise<Types.MongoDBDatabaseListResult> {
const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Gets the MongoDB databases under an existing Azure Cosmos DB database account with the provided name. */ /* Gets the MongoDB databases under an existing Azure Cosmos DB database account with the provided name. */
export async function getMongoDBDatabase ( async getMongoDBDatabase(databaseName: string): Promise<Types.MongoDBDatabaseGetResults> {
subscriptionId: string, const path = `/${databaseName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<Types.MongoDBDatabaseGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}`, { method: "get", }).then((response) => response.json())
}
/* Create or updates Azure Cosmos DB MongoDB database */
async createUpdateMongoDBDatabase(
databaseName: string,
body: Types.MongoDBDatabaseCreateUpdateParameters
): Promise<Types.MongoDBDatabaseGetResults | void> {
const path = `/${databaseName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Create or updates Azure Cosmos DB MongoDB database */ /* Deletes an existing Azure Cosmos DB MongoDB database. */
export async function createUpdateMongoDBDatabase ( async deleteMongoDBDatabase(databaseName: string): Promise<void | void> {
subscriptionId: string, const path = `/${databaseName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
databaseName: string
,body: Types.MongoDBDatabaseCreateUpdateParameters
) : Promise<Types.MongoDBDatabaseGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Lists the MongoDB collection under an existing Azure Cosmos DB database account. */
async listMongoDBCollections(databaseName: string): Promise<Types.MongoDBCollectionListResult> {
const path = `/${databaseName}/collections`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Deletes an existing Azure Cosmos DB MongoDB database. */ /* Gets the MongoDB collection under an existing Azure Cosmos DB database account. */
export async function deleteMongoDBDatabase ( async getMongoDBCollection(databaseName: string, collectionName: string): Promise<Types.MongoDBCollectionGetResults> {
subscriptionId: string, const path = `/${databaseName}/collections/${collectionName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}`, { method: "delete", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB MongoDB Collection */
async createUpdateMongoDBCollection(
databaseName: string,
collectionName: string,
body: Types.MongoDBCollectionCreateUpdateParameters
): Promise<Types.MongoDBCollectionGetResults | void> {
const path = `/${databaseName}/collections/${collectionName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Gets the RUs per second of the MongoDB database under an existing Azure Cosmos DB database account with the provided name. */ /* Deletes an existing Azure Cosmos DB MongoDB Collection. */
export async function getMongoDBDatabaseThroughput ( async deleteMongoDBCollection(databaseName: string, collectionName: string): Promise<void | void> {
subscriptionId: string, const path = `/${databaseName}/collections/${collectionName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Gets the RUs per second of the MongoDB collection under an existing Azure Cosmos DB database account with the provided name. */
async getMongoDBCollectionThroughput(
databaseName: string,
collectionName: string
): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${databaseName}/collections/${collectionName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Update RUs per second of the an Azure Cosmos DB MongoDB database */ /* Update the RUs per second of an Azure Cosmos DB MongoDB collection */
export async function updateMongoDBDatabaseThroughput ( async updateMongoDBCollectionThroughput(
subscriptionId: string, databaseName: string,
resourceGroupName: string, collectionName: string,
accountName: string, body: Types.ThroughputSettingsUpdateParameters
databaseName: string ): Promise<Types.ThroughputSettingsGetResults | void> {
,body: Types.ThroughputSettingsUpdateParameters const path = `/${databaseName}/collections/${collectionName}/throughputSettings/default`;
) : Promise<Types.ThroughputSettingsGetResults | void> { return window
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json()) .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
} .then(response => response.json());
}
/* Gets the RUs per second of the MongoDB database under an existing Azure Cosmos DB database account with the provided name. */
async getMongoDBDatabaseThroughput(databaseName: string): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${databaseName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Lists the MongoDB collection under an existing Azure Cosmos DB database account. */ /* Update RUs per second of the an Azure Cosmos DB MongoDB database */
export async function listMongoDBCollections ( async updateMongoDBDatabaseThroughput(
subscriptionId: string, databaseName: string,
resourceGroupName: string, body: Types.ThroughputSettingsUpdateParameters
accountName: string, ): Promise<Types.ThroughputSettingsGetResults | void> {
databaseName: string const path = `/${databaseName}/throughputSettings/default`;
return window
) : Promise<Types.MongoDBCollectionListResult> { .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/collections`, { method: "get", }).then((response) => response.json()) .then(response => response.json());
} }
}
/* Gets the MongoDB collection under an existing Azure Cosmos DB database account. */
export async function getMongoDBCollection (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
collectionName: string
) : Promise<Types.MongoDBCollectionGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/collections/${collectionName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB MongoDB Collection */
export async function createUpdateMongoDBCollection (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
collectionName: string
,body: Types.MongoDBCollectionCreateUpdateParameters
) : Promise<Types.MongoDBCollectionGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/collections/${collectionName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Deletes an existing Azure Cosmos DB MongoDB Collection. */
export async function deleteMongoDBCollection (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
collectionName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/collections/${collectionName}`, { method: "delete", }).then((response) => response.json())
}
/* Gets the RUs per second of the MongoDB collection under an existing Azure Cosmos DB database account with the provided name. */
export async function getMongoDBCollectionThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
collectionName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/collections/${collectionName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Update the RUs per second of an Azure Cosmos DB MongoDB collection */
export async function updateMongoDBCollectionThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
collectionName: string
,body: Types.ThroughputSettingsUpdateParameters
) : Promise<Types.ThroughputSettingsGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/mongodbDatabases/${databaseName}/collections/${collectionName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}

19
src/Utils/arm/Operations.ts
View File

@@ -4,14 +4,15 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class OperationsClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/providers/Microsoft.DocumentDB/operations`;
/* Lists all of the available Cosmos DB Resource Provider operations. */ /* Lists all of the available Cosmos DB Resource Provider operations. */
export async function list ( async list(): Promise<Types.OperationListResult> {
const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
) : Promise<Types.OperationListResult> { }
return window.fetch(`https://management.azure.com/providers/Microsoft.DocumentDB/operations`, { method: "get", }).then((response) => response.json()) }
}

33
src/Utils/arm/PartitionKeyRangeId.ts
View File

@@ -4,19 +4,24 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class PartitionKeyRangeIdClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/databases/${this.databaseRid}/collections/${this.collectionRid}/partitionKeyRangeId/${this.partitionKeyRangeId}/metrics`;
/* Retrieves the metrics determined by the given filter for the given partition key range id. */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly databaseRid: string,
databaseRid: string, private readonly collectionRid: string,
collectionRid: string, private readonly partitionKeyRangeId: string
partitionKeyRangeId: string ) {}
) : Promise<Types.PartitionMetricListResult> { /* Retrieves the metrics determined by the given filter for the given partition key range id. */
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/databases/${databaseRid}/collections/${collectionRid}/partitionKeyRangeId/${partitionKeyRangeId}/metrics`, { method: "get", }).then((response) => response.json()) async listMetrics(): Promise<Types.PartitionMetricListResult> {
} const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
}

35
src/Utils/arm/PartitionKeyRangeIdRegion.ts
View File

@@ -4,20 +4,25 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class PartitionKeyRangeIdRegionClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/region/${this.region}/databases/${this.databaseRid}/collections/${this.collectionRid}/partitionKeyRangeId/${this.partitionKeyRangeId}/metrics`;
/* Retrieves the metrics determined by the given filter for the given partition key range id and region. */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly region: string,
region: string, private readonly databaseRid: string,
databaseRid: string, private readonly collectionRid: string,
collectionRid: string, private readonly partitionKeyRangeId: string
partitionKeyRangeId: string ) {}
) : Promise<Types.PartitionMetricListResult> { /* Retrieves the metrics determined by the given filter for the given partition key range id and region. */
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/region/${region}/databases/${databaseRid}/collections/${collectionRid}/partitionKeyRangeId/${partitionKeyRangeId}/metrics`, { method: "get", }).then((response) => response.json()) async listMetrics(): Promise<Types.PartitionMetricListResult> {
} const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
}

27
src/Utils/arm/Percentile.ts
View File

@@ -4,16 +4,21 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class PercentileClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/percentile/metrics`;
/* Retrieves the metrics determined by the given filter for the given database account. This url is only for PBS and Replication Latency data */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string
accountName: string ) {}
) : Promise<Types.PercentileMetricListResult> { /* Retrieves the metrics determined by the given filter for the given database account. This url is only for PBS and Replication Latency data */
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/percentile/metrics`, { method: "get", }).then((response) => response.json()) async listMetrics(): Promise<Types.PercentileMetricListResult> {
} const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
}

31
src/Utils/arm/PercentileSourceTarget.ts
View File

@@ -4,18 +4,23 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class PercentileSourceTargetClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/sourceRegion/${this.sourceRegion}/targetRegion/${this.targetRegion}/percentile/metrics`;
/* Retrieves the metrics determined by the given filter for the given account, source and target region. This url is only for PBS and Replication Latency data */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly sourceRegion: string,
sourceRegion: string, private readonly targetRegion: string
targetRegion: string ) {}
) : Promise<Types.PercentileMetricListResult> { /* Retrieves the metrics determined by the given filter for the given account, source and target region. This url is only for PBS and Replication Latency data */
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sourceRegion/${sourceRegion}/targetRegion/${targetRegion}/percentile/metrics`, { method: "get", }).then((response) => response.json()) async listMetrics(): Promise<Types.PercentileMetricListResult> {
} const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
}

29
src/Utils/arm/PercentileTarget.ts
View File

@@ -4,17 +4,22 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class PercentileTargetClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/targetRegion/${this.targetRegion}/percentile/metrics`;
/* Retrieves the metrics determined by the given filter for the given account target region. This url is only for PBS and Replication Latency data */ constructor(
export async function listMetrics ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string,
accountName: string, private readonly targetRegion: string
targetRegion: string ) {}
) : Promise<Types.PercentileMetricListResult> { /* Retrieves the metrics determined by the given filter for the given account target region. This url is only for PBS and Replication Latency data */
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/targetRegion/${targetRegion}/percentile/metrics`, { method: "get", }).then((response) => response.json()) async listMetrics(): Promise<Types.PercentileMetricListResult> {
} const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
}

55
src/Utils/arm/RestorableDatabaseAccounts.ts
View File

@@ -4,37 +4,34 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class RestorableDatabaseAccountsClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/providers/Microsoft.DocumentDB/`;
/* Lists all the restorable Azure Cosmos DB database accounts available under the subscription and in a region. */ constructor(private readonly subscriptionId: string) {}
export async function listByLocation (
subscriptionId: string,
location: string
) : Promise<Types.RestorableDatabaseAccountsListResult | Types.ErrorResponseUpdatedFormat> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/providers/Microsoft.DocumentDB/locations/${location}/restorableDatabaseAccounts`, { method: "get", }).then((response) => response.json())
}
/* Lists all the restorable Azure Cosmos DB database accounts available under the subscription and in a region. */
async listByLocation(
location: string
): Promise<Types.RestorableDatabaseAccountsListResult | Types.ErrorResponseUpdatedFormat> {
const path = `locations/${location}/restorableDatabaseAccounts`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Lists all the restorable Azure Cosmos DB database accounts available under the subscription. */ /* Retrieves the properties of an existing Azure Cosmos DB restorable database account. */
export async function list ( async getByLocation(
subscriptionId: string location: string,
instanceId: string
) : Promise<Types.RestorableDatabaseAccountsListResult | Types.ErrorResponseUpdatedFormat> { ): Promise<Types.RestorableDatabaseAccountGetResult | Types.ErrorResponseUpdatedFormat> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/providers/Microsoft.DocumentDB/restorableDatabaseAccounts`, { method: "get", }).then((response) => response.json()) const path = `locations/${location}/restorableDatabaseAccounts/${instanceId}`;
} return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Lists all the restorable Azure Cosmos DB database accounts available under the subscription. */
/* Retrieves the properties of an existing Azure Cosmos DB restorable database account. */ async list(): Promise<Types.RestorableDatabaseAccountsListResult | Types.ErrorResponseUpdatedFormat> {
export async function getByLocation ( const path = `restorableDatabaseAccounts`;
subscriptionId: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
location: string, }
instanceId: string }
) : Promise<Types.RestorableDatabaseAccountGetResult | Types.ErrorResponseUpdatedFormat> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/providers/Microsoft.DocumentDB/locations/${location}/restorableDatabaseAccounts/${instanceId}`, { method: "get", }).then((response) => response.json())
}

514
src/Utils/arm/SqlResources.ts
View File

@@ -4,341 +4,231 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class SqlResourcesClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/sqlDatabases`;
/* Lists the SQL databases under an existing Azure Cosmos DB database account. */ constructor(
export async function listSqlDatabases ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string
accountName: string ) {}
) : Promise<Types.SqlDatabaseListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases`, { method: "get", }).then((response) => response.json())
}
/* Lists the SQL databases under an existing Azure Cosmos DB database account. */
async listSqlDatabases(): Promise<Types.SqlDatabaseListResult> {
const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Gets the SQL database under an existing Azure Cosmos DB database account with the provided name. */ /* Gets the SQL database under an existing Azure Cosmos DB database account with the provided name. */
export async function getSqlDatabase ( async getSqlDatabase(databaseName: string): Promise<Types.SqlDatabaseGetResults> {
subscriptionId: string, const path = `/${databaseName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<Types.SqlDatabaseGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB SQL database */
async createUpdateSqlDatabase(
databaseName: string,
body: Types.SqlDatabaseCreateUpdateParameters
): Promise<Types.SqlDatabaseGetResults | void> {
const path = `/${databaseName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Create or update an Azure Cosmos DB SQL database */ /* Deletes an existing Azure Cosmos DB SQL database. */
export async function createUpdateSqlDatabase ( async deleteSqlDatabase(databaseName: string): Promise<void | void> {
subscriptionId: string, const path = `/${databaseName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
databaseName: string
,body: Types.SqlDatabaseCreateUpdateParameters
) : Promise<Types.SqlDatabaseGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Lists the SQL container under an existing Azure Cosmos DB database account. */
async listSqlContainers(databaseName: string): Promise<Types.SqlContainerListResult> {
const path = `/${databaseName}/containers`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Deletes an existing Azure Cosmos DB SQL database. */ /* Gets the SQL container under an existing Azure Cosmos DB database account. */
export async function deleteSqlDatabase ( async getSqlContainer(databaseName: string, containerName: string): Promise<Types.SqlContainerGetResults> {
subscriptionId: string, const path = `/${databaseName}/containers/${containerName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}`, { method: "delete", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB SQL container */
async createUpdateSqlContainer(
databaseName: string,
containerName: string,
body: Types.SqlContainerCreateUpdateParameters
): Promise<Types.SqlContainerGetResults | void> {
const path = `/${databaseName}/containers/${containerName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Gets the RUs per second of the SQL database under an existing Azure Cosmos DB database account with the provided name. */ /* Deletes an existing Azure Cosmos DB SQL container. */
export async function getSqlDatabaseThroughput ( async deleteSqlContainer(databaseName: string, containerName: string): Promise<void | void> {
subscriptionId: string, const path = `/${databaseName}/containers/${containerName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
databaseName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Lists the SQL storedProcedure under an existing Azure Cosmos DB database account. */
async listSqlStoredProcedures(
databaseName: string,
containerName: string
): Promise<Types.SqlStoredProcedureListResult> {
const path = `/${databaseName}/containers/${containerName}/storedProcedures`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Update RUs per second of an Azure Cosmos DB SQL database */ /* Gets the SQL storedProcedure under an existing Azure Cosmos DB database account. */
export async function updateSqlDatabaseThroughput ( async getSqlStoredProcedure(
subscriptionId: string, databaseName: string,
resourceGroupName: string, containerName: string,
accountName: string, storedProcedureName: string
databaseName: string ): Promise<Types.SqlStoredProcedureGetResults> {
,body: Types.ThroughputSettingsUpdateParameters const path = `/${databaseName}/containers/${containerName}/storedProcedures/${storedProcedureName}`;
) : Promise<Types.ThroughputSettingsGetResults | void> { return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json()) }
}
/* Create or update an Azure Cosmos DB SQL storedProcedure */
async createUpdateSqlStoredProcedure(
databaseName: string,
containerName: string,
storedProcedureName: string,
body: Types.SqlStoredProcedureCreateUpdateParameters
): Promise<Types.SqlStoredProcedureGetResults | void> {
const path = `/${databaseName}/containers/${containerName}/storedProcedures/${storedProcedureName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Lists the SQL container under an existing Azure Cosmos DB database account. */ /* Deletes an existing Azure Cosmos DB SQL storedProcedure. */
export async function listSqlContainers ( async deleteSqlStoredProcedure(
subscriptionId: string, databaseName: string,
resourceGroupName: string, containerName: string,
accountName: string, storedProcedureName: string
databaseName: string ): Promise<void | void> {
const path = `/${databaseName}/containers/${containerName}/storedProcedures/${storedProcedureName}`;
) : Promise<Types.SqlContainerListResult> { return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers`, { method: "get", }).then((response) => response.json()) }
}
/* Gets the RUs per second of the SQL container under an existing Azure Cosmos DB database account. */
async getSqlContainerThroughput(
databaseName: string,
containerName: string
): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${databaseName}/containers/${containerName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Gets the SQL container under an existing Azure Cosmos DB database account. */ /* Update RUs per second of an Azure Cosmos DB SQL container */
export async function getSqlContainer ( async updateSqlContainerThroughput(
subscriptionId: string, databaseName: string,
resourceGroupName: string, containerName: string,
accountName: string, body: Types.ThroughputSettingsUpdateParameters
databaseName: string, ): Promise<Types.ThroughputSettingsGetResults | void> {
containerName: string const path = `/${databaseName}/containers/${containerName}/throughputSettings/default`;
return window
) : Promise<Types.SqlContainerGetResults> { .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}`, { method: "get", }).then((response) => response.json()) .then(response => response.json());
} }
/* Lists the SQL trigger under an existing Azure Cosmos DB database account. */
async listSqlTriggers(databaseName: string, containerName: string): Promise<Types.SqlTriggerListResult> {
const path = `/${databaseName}/containers/${containerName}/triggers`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Create or update an Azure Cosmos DB SQL container */ /* Gets the SQL trigger under an existing Azure Cosmos DB database account. */
export async function createUpdateSqlContainer ( async getSqlTrigger(
subscriptionId: string, databaseName: string,
resourceGroupName: string, containerName: string,
accountName: string, triggerName: string
databaseName: string, ): Promise<Types.SqlTriggerGetResults> {
containerName: string const path = `/${databaseName}/containers/${containerName}/triggers/${triggerName}`;
,body: Types.SqlContainerCreateUpdateParameters return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
) : Promise<Types.SqlContainerGetResults | void> { }
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB SQL trigger */
async createUpdateSqlTrigger(
databaseName: string,
containerName: string,
triggerName: string,
body: Types.SqlTriggerCreateUpdateParameters
): Promise<Types.SqlTriggerGetResults | void> {
const path = `/${databaseName}/containers/${containerName}/triggers/${triggerName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Deletes an existing Azure Cosmos DB SQL container. */ /* Deletes an existing Azure Cosmos DB SQL trigger. */
export async function deleteSqlContainer ( async deleteSqlTrigger(databaseName: string, containerName: string, triggerName: string): Promise<void | void> {
subscriptionId: string, const path = `/${databaseName}/containers/${containerName}/triggers/${triggerName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
databaseName: string,
containerName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}`, { method: "delete", }).then((response) => response.json())
}
/* Lists the SQL userDefinedFunction under an existing Azure Cosmos DB database account. */
async listSqlUserDefinedFunctions(
databaseName: string,
containerName: string
): Promise<Types.SqlUserDefinedFunctionListResult> {
const path = `/${databaseName}/containers/${containerName}/userDefinedFunctions`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Gets the RUs per second of the SQL container under an existing Azure Cosmos DB database account. */ /* Gets the SQL userDefinedFunction under an existing Azure Cosmos DB database account. */
export async function getSqlContainerThroughput ( async getSqlUserDefinedFunction(
subscriptionId: string, databaseName: string,
resourceGroupName: string, containerName: string,
accountName: string, userDefinedFunctionName: string
databaseName: string, ): Promise<Types.SqlUserDefinedFunctionGetResults> {
containerName: string const path = `/${databaseName}/containers/${containerName}/userDefinedFunctions/${userDefinedFunctionName}`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
) : Promise<Types.ThroughputSettingsGetResults> { }
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB SQL userDefinedFunction */
async createUpdateSqlUserDefinedFunction(
databaseName: string,
containerName: string,
userDefinedFunctionName: string,
body: Types.SqlUserDefinedFunctionCreateUpdateParameters
): Promise<Types.SqlUserDefinedFunctionGetResults | void> {
const path = `/${databaseName}/containers/${containerName}/userDefinedFunctions/${userDefinedFunctionName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Update RUs per second of an Azure Cosmos DB SQL container */ /* Deletes an existing Azure Cosmos DB SQL userDefinedFunction. */
export async function updateSqlContainerThroughput ( async deleteSqlUserDefinedFunction(
subscriptionId: string, databaseName: string,
resourceGroupName: string, containerName: string,
accountName: string, userDefinedFunctionName: string
databaseName: string, ): Promise<void | void> {
containerName: string const path = `/${databaseName}/containers/${containerName}/userDefinedFunctions/${userDefinedFunctionName}`;
,body: Types.ThroughputSettingsUpdateParameters return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
) : Promise<Types.ThroughputSettingsGetResults | void> { }
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Gets the RUs per second of the SQL database under an existing Azure Cosmos DB database account with the provided name. */
async getSqlDatabaseThroughput(databaseName: string): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${databaseName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Lists the SQL storedProcedure under an existing Azure Cosmos DB database account. */ /* Update RUs per second of an Azure Cosmos DB SQL database */
export async function listSqlStoredProcedures ( async updateSqlDatabaseThroughput(
subscriptionId: string, databaseName: string,
resourceGroupName: string, body: Types.ThroughputSettingsUpdateParameters
accountName: string, ): Promise<Types.ThroughputSettingsGetResults | void> {
databaseName: string, const path = `/${databaseName}/throughputSettings/default`;
containerName: string return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
) : Promise<Types.SqlStoredProcedureListResult> { .then(response => response.json());
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/storedProcedures`, { method: "get", }).then((response) => response.json()) }
} }
/* Gets the SQL storedProcedure under an existing Azure Cosmos DB database account. */
export async function getSqlStoredProcedure (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
storedProcedureName: string
) : Promise<Types.SqlStoredProcedureGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/storedProcedures/${storedProcedureName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB SQL storedProcedure */
export async function createUpdateSqlStoredProcedure (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
storedProcedureName: string
,body: Types.SqlStoredProcedureCreateUpdateParameters
) : Promise<Types.SqlStoredProcedureGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/storedProcedures/${storedProcedureName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Deletes an existing Azure Cosmos DB SQL storedProcedure. */
export async function deleteSqlStoredProcedure (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
storedProcedureName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/storedProcedures/${storedProcedureName}`, { method: "delete", }).then((response) => response.json())
}
/* Lists the SQL userDefinedFunction under an existing Azure Cosmos DB database account. */
export async function listSqlUserDefinedFunctions (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string
) : Promise<Types.SqlUserDefinedFunctionListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/userDefinedFunctions`, { method: "get", }).then((response) => response.json())
}
/* Gets the SQL userDefinedFunction under an existing Azure Cosmos DB database account. */
export async function getSqlUserDefinedFunction (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
userDefinedFunctionName: string
) : Promise<Types.SqlUserDefinedFunctionGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/userDefinedFunctions/${userDefinedFunctionName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB SQL userDefinedFunction */
export async function createUpdateSqlUserDefinedFunction (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
userDefinedFunctionName: string
,body: Types.SqlUserDefinedFunctionCreateUpdateParameters
) : Promise<Types.SqlUserDefinedFunctionGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/userDefinedFunctions/${userDefinedFunctionName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Deletes an existing Azure Cosmos DB SQL userDefinedFunction. */
export async function deleteSqlUserDefinedFunction (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
userDefinedFunctionName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/userDefinedFunctions/${userDefinedFunctionName}`, { method: "delete", }).then((response) => response.json())
}
/* Lists the SQL trigger under an existing Azure Cosmos DB database account. */
export async function listSqlTriggers (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string
) : Promise<Types.SqlTriggerListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/triggers`, { method: "get", }).then((response) => response.json())
}
/* Gets the SQL trigger under an existing Azure Cosmos DB database account. */
export async function getSqlTrigger (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
triggerName: string
) : Promise<Types.SqlTriggerGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/triggers/${triggerName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB SQL trigger */
export async function createUpdateSqlTrigger (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
triggerName: string
,body: Types.SqlTriggerCreateUpdateParameters
) : Promise<Types.SqlTriggerGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/triggers/${triggerName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Deletes an existing Azure Cosmos DB SQL trigger. */
export async function deleteSqlTrigger (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
databaseName: string,
containerName: string,
triggerName: string
) : Promise<void | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/sqlDatabases/${databaseName}/containers/${containerName}/triggers/${triggerName}`, { method: "delete", }).then((response) => response.json())
}

120
src/Utils/arm/TableResources.ts
View File

@@ -4,81 +4,61 @@
Run "npm run generateARMClients" to regenerate Run "npm run generateARMClients" to regenerate
*/ */
import * as Types from "./types" import * as Types from "./types";
export class TableResourcesClient {
private readonly baseUrl = "https://management.azure.com";
private readonly basePath = `/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${this.accountName}/tables`;
/* Lists the Tables under an existing Azure Cosmos DB database account. */ constructor(
export async function listTables ( private readonly subscriptionId: string,
subscriptionId: string, private readonly resourceGroupName: string,
resourceGroupName: string, private readonly accountName: string
accountName: string ) {}
) : Promise<Types.TableListResult> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/tables`, { method: "get", }).then((response) => response.json())
}
/* Lists the Tables under an existing Azure Cosmos DB database account. */
async listTables(): Promise<Types.TableListResult> {
const path = ``;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Gets the Tables under an existing Azure Cosmos DB database account with the provided name. */ /* Gets the Tables under an existing Azure Cosmos DB database account with the provided name. */
export async function getTable ( async getTable(tableName: string): Promise<Types.TableGetResults> {
subscriptionId: string, const path = `/${tableName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
accountName: string, }
tableName: string
) : Promise<Types.TableGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/tables/${tableName}`, { method: "get", }).then((response) => response.json())
}
/* Create or update an Azure Cosmos DB Table */
async createUpdateTable(
tableName: string,
body: Types.TableCreateUpdateParameters
): Promise<Types.TableGetResults | void> {
const path = `/${tableName}`;
return window
.fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
.then(response => response.json());
}
/* Create or update an Azure Cosmos DB Table */ /* Deletes an existing Azure Cosmos DB Table. */
export async function createUpdateTable ( async deleteTable(tableName: string): Promise<void | void> {
subscriptionId: string, const path = `/${tableName}`;
resourceGroupName: string, return window.fetch(this.baseUrl + this.basePath + path, { method: "delete" }).then(response => response.json());
accountName: string, }
tableName: string
,body: Types.TableCreateUpdateParameters
) : Promise<Types.TableGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/tables/${tableName}`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}
/* Gets the RUs per second of the Table under an existing Azure Cosmos DB database account with the provided name. */
async getTableThroughput(tableName: string): Promise<Types.ThroughputSettingsGetResults> {
const path = `/${tableName}/throughputSettings/default`;
return window.fetch(this.baseUrl + this.basePath + path, { method: "get" }).then(response => response.json());
}
/* Deletes an existing Azure Cosmos DB Table. */ /* Update RUs per second of an Azure Cosmos DB Table */
export async function deleteTable ( async updateTableThroughput(
subscriptionId: string, tableName: string,
resourceGroupName: string, body: Types.ThroughputSettingsUpdateParameters
accountName: string, ): Promise<Types.ThroughputSettingsGetResults | void> {
tableName: string const path = `/${tableName}/throughputSettings/default`;
return window
) : Promise<void | void> { .fetch(this.baseUrl + this.basePath + path, { method: "put", body: JSON.stringify(body) })
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/tables/${tableName}`, { method: "delete", }).then((response) => response.json()) .then(response => response.json());
} }
}
/* Gets the RUs per second of the Table under an existing Azure Cosmos DB database account with the provided name. */
export async function getTableThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
tableName: string
) : Promise<Types.ThroughputSettingsGetResults> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/tables/${tableName}/throughputSettings/default`, { method: "get", }).then((response) => response.json())
}
/* Update RUs per second of an Azure Cosmos DB Table */
export async function updateTableThroughput (
subscriptionId: string,
resourceGroupName: string,
accountName: string,
tableName: string
,body: Types.ThroughputSettingsUpdateParameters
) : Promise<Types.ThroughputSettingsGetResults | void> {
return window.fetch(`https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/${accountName}/tables/${tableName}/throughputSettings/default`, { method: "put", body: JSON.stringify(body) }).then((response) => response.json())
}

1939
src/Utils/arm/types.ts
View File

File diff suppressed because it is too large Load Diff

1
tsconfig.strict.json
View File

@@ -47,6 +47,7 @@
"./src/Explorer/Controls/Toolbar/KeyCodes.ts", "./src/Explorer/Controls/Toolbar/KeyCodes.ts",
"./src/Explorer/Notebook/FileSystemUtil.ts", "./src/Explorer/Notebook/FileSystemUtil.ts",
"./src/Explorer/Notebook/NTeractUtil.ts", "./src/Explorer/Notebook/NTeractUtil.ts",
"./src/Explorer/Notebook/NotebookComponent/__mocks__/rx-jupyter.ts",
"./src/Explorer/Notebook/NotebookComponent/actions.ts", "./src/Explorer/Notebook/NotebookComponent/actions.ts",
"./src/Explorer/Notebook/NotebookComponent/loadTransform.ts", "./src/Explorer/Notebook/NotebookComponent/loadTransform.ts",
"./src/Explorer/Notebook/NotebookComponent/reducers.ts", "./src/Explorer/Notebook/NotebookComponent/reducers.ts",

114
utils/armClientGenerator/generator.ts
View File

@@ -24,7 +24,12 @@ const outputDir = path.join(__dirname, "../../src/Utils/arm/");
mkdirp.sync(outputDir); mkdirp.sync(outputDir);
// Buckets for grouping operations based on their name // Buckets for grouping operations based on their name
const namespaces: { [key: string]: string[] } = {}; interface Client {
paths: string[];
functions: string[];
constructorParams: string[];
}
const clients: { [key: string]: Client } = {};
// Mapping for OpenAPI types to TypeScript types // Mapping for OpenAPI types to TypeScript types
const propertyMap: { [key: string]: string } = { const propertyMap: { [key: string]: string } = {
@@ -63,9 +68,7 @@ function parametersFromPath(path: string) {
// TODO: Remove any. String.matchAll is a real thing. // TODO: Remove any. String.matchAll is a real thing.
// eslint-disable-next-line @typescript-eslint/no-explicit-any // eslint-disable-next-line @typescript-eslint/no-explicit-any
const matches = (path as any).matchAll(/{(\w+)}/g); const matches = (path as any).matchAll(/{(\w+)}/g);
return Array.from(matches) return Array.from(matches).map((match: string[]) => match[1]);
.map((match: string[]) => `${match[1]}: string`)
.join(",\n");
} }
type Operation = { responses: { [key: string]: { schema: { $ref: string } } } }; type Operation = { responses: { [key: string]: { schema: { $ref: string } } } };
@@ -168,43 +171,102 @@ async function main() {
} }
} }
// STEP 2: Convert all paths and operations to simple fetch functions. // STEP 2: Group all paths by output client and extract common constructor parameters
// Functions are grouped into objects based on resource types // Functions are grouped into clients based on operation name
for (const path in schema.paths) { for (const path in schema.paths) {
for (const method in schema.paths[path]) { for (const method in schema.paths[path]) {
const operation = schema.paths[path][method]; const operation = schema.paths[path][method];
const bodyParameter = operation.parameters.find( const [namespace] = operation.operationId.split("_");
(parameter: { in: string; required: boolean }) => parameter.in === "body" && parameter.required === true if (clients[namespace] === undefined) {
); clients[namespace] = { paths: [], functions: [], constructorParams: [] };
const [namespace, operationName] = operation.operationId.split("_"); clients[namespace];
if (namespaces[namespace] === undefined) { }
namespaces[namespace] = []; if (!clients[namespace].paths.includes(path)) {
clients[namespace].paths.push(path);
} }
namespaces[namespace].push(`
/* ${operation.description} */
export async function ${camelize(operationName)} (
${parametersFromPath(path)}
${bodyParam(bodyParameter, "Types")}
) : Promise<${responseType(operation, "Types")}> {
return window.fetch(\`https://management.azure.com${path.replace(/{/g, "${")}\`, { method: "${method}", ${
bodyParameter ? "body: JSON.stringify(body)" : ""
} }).then((response) => response.json())
}
`);
} }
} }
// Write all grouped fetch functions to objects // Write all grouped fetch functions to objects
for (const namespace in namespaces) { for (const clientName in clients) {
const outputClient: string[] = [""]; const outputClient: string[] = [""];
outputClient.push(`import * as Types from "./types"\n\n`); outputClient.push(`import * as Types from "./types"\n\n`);
outputClient.push(namespaces[namespace].join("\n\n")); outputClient.push(`export class ${clientName}Client {\n\n`);
writeOutputFile(`./${namespace}.ts`, outputClient); outputClient.push(`private readonly baseUrl = "https://management.azure.com"\n`);
const basePath = buildBasePath(clients[clientName].paths);
outputClient.push(`private readonly basePath = \`${basePath.replace(/{/g, "${this.")}\`\n\n`);
outputClient.push(buildConstructor(clients[clientName]));
for (const path of clients[clientName].paths) {
for (const method in schema.paths[path]) {
const operation = schema.paths[path][method];
const [, methodName] = operation.operationId.split("_");
const bodyParameter = operation.parameters.find(
(parameter: { in: string; required: boolean }) => parameter.in === "body" && parameter.required === true
);
const constructorParameters = constructorParams(clients[clientName]);
const methodParameters = parametersFromPath(path).filter(p => !constructorParameters.includes(p));
outputClient.push(`
/* ${operation.description} */
async ${camelize(methodName)} (
${methodParameters.map(p => `${p}: string`).join(",\n")}
${bodyParam(bodyParameter, "Types")}
) : Promise<${responseType(operation, "Types")}> {
const path = \`${path.replace(basePath, "").replace(/{/g, "${")}\`
return window.fetch(this.baseUrl + this.basePath + path, { method: "${method}", ${
bodyParameter ? "body: JSON.stringify(body)" : ""
} }).then((response) => response.json())
}
`);
// clients[clientName].functions.push(`
// /* ${operation.description} */
// async ${camelize(methodName)} (
// ${parametersFromPath(path)}
// ${bodyParam(bodyParameter, "Types")}
// ) : Promise<${responseType(operation, "Types")}> {
// return window.fetch(\`https://management.azure.com${path.replace(/{/g, "${")}\`, { method: "${method}", ${
// bodyParameter ? "body: JSON.stringify(body)" : ""
// } }).then((response) => response.json())
// }
// `);
// outputClient.push(clients[client].join("\n\n"));
}
}
outputClient.push(`}`);
writeOutputFile(`./${clientName}.ts`, outputClient);
} }
writeOutputFile("./types.ts", outputTypes); writeOutputFile("./types.ts", outputTypes);
} }
function buildBasePath(strings: string[]) {
const sortArr = strings.sort();
const arrFirstElem = strings[0];
const arrLastElem = sortArr[sortArr.length - 1];
const arrFirstElemLength = arrFirstElem.length;
let i = 0;
while (i < arrFirstElemLength && arrFirstElem.charAt(i) === arrLastElem.charAt(i)) {
i++;
}
return arrFirstElem.substring(0, i);
}
function buildConstructor(client: Client) {
const params = constructorParams(client);
if (params.length === 0) {
return "";
}
return `\nconstructor(${params.map(p => `private readonly ${p}: string`).join(",")}){}\n`;
}
function constructorParams(client: Client) {
let commonParams = parametersFromPath(client.paths[0]);
for (const path of client.paths) {
const params = parametersFromPath(path);
commonParams = commonParams.filter(p => params.includes(p));
}
return commonParams;
}
function writeOutputFile(outputPath: string, components: string[]) { function writeOutputFile(outputPath: string, components: string[]) {
components.unshift(`/* components.unshift(`/*
AUTOGENERATED FILE AUTOGENERATED FILE