Abstract the Postgres management client to allow both single and flexible server

package.json

@@ -1100,7 +1100,8 @@
     },
     "dependencies": {
         "@azure/arm-cosmosdb": "^9.1.0",
-        "@azure/arm-postgresql": "^4.4.0",
+        "@azure/arm-postgresql": "^5.0.0",
+        "@azure/arm-postgresql-flexible": "^1.0.0",
         "@azure/cosmos": "^3.6.3",
         "antlr4ts": "^0.4.1-alpha.0",
         "bson": "^1.1.3",

src/AzureDBExperiences.ts

@@ -12,7 +12,8 @@ export enum API {
     Graph = 'Graph',
     Table = 'Table',
     Core = 'Core',
-    Postgres = 'Postgres'
+    Postgres = 'Postgres',
+    PostgresFlexible = 'PostgresFlexible'
 }
 
 export enum DBAccountKind {
@@ -109,8 +110,9 @@ const CoreExperience: Experience = { api: API.Core, longName: "Core", descriptio
 export const MongoExperience: Experience = { api: API.MongoDB, longName: "Azure Cosmos DB for MongoDB API", shortName: "MongoDB", kind: DBAccountKind.MongoDB, tag: "Azure Cosmos DB for MongoDB API" };
 const TableExperience: Experience = { api: API.Table, longName: "Azure Table", shortName: "Table", kind: DBAccountKind.GlobalDocumentDB, capability: 'EnableTable', tag: "Azure Table" };
 const GremlinExperience: Experience = { api: API.Graph, longName: "Gremlin", description: "(graph)", shortName: "Gremlin", kind: DBAccountKind.GlobalDocumentDB, capability: 'EnableGremlin', tag: "Gremlin (graph)" };
-const PostgresExperience: Experience = { api: API.Postgres, longName: "PostgreSQL", shortName: "PostgreSQL" };
+const PostgresSingleExperience: Experience = { api: API.Postgres, longName: "PostgreSQL Single Server", shortName: "PostgreSQLSingle"};
+const PostgresFlexibleExperience: Experience = { api: API.PostgresFlexible, longName: "PostgreSQL Flexible Server", shortName: "PostgreSQLFlexible"};
 
 const cosmosExperiencesArray: Experience[] = [CoreExperience, MongoExperience, TableExperience, GremlinExperience];
-const experiencesArray: Experience[] = [...cosmosExperiencesArray, PostgresExperience];
+const experiencesArray: Experience[] = [...cosmosExperiencesArray, PostgresSingleExperience, PostgresFlexibleExperience];
 const experiencesMap = new Map<API, Experience>(experiencesArray.map((info: Experience): [API, Experience] => [info.api, info]));

src/postgres/abstract/AbstractPostgresClient.ts

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { PostgreSQLManagementClient } from "@azure/arm-postgresql";
+import { PostgreSQLFlexibleManagementClient } from "@azure/arm-postgresql-flexible";
+import * as msRest from "@azure/ms-rest-js";
+import { IMinimumServiceClientOptions } from "vscode-azureextensionui";
+import { IAbstractPostgresClient } from "./IAbstractPostgresClient";
+import { asAbstractDatabase, asFlexibleParameters, asSingleParameters, flexibleAsAbstractServer, singleAsAbstractServer } from "./maps";
+import * as Models from "./models";
+
+export class AbstractPostgresClient implements IAbstractPostgresClient  {
+    private postgresFlexibleClient: PostgreSQLFlexibleManagementClient;
+    private postgresSingleClient: PostgreSQLManagementClient;
+
+    constructor(credentials: msRest.ServiceClientCredentials, subscriptionId: string, options?: IMinimumServiceClientOptions) {
+        this.postgresFlexibleClient = new PostgreSQLFlexibleManagementClient(credentials, subscriptionId, options);
+        this.postgresSingleClient = new PostgreSQLManagementClient(credentials, subscriptionId, options);
+    }
+
+    async checkNameAvailability(serverType: Models.PostgresServerType, name: string) : Promise<Models.AbstractNameAvailability> {
+        switch (serverType){
+            case Models.PostgresServerType.Flexible:
+                return this.postgresFlexibleClient.checkNameAvailability.execute({name: name, type: "Microsoft.DBforPostgreSQL"});
+            case Models.PostgresServerType.Single:
+                return this.postgresSingleClient.checkNameAvailability.execute({name: name, type: "Microsoft.DBforPostgreSQL"});
+            default:
+                throw new Error("Service not implemented.");
+        }
+    }
+
+    async createFirewallRule(serverType: Models.PostgresServerType, resourceGroup: string, name: string, ruleName: string, rule: Models.AbstractFirewallRule): Promise<Models.AbstractFirewallRule> {
+        switch (serverType){
+            case Models.PostgresServerType.Flexible:
+                return this.postgresFlexibleClient.firewallRules.createOrUpdate(resourceGroup, name, ruleName, rule);
+            case Models.PostgresServerType.Single:
+                return this.postgresSingleClient.firewallRules.createOrUpdate(resourceGroup, name, ruleName, rule);
+            default:
+                throw new Error("Service not implemented.");
+        }
+    }
+
+    async createServer(serverType: Models.PostgresServerType, resourceGroup: string, name: string, parameters: Models.AbstractServerCreate): Promise<Models.PostgresAbstractServer> {
+        switch (serverType){
+            case Models.PostgresServerType.Flexible:
+                return flexibleAsAbstractServer(await this.postgresFlexibleClient.servers.create(resourceGroup, name, asFlexibleParameters(parameters)));
+            case Models.PostgresServerType.Single:
+                return singleAsAbstractServer(await this.postgresSingleClient.servers.create(resourceGroup, name, asSingleParameters(parameters)));
+            default:
+                throw new Error("Service not implemented.");
+        }
+    }
+
+    async deleteServer(serverType: Models.PostgresServerType, resourceGroup: string, name: string): Promise<msRest.RestResponse> {
+        switch (serverType){
+            case Models.PostgresServerType.Flexible:
+                return this.postgresFlexibleClient.servers.deleteMethod(resourceGroup, name);
+            case Models.PostgresServerType.Single:
+                return this.postgresSingleClient.servers.deleteMethod(resourceGroup, name);
+            default:
+                throw new Error("Service not implemented.");
+        }
+    }
+
+    async listServers(): Promise<Models.PostgresAbstractServerList> {
+        const flexServers = (await this.postgresFlexibleClient.servers.list()).map(flexibleAsAbstractServer);
+        const singleServers = (await this.postgresSingleClient.servers.list()).map(singleAsAbstractServer);
+        return Array<Models.PostgresAbstractServer>().concat(flexServers, singleServers);
+    }
+
+    async listDatabases(serverType: Models.PostgresServerType, resourceGroup: string, name: string): Promise<Models.PostgresAbstractDatabaseList> {
+        switch (serverType){
+            case Models.PostgresServerType.Flexible:
+                return (await this.postgresFlexibleClient.databases.listByServer(resourceGroup, name)).map(asAbstractDatabase);
+            case Models.PostgresServerType.Single:
+                return (await this.postgresSingleClient.databases.listByServer(resourceGroup, name)).map(asAbstractDatabase);
+            default:
+                throw new Error("Service not implemented.");
+        }
+    }
+}

src/postgres/abstract/IAbstractPostgresClient.ts

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as msRest from "@azure/ms-rest-js";
+import * as Models from './models';
+
+export interface IAbstractPostgresClient {
+    deleteServer(serverType: Models.PostgresServerType, resourceGroup: string, name: string): Promise<msRest.RestResponse>;
+    listDatabases(serverType: Models.PostgresServerType, resourceGroup: string, name: string): Promise<Models.PostgresAbstractDatabaseList>;
+    listServers(): Promise<Models.PostgresAbstractServerList>;
+    createServer(serverType: Models.PostgresServerType, resourceGroup: string, name: string, options: Models.AbstractServerCreate): Promise<Models.PostgresAbstractServer>;
+    checkNameAvailability(serverType: Models.PostgresServerType, name: string) : Promise<Models.AbstractNameAvailability>;
+    createFirewallRule(serverType: Models.PostgresServerType, resourceGroup: string, name: string, ruleName: string, rule: Models.AbstractFirewallRule) : Promise<Models.AbstractFirewallRule>;
+}