More layering (#9111)

* move handling generated files to the serilization classes

* remove unneeded methods

* add more folders to strictire compile, add more strict compile options

* update ci

* wip

* add more layering and fix issues

* add more strictness

* remove unnecessary assertion

* add missing checks

* fix indentation

* wip

* remove jsdoc

* fix layering

* fix compile

* fix compile errors

* wip

* wip

* finish layering

* fix css

* more layering

* rip

* reworking results serializer

* move some files around

* move capabilities to platform wip

* implement capabilities register provider

* fix capabilities service

* fix usage of the regist4ry

* add contribution

* remove no longer good parts

* fix issues with startup

* another try

* fix startup

* fix imports

* fix tests

* fix tests

* fix more tests

* fix tests

* fix more tests

* fix broken test

* fix tabbing

* fix naming

src/sql/platform/capabilities/common/capabilitiesService.ts

@@ -7,6 +7,7 @@ import * as azdata from 'azdata';
 
 import { Event } from 'vs/base/common/event';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import type { IDisposable } from 'vs/base/common/lifecycle';
 
 export const SERVICE_ID = 'capabilitiesService';
 export const HOST_NAME = 'azdata';
@@ -55,11 +56,13 @@ export interface ICapabilitiesService {
 	/**
 	 * When new capabilities are registered, it emits the @see ProviderFeatures, which can be used to get the new capabilities
 	 */
-	readonly onCapabilitiesRegistered: Event<ProviderFeatures>;
+	readonly onCapabilitiesRegistered: Event<{ id: string; features: ProviderFeatures }>;
 
 	/**
 	 * Get an array of all known providers
 	 */
 	readonly providers: { [id: string]: ProviderFeatures };
 
+	registerConnectionProvider(id: string, properties: ConnectionProviderProperties): IDisposable;
+
 }

src/sql/platform/capabilities/common/capabilitiesServiceImpl.ts

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter } from 'vs/base/common/event';
+import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+
+import * as azdata from 'azdata';
+
+import { toObject } from 'sql/base/common/map';
+import { ICapabilitiesService, ProviderFeatures, clientCapabilities, ConnectionProviderProperties } from 'sql/platform/capabilities/common/capabilitiesService';
+
+/**
+ * Capabilities service implementation class.  This class provides the ability
+ * to discover the DMP capabilities that a DMP provider offers.
+ */
+export class CapabilitiesService extends Disposable implements ICapabilitiesService {
+	_serviceBrand: undefined;
+
+	private _providers = new Map<string, ProviderFeatures>();
+	private _legacyProviders = new Map<string, azdata.DataProtocolServerCapabilities>();
+
+	private _onCapabilitiesRegistered = this._register(new Emitter<{ id: string; features: ProviderFeatures }>());
+	public readonly onCapabilitiesRegistered = this._onCapabilitiesRegistered.event;
+
+	private _onCapabilitiesUnregistered = this._register(new Emitter<string>());
+	public readonly onCapabilitiesUnregistered = this._onCapabilitiesUnregistered.event;
+
+	private handleConnectionProvider(id: string, properties: ConnectionProviderProperties): void {
+
+		let provider = this._providers.get(id);
+		if (provider) {
+			provider.connection = properties;
+		} else {
+			provider = {
+				connection: properties
+			};
+			this._providers.set(id, provider);
+		}
+
+		this._onCapabilitiesRegistered.fire({ id, features: provider });
+	}
+
+	/**
+	 * Retrieve a list of registered server capabilities
+	 */
+	public getCapabilities(provider: string): ProviderFeatures | undefined {
+		return this._providers.get(provider);
+	}
+
+	public getLegacyCapabilities(provider: string): azdata.DataProtocolServerCapabilities | undefined {
+		return this._legacyProviders.get(provider);
+	}
+
+	public get providers(): { [id: string]: ProviderFeatures } {
+		return toObject(this._providers);
+	}
+
+	/**
+	 * Register the capabilities provider and query the provider for its capabilities
+	 */
+	public registerProvider(provider: azdata.CapabilitiesProvider): void {
+		// request the capabilities from server
+		provider.getServerCapabilities(clientCapabilities).then(serverCapabilities => {
+			this._legacyProviders.set(serverCapabilities.providerName, serverCapabilities);
+		});
+	}
+
+	public registerConnectionProvider(id: string, properties: ConnectionProviderProperties): IDisposable {
+		this.handleConnectionProvider(id, properties);
+		return toDisposable(() => {
+			this._providers.delete(id);
+			this._onCapabilitiesUnregistered.fire(id);
+		});
+	}
+}

src/sql/platform/capabilities/test/common/testCapabilitiesService.ts

@@ -5,12 +5,13 @@
 
 import * as azdata from 'azdata';
 import { ConnectionManagementInfo } from 'sql/platform/connection/common/connectionManagementInfo';
-import { ICapabilitiesService, ProviderFeatures } from 'sql/platform/capabilities/common/capabilitiesService';
+import { ICapabilitiesService, ProviderFeatures, ConnectionProviderProperties } from 'sql/platform/capabilities/common/capabilitiesService';
 
 import { Event, Emitter } from 'vs/base/common/event';
 import { Action } from 'vs/base/common/actions';
 import { mssqlProviderName } from 'sql/platform/connection/common/constants';
 import { ConnectionOptionSpecialType, ServiceOptionType } from 'sql/platform/connection/common/interfaces';
+import { IDisposable } from 'vs/base/common/lifecycle';
 
 export class TestCapabilitiesService implements ICapabilitiesService {
 
@@ -109,6 +110,10 @@ export class TestCapabilitiesService implements ICapabilitiesService {
 		this.capabilities[this.pgsqlProviderName] = { connection: pgSQLCapabilities };
 	}
 
+	registerConnectionProvider(id: string, properties: ConnectionProviderProperties): IDisposable {
+		throw new Error('Method not implemented.');
+	}
+
 	/**
 	 * Retrieve a list of registered server capabilities
 	 */
@@ -143,10 +148,10 @@ export class TestCapabilitiesService implements ICapabilitiesService {
 		return Promise.resolve();
 	}
 
-	public fireCapabilitiesRegistered(providerFeatures: ProviderFeatures): void {
-		this._onCapabilitiesRegistered.fire(providerFeatures);
+	public fireCapabilitiesRegistered(id: string, features: ProviderFeatures): void {
+		this._onCapabilitiesRegistered.fire({ id, features });
 	}
 
-	private _onCapabilitiesRegistered = new Emitter<ProviderFeatures>();
+	private _onCapabilitiesRegistered = new Emitter<{ id: string; features: ProviderFeatures }>();
 	public readonly onCapabilitiesRegistered = this._onCapabilitiesRegistered.event;
 }