ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-01-16 01:25:36 -05:00
Code Issues Packages Projects Releases Wiki Activity

Move protocol client out (#643)

Browse Source 
* close

* connection is working

* formatting

* adds all

* formatting

* formatting and changing how features are initialized

* formatting

* changed named of typings file

* update

* updated to use dataprotocol npm

* formatting

* removed unneeded logging

* readd npm shrinkwrap

* still not working

* removed unnecessary codfe

* addressed comments

* readded azure resource provider

* fix capabilities cacheing

* added backwards capat for older protocol

* update shrinkwrap

* update shrinkwrap

* updated shrinkwrap

* fixed tests

* removed dead code

* remove dead code

* fix compile

* remove backcompat stuff

* change location of npm

* vbump sqltools

* merge master

* fix imports

* fix build breaks

* update for sqlops

* update yarn dependencies
This commit is contained in:
Anthony Dresser
2018-02-20 13:38:16 -08:00
committed by GitHub
parent 8a9ee40524
commit 8570910a43
159 changed files with 4421 additions and 7180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/sql/workbench/api/node/extHostAccountManagement.ts
View File

@@ -5,7 +5,7 @@
'use strict';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { TPromise } from 'vs/base/common/winjs.base';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { Disposable } from 'vs/workbench/api/node/extHostTypes';
@@ -27,28 +27,28 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
// PUBLIC METHODS //////////////////////////////////////////////////////
// - MAIN THREAD AVAILABLE METHODS /////////////////////////////////////
public $clear(handle: number, accountKey: data.AccountKey): Thenable<void> {
return this._withProvider(handle, (provider: data.AccountProvider) => provider.clear(accountKey));
public $clear(handle: number, accountKey: sqlops.AccountKey): Thenable<void> {
return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.clear(accountKey));
}
public $getSecurityToken(handle: number, account: data.Account): Thenable<{}> {
return this._withProvider(handle, (provider: data.AccountProvider) => provider.getSecurityToken(account));
public $getSecurityToken(handle: number, account: sqlops.Account): Thenable<{}> {
return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.getSecurityToken(account));
}
public $initialize(handle: number, restoredAccounts: data.Account[]): Thenable<data.Account[]> {
return this._withProvider(handle, (provider: data.AccountProvider) => provider.initialize(restoredAccounts));
public $initialize(handle: number, restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> {
return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.initialize(restoredAccounts));
}
public $prompt(handle: number): Thenable<data.Account> {
return this._withProvider(handle, (provider: data.AccountProvider) => provider.prompt());
public $prompt(handle: number): Thenable<sqlops.Account> {
return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.prompt());
}
public $refresh(handle: number, account: data.Account): Thenable<data.Account> {
return this._withProvider(handle, (provider: data.AccountProvider) => provider.refresh(account));
public $refresh(handle: number, account: sqlops.Account): Thenable<sqlops.Account> {
return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.refresh(account));
}
public $autoOAuthCancelled(handle: number): Thenable<void> {
return this._withProvider(handle, (provider: data.AccountProvider) => provider.autoOAuthCancelled());
return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.autoOAuthCancelled());
}
// - EXTENSION HOST AVAILABLE METHODS //////////////////////////////////
@@ -60,11 +60,11 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
this._proxy.$endAutoOAuthDeviceCode();
}
public $accountUpdated(updatedAccount: data.Account): void {
public $accountUpdated(updatedAccount: sqlops.Account): void {
this._proxy.$accountUpdated(updatedAccount);
}
public $registerAccountProvider(providerMetadata: data.AccountProviderMetadata, provider: data.AccountProvider): Disposable {
public $registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, provider: sqlops.AccountProvider): Disposable {
let self = this;
// Look for any account providers that have the same provider ID
@@ -105,7 +105,7 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
return this._handlePool++;
}
private _withProvider<R>(handle: number, callback: (provider: data.AccountProvider) => Thenable<R>): Thenable<R> {
private _withProvider<R>(handle: number, callback: (provider: sqlops.AccountProvider) => Thenable<R>): Thenable<R> {
let provider = this._providers[handle];
if (provider === undefined) {
return TPromise.wrapError(new Error(`Provider ${handle} not found.`));
@@ -115,8 +115,8 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
}
interface AccountProviderWithMetadata {
metadata: data.AccountProviderMetadata;
provider: data.AccountProvider;
metadata: sqlops.AccountProviderMetadata;
provider: sqlops.AccountProvider;
}

6
src/sql/workbench/api/node/extHostConnectionManagement.ts
View File

@@ -6,7 +6,7 @@
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { ExtHostConnectionManagementShape, SqlMainContext, MainThreadConnectionManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
import * as data from 'data';
import * as sqlops from 'sqlops';
export class ExtHostConnectionManagement extends ExtHostConnectionManagementShape {
@@ -19,11 +19,11 @@ export class ExtHostConnectionManagement extends ExtHostConnectionManagementShap
this._proxy = threadService.get(SqlMainContext.MainThreadConnectionManagement);
}
public $getActiveConnections(): Thenable<data.connection.Connection[]> {
public $getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
return this._proxy.$getActiveConnections();
}
public $getCurrentConnection(): Thenable<data.connection.Connection> {
public $getCurrentConnection(): Thenable<sqlops.connection.Connection> {
return this._proxy.$getCurrentConnection();
}

28
src/sql/workbench/api/node/extHostCredentialManagement.ts
View File

@@ -8,32 +8,32 @@ import { TPromise } from 'vs/base/common/winjs.base';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { SqlMainContext, MainThreadCredentialManagementShape, ExtHostCredentialManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
import * as vscode from 'vscode';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { Disposable } from 'vs/workbench/api/node/extHostTypes';
class CredentialAdapter {
public provider: data.CredentialProvider;
public provider: sqlops.CredentialProvider;
constructor(provider: data.CredentialProvider) {
constructor(provider: sqlops.CredentialProvider) {
this.provider = provider;
}
public saveCredential(credentialId: string, password: string): Thenable<boolean> {
public saveCredential(credentialId: string, password: string): Thenable<boolean> {
return this.provider.saveCredential(credentialId, password);
}
public readCredential(credentialId: string): Thenable<data.Credential> {
public readCredential(credentialId: string): Thenable<sqlops.Credential> {
return this.provider.readCredential(credentialId);
}
public deleteCredential(credentialId: string): Thenable<boolean> {
public deleteCredential(credentialId: string): Thenable<boolean> {
return this.provider.deleteCredential(credentialId);
}
}
type Adapter = CredentialAdapter;
export class ExtHostCredentialManagement extends ExtHostCredentialManagementShape {
export class ExtHostCredentialManagement extends ExtHostCredentialManagementShape {
// MEMBER VARIABLES ////////////////////////////////////////////////////
private _adapter: { [handle: number]: Adapter } = Object.create(null);
private _handlePool: number = 0;
@@ -54,7 +54,7 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
}
// PUBLIC METHODS //////////////////////////////////////////////////////
public $registerCredentialProvider(provider: data.CredentialProvider): vscode.Disposable {
public $registerCredentialProvider(provider: sqlops.CredentialProvider): vscode.Disposable {
// Store the credential provider
provider.handle = this._nextHandle();
this._adapter[provider.handle] = new CredentialAdapter(provider);
@@ -67,7 +67,7 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
return this._createDisposable(provider.handle);
}
public $getCredentialProvider(namespaceId: string): Thenable<data.CredentialProvider> {
public $getCredentialProvider(namespaceId: string): Thenable<sqlops.CredentialProvider> {
let self = this;
if (!namespaceId) {
@@ -84,11 +84,11 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
return this._withAdapter(0, CredentialAdapter, adapter => adapter.saveCredential(credentialId, password));
}
public $readCredential(credentialId: string): Thenable<data.Credential> {
public $readCredential(credentialId: string): Thenable<sqlops.Credential> {
return this._withAdapter(0, CredentialAdapter, adapter => adapter.readCredential(credentialId));
}
public $deleteCredential(credentialId: string): Thenable<boolean> {
public $deleteCredential(credentialId: string): Thenable<boolean> {
return this._withAdapter(0, CredentialAdapter, adapter => adapter.deleteCredential(credentialId));
}
@@ -105,9 +105,9 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
return `${namespaceId}|${credentialId}`;
}
private _createNamespacedCredentialProvider(namespaceId: string, adapter: CredentialAdapter): Thenable<data.CredentialProvider> {
private _createNamespacedCredentialProvider(namespaceId: string, adapter: CredentialAdapter): Thenable<sqlops.CredentialProvider> {
// Create a provider that wraps the methods in a namespace
let provider: data.CredentialProvider = {
let provider: sqlops.CredentialProvider = {
handle: adapter.provider.handle,
deleteCredential: (credentialId: string) => {
let namespacedId = ExtHostCredentialManagement._getNamespacedCredentialId(namespaceId, credentialId);
@@ -136,7 +136,7 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
return this._handlePool++;
}
private _withAdapter<A, R>(handle: number, ctor: { new (...args: any[]): A }, callback: (adapter: A) => Thenable<R>): Thenable<R> {
private _withAdapter<A, R>(handle: number, ctor: { new(...args: any[]): A }, callback: (adapter: A) => Thenable<R>): Thenable<R> {
let adapter = this._adapter[handle];
if (!(adapter instanceof ctor)) {
return TPromise.wrapError(new Error('no adapter found'));

18
src/sql/workbench/api/node/extHostDashboardWebview.ts
View File

@@ -11,9 +11,9 @@ import { Emitter } from 'vs/base/common/event';
import { deepClone } from 'vs/base/common/objects';
import * as vscode from 'vscode';
import * as data from 'data';
import * as sqlops from 'sqlops';
class ExtHostDashboardWebview implements data.DashboardWebview {
class ExtHostDashboardWebview implements sqlops.DashboardWebview {
private _html: string;
public onMessageEmitter = new Emitter<any>();
@@ -22,8 +22,8 @@ class ExtHostDashboardWebview implements data.DashboardWebview {
constructor(
private readonly _proxy: MainThreadDashboardWebviewShape,
private readonly _handle: number,
private readonly _connection: data.connection.Connection,
private readonly _serverInfo: data.ServerInfo
private readonly _connection: sqlops.connection.Connection,
private readonly _serverInfo: sqlops.ServerInfo
) { }
public postMessage(message: any): Thenable<any> {
@@ -38,11 +38,11 @@ class ExtHostDashboardWebview implements data.DashboardWebview {
return this.onClosedEmitter.event;
}
public get connection(): data.connection.Connection {
public get connection(): sqlops.connection.Connection {
return deepClone(this._connection);
}
public get serverInfo(): data.ServerInfo {
public get serverInfo(): sqlops.ServerInfo {
return deepClone(this._serverInfo);
}
@@ -62,7 +62,7 @@ export class ExtHostDashboardWebviews implements ExtHostDashboardWebviewsShape {
private readonly _proxy: MainThreadDashboardWebviewShape;
private readonly _webviews = new Map<number, ExtHostDashboardWebview>();
private readonly _handlers = new Map<string, (webview: data.DashboardWebview) => void>();
private readonly _handlers = new Map<string, (webview: sqlops.DashboardWebview) => void>();
constructor(
mainContext: IMainContext
@@ -81,12 +81,12 @@ export class ExtHostDashboardWebviews implements ExtHostDashboardWebviewsShape {
this._webviews.delete(handle);
}
$registerProvider(widgetId: string, handler: (webview: data.DashboardWebview) => void): void {
$registerProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void): void {
this._handlers.set(widgetId, handler);
this._proxy.$registerProvider(widgetId);
}
$registerWidget(handle: number, id: string, connection: data.connection.Connection, serverInfo: data.ServerInfo): void {
$registerWidget(handle: number, id: string, connection: sqlops.connection.Connection, serverInfo: sqlops.ServerInfo): void {
let webview = new ExtHostDashboardWebview(this._proxy, handle, connection, serverInfo);
this._webviews.set(handle, webview);
this._handlers.get(id)(webview);

238
src/sql/workbench/api/node/extHostDataProtocol.ts
View File

@@ -8,19 +8,19 @@ import Event, { Emitter } from 'vs/base/common/event';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { SqlMainContext, MainThreadDataProtocolShape, ExtHostDataProtocolShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
import * as vscode from 'vscode';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { Disposable } from 'vs/workbench/api/node/extHostTypes';
export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
private readonly _onDidChangeLanguageFlavor = new Emitter<data.DidChangeLanguageFlavorParams>();
private readonly _onDidChangeLanguageFlavor = new Emitter<sqlops.DidChangeLanguageFlavorParams>();
readonly onDidChangeLanguageFlavor: Event<data.DidChangeLanguageFlavorParams> = this._onDidChangeLanguageFlavor.event;
readonly onDidChangeLanguageFlavor: Event<sqlops.DidChangeLanguageFlavorParams> = this._onDidChangeLanguageFlavor.event;
private _proxy: MainThreadDataProtocolShape;
private static _handlePool: number = 0;
private _adapter = new Map<number, data.DataProvider>();
private _adapter = new Map<number, sqlops.DataProvider>();
constructor(
threadService: IThreadService
@@ -40,7 +40,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
return ExtHostDataProtocol._handlePool++;
}
private _resolveProvider<P extends data.DataProvider>(handle: number): P {
private _resolveProvider<P extends sqlops.DataProvider>(handle: number): P {
let provider = this._adapter.get(handle) as P;
if (provider) {
return provider;
@@ -49,115 +49,115 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
}
}
private registerProvider(provider: data.DataProvider): vscode.Disposable {
private registerProvider(provider: sqlops.DataProvider): vscode.Disposable {
provider.handle = this._nextHandle();
this._adapter.set(provider.handle, provider);
return this._createDisposable(provider.handle);
};
$registerConnectionProvider(provider: data.ConnectionProvider): vscode.Disposable {
$registerConnectionProvider(provider: sqlops.ConnectionProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerConnectionProvider(provider.providerId, provider.handle);
return rt;
}
$registerBackupProvider(provider: data.BackupProvider): vscode.Disposable {
$registerBackupProvider(provider: sqlops.BackupProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerBackupProvider(provider.providerId, provider.handle);
return rt;
}
$registerRestoreProvider(provider: data.RestoreProvider): vscode.Disposable {
$registerRestoreProvider(provider: sqlops.RestoreProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerRestoreProvider(provider.providerId, provider.handle);
return rt;
}
$registerScriptingProvider(provider: data.ScriptingProvider): vscode.Disposable {
$registerScriptingProvider(provider: sqlops.ScriptingProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerScriptingProvider(provider.providerId, provider.handle);
return rt;
}
$registerQueryProvider(provider: data.QueryProvider): vscode.Disposable {
$registerQueryProvider(provider: sqlops.QueryProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerQueryProvider(provider.providerId, provider.handle);
return rt;
}
$registerMetadataProvider(provider: data.MetadataProvider): vscode.Disposable {
$registerMetadataProvider(provider: sqlops.MetadataProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerMetadataProvider(provider.providerId, provider.handle);
return rt;
}
$registerTaskServicesProvider(provider: data.TaskServicesProvider): vscode.Disposable {
$registerTaskServicesProvider(provider: sqlops.TaskServicesProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerTaskServicesProvider(provider.providerId, provider.handle);
return rt;
}
$registerFileBrowserProvider(provider: data.FileBrowserProvider): vscode.Disposable {
$registerFileBrowserProvider(provider: sqlops.FileBrowserProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerFileBrowserProvider(provider.providerId, provider.handle);
return rt;
}
$registerObjectExplorerProvider(provider: data.ObjectExplorerProvider): vscode.Disposable {
$registerObjectExplorerProvider(provider: sqlops.ObjectExplorerProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerObjectExplorerProvider(provider.providerId, provider.handle);
return rt;
}
$registerProfilerProvider(provider: data.ProfilerProvider): vscode.Disposable {
$registerProfilerProvider(provider: sqlops.ProfilerProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerProfilerProvider(provider.providerId, provider.handle);
return rt;
}
$registerAdminServicesProvider(provider: data.AdminServicesProvider): vscode.Disposable {
$registerAdminServicesProvider(provider: sqlops.AdminServicesProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerAdminServicesProvider(provider.providerId, provider.handle);
return rt;
}
$registerCapabilitiesServiceProvider(provider: data.CapabilitiesProvider): vscode.Disposable {
$registerCapabilitiesServiceProvider(provider: sqlops.CapabilitiesProvider): vscode.Disposable {
let rt = this.registerProvider(provider);
this._proxy.$registerCapabilitiesServiceProvider(provider.providerId, provider.handle);
return rt;
}
// Capabilities Discovery handlers
$getServerCapabilities(handle: number, client: data.DataProtocolClientCapabilities): Thenable<data.DataProtocolServerCapabilities> {
return this._resolveProvider<data.CapabilitiesProvider>(handle).getServerCapabilities(client);
$getServerCapabilities(handle: number, client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> {
return this._resolveProvider<sqlops.CapabilitiesProvider>(handle).getServerCapabilities(client);
}
// Connection Management handlers
$connect(handle: number, connectionUri: string, connection: data.ConnectionInfo): Thenable<boolean> {
return this._resolveProvider<data.ConnectionProvider>(handle).connect(connectionUri, connection);
$connect(handle: number, connectionUri: string, connection: sqlops.ConnectionInfo): Thenable<boolean> {
return this._resolveProvider<sqlops.ConnectionProvider>(handle).connect(connectionUri, connection);
}
$disconnect(handle: number, connectionUri: string): Thenable<boolean> {
return this._resolveProvider<data.ConnectionProvider>(handle).disconnect(connectionUri);
return this._resolveProvider<sqlops.ConnectionProvider>(handle).disconnect(connectionUri);
}
$cancelConnect(handle: number, connectionUri: string): Thenable<boolean> {
return this._resolveProvider<data.ConnectionProvider>(handle).cancelConnect(connectionUri);
return this._resolveProvider<sqlops.ConnectionProvider>(handle).cancelConnect(connectionUri);
}
$changeDatabase(handle: number, connectionUri: string, newDatabase: string): Thenable<boolean> {
return this._resolveProvider<data.ConnectionProvider>(handle).changeDatabase(connectionUri, newDatabase);
return this._resolveProvider<sqlops.ConnectionProvider>(handle).changeDatabase(connectionUri, newDatabase);
}
$listDatabases(handle: number, connectionUri: string): Thenable<data.ListDatabasesResult> {
return this._resolveProvider<data.ConnectionProvider>(handle).listDatabases(connectionUri);
$listDatabases(handle: number, connectionUri: string): Thenable<sqlops.ListDatabasesResult> {
return this._resolveProvider<sqlops.ConnectionProvider>(handle).listDatabases(connectionUri);
}
$rebuildIntelliSenseCache(handle: number, connectionUri: string): Thenable<void> {
return this._resolveProvider<data.ConnectionProvider>(handle).rebuildIntelliSenseCache(connectionUri);
return this._resolveProvider<sqlops.ConnectionProvider>(handle).rebuildIntelliSenseCache(connectionUri);
}
$onConnectComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void {
$onConnectComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void {
this._proxy.$onConnectionComplete(handle, connectionInfoSummary);
}
@@ -165,100 +165,100 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
this._proxy.$onIntelliSenseCacheComplete(handle, connectionUri);
}
public $onConnectionChanged(handle: number, changedConnInfo: data.ChangedConnectionInfo): void {
public $onConnectionChanged(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void {
this._proxy.$onConnectionChangeNotification(handle, changedConnInfo);
}
// Protocol-wide Event Handlers
public $languageFlavorChanged(params: data.DidChangeLanguageFlavorParams): void {
public $languageFlavorChanged(params: sqlops.DidChangeLanguageFlavorParams): void {
this._onDidChangeLanguageFlavor.fire(params);
}
// Query Management handlers
$cancelQuery(handle: number, ownerUri: string): Thenable<data.QueryCancelResult> {
return this._resolveProvider<data.QueryProvider>(handle).cancelQuery(ownerUri);
$cancelQuery(handle: number, ownerUri: string): Thenable<sqlops.QueryCancelResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).cancelQuery(ownerUri);
}
$runQuery(handle: number, ownerUri: string, selection: data.ISelectionData, runOptions?: data.ExecutionPlanOptions): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).runQuery(ownerUri, selection, runOptions);
$runQuery(handle: number, ownerUri: string, selection: sqlops.ISelectionData, runOptions?: sqlops.ExecutionPlanOptions): Thenable<void> {
return this._resolveProvider<sqlops.QueryProvider>(handle).runQuery(ownerUri, selection, runOptions);
}
$runQueryStatement(handle: number, ownerUri: string, line: number, column: number): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).runQueryStatement(ownerUri, line, column);
return this._resolveProvider<sqlops.QueryProvider>(handle).runQueryStatement(ownerUri, line, column);
}
$runQueryString(handle: number, ownerUri: string, queryString: string): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).runQueryString(ownerUri, queryString);
return this._resolveProvider<sqlops.QueryProvider>(handle).runQueryString(ownerUri, queryString);
}
$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<data.SimpleExecuteResult> {
return this._resolveProvider<data.QueryProvider>(handle).runQueryAndReturn(ownerUri, queryString);
$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<sqlops.SimpleExecuteResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).runQueryAndReturn(ownerUri, queryString);
}
$getQueryRows(handle: number, rowData: data.QueryExecuteSubsetParams): Thenable<data.QueryExecuteSubsetResult> {
return this._resolveProvider<data.QueryProvider>(handle).getQueryRows(rowData);
$getQueryRows(handle: number, rowData: sqlops.QueryExecuteSubsetParams): Thenable<sqlops.QueryExecuteSubsetResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).getQueryRows(rowData);
}
$disposeQuery(handle: number, ownerUri: string): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).disposeQuery(ownerUri);
return this._resolveProvider<sqlops.QueryProvider>(handle).disposeQuery(ownerUri);
}
$onQueryComplete(handle: number, result: data.QueryExecuteCompleteNotificationResult): void {
$onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void {
this._proxy.$onQueryComplete(handle, result);
}
$onBatchStart(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void {
$onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
this._proxy.$onBatchStart(handle, batchInfo);
}
$onBatchComplete(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void {
$onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
this._proxy.$onBatchComplete(handle, batchInfo);
}
$onResultSetComplete(handle: number, resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams): void {
$onResultSetComplete(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetCompleteNotificationParams): void {
this._proxy.$onResultSetComplete(handle, resultSetInfo);
}
$onQueryMessage(handle: number, message: data.QueryExecuteMessageParams): void {
$onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void {
this._proxy.$onQueryMessage(handle, message);
}
$saveResults(handle: number, requestParams: data.SaveResultsRequestParams): Thenable<data.SaveResultRequestResult> {
return this._resolveProvider<data.QueryProvider>(handle).saveResults(requestParams);
$saveResults(handle: number, requestParams: sqlops.SaveResultsRequestParams): Thenable<sqlops.SaveResultRequestResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).saveResults(requestParams);
}
// Edit Data handlers
$commitEdit(handle: number, ownerUri: string): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).commitEdit(ownerUri);
return this._resolveProvider<sqlops.QueryProvider>(handle).commitEdit(ownerUri);
}
$createRow(handle: number, ownerUri: string): Thenable<data.EditCreateRowResult> {
return this._resolveProvider<data.QueryProvider>(handle).createRow(ownerUri);
$createRow(handle: number, ownerUri: string): Thenable<sqlops.EditCreateRowResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).createRow(ownerUri);
}
$deleteRow(handle: number, ownerUri: string, rowId: number): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).deleteRow(ownerUri, rowId);
return this._resolveProvider<sqlops.QueryProvider>(handle).deleteRow(ownerUri, rowId);
}
$disposeEdit(handle: number, ownerUri: string): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).disposeEdit(ownerUri);
return this._resolveProvider<sqlops.QueryProvider>(handle).disposeEdit(ownerUri);
}
$initializeEdit(handle: number, ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).initializeEdit(ownerUri, schemaName, objectName, objectType, rowLimit);
return this._resolveProvider<sqlops.QueryProvider>(handle).initializeEdit(ownerUri, schemaName, objectName, objectType, rowLimit);
}
$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<data.EditRevertCellResult> {
return this._resolveProvider<data.QueryProvider>(handle).revertCell(ownerUri, rowId, columnId);
$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<sqlops.EditRevertCellResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).revertCell(ownerUri, rowId, columnId);
}
$revertRow(handle: number, ownerUri: string, rowId: number): Thenable<void> {
return this._resolveProvider<data.QueryProvider>(handle).revertRow(ownerUri, rowId);
return this._resolveProvider<sqlops.QueryProvider>(handle).revertRow(ownerUri, rowId);
}
$updateCell(handle: number, ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<data.EditUpdateCellResult> {
return this._resolveProvider<data.QueryProvider>(handle).updateCell(ownerUri, rowId, columnId, newValue);
$updateCell(handle: number, ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<sqlops.EditUpdateCellResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).updateCell(ownerUri, rowId, columnId, newValue);
}
$getEditRows(handle: number, rowData: data.EditSubsetParams): Thenable<data.EditSubsetResult> {
return this._resolveProvider<data.QueryProvider>(handle).getEditRows(rowData);
$getEditRows(handle: number, rowData: sqlops.EditSubsetParams): Thenable<sqlops.EditSubsetResult> {
return this._resolveProvider<sqlops.QueryProvider>(handle).getEditRows(rowData);
}
$onEditSessionReady(handle: number, ownerUri: string, success: boolean, message: string): void {
@@ -266,155 +266,155 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
}
// Metadata handlers
public $getMetadata(handle: number, connectionUri: string): Thenable<data.ProviderMetadata> {
return this._resolveProvider<data.MetadataProvider>(handle).getMetadata(connectionUri);
public $getMetadata(handle: number, connectionUri: string): Thenable<sqlops.ProviderMetadata> {
return this._resolveProvider<sqlops.MetadataProvider>(handle).getMetadata(connectionUri);
}
public $getDatabases(handle: number, connectionUri: string): Thenable<string[]> {
return this._resolveProvider<data.MetadataProvider>(handle).getDatabases(connectionUri);
return this._resolveProvider<sqlops.MetadataProvider>(handle).getDatabases(connectionUri);
}
public $getTableInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
return this._resolveProvider<data.MetadataProvider>(handle).getTableInfo(connectionUri, metadata);
public $getTableInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
return this._resolveProvider<sqlops.MetadataProvider>(handle).getTableInfo(connectionUri, metadata);
}
public $getViewInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
return this._resolveProvider<data.MetadataProvider>(handle).getViewInfo(connectionUri, metadata);
public $getViewInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
return this._resolveProvider<sqlops.MetadataProvider>(handle).getViewInfo(connectionUri, metadata);
}
// Object Explorer Service
public $createObjectExplorerSession(handle: number, connInfo: data.ConnectionInfo): Thenable<data.ObjectExplorerSessionResponse> {
return this._resolveProvider<data.ObjectExplorerProvider>(handle).createNewSession(connInfo);
public $createObjectExplorerSession(handle: number, connInfo: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerSessionResponse> {
return this._resolveProvider<sqlops.ObjectExplorerProvider>(handle).createNewSession(connInfo);
}
public $expandObjectExplorerNode(handle: number, nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
return this._resolveProvider<data.ObjectExplorerProvider>(handle).expandNode(nodeInfo);
public $expandObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
return this._resolveProvider<sqlops.ObjectExplorerProvider>(handle).expandNode(nodeInfo);
}
public $refreshObjectExplorerNode(handle: number, nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
return this._resolveProvider<data.ObjectExplorerProvider>(handle).refreshNode(nodeInfo);
public $refreshObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
return this._resolveProvider<sqlops.ObjectExplorerProvider>(handle).refreshNode(nodeInfo);
}
public $closeObjectExplorerSession(handle: number, closeSessionInfo: data.ObjectExplorerCloseSessionInfo): Thenable<data.ObjectExplorerCloseSessionResponse> {
return this._resolveProvider<data.ObjectExplorerProvider>(handle).closeSession(closeSessionInfo);
public $closeObjectExplorerSession(handle: number, closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> {
return this._resolveProvider<sqlops.ObjectExplorerProvider>(handle).closeSession(closeSessionInfo);
}
public $onObjectExplorerSessionCreated(handle: number, response: data.ObjectExplorerSession): void {
public $onObjectExplorerSessionCreated(handle: number, response: sqlops.ObjectExplorerSession): void {
this._proxy.$onObjectExplorerSessionCreated(handle, response);
}
public $onObjectExplorerNodeExpanded(handle: number, response: data.ObjectExplorerExpandInfo): void {
public $onObjectExplorerNodeExpanded(handle: number, response: sqlops.ObjectExplorerExpandInfo): void {
this._proxy.$onObjectExplorerNodeExpanded(handle, response);
}
// Task Service
public $getAllTasks(handle: number, listTasksParams: data.ListTasksParams): Thenable<data.ListTasksResponse> {
return this._resolveProvider<data.TaskServicesProvider>(handle).getAllTasks(listTasksParams);
public $getAllTasks(handle: number, listTasksParams: sqlops.ListTasksParams): Thenable<sqlops.ListTasksResponse> {
return this._resolveProvider<sqlops.TaskServicesProvider>(handle).getAllTasks(listTasksParams);
}
public $cancelTask(handle: number, cancelTaskParams: data.CancelTaskParams): Thenable<boolean> {
return this._resolveProvider<data.TaskServicesProvider>(handle).cancelTask(cancelTaskParams);
public $cancelTask(handle: number, cancelTaskParams: sqlops.CancelTaskParams): Thenable<boolean> {
return this._resolveProvider<sqlops.TaskServicesProvider>(handle).cancelTask(cancelTaskParams);
}
public $onTaskStatusChanged(handle: number, response: data.TaskProgressInfo): void {
public $onTaskStatusChanged(handle: number, response: sqlops.TaskProgressInfo): void {
this._proxy.$onTaskStatusChanged(handle, response);
}
public $onTaskCreated(handle: number, response: data.TaskInfo): void {
public $onTaskCreated(handle: number, response: sqlops.TaskInfo): void {
this._proxy.$onTaskCreated(handle, response);
}
// Scripting handlers
public $scriptAsOperation(handle: number, connectionUri: string, operation: data.ScriptOperation, metadata: data.ObjectMetadata, paramDetails: data.ScriptingParamDetails): Thenable<data.ScriptingResult> {
return this._resolveProvider<data.ScriptingProvider>(handle).scriptAsOperation(connectionUri, operation, metadata, paramDetails);
public $scriptAsOperation(handle: number, connectionUri: string, operation: sqlops.ScriptOperation, metadata: sqlops.ObjectMetadata, paramDetails: sqlops.ScriptingParamDetails): Thenable<sqlops.ScriptingResult> {
return this._resolveProvider<sqlops.ScriptingProvider>(handle).scriptAsOperation(connectionUri, operation, metadata, paramDetails);
}
public $onScriptingComplete(handle: number, scriptingCompleteResult: data.ScriptingCompleteResult): void {
public $onScriptingComplete(handle: number, scriptingCompleteResult: sqlops.ScriptingCompleteResult): void {
this._proxy.$onScriptingComplete(handle, scriptingCompleteResult);
}
/**
* Create a new database on the provided connection
*/
public $createDatabase(handle: number, connectionUri: string, database: data.DatabaseInfo): Thenable<data.CreateDatabaseResponse> {
return this._resolveProvider<data.AdminServicesProvider>(handle).createDatabase(connectionUri, database);
public $createDatabase(handle: number, connectionUri: string, database: sqlops.DatabaseInfo): Thenable<sqlops.CreateDatabaseResponse> {
return this._resolveProvider<sqlops.AdminServicesProvider>(handle).createDatabase(connectionUri, database);
}
/**
* Create a new database on the provided connection
*/
public $getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<data.DatabaseInfo> {
return this._resolveProvider<data.AdminServicesProvider>(handle).getDefaultDatabaseInfo(connectionUri);
public $getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> {
return this._resolveProvider<sqlops.AdminServicesProvider>(handle).getDefaultDatabaseInfo(connectionUri);
}
/**
* Get the info on a database
*/
public $getDatabaseInfo(handle: number, connectionUri: string): Thenable<data.DatabaseInfo> {
return this._resolveProvider<data.AdminServicesProvider>(handle).getDatabaseInfo(connectionUri);
public $getDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> {
return this._resolveProvider<sqlops.AdminServicesProvider>(handle).getDatabaseInfo(connectionUri);
}
/**
* Create a new login on the provided connection
*/
public $createLogin(handle: number, connectionUri: string, login: data.LoginInfo): Thenable<data.CreateLoginResponse> {
return this._resolveProvider<data.AdminServicesProvider>(handle).createLogin(connectionUri, login);
public $createLogin(handle: number, connectionUri: string, login: sqlops.LoginInfo): Thenable<sqlops.CreateLoginResponse> {
return this._resolveProvider<sqlops.AdminServicesProvider>(handle).createLogin(connectionUri, login);
}
/**
* Backup a database
*/
public $backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse> {
return this._resolveProvider<data.BackupProvider>(handle).backup(connectionUri, backupInfo, taskExecutionMode);
public $backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.BackupResponse> {
return this._resolveProvider<sqlops.BackupProvider>(handle).backup(connectionUri, backupInfo, taskExecutionMode);
}
/**
* Create a new database on the provided connection
*/
public $getBackupConfigInfo(handle: number, connectionUri: string): Thenable<data.BackupConfigInfo> {
return this._resolveProvider<data.BackupProvider>(handle).getBackupConfigInfo(connectionUri);
public $getBackupConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.BackupConfigInfo> {
return this._resolveProvider<sqlops.BackupProvider>(handle).getBackupConfigInfo(connectionUri);
}
/**
* Restores a database
*/
public $restore(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
return this._resolveProvider<data.RestoreProvider>(handle).restore(connectionUri, restoreInfo);
public $restore(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestoreResponse> {
return this._resolveProvider<sqlops.RestoreProvider>(handle).restore(connectionUri, restoreInfo);
}
/**
* Gets a plan for restoring a database
*/
public $getRestorePlan(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
return this._resolveProvider<data.RestoreProvider>(handle).getRestorePlan(connectionUri, restoreInfo);
public $getRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestorePlanResponse> {
return this._resolveProvider<sqlops.RestoreProvider>(handle).getRestorePlan(connectionUri, restoreInfo);
}
/**
* cancels a restore plan
*/
public $cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
return this._resolveProvider<data.RestoreProvider>(handle).cancelRestorePlan(connectionUri, restoreInfo);
public $cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<boolean> {
return this._resolveProvider<sqlops.RestoreProvider>(handle).cancelRestorePlan(connectionUri, restoreInfo);
}
/**
* Gets restore config Info
*/
public $getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<data.RestoreConfigInfo> {
return this._resolveProvider<data.RestoreProvider>(handle).getRestoreConfigInfo(connectionUri);
public $getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.RestoreConfigInfo> {
return this._resolveProvider<sqlops.RestoreProvider>(handle).getRestoreConfigInfo(connectionUri);
}
/**
* Open a file browser
*/
public $openFileBrowser(handle: number, ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
return this._resolveProvider<data.FileBrowserProvider>(handle).openFileBrowser(ownerUri, expandPath, fileFilters, changeFilter);
return this._resolveProvider<sqlops.FileBrowserProvider>(handle).openFileBrowser(ownerUri, expandPath, fileFilters, changeFilter);
}
/**
* Send event when opening browser is complete
*/
public $onFileBrowserOpened(handle: number, response: data.FileBrowserOpenedParams): void {
public $onFileBrowserOpened(handle: number, response: sqlops.FileBrowserOpenedParams): void {
this._proxy.$onFileBrowserOpened(handle, response);
}
@@ -422,13 +422,13 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
* Expand a folder node
*/
public $expandFolderNode(handle: number, ownerUri: string, expandPath: string): Thenable<boolean> {
return this._resolveProvider<data.FileBrowserProvider>(handle).expandFolderNode(ownerUri, expandPath);
return this._resolveProvider<sqlops.FileBrowserProvider>(handle).expandFolderNode(ownerUri, expandPath);
}
/**
* Send event when expansion is complete
*/
public $onFolderNodeExpanded(handle: number, response: data.FileBrowserExpandedParams): void {
public $onFolderNodeExpanded(handle: number, response: sqlops.FileBrowserExpandedParams): void {
this._proxy.$onFolderNodeExpanded(handle, response);
}
@@ -436,21 +436,21 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
* Validate selected file path
*/
public $validateFilePaths(handle: number, ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean> {
return this._resolveProvider<data.FileBrowserProvider>(handle).validateFilePaths(ownerUri, serviceType, selectedFiles);
return this._resolveProvider<sqlops.FileBrowserProvider>(handle).validateFilePaths(ownerUri, serviceType, selectedFiles);
}
/**
* Send event when validation is complete
*/
public $onFilePathsValidated(handle: number, response: data.FileBrowserValidatedParams) {
public $onFilePathsValidated(handle: number, response: sqlops.FileBrowserValidatedParams) {
this._proxy.$onFilePathsValidated(handle, response);
}
/**
* Close file browser
*/
public $closeFileBrowser(handle: number, ownerUri: string): Thenable<data.FileBrowserCloseResponse> {
return this._resolveProvider<data.FileBrowserProvider>(handle).closeFileBrowser(ownerUri);
public $closeFileBrowser(handle: number, ownerUri: string): Thenable<sqlops.FileBrowserCloseResponse> {
return this._resolveProvider<sqlops.FileBrowserProvider>(handle).closeFileBrowser(ownerUri);
}
/**
@@ -461,20 +461,20 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
* Start a profiler session
*/
public $startSession(handle: number, sessionId: string): Thenable<boolean> {
return this._resolveProvider<data.ProfilerProvider>(handle).startSession(sessionId);
return this._resolveProvider<sqlops.ProfilerProvider>(handle).startSession(sessionId);
}
/**
* Stop a profiler session
*/
public $stopSession(handle: number, sessionId: string): Thenable<boolean> {
return this._resolveProvider<data.ProfilerProvider>(handle).stopSession(sessionId);
return this._resolveProvider<sqlops.ProfilerProvider>(handle).stopSession(sessionId);
}
/**
* Profiler session events available notification
*/
public $onSessionEventsAvailable(handle: number, response: data.ProfilerSessionEvents): void {
public $onSessionEventsAvailable(handle: number, response: sqlops.ProfilerSessionEvents): void {
this._proxy.$onSessionEventsAvailable(handle, response);
}
}

6
src/sql/workbench/api/node/extHostModalDialog.ts
View File

@@ -7,10 +7,10 @@
import { SqlMainContext, MainThreadModalDialogShape, ExtHostModalDialogsShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
import * as vscode from 'vscode';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { Emitter } from 'vs/base/common/event';
class ExtHostDialog implements data.ModalDialog {
class ExtHostDialog implements sqlops.ModalDialog {
private _title: string;
private _html: string;
private _okTitle: string;
@@ -97,7 +97,7 @@ export class ExtHostModalDialogs implements ExtHostModalDialogsShape {
createDialog(
title: string
): data.ModalDialog {
): sqlops.ModalDialog {
console.log(title);
const handle = ExtHostModalDialogs._handlePool++;
this._proxy.$createDialog(handle);

26
src/sql/workbench/api/node/extHostResourceProvider.ts
View File

@@ -5,10 +5,10 @@
'use strict';
import * as data from 'data';
import {TPromise} from 'vs/base/common/winjs.base';
import {IThreadService} from 'vs/workbench/services/thread/common/threadService';
import {Disposable} from 'vs/workbench/api/node/extHostTypes';
import * as sqlops from 'sqlops';
import { TPromise } from 'vs/base/common/winjs.base';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { Disposable } from 'vs/workbench/api/node/extHostTypes';
import {
ExtHostResourceProviderShape,
MainThreadResourceProviderShape,
@@ -18,7 +18,7 @@ import {
export class ExtHostResourceProvider extends ExtHostResourceProviderShape {
private _handlePool: number = 0;
private _proxy: MainThreadResourceProviderShape;
private _providers: {[handle: number]: ResourceProviderWithMetadata} = {};
private _providers: { [handle: number]: ResourceProviderWithMetadata } = {};
constructor(threadService: IThreadService) {
super();
@@ -27,15 +27,15 @@ export class ExtHostResourceProvider extends ExtHostResourceProviderShape {
// PUBLIC METHODS //////////////////////////////////////////////////////
// - MAIN THREAD AVAILABLE METHODS /////////////////////////////////////
public $createFirewallRule(handle: number, account: data.Account, firewallRuleInfo: data.FirewallRuleInfo): Thenable<data.CreateFirewallRuleResponse> {
return this._withProvider(handle, (provider: data.ResourceProvider) => provider.createFirewallRule(account, firewallRuleInfo));
public $createFirewallRule(handle: number, account: sqlops.Account, firewallRuleInfo: sqlops.FirewallRuleInfo): Thenable<sqlops.CreateFirewallRuleResponse> {
return this._withProvider(handle, (provider: sqlops.ResourceProvider) => provider.createFirewallRule(account, firewallRuleInfo));
}
public $handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<data.HandleFirewallRuleResponse> {
return this._withProvider(handle, (provider: data.ResourceProvider) => provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId));
public $handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<sqlops.HandleFirewallRuleResponse> {
return this._withProvider(handle, (provider: sqlops.ResourceProvider) => provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId));
}
// - EXTENSION HOST AVAILABLE METHODS //////////////////////////////////
public $registerResourceProvider(providerMetadata: data.ResourceProviderMetadata, provider: data.ResourceProvider): Disposable {
public $registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, provider: sqlops.ResourceProvider): Disposable {
let self = this;
// Look for any account providers that have the same provider ID
@@ -76,7 +76,7 @@ export class ExtHostResourceProvider extends ExtHostResourceProviderShape {
return this._handlePool++;
}
private _withProvider<R>(handle: number, callback: (provider: data.ResourceProvider) => Thenable<R>): Thenable<R> {
private _withProvider<R>(handle: number, callback: (provider: sqlops.ResourceProvider) => Thenable<R>): Thenable<R> {
let provider = this._providers[handle];
if (provider === undefined) {
return TPromise.wrapError(new Error(`Provider ${handle} not found.`));
@@ -86,8 +86,8 @@ export class ExtHostResourceProvider extends ExtHostResourceProviderShape {
}
interface ResourceProviderWithMetadata {
metadata: data.ResourceProviderMetadata;
provider: data.ResourceProvider;
metadata: sqlops.ResourceProviderMetadata;
provider: sqlops.ResourceProvider;
}

16
src/sql/workbench/api/node/extHostSerializationProvider.ts
View File

@@ -8,17 +8,17 @@ import { TPromise } from 'vs/base/common/winjs.base';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { SqlMainContext, MainThreadSerializationProviderShape, ExtHostSerializationProviderShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
import * as vscode from 'vscode';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { Disposable } from 'vs/workbench/api/node/extHostTypes';
class SerializationAdapter {
private _provider: data.SerializationProvider;
private _provider: sqlops.SerializationProvider;
constructor(provider: data.SerializationProvider) {
constructor(provider: sqlops.SerializationProvider) {
this._provider = provider;
}
public saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<data.SaveResultRequestResult> {
public saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> {
return this._provider.saveAs(saveFormat, savePath, results, appendToFile);
}
@@ -26,7 +26,7 @@ class SerializationAdapter {
type Adapter = SerializationAdapter;
export class ExtHostSerializationProvider extends ExtHostSerializationProviderShape {
export class ExtHostSerializationProvider extends ExtHostSerializationProviderShape {
private _proxy: MainThreadSerializationProviderShape;
@@ -44,7 +44,7 @@ export class ExtHostSerializationProvider extends ExtHostSerializationProviderSh
return ExtHostSerializationProvider._handlePool++;
}
private _withAdapter<A, R>(handle: number, ctor: { new (...args: any[]): A }, callback: (adapter: A) => Thenable<R>): Thenable<R> {
private _withAdapter<A, R>(handle: number, ctor: { new(...args: any[]): A }, callback: (adapter: A) => Thenable<R>): Thenable<R> {
let adapter = this._adapter[handle];
if (!(adapter instanceof ctor)) {
return TPromise.wrapError(new Error('no adapter found'));
@@ -59,14 +59,14 @@ export class ExtHostSerializationProvider extends ExtHostSerializationProviderSh
this._proxy = threadService.get(SqlMainContext.MainThreadSerializationProvider);
}
public $registerSerializationProvider(provider: data.SerializationProvider): vscode.Disposable {
public $registerSerializationProvider(provider: sqlops.SerializationProvider): vscode.Disposable {
provider.handle = this._nextHandle();
this._adapter[provider.handle] = new SerializationAdapter(provider);
this._proxy.$registerSerializationProvider(provider.handle);
return this._createDisposable(provider.handle);
}
public $saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<data.SaveResultRequestResult> {
public $saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> {
return this._withAdapter(0, SerializationAdapter, adapter => adapter.saveAs(saveFormat, savePath, results, appendToFile));
}

20
src/sql/workbench/api/node/mainThreadAccountManagement.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { TPromise } from 'vs/base/common/winjs.base';
import { IAccountManagementService } from 'sql/services/accountManagement/interfaces';
import { dispose, IDisposable } from 'vs/base/common/lifecycle';
@@ -19,7 +19,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostC
@extHostNamedCustomer(SqlMainContext.MainThreadAccountManagement)
export class MainThreadAccountManagement implements MainThreadAccountManagementShape {
private _providerMetadata: { [handle: number]: data.AccountProviderMetadata };
private _providerMetadata: { [handle: number]: sqlops.AccountProviderMetadata };
private _proxy: ExtHostAccountManagementShape;
private _toDispose: IDisposable[];
@@ -42,31 +42,31 @@ export class MainThreadAccountManagement implements MainThreadAccountManagementS
return this._accountManagementService.endAutoOAuthDeviceCode();
}
$accountUpdated(updatedAccount: data.Account): void {
$accountUpdated(updatedAccount: sqlops.Account): void {
this._accountManagementService.accountUpdated(updatedAccount);
}
public $registerAccountProvider(providerMetadata: data.AccountProviderMetadata, handle: number): Thenable<any> {
public $registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, handle: number): Thenable<any> {
let self = this;
// Create the account provider that interfaces with the extension via the proxy and register it
let accountProvider: data.AccountProvider = {
let accountProvider: sqlops.AccountProvider = {
autoOAuthCancelled(): Thenable<void> {
return self._proxy.$autoOAuthCancelled(handle);
},
clear(accountKey: data.AccountKey): Thenable<void> {
clear(accountKey: sqlops.AccountKey): Thenable<void> {
return self._proxy.$clear(handle, accountKey);
},
getSecurityToken(account: data.Account): Thenable<{}> {
getSecurityToken(account: sqlops.Account): Thenable<{}> {
return self._proxy.$getSecurityToken(handle, account);
},
initialize(restoredAccounts: data.Account[]): Thenable<data.Account[]> {
initialize(restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> {
return self._proxy.$initialize(handle, restoredAccounts);
},
prompt(): Thenable<data.Account> {
prompt(): Thenable<sqlops.Account> {
return self._proxy.$prompt(handle);
},
refresh(account: data.Account): Thenable<data.Account> {
refresh(account: sqlops.Account): Thenable<sqlops.Account> {
return self._proxy.$refresh(handle, account);
}
};

10
src/sql/workbench/api/node/mainThreadConnectionManagement.ts
View File

@@ -5,7 +5,7 @@
'use strict';
import { SqlExtHostContext, SqlMainContext, ExtHostConnectionManagementShape, MainThreadConnectionManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
@@ -37,11 +37,11 @@ export class MainThreadConnectionManagement implements MainThreadConnectionManag
this._toDispose = dispose(this._toDispose);
}
public $getActiveConnections(): Thenable<data.connection.Connection[]> {
public $getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
return Promise.resolve(this._connectionManagementService.getActiveConnections().map(profile => this.convertConnection(profile)));
}
public $getCurrentConnection(): Thenable<data.connection.Connection> {
public $getCurrentConnection(): Thenable<sqlops.connection.Connection> {
return Promise.resolve(this.convertConnection(TaskUtilities.getCurrentGlobalConnection(this._objectExplorerService, this._connectionManagementService, this._workbenchEditorService, true)));
}
@@ -49,12 +49,12 @@ export class MainThreadConnectionManagement implements MainThreadConnectionManag
return Promise.resolve(this._connectionManagementService.getActiveConnectionCredentials(connectionId));
}
private convertConnection(profile: IConnectionProfile): data.connection.Connection {
private convertConnection(profile: IConnectionProfile): sqlops.connection.Connection {
if (!profile) {
return undefined;
}
profile = this._connectionManagementService.removeConnectionProfileCredentials(profile);
let connection: data.connection.Connection = {
let connection: sqlops.connection.Connection = {
providerName: profile.providerName,
connectionId: profile.id,
options: profile.options

7
src/sql/workbench/api/node/mainThreadCredentialManagement.ts
View File

@@ -8,9 +8,10 @@ import { TPromise } from 'vs/base/common/winjs.base';
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import {
SqlExtHostContext, ExtHostCredentialManagementShape,
MainThreadCredentialManagementShape, SqlMainContext } from 'sql/workbench/api/node/sqlExtHost.protocol';
MainThreadCredentialManagementShape, SqlMainContext
} from 'sql/workbench/api/node/sqlExtHost.protocol';
import { ICredentialsService } from 'sql/services/credentials/credentialsService';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
@@ -43,7 +44,7 @@ export class MainThreadCredentialManagement implements MainThreadCredentialManag
onSaveCredential(credentialId: string, password: string): Thenable<boolean> {
return self._proxy.$saveCredential(credentialId, password);
},
onReadCredential(credentialId: string): Thenable<data.Credential> {
onReadCredential(credentialId: string): Thenable<sqlops.Credential> {
return self._proxy.$readCredential(credentialId);
},
onDeleteCredential(credentialId: string): Thenable<boolean> {

127
src/sql/workbench/api/node/mainThreadDataProtocol.ts
View File

@@ -13,7 +13,7 @@ import {
import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
import { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
import { IQueryManagementService } from 'sql/parts/query/common/queryManagement';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { IMetadataService } from 'sql/services/metadata/metadataService';
import { IObjectExplorerService } from 'sql/parts/registeredServer/common/objectExplorerService';
import { IScriptingService } from 'sql/services/scripting/scriptingService';
@@ -26,6 +26,8 @@ import { ISerializationService } from 'sql/services/serialization/serializationS
import { IFileBrowserService } from 'sql/parts/fileBrowser/common/interfaces';
import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
import { IMessageService } from 'vs/platform/message/common/message';
import severity from 'vs/base/common/severity';
/**
* Main thread class for handling data protocol management registration.
@@ -53,7 +55,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
@ITaskService private _taskService: ITaskService,
@IProfilerService private _profilerService: IProfilerService,
@ISerializationService private _serializationService: ISerializationService,
@IFileBrowserService private _fileBrowserService: IFileBrowserService
@IFileBrowserService private _fileBrowserService: IFileBrowserService,
@IMessageService private _messageService: IMessageService
) {
if (extHostContext) {
this._proxy = extHostContext.get(SqlExtHostContext.ExtHostDataProtocol);
@@ -69,8 +72,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerConnectionProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._connectionManagementService.registerProvider(providerId, <data.ConnectionProvider>{
connect(connectionUri: string, connectionInfo: data.ConnectionInfo): Thenable<boolean> {
this._connectionManagementService.registerProvider(providerId, <sqlops.ConnectionProvider>{
connect(connectionUri: string, connectionInfo: sqlops.ConnectionInfo): Thenable<boolean> {
return self._proxy.$connect(handle, connectionUri, connectionInfo);
},
disconnect(connectionUri: string): Thenable<boolean> {
@@ -82,7 +85,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
cancelConnect(connectionUri: string): Thenable<boolean> {
return self._proxy.$cancelConnect(handle, connectionUri);
},
listDatabases(connectionUri: string): Thenable<data.ListDatabasesResult> {
listDatabases(connectionUri: string): Thenable<sqlops.ListDatabasesResult> {
return self._proxy.$listDatabases(handle, connectionUri);
},
rebuildIntelliSenseCache(connectionUri: string): Thenable<void> {
@@ -96,10 +99,10 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerQueryProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._queryManagementService.addQueryRequestHandler(providerId, {
cancelQuery(ownerUri: string): Thenable<data.QueryCancelResult> {
cancelQuery(ownerUri: string): Thenable<sqlops.QueryCancelResult> {
return self._proxy.$cancelQuery(handle, ownerUri);
},
runQuery(ownerUri: string, selection: data.ISelectionData, runOptions?: data.ExecutionPlanOptions): Thenable<void> {
runQuery(ownerUri: string, selection: sqlops.ISelectionData, runOptions?: sqlops.ExecutionPlanOptions): Thenable<void> {
return self._proxy.$runQuery(handle, ownerUri, selection, runOptions);
},
runQueryStatement(ownerUri: string, line: number, column: number): Thenable<void> {
@@ -108,16 +111,16 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
runQueryString(ownerUri: string, queryString: string): Thenable<void> {
return self._proxy.$runQueryString(handle, ownerUri, queryString);
},
runQueryAndReturn(ownerUri: string, queryString: string): Thenable<data.SimpleExecuteResult> {
runQueryAndReturn(ownerUri: string, queryString: string): Thenable<sqlops.SimpleExecuteResult> {
return self._proxy.$runQueryAndReturn(handle, ownerUri, queryString);
},
getQueryRows(rowData: data.QueryExecuteSubsetParams): Thenable<data.QueryExecuteSubsetResult> {
getQueryRows(rowData: sqlops.QueryExecuteSubsetParams): Thenable<sqlops.QueryExecuteSubsetResult> {
return self._proxy.$getQueryRows(handle, rowData);
},
disposeQuery(ownerUri: string): Thenable<void> {
return self._proxy.$disposeQuery(handle, ownerUri);
},
saveResults(requestParams: data.SaveResultsRequestParams): Thenable<data.SaveResultRequestResult> {
saveResults(requestParams: sqlops.SaveResultsRequestParams): Thenable<sqlops.SaveResultRequestResult> {
let serializationProvider = self._serializationService.getSerializationFeatureMetadataProvider(requestParams.ownerUri);
if (serializationProvider && serializationProvider.enabled) {
return self._proxy.$saveResults(handle, requestParams);
@@ -132,13 +135,13 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
initializeEdit(ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number): Thenable<void> {
return self._proxy.$initializeEdit(handle, ownerUri, schemaName, objectName, objectType, rowLimit);
},
updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<data.EditUpdateCellResult> {
updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<sqlops.EditUpdateCellResult> {
return self._proxy.$updateCell(handle, ownerUri, rowId, columnId, newValue);
},
commitEdit(ownerUri): Thenable<void> {
return self._proxy.$commitEdit(handle, ownerUri);
},
createRow(ownerUri: string): Thenable<data.EditCreateRowResult> {
createRow(ownerUri: string): Thenable<sqlops.EditCreateRowResult> {
return self._proxy.$createRow(handle, ownerUri);
},
deleteRow(ownerUri: string, rowId: number): Thenable<void> {
@@ -147,13 +150,13 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
disposeEdit(ownerUri: string): Thenable<void> {
return self._proxy.$disposeEdit(handle, ownerUri);
},
revertCell(ownerUri: string, rowId: number, columnId: number): Thenable<data.EditRevertCellResult> {
revertCell(ownerUri: string, rowId: number, columnId: number): Thenable<sqlops.EditRevertCellResult> {
return self._proxy.$revertCell(handle, ownerUri, rowId, columnId);
},
revertRow(ownerUri: string, rowId: number): Thenable<void> {
return self._proxy.$revertRow(handle, ownerUri, rowId);
},
getEditRows(rowData: data.EditSubsetParams): Thenable<data.EditSubsetResult> {
getEditRows(rowData: sqlops.EditSubsetParams): Thenable<sqlops.EditSubsetResult> {
return self._proxy.$getEditRows(handle, rowData);
}
});
@@ -163,11 +166,11 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerBackupProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._backupService.registerProvider(providerId, <data.BackupProvider>{
backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse> {
this._backupService.registerProvider(providerId, <sqlops.BackupProvider>{
backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.BackupResponse> {
return self._proxy.$backup(handle, connectionUri, backupInfo, taskExecutionMode);
},
getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo> {
getBackupConfigInfo(connectionUri: string): Thenable<sqlops.BackupConfigInfo> {
return self._proxy.$getBackupConfigInfo(handle, connectionUri);
}
});
@@ -177,17 +180,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerRestoreProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._restoreService.registerProvider(providerId, <data.RestoreProvider>{
getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
this._restoreService.registerProvider(providerId, <sqlops.RestoreProvider>{
getRestorePlan(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestorePlanResponse> {
return self._proxy.$getRestorePlan(handle, connectionUri, restoreInfo);
},
cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
cancelRestorePlan(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<boolean> {
return self._proxy.$cancelRestorePlan(handle, connectionUri, restoreInfo);
},
restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
restore(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestoreResponse> {
return self._proxy.$restore(handle, connectionUri, restoreInfo);
},
getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo> {
getRestoreConfigInfo(connectionUri: string): Thenable<sqlops.RestoreConfigInfo> {
return self._proxy.$getRestoreConfigInfo(handle, connectionUri);
}
});
@@ -197,17 +200,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerMetadataProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._metadataService.registerProvider(providerId, <data.MetadataProvider>{
getMetadata(connectionUri: string): Thenable<data.ProviderMetadata> {
this._metadataService.registerProvider(providerId, <sqlops.MetadataProvider>{
getMetadata(connectionUri: string): Thenable<sqlops.ProviderMetadata> {
return self._proxy.$getMetadata(handle, connectionUri);
},
getDatabases(connectionUri: string): Thenable<string[]> {
return self._proxy.$getDatabases(handle, connectionUri);
},
getTableInfo(connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
getTableInfo(connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
return self._proxy.$getTableInfo(handle, connectionUri, metadata);
},
getViewInfo(connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
getViewInfo(connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
return self._proxy.$getViewInfo(handle, connectionUri, metadata);
}
});
@@ -217,17 +220,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerObjectExplorerProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._objectExplorerService.registerProvider(providerId, <data.ObjectExplorerProvider>{
createNewSession(connection: data.ConnectionInfo): Thenable<data.ObjectExplorerSessionResponse> {
this._objectExplorerService.registerProvider(providerId, <sqlops.ObjectExplorerProvider>{
createNewSession(connection: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerSessionResponse> {
return self._proxy.$createObjectExplorerSession(handle, connection);
},
expandNode(nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
expandNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
return self._proxy.$expandObjectExplorerNode(handle, nodeInfo);
},
refreshNode(nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
refreshNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
return self._proxy.$refreshObjectExplorerNode(handle, nodeInfo);
},
closeSession(closeSessionInfo: data.ObjectExplorerCloseSessionInfo): Thenable<data.ObjectExplorerCloseSessionResponse> {
closeSession(closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> {
return self._proxy.$closeObjectExplorerSession(handle, closeSessionInfo);
}
});
@@ -237,11 +240,11 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerTaskServicesProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._taskService.registerProvider(providerId, <data.TaskServicesProvider>{
getAllTasks(listTasksParams: data.ListTasksParams): Thenable<data.ListTasksResponse> {
this._taskService.registerProvider(providerId, <sqlops.TaskServicesProvider>{
getAllTasks(listTasksParams: sqlops.ListTasksParams): Thenable<sqlops.ListTasksResponse> {
return self._proxy.$getAllTasks(handle, listTasksParams);
},
cancelTask(cancelTaskParams: data.CancelTaskParams): Thenable<boolean> {
cancelTask(cancelTaskParams: sqlops.CancelTaskParams): Thenable<boolean> {
return self._proxy.$cancelTask(handle, cancelTaskParams);
}
});
@@ -251,8 +254,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerScriptingProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._scriptingService.registerProvider(providerId, <data.ScriptingProvider>{
scriptAsOperation(connectionUri: string, operation: data.ScriptOperation, metadata: data.ObjectMetadata, paramDetails: data.ScriptingParamDetails): Thenable<data.ScriptingResult> {
this._scriptingService.registerProvider(providerId, <sqlops.ScriptingProvider>{
scriptAsOperation(connectionUri: string, operation: sqlops.ScriptOperation, metadata: sqlops.ObjectMetadata, paramDetails: sqlops.ScriptingParamDetails): Thenable<sqlops.ScriptingResult> {
return self._proxy.$scriptAsOperation(handle, connectionUri, operation, metadata, paramDetails);
}
});
@@ -262,7 +265,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerFileBrowserProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._fileBrowserService.registerProvider(providerId, <data.FileBrowserProvider>{
this._fileBrowserService.registerProvider(providerId, <sqlops.FileBrowserProvider>{
openFileBrowser(ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
return self._proxy.$openFileBrowser(handle, ownerUri, expandPath, fileFilters, changeFilter);
},
@@ -272,7 +275,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
validateFilePaths(ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean> {
return self._proxy.$validateFilePaths(handle, ownerUri, serviceType, selectedFiles);
},
closeFileBrowser(ownerUri: string): Thenable<data.FileBrowserCloseResponse> {
closeFileBrowser(ownerUri: string): Thenable<sqlops.FileBrowserCloseResponse> {
return self._proxy.$closeFileBrowser(handle, ownerUri);
}
});
@@ -282,7 +285,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerProfilerProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._profilerService.registerProvider(providerId, <data.ProfilerProvider>{
this._profilerService.registerProvider(providerId, <sqlops.ProfilerProvider>{
startSession(sessionId: string): Thenable<boolean> {
return self._proxy.$startSession(handle, sessionId);
},
@@ -305,17 +308,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerAdminServicesProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._adminService.registerProvider(providerId, <data.AdminServicesProvider>{
createDatabase(connectionUri: string, database: data.DatabaseInfo): Thenable<data.CreateDatabaseResponse> {
this._adminService.registerProvider(providerId, <sqlops.AdminServicesProvider>{
createDatabase(connectionUri: string, database: sqlops.DatabaseInfo): Thenable<sqlops.CreateDatabaseResponse> {
return self._proxy.$createDatabase(handle, connectionUri, database);
},
getDefaultDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
getDefaultDatabaseInfo(connectionUri: string): Thenable<sqlops.DatabaseInfo> {
return self._proxy.$getDefaultDatabaseInfo(handle, connectionUri);
},
getDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
getDatabaseInfo(connectionUri: string): Thenable<sqlops.DatabaseInfo> {
return self._proxy.$getDatabaseInfo(handle, connectionUri);
},
createLogin(connectionUri: string, login: data.LoginInfo): Thenable<data.CreateLoginResponse> {
createLogin(connectionUri: string, login: sqlops.LoginInfo): Thenable<sqlops.CreateLoginResponse> {
return self._proxy.$createLogin(handle, connectionUri, login);
}
});
@@ -325,8 +328,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerCapabilitiesServiceProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._capabilitiesService.registerProvider(<data.CapabilitiesProvider>{
getServerCapabilities(client: data.DataProtocolClientCapabilities): Thenable<data.DataProtocolServerCapabilities> {
this._capabilitiesService.registerProvider(<sqlops.CapabilitiesProvider>{
getServerCapabilities(client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> {
return self._proxy.$getServerCapabilities(handle, client);
}
});
@@ -335,7 +338,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
}
// Connection Management handlers
public $onConnectionComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void {
public $onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void {
this._connectionManagementService.onConnectionComplete(handle, connectionInfoSummary);
}
@@ -343,24 +346,24 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
this._connectionManagementService.onIntelliSenseCacheComplete(handle, connectionUri);
}
public $onConnectionChangeNotification(handle: number, changedConnInfo: data.ChangedConnectionInfo): void {
public $onConnectionChangeNotification(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void {
this._connectionManagementService.onConnectionChangedNotification(handle, changedConnInfo);
}
// Query Management handlers
public $onQueryComplete(handle: number, result: data.QueryExecuteCompleteNotificationResult): void {
public $onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void {
this._queryManagementService.onQueryComplete(result);
}
public $onBatchStart(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void {
public $onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
this._queryManagementService.onBatchStart(batchInfo);
}
public $onBatchComplete(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void {
public $onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
this._queryManagementService.onBatchComplete(batchInfo);
}
public $onResultSetComplete(handle: number, resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams): void {
public $onResultSetComplete(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetCompleteNotificationParams): void {
this._queryManagementService.onResultSetComplete(resultSetInfo);
}
public $onQueryMessage(handle: number, message: data.QueryExecuteMessageParams): void {
public $onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void {
this._queryManagementService.onMessage(message);
}
public $onEditSessionReady(handle: number, ownerUri: string, success: boolean, message: string): void {
@@ -368,43 +371,43 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
}
// Script Handlers
public $onScriptingComplete(handle: number, scriptingCompleteResult: data.ScriptingCompleteResult): void {
public $onScriptingComplete(handle: number, scriptingCompleteResult: sqlops.ScriptingCompleteResult): void {
this._scriptingService.onScriptingComplete(handle, scriptingCompleteResult);
}
//OE handlers
public $onObjectExplorerSessionCreated(handle: number, sessionResponse: data.ObjectExplorerSession): void {
public $onObjectExplorerSessionCreated(handle: number, sessionResponse: sqlops.ObjectExplorerSession): void {
this._objectExplorerService.onSessionCreated(handle, sessionResponse);
}
public $onObjectExplorerNodeExpanded(handle: number, expandResponse: data.ObjectExplorerExpandInfo): void {
public $onObjectExplorerNodeExpanded(handle: number, expandResponse: sqlops.ObjectExplorerExpandInfo): void {
this._objectExplorerService.onNodeExpanded(handle, expandResponse);
}
//Tasks handlers
public $onTaskCreated(handle: number, taskInfo: data.TaskInfo): void {
public $onTaskCreated(handle: number, taskInfo: sqlops.TaskInfo): void {
this._taskService.onNewTaskCreated(handle, taskInfo);
}
public $onTaskStatusChanged(handle: number, taskProgressInfo: data.TaskProgressInfo): void {
public $onTaskStatusChanged(handle: number, taskProgressInfo: sqlops.TaskProgressInfo): void {
this._taskService.onTaskStatusChanged(handle, taskProgressInfo);
}
//File browser handlers
public $onFileBrowserOpened(handle: number, response: data.FileBrowserOpenedParams): void {
public $onFileBrowserOpened(handle: number, response: sqlops.FileBrowserOpenedParams): void {
this._fileBrowserService.onFileBrowserOpened(handle, response);
}
public $onFolderNodeExpanded(handle: number, response: data.FileBrowserExpandedParams): void {
public $onFolderNodeExpanded(handle: number, response: sqlops.FileBrowserExpandedParams): void {
this._fileBrowserService.onFolderNodeExpanded(handle, response);
}
public $onFilePathsValidated(handle: number, response: data.FileBrowserValidatedParams): void {
public $onFilePathsValidated(handle: number, response: sqlops.FileBrowserValidatedParams): void {
this._fileBrowserService.onFilePathsValidated(handle, response);
}
// Profiler handlers
public $onSessionEventsAvailable(handle: number, response: data.ProfilerSessionEvents): void {
public $onSessionEventsAvailable(handle: number, response: sqlops.ProfilerSessionEvents): void {
this._profilerService.onMoreRows(response);
}

16
src/sql/workbench/api/node/mainThreadResourceProvider.ts
View File

@@ -4,10 +4,10 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as data from 'data';
import {TPromise} from 'vs/base/common/winjs.base';
import * as sqlops from 'sqlops';
import { TPromise } from 'vs/base/common/winjs.base';
import { IResourceProviderService } from 'sql/parts/accountManagement/common/interfaces';
import {dispose, IDisposable} from 'vs/base/common/lifecycle';
import { dispose, IDisposable } from 'vs/base/common/lifecycle';
import {
ExtHostResourceProviderShape,
MainThreadResourceProviderShape,
@@ -20,7 +20,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostC
@extHostNamedCustomer(SqlMainContext.MainThreadResourceProvider)
export class MainThreadResourceProvider implements MainThreadResourceProviderShape {
private _providerMetadata: {[handle: number]: data.AccountProviderMetadata};
private _providerMetadata: { [handle: number]: sqlops.AccountProviderMetadata };
private _proxy: ExtHostResourceProviderShape;
private _toDispose: IDisposable[];
@@ -35,15 +35,15 @@ export class MainThreadResourceProvider implements MainThreadResourceProviderSha
this._toDispose = [];
}
public $registerResourceProvider(providerMetadata: data.ResourceProviderMetadata, handle: number): Thenable<any> {
public $registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, handle: number): Thenable<any> {
let self = this;
// Create the account provider that interfaces with the extension via the proxy and register it
let resourceProvider: data.ResourceProvider = {
createFirewallRule(account: data.Account, firewallruleInfo: data.FirewallRuleInfo): Thenable<data.CreateFirewallRuleResponse> {
let resourceProvider: sqlops.ResourceProvider = {
createFirewallRule(account: sqlops.Account, firewallruleInfo: sqlops.FirewallRuleInfo): Thenable<sqlops.CreateFirewallRuleResponse> {
return self._proxy.$createFirewallRule(handle, account, firewallruleInfo);
},
handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<data.HandleFirewallRuleResponse> {
handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<sqlops.HandleFirewallRuleResponse> {
return self._proxy.$handleFirewallRule(handle, errorCode, errorMessage, connectionTypeId);
}
};

8
src/sql/workbench/api/node/mainThreadSerializationProvider.ts
View File

@@ -6,12 +6,12 @@
import { TPromise } from 'vs/base/common/winjs.base';
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import {
SqlExtHostContext, ExtHostSerializationProviderShape,
MainThreadSerializationProviderShape, SqlMainContext } from 'sql/workbench/api/node/sqlExtHost.protocol';
MainThreadSerializationProviderShape, SqlMainContext
} from 'sql/workbench/api/node/sqlExtHost.protocol';
import { ISerializationService } from 'sql/services/serialization/serializationService';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
@@ -42,7 +42,7 @@ export class MainThreadSerializationProvider implements MainThreadSerializationP
let self = this;
this._registrations[handle] = this.serializationService.addEventListener(handle, {
onSaveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<data.SaveResultRequestResult> {
onSaveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> {
return self._proxy.$saveAs(saveFormat, savePath, results, appendToFile);
}
});

106
src/sql/workbench/api/node/sqlExtHost.api.impl.ts
View File

@@ -13,7 +13,7 @@ import { IExtensionDescription } from 'vs/platform/extensions/common/extensions'
import { realpath } from 'fs';
import * as extHostTypes from 'vs/workbench/api/node/extHostTypes';
import * as data from 'data';
import * as sqlops from 'sqlops';
import * as vscode from 'vscode';
import { SqlExtHostContext } from 'sql/workbench/api/node/sqlExtHost.protocol';
import { ExtHostAccountManagement } from 'sql/workbench/api/node/extHostAccountManagement';
@@ -33,7 +33,7 @@ import { ExtHostConnectionManagement } from 'sql/workbench/api/node/extHostConne
export interface ISqlExtensionApiFactory {
vsCodeFactory(extension: IExtensionDescription): typeof vscode;
dataFactory(extension: IExtensionDescription): typeof data;
sqlopsFactory(extension: IExtensionDescription): typeof sqlops;
}
/**
@@ -61,10 +61,10 @@ export function createApiFactory(
return {
vsCodeFactory: vsCodeFactory,
dataFactory: function (extension: IExtensionDescription): typeof data {
sqlopsFactory: function (extension: IExtensionDescription): typeof sqlops {
// namespace: accounts
const accounts: typeof data.accounts = {
registerAccountProvider(providerMetadata: data.AccountProviderMetadata, provider: data.AccountProvider): vscode.Disposable {
const accounts: typeof sqlops.accounts = {
registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, provider: sqlops.AccountProvider): vscode.Disposable {
return extHostAccountManagement.$registerAccountProvider(providerMetadata, provider);
},
beginAutoOAuthDeviceCode(providerId: string, title: string, message: string, userCode: string, uri: string): Thenable<void> {
@@ -73,17 +73,17 @@ export function createApiFactory(
endAutoOAuthDeviceCode(): void {
return extHostAccountManagement.$endAutoOAuthDeviceCode();
},
accountUpdated(updatedAccount: data.Account): void {
accountUpdated(updatedAccount: sqlops.Account): void {
return extHostAccountManagement.$accountUpdated(updatedAccount);
}
};
// namespace: connection
const connection: typeof data.connection = {
getActiveConnections(): Thenable<data.connection.Connection[]> {
const connection: typeof sqlops.connection = {
getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
return extHostConnectionManagement.$getActiveConnections();
},
getCurrentConnection(): Thenable<data.connection.Connection> {
getCurrentConnection(): Thenable<sqlops.connection.Connection> {
return extHostConnectionManagement.$getCurrentConnection();
},
getCredentials(connectionId: string): Thenable<{ [name: string]: string }> {
@@ -92,32 +92,32 @@ export function createApiFactory(
};
// namespace: credentials
const credentials: typeof data.credentials = {
registerProvider(provider: data.CredentialProvider): vscode.Disposable {
const credentials: typeof sqlops.credentials = {
registerProvider(provider: sqlops.CredentialProvider): vscode.Disposable {
return extHostCredentialManagement.$registerCredentialProvider(provider);
},
getProvider(namespaceId: string): Thenable<data.CredentialProvider> {
getProvider(namespaceId: string): Thenable<sqlops.CredentialProvider> {
return extHostCredentialManagement.$getCredentialProvider(namespaceId);
}
};
// namespace: serialization
const serialization: typeof data.serialization = {
registerProvider(provider: data.SerializationProvider): vscode.Disposable {
const serialization: typeof sqlops.serialization = {
registerProvider(provider: sqlops.SerializationProvider): vscode.Disposable {
return extHostSerializationProvider.$registerSerializationProvider(provider);
},
};
// namespace: serialization
const resources: typeof data.resources = {
registerResourceProvider(providerMetadata: data.ResourceProviderMetadata, provider: data.ResourceProvider): vscode.Disposable {
const resources: typeof sqlops.resources = {
registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, provider: sqlops.ResourceProvider): vscode.Disposable {
return extHostResourceProvider.$registerResourceProvider(providerMetadata, provider);
}
};
let registerConnectionProvider = (provider: data.ConnectionProvider): vscode.Disposable => {
let registerConnectionProvider = (provider: sqlops.ConnectionProvider): vscode.Disposable => {
// Connection callbacks
provider.registerOnConnectionComplete((connSummary: data.ConnectionInfoSummary) => {
provider.registerOnConnectionComplete((connSummary: sqlops.ConnectionInfoSummary) => {
extHostDataProvider.$onConnectComplete(provider.handle, connSummary);
});
@@ -125,31 +125,31 @@ export function createApiFactory(
extHostDataProvider.$onIntelliSenseCacheComplete(provider.handle, connectionUri);
});
provider.registerOnConnectionChanged((changedConnInfo: data.ChangedConnectionInfo) => {
provider.registerOnConnectionChanged((changedConnInfo: sqlops.ChangedConnectionInfo) => {
extHostDataProvider.$onConnectionChanged(provider.handle, changedConnInfo);
});
return extHostDataProvider.$registerConnectionProvider(provider);
};
let registerQueryProvider = (provider: data.QueryProvider): vscode.Disposable => {
provider.registerOnQueryComplete((result: data.QueryExecuteCompleteNotificationResult) => {
let registerQueryProvider = (provider: sqlops.QueryProvider): vscode.Disposable => {
provider.registerOnQueryComplete((result: sqlops.QueryExecuteCompleteNotificationResult) => {
extHostDataProvider.$onQueryComplete(provider.handle, result);
});
provider.registerOnBatchStart((batchInfo: data.QueryExecuteBatchNotificationParams) => {
provider.registerOnBatchStart((batchInfo: sqlops.QueryExecuteBatchNotificationParams) => {
extHostDataProvider.$onBatchStart(provider.handle, batchInfo);
});
provider.registerOnBatchComplete((batchInfo: data.QueryExecuteBatchNotificationParams) => {
provider.registerOnBatchComplete((batchInfo: sqlops.QueryExecuteBatchNotificationParams) => {
extHostDataProvider.$onBatchComplete(provider.handle, batchInfo);
});
provider.registerOnResultSetComplete((resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams) => {
provider.registerOnResultSetComplete((resultSetInfo: sqlops.QueryExecuteResultSetCompleteNotificationParams) => {
extHostDataProvider.$onResultSetComplete(provider.handle, resultSetInfo);
});
provider.registerOnMessage((message: data.QueryExecuteMessageParams) => {
provider.registerOnMessage((message: sqlops.QueryExecuteMessageParams) => {
extHostDataProvider.$onQueryMessage(provider.handle, message);
});
@@ -160,84 +160,84 @@ export function createApiFactory(
return extHostDataProvider.$registerQueryProvider(provider);
};
let registerObjectExplorerProvider = (provider: data.ObjectExplorerProvider): vscode.Disposable => {
provider.registerOnSessionCreated((response: data.ObjectExplorerSession) => {
let registerObjectExplorerProvider = (provider: sqlops.ObjectExplorerProvider): vscode.Disposable => {
provider.registerOnSessionCreated((response: sqlops.ObjectExplorerSession) => {
extHostDataProvider.$onObjectExplorerSessionCreated(provider.handle, response);
});
provider.registerOnExpandCompleted((response: data.ObjectExplorerExpandInfo) => {
provider.registerOnExpandCompleted((response: sqlops.ObjectExplorerExpandInfo) => {
extHostDataProvider.$onObjectExplorerNodeExpanded(provider.handle, response);
});
return extHostDataProvider.$registerObjectExplorerProvider(provider);
};
let registerTaskServicesProvider = (provider: data.TaskServicesProvider): vscode.Disposable => {
provider.registerOnTaskCreated((response: data.TaskInfo) => {
let registerTaskServicesProvider = (provider: sqlops.TaskServicesProvider): vscode.Disposable => {
provider.registerOnTaskCreated((response: sqlops.TaskInfo) => {
extHostDataProvider.$onTaskCreated(provider.handle, response);
});
provider.registerOnTaskStatusChanged((response: data.TaskProgressInfo) => {
provider.registerOnTaskStatusChanged((response: sqlops.TaskProgressInfo) => {
extHostDataProvider.$onTaskStatusChanged(provider.handle, response);
});
return extHostDataProvider.$registerTaskServicesProvider(provider);
};
let registerFileBrowserProvider = (provider: data.FileBrowserProvider): vscode.Disposable => {
provider.registerOnFileBrowserOpened((response: data.FileBrowserOpenedParams) => {
let registerFileBrowserProvider = (provider: sqlops.FileBrowserProvider): vscode.Disposable => {
provider.registerOnFileBrowserOpened((response: sqlops.FileBrowserOpenedParams) => {
extHostDataProvider.$onFileBrowserOpened(provider.handle, response);
});
provider.registerOnFolderNodeExpanded((response: data.FileBrowserExpandedParams) => {
provider.registerOnFolderNodeExpanded((response: sqlops.FileBrowserExpandedParams) => {
extHostDataProvider.$onFolderNodeExpanded(provider.handle, response);
});
provider.registerOnFilePathsValidated((response: data.FileBrowserValidatedParams) => {
provider.registerOnFilePathsValidated((response: sqlops.FileBrowserValidatedParams) => {
extHostDataProvider.$onFilePathsValidated(provider.handle, response);
});
return extHostDataProvider.$registerFileBrowserProvider(provider);
};
let registerScriptingProvider = (provider: data.ScriptingProvider): vscode.Disposable => {
provider.registerOnScriptingComplete((response: data.ScriptingCompleteResult) => {
let registerScriptingProvider = (provider: sqlops.ScriptingProvider): vscode.Disposable => {
provider.registerOnScriptingComplete((response: sqlops.ScriptingCompleteResult) => {
extHostDataProvider.$onScriptingComplete(provider.handle, response);
});
return extHostDataProvider.$registerScriptingProvider(provider);
};
let registerProfilerProvider = (provider: data.ProfilerProvider): vscode.Disposable => {
provider.registerOnSessionEventsAvailable((response: data.ProfilerSessionEvents) => {
let registerProfilerProvider = (provider: sqlops.ProfilerProvider): vscode.Disposable => {
provider.registerOnSessionEventsAvailable((response: sqlops.ProfilerSessionEvents) => {
extHostDataProvider.$onSessionEventsAvailable(provider.handle, response);
});
return extHostDataProvider.$registerProfilerProvider(provider);
};
let registerBackupProvider = (provider: data.BackupProvider): vscode.Disposable => {
let registerBackupProvider = (provider: sqlops.BackupProvider): vscode.Disposable => {
return extHostDataProvider.$registerBackupProvider(provider);
};
let registerRestoreProvider = (provider: data.RestoreProvider): vscode.Disposable => {
let registerRestoreProvider = (provider: sqlops.RestoreProvider): vscode.Disposable => {
return extHostDataProvider.$registerRestoreProvider(provider);
};
let registerMetadataProvider = (provider: data.MetadataProvider): vscode.Disposable => {
let registerMetadataProvider = (provider: sqlops.MetadataProvider): vscode.Disposable => {
return extHostDataProvider.$registerMetadataProvider(provider);
};
let registerCapabilitiesServiceProvider = (provider: data.CapabilitiesProvider): vscode.Disposable => {
let registerCapabilitiesServiceProvider = (provider: sqlops.CapabilitiesProvider): vscode.Disposable => {
return extHostDataProvider.$registerCapabilitiesServiceProvider(provider);
};
let registerAdminServicesProvider = (provider: data.AdminServicesProvider): vscode.Disposable => {
let registerAdminServicesProvider = (provider: sqlops.AdminServicesProvider): vscode.Disposable => {
return extHostDataProvider.$registerAdminServicesProvider(provider);
};
// namespace: dataprotocol
const dataprotocol: typeof data.dataprotocol = {
const dataprotocol: typeof sqlops.dataprotocol = {
registerBackupProvider,
registerConnectionProvider,
registerFileBrowserProvider,
@@ -250,7 +250,7 @@ export function createApiFactory(
registerQueryProvider,
registerAdminServicesProvider,
registerCapabilitiesServiceProvider,
onDidChangeLanguageFlavor(listener: (e: data.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
onDidChangeLanguageFlavor(listener: (e: sqlops.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
return extHostDataProvider.onDidChangeLanguageFlavor(listener, thisArgs, disposables);
}
};
@@ -262,7 +262,7 @@ export function createApiFactory(
};
const dashboard = {
registerWebviewProvider(widgetId: string, handler: (webview: data.DashboardWebview) => void) {
registerWebviewProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void) {
extHostWebviewWidgets.$registerProvider(widgetId, handler);
}
};
@@ -316,13 +316,13 @@ function createExtensionPathIndex(extensionService: ExtHostExtensionService): TP
}
function defineAPI(factory: ISqlExtensionApiFactory, extensionPaths: TrieMap<IExtensionDescription>): void {
type ApiImpl = typeof vscode | typeof data;
type ApiImpl = typeof vscode | typeof sqlops;
// each extension is meant to get its own api implementation
const extApiImpl = new Map<string, typeof vscode>();
const dataExtApiImpl = new Map<string, typeof data>();
const dataExtApiImpl = new Map<string, typeof sqlops>();
let defaultApiImpl: typeof vscode;
let defaultDataApiImpl: typeof data;
let defaultDataApiImpl: typeof sqlops;
// The module factory looks for an entry in the API map for an extension. If found, it reuses this.
// If not, it loads it & saves it in the map
@@ -360,11 +360,11 @@ function defineAPI(factory: ISqlExtensionApiFactory, extensionPaths: TrieMap<IEx
defaultApiImpl,
(impl) => defaultApiImpl = <typeof vscode>impl,
parent);
} else if (request === 'data') {
} else if (request === 'sqlops') {
return getModuleFactory(dataExtApiImpl,
(ext) => factory.dataFactory(ext),
(ext) => factory.sqlopsFactory(ext),
defaultDataApiImpl,
(impl) => defaultDataApiImpl = <typeof data>impl,
(impl) => defaultDataApiImpl = <typeof sqlops>impl,
parent);
} else {
// Allow standard node_module load to occur

148
src/sql/workbench/api/node/sqlExtHost.protocol.ts
View File

@@ -7,21 +7,21 @@
import {
createMainContextProxyIdentifier as createMainId,
createExtHostContextProxyIdentifier as createExtId,
ProxyIdentifier, IThreadService
ProxyIdentifier
} from 'vs/workbench/services/thread/common/threadService';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { TPromise } from 'vs/base/common/winjs.base';
import { IDisposable } from 'vs/base/common/lifecycle';
export abstract class ExtHostAccountManagementShape {
$autoOAuthCancelled(handle: number): Thenable<void> { throw ni(); }
$clear(handle: number, accountKey: data.AccountKey): Thenable<void> { throw ni(); }
$getSecurityToken(handle: number, account: data.Account): Thenable<{}> { throw ni(); }
$initialize(handle: number, restoredAccounts: data.Account[]): Thenable<data.Account[]> { throw ni(); }
$prompt(handle: number): Thenable<data.Account> { throw ni(); }
$refresh(handle: number, account: data.Account): Thenable<data.Account> { throw ni(); }
$clear(handle: number, accountKey: sqlops.AccountKey): Thenable<void> { throw ni(); }
$getSecurityToken(handle: number, account: sqlops.Account): Thenable<{}> { throw ni(); }
$initialize(handle: number, restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> { throw ni(); }
$prompt(handle: number): Thenable<sqlops.Account> { throw ni(); }
$refresh(handle: number, account: sqlops.Account): Thenable<sqlops.Account> { throw ni(); }
}
export abstract class ExtHostConnectionManagementShape { }
@@ -31,7 +31,7 @@ export abstract class ExtHostDataProtocolShape {
/**
* Establish a connection to a data source using the provided ConnectionInfo instance.
*/
$connect(handle: number, connectionUri: string, connection: data.ConnectionInfo): Thenable<boolean> { throw ni(); }
$connect(handle: number, connectionUri: string, connection: sqlops.ConnectionInfo): Thenable<boolean> { throw ni(); }
/**
* Disconnect from a data source using the provided connectionUri string.
@@ -53,7 +53,7 @@ export abstract class ExtHostDataProtocolShape {
* @param handle the handle to use when looking up a provider
* @param connectionUri URI identifying a connected resource
*/
$listDatabases(handle: number, connectionUri: string): Thenable<data.ListDatabasesResult> { throw ni(); }
$listDatabases(handle: number, connectionUri: string): Thenable<sqlops.ListDatabasesResult> { throw ni(); }
/**
* Notifies all listeners on the Extension Host side that a language change occurred
@@ -61,63 +61,63 @@ export abstract class ExtHostDataProtocolShape {
* and other events
* @param params information on what URI was changed and the new language
*/
$languageFlavorChanged(params: data.DidChangeLanguageFlavorParams): void { throw ni(); }
$languageFlavorChanged(params: sqlops.DidChangeLanguageFlavorParams): void { throw ni(); }
/**
* Callback when a connection request has completed
*/
$onConnectComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void { throw ni(); }
$onConnectComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void { throw ni(); }
/**
* Callback when a IntelliSense cache has been built
*/
$onIntelliSenseCacheComplete(handle: number, connectionUri: string): void { throw ni(); }
$getServerCapabilities(handle: number, client: data.DataProtocolClientCapabilities): Thenable<data.DataProtocolServerCapabilities> { throw ni(); }
$getServerCapabilities(handle: number, client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> { throw ni(); }
/**
* Metadata service methods
*
*/
$getMetadata(handle: number, connectionUri: string): Thenable<data.ProviderMetadata> { throw ni(); }
$getMetadata(handle: number, connectionUri: string): Thenable<sqlops.ProviderMetadata> { throw ni(); }
$getDatabases(handle: number, connectionUri: string): Thenable<string[]> { throw ni(); }
$getTableInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> { throw ni(); }
$getTableInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> { throw ni(); }
$getViewInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> { throw ni(); }
$getViewInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> { throw ni(); }
/**
* Object Explorer
*/
$createObjectExplorerSession(handle: number, connInfo: data.ConnectionInfo): Thenable<data.ObjectExplorerSessionResponse> { throw ni(); }
$createObjectExplorerSession(handle: number, connInfo: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerSessionResponse> { throw ni(); }
$expandObjectExplorerNode(handle: number, nodeInfo: data.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
$expandObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
$refreshObjectExplorerNode(handle: number, nodeInfo: data.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
$refreshObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
$closeObjectExplorerSession(handle: number, closeSessionInfo: data.ObjectExplorerCloseSessionInfo): Thenable<data.ObjectExplorerCloseSessionResponse> { throw ni(); }
$closeObjectExplorerSession(handle: number, closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> { throw ni(); }
/**
* Tasks
*/
$getAllTasks(handle: number, listTasksParams: data.ListTasksParams): Thenable<data.ListTasksResponse> { throw ni(); }
$cancelTask(handle: number, cancelTaskParams: data.CancelTaskParams): Thenable<boolean> { throw ni(); }
$getAllTasks(handle: number, listTasksParams: sqlops.ListTasksParams): Thenable<sqlops.ListTasksResponse> { throw ni(); }
$cancelTask(handle: number, cancelTaskParams: sqlops.CancelTaskParams): Thenable<boolean> { throw ni(); }
/**
* Scripting methods
*/
$scriptAsOperation(handle: number, connectionUri: string, operation: data.ScriptOperation, metadata: data.ObjectMetadata, paramDetails: data.ScriptingParamDetails): Thenable<data.ScriptingResult> { throw ni(); }
$scriptAsOperation(handle: number, connectionUri: string, operation: sqlops.ScriptOperation, metadata: sqlops.ObjectMetadata, paramDetails: sqlops.ScriptingParamDetails): Thenable<sqlops.ScriptingResult> { throw ni(); }
/**
* Cancels the currently running query for a URI
*/
$cancelQuery(handle: number, ownerUri: string): Thenable<data.QueryCancelResult> { throw ni(); }
$cancelQuery(handle: number, ownerUri: string): Thenable<sqlops.QueryCancelResult> { throw ni(); }
/**
* Runs a query for a text selection inside a document
*/
$runQuery(handle: number, ownerUri: string, selection: data.ISelectionData, runOptions?: data.ExecutionPlanOptions): Thenable<void> { throw ni(); }
$runQuery(handle: number, ownerUri: string, selection: sqlops.ISelectionData, runOptions?: sqlops.ExecutionPlanOptions): Thenable<void> { throw ni(); }
/**
* Runs the current SQL statement query for a text document
*/
@@ -129,11 +129,11 @@ export abstract class ExtHostDataProtocolShape {
/**
* Runs a query for a provided query and returns result
*/
$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<data.SimpleExecuteResult> { throw ni(); }
$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<sqlops.SimpleExecuteResult> { throw ni(); }
/**
* Gets a subset of rows in a result set in order to display in the UI
*/
$getQueryRows(handle: number, rowData: data.QueryExecuteSubsetParams): Thenable<data.QueryExecuteSubsetResult> { throw ni(); }
$getQueryRows(handle: number, rowData: sqlops.QueryExecuteSubsetParams): Thenable<sqlops.QueryExecuteSubsetResult> { throw ni(); }
/**
* Disposes the cached information regarding a query
@@ -148,29 +148,29 @@ export abstract class ExtHostDataProtocolShape {
/**
* Callback when a query has completed
*/
$onQueryComplete(handle: number, result: data.QueryExecuteCompleteNotificationResult): void { throw ni(); }
$onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void { throw ni(); }
/**
* Callback when a batch has started. This enables the UI to display when batch execution has started
*/
$onBatchStart(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void { throw ni(); }
$onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void { throw ni(); }
/**
* Callback when a batch is complete. This includes updated information on result sets, time to execute, and
* other relevant batch information
*/
$onBatchComplete(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void { throw ni(); }
$onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void { throw ni(); }
/**
* Callback when a result set has been returned from query execution and can be displayed
*/
$onResultSetComplete(handle: number, resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams): void { throw ni(); }
$onResultSetComplete(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetCompleteNotificationParams): void { throw ni(); }
/**
* Callback when a message generated during query execution is issued
*/
$onQueryMessage(handle: number, message: data.QueryExecuteMessageParams): void { throw ni(); }
$onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void { throw ni(); }
/**
* Requests saving of the results from a result set into a specific format (CSV, JSON, Excel)
*/
$saveResults(handle: number, requestParams: data.SaveResultsRequestParams): Thenable<data.SaveResultRequestResult> { throw ni(); }
$saveResults(handle: number, requestParams: sqlops.SaveResultsRequestParams): Thenable<sqlops.SaveResultRequestResult> { throw ni(); }
/**
* Commits all pending edits in an edit session
@@ -180,7 +180,7 @@ export abstract class ExtHostDataProtocolShape {
/**
* Creates a new row in the edit session
*/
$createRow(handle: number, ownerUri: string): Thenable<data.EditCreateRowResult> { throw ni(); }
$createRow(handle: number, ownerUri: string): Thenable<sqlops.EditCreateRowResult> { throw ni(); }
/**
* Marks the selected row for deletion in the edit session
@@ -195,7 +195,7 @@ export abstract class ExtHostDataProtocolShape {
/**
* Reverts any pending changes for the requested cell and returns the original value
*/
$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<data.EditRevertCellResult> { throw ni(); }
$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<sqlops.EditRevertCellResult> { throw ni(); }
/**
* Reverts any pending changes for the requested row
@@ -205,12 +205,12 @@ export abstract class ExtHostDataProtocolShape {
/**
* Updates a cell value in the requested row. Returns if there are any corrections to the value
*/
$updateCell(handle: number, ownerUri: string, rowId: number, columId: number, newValue: string): Thenable<data.EditUpdateCellResult> { throw ni(); }
$updateCell(handle: number, ownerUri: string, rowId: number, columId: number, newValue: string): Thenable<sqlops.EditUpdateCellResult> { throw ni(); }
/**
* Gets a subset of rows in a result set, merging pending edit changes in order to display in the UI
*/
$getEditRows(handle: number, rowData: data.EditSubsetParams): Thenable<data.EditSubsetResult> { throw ni(); }
$getEditRows(handle: number, rowData: sqlops.EditSubsetParams): Thenable<sqlops.EditSubsetResult> { throw ni(); }
/**
* Diposes an initialized edit session and cleans up pending edits
@@ -220,52 +220,52 @@ export abstract class ExtHostDataProtocolShape {
/**
* Create a new database on the provided connection
*/
$createDatabase(handle: number, connectionUri: string, database: data.DatabaseInfo): Thenable<data.CreateDatabaseResponse> { throw ni(); }
$createDatabase(handle: number, connectionUri: string, database: sqlops.DatabaseInfo): Thenable<sqlops.CreateDatabaseResponse> { throw ni(); }
/**
* Get the default database prototype
*/
$getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<data.DatabaseInfo> { throw ni(); }
$getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> { throw ni(); }
/**
* Get the database info
*/
$getDatabaseInfo(handle: number, connectionUri: string): Thenable<data.DatabaseInfo> { throw ni(); }
$getDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> { throw ni(); }
/**
* Create a new login on the provided connection
*/
$createLogin(handle: number, connectionUri: string, login: data.LoginInfo): Thenable<data.CreateLoginResponse> { throw ni(); }
$createLogin(handle: number, connectionUri: string, login: sqlops.LoginInfo): Thenable<sqlops.CreateLoginResponse> { throw ni(); }
/**
* Backup a database
*/
$backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse> { throw ni(); }
$backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.BackupResponse> { throw ni(); }
/**
* Get the extended database prototype
*/
$getBackupConfigInfo(handle: number, connectionUri: string): Thenable<data.BackupConfigInfo> { throw ni(); }
$getBackupConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.BackupConfigInfo> { throw ni(); }
/**
* Restores a database
*/
$restore(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> { throw ni(); }
$restore(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestoreResponse> { throw ni(); }
/**
* Gets a plan for restoring a database
*/
$getRestorePlan(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> { throw ni(); }
$getRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestorePlanResponse> { throw ni(); }
/**
* Cancels a plan
*/
$cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> { throw ni(); }
$cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<boolean> { throw ni(); }
/**
* Gets restore config Info
*/
$getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<data.RestoreConfigInfo> { throw ni(); }
$getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.RestoreConfigInfo> { throw ni(); }
/**
@@ -287,7 +287,7 @@ export abstract class ExtHostDataProtocolShape {
/**
* Close file browser
*/
$closeFileBrowser(handle: number, ownerUri: string): Thenable<data.FileBrowserCloseResponse> { throw ni(); }
$closeFileBrowser(handle: number, ownerUri: string): Thenable<sqlops.FileBrowserCloseResponse> { throw ni(); }
/**
* Profiler Provider methods
@@ -312,12 +312,12 @@ export abstract class ExtHostResourceProviderShape {
/**
* Create a firewall rule
*/
$createFirewallRule(handle: number, account: data.Account, firewallRuleInfo: data.FirewallRuleInfo): Thenable<data.CreateFirewallRuleResponse> { throw ni(); }
$createFirewallRule(handle: number, account: sqlops.Account, firewallRuleInfo: sqlops.FirewallRuleInfo): Thenable<sqlops.CreateFirewallRuleResponse> { throw ni(); }
/**
* Handle firewall rule
*/
$handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<data.HandleFirewallRuleResponse> { throw ni(); }
$handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<sqlops.HandleFirewallRuleResponse> { throw ni(); }
}
@@ -327,7 +327,7 @@ export abstract class ExtHostResourceProviderShape {
export abstract class ExtHostCredentialManagementShape {
$saveCredential(credentialId: string, password: string): Thenable<boolean> { throw ni(); }
$readCredential(credentialId: string): Thenable<data.Credential> { throw ni(); }
$readCredential(credentialId: string): Thenable<sqlops.Credential> { throw ni(); }
$deleteCredential(credentialId: string): Thenable<boolean> { throw ni(); }
}
@@ -336,21 +336,21 @@ export abstract class ExtHostCredentialManagementShape {
* Serialization provider extension host class.
*/
export abstract class ExtHostSerializationProviderShape {
$saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<data.SaveResultRequestResult> { throw ni(); }
$saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> { throw ni(); }
}
export interface MainThreadAccountManagementShape extends IDisposable {
$registerAccountProvider(providerMetadata: data.AccountProviderMetadata, handle: number): Thenable<any>;
$registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, handle: number): Thenable<any>;
$unregisterAccountProvider(handle: number): Thenable<any>;
$beginAutoOAuthDeviceCode(providerId: string, title: string, message: string, userCode: string, uri: string): Thenable<void>;
$endAutoOAuthDeviceCode(): void;
$accountUpdated(updatedAccount: data.Account): void;
$accountUpdated(updatedAccount: sqlops.Account): void;
}
export interface MainThreadResourceProviderShape extends IDisposable {
$registerResourceProvider(providerMetadata: data.ResourceProviderMetadata, handle: number): Thenable<any>;
$registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, handle: number): Thenable<any>;
$unregisterResourceProvider(handle: number): Thenable<any>;
}
@@ -368,23 +368,23 @@ export interface MainThreadDataProtocolShape extends IDisposable {
$registerCapabilitiesServiceProvider(providerId: string, handle: number): TPromise<any>;
$registerAdminServicesProvider(providerId: string, handle: number): TPromise<any>;
$unregisterProvider(handle: number): TPromise<any>;
$onConnectionComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void;
$onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void;
$onIntelliSenseCacheComplete(handle: number, connectionUri: string): void;
$onConnectionChangeNotification(handle: number, changedConnInfo: data.ChangedConnectionInfo): void;
$onQueryComplete(handle: number, result: data.QueryExecuteCompleteNotificationResult): void;
$onBatchStart(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void;
$onBatchComplete(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void;
$onResultSetComplete(handle: number, resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams): void;
$onQueryMessage(handle: number, message: data.QueryExecuteMessageParams): void;
$onObjectExplorerSessionCreated(handle: number, message: data.ObjectExplorerSession): void;
$onObjectExplorerNodeExpanded(handle: number, message: data.ObjectExplorerExpandInfo): void;
$onTaskCreated(handle: number, sessionResponse: data.TaskInfo): void;
$onTaskStatusChanged(handle: number, sessionResponse: data.TaskProgressInfo): void;
$onFileBrowserOpened(handle: number, response: data.FileBrowserOpenedParams): void;
$onFolderNodeExpanded(handle: number, response: data.FileBrowserExpandedParams): void;
$onFilePathsValidated(handle: number, response: data.FileBrowserValidatedParams): void;
$onScriptingComplete(handle: number, message: data.ScriptingCompleteResult): void;
$onSessionEventsAvailable(handle: number, response: data.ProfilerSessionEvents): void;
$onConnectionChangeNotification(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void;
$onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void;
$onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void;
$onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void;
$onResultSetComplete(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetCompleteNotificationParams): void;
$onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void;
$onObjectExplorerSessionCreated(handle: number, message: sqlops.ObjectExplorerSession): void;
$onObjectExplorerNodeExpanded(handle: number, message: sqlops.ObjectExplorerExpandInfo): void;
$onTaskCreated(handle: number, sessionResponse: sqlops.TaskInfo): void;
$onTaskStatusChanged(handle: number, sessionResponse: sqlops.TaskProgressInfo): void;
$onFileBrowserOpened(handle: number, response: sqlops.FileBrowserOpenedParams): void;
$onFolderNodeExpanded(handle: number, response: sqlops.FileBrowserExpandedParams): void;
$onFilePathsValidated(handle: number, response: sqlops.FileBrowserValidatedParams): void;
$onScriptingComplete(handle: number, message: sqlops.ScriptingCompleteResult): void;
$onSessionEventsAvailable(handle: number, response: sqlops.ProfilerSessionEvents): void;
/**
* Callback when a session has completed initialization
@@ -393,8 +393,8 @@ export interface MainThreadDataProtocolShape extends IDisposable {
}
export interface MainThreadConnectionManagementShape extends IDisposable {
$getActiveConnections(): Thenable<data.connection.Connection[]>;
$getCurrentConnection(): Thenable<data.connection.Connection>;
$getActiveConnections(): Thenable<sqlops.connection.Connection[]>;
$getCurrentConnection(): Thenable<sqlops.connection.Connection>;
$getCredentials(connectionId: string): Thenable<{ [name: string]: string }>;
}
@@ -450,10 +450,10 @@ export interface ExtHostModalDialogsShape {
}
export interface ExtHostDashboardWebviewsShape {
$registerProvider(widgetId: string, handler: (webview: data.DashboardWebview) => void): void;
$registerProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void): void;
$onMessage(handle: number, message: any): void;
$onClosed(handle: number): void;
$registerWidget(handle: number, id: string, connection: data.connection.Connection, serverInfo: data.ServerInfo): void;
$registerWidget(handle: number, id: string, connection: sqlops.connection.Connection, serverInfo: sqlops.ServerInfo): void;
}
export interface MainThreadDashboardWebviewShape extends IDisposable {