From 65c71d9b3bca20ffd803b19f41bc99ad3852289c Mon Sep 17 00:00:00 2001
From: Wroud <wrouds@gmail.com>
Date: Tue, 6 Oct 2020 13:00:42 +0300
Subject: [PATCH] fix(core-connections): CB-362 connection duplication

---
 .../NodesManager/NavNodeManagerService.ts     |  29 ++--
 .../src/Administration/ConnectionsResource.ts |  22 +--
 .../src/ConnectionInfoResource.ts             |  34 ++++-
 .../queries/connections/createConnection.gql  |   2 +-
 webapp/packages/core-sdk/src/sdk.ts           | 138 +++++++++++++++++-
 .../src/CustomConnectionService.ts            |  12 +-
 6 files changed, 199 insertions(+), 38 deletions(-)

diff --git a/webapp/packages/core-app/src/shared/NodesManager/NavNodeManagerService.ts b/webapp/packages/core-app/src/shared/NodesManager/NavNodeManagerService.ts
index 6c4244f0f4..bb602a3e17 100644
--- a/webapp/packages/core-app/src/shared/NodesManager/NavNodeManagerService.ts
+++ b/webapp/packages/core-app/src/shared/NodesManager/NavNodeManagerService.ts
@@ -119,6 +119,7 @@ export class NavNodeManagerService extends Bootstrap {
   register(): void {
     this.connectionInfo.onItemAdd.subscribe(this.connectionUpdateHandler.bind(this));
     this.connectionInfo.onItemDelete.subscribe(this.connectionRemoveHandler.bind(this));
+    this.connectionInfo.onConnectionCreate.subscribe(this.connectionCreateHandler.bind(this));
     this.sessionResource.onDataUpdate.subscribe(this.updateRootChildren.bind(this));
   }
 
@@ -325,6 +326,23 @@ export class NavNodeManagerService extends Bootstrap {
     }
   }
 
+  private async connectionCreateHandler(connection: Connection) {
+    if (!await this.isNavTreeEnabled()) {
+      return;
+    }
+
+    await this.navTree.load(ROOT_NODE_PATH);
+    const nodeId = NodeManagerUtils.connectionIdToConnectionNodeId(connection.id);
+    this.markTreeOutdated(nodeId);
+
+    await this.navNodeInfoResource.refresh(nodeId);
+    const tree = this.navTree.get(ROOT_NODE_PATH);
+
+    if (!tree?.includes(nodeId)) {
+      this.navTree.unshiftToNode(ROOT_NODE_PATH, [nodeId]);
+    }
+  }
+
   private async connectionUpdateHandler(key: ResourceKey<string>) {
     if (!await this.isNavTreeEnabled()) {
       return;
@@ -345,17 +363,6 @@ export class NavNodeManagerService extends Bootstrap {
       }
 
       this.navNodeInfoResource.markOutdated(nodeId);
-
-      const node = this.navNodeInfoResource.get(nodeId);
-
-      if(!node) {
-        await this.navNodeInfoResource.load(nodeId);
-        const tree = this.navTree.get(ROOT_NODE_PATH);
-
-        if (!tree?.includes(nodeId)) {
-          this.navTree.unshiftToNode(ROOT_NODE_PATH, [nodeId]);
-        }
-      }
     }
   }
 
diff --git a/webapp/packages/core-connections/src/Administration/ConnectionsResource.ts b/webapp/packages/core-connections/src/Administration/ConnectionsResource.ts
index 08d2eb63d1..2595d50b5e 100644
--- a/webapp/packages/core-connections/src/Administration/ConnectionsResource.ts
+++ b/webapp/packages/core-connections/src/Administration/ConnectionsResource.ts
@@ -6,6 +6,8 @@
  * you may not use this file except in compliance with the License.
  */
 
+import { Observable, Subject } from 'rxjs';
+
 import { injectable } from '@cloudbeaver/core-di';
 import {
   GraphQLService,
@@ -20,8 +22,6 @@ import {
 } from '@cloudbeaver/core-sdk';
 import { uuid, MetadataMap } from '@cloudbeaver/core-utils';
 
-import { DBDriverResource } from '../DBDriverResource';
-
 export const NEW_CONNECTION_SYMBOL = Symbol('new-connection');
 export const SEARCH_CONNECTION_SYMBOL = Symbol('search-connection');
 
@@ -30,13 +30,17 @@ export type ConnectionSearch = ConnectionNew & { [SEARCH_CONNECTION_SYMBOL]: Adm
 
 @injectable()
 export class ConnectionsResource extends CachedMapResource<string, ConnectionInfo> {
+  readonly onConnectionCreate: Observable<ConnectionInfo>;
+
   private metadata: MetadataMap<string, boolean>;
+  private connectionCreateSubject: Subject<ConnectionInfo>;
 
   constructor(
     private graphQLService: GraphQLService,
-    private dbDriverResource: DBDriverResource
   ) {
     super(new Map());
+    this.connectionCreateSubject = new Subject<ConnectionInfo>();
+    this.onConnectionCreate = this.connectionCreateSubject.asObservable();
     this.metadata = new MetadataMap(() => false);
   }
 
@@ -85,7 +89,7 @@ export class ConnectionsResource extends CachedMapResource<string, ConnectionInf
     return databases;
   }
 
-  async create(config: ConnectionConfig) {
+  async create(config: ConnectionConfig): Promise<ConnectionInfo> {
     const { connection } = await this.graphQLService.sdk.createConnectionConfiguration({ config });
     await this.graphQLService.sdk.refreshSessionConnections();
 
@@ -95,7 +99,9 @@ export class ConnectionsResource extends CachedMapResource<string, ConnectionInf
     };
     this.set(newConnection.id, newConnection);
 
-    return this.get(connection.id)!;
+    const observedConnection = this.get(connection.id)!;
+    this.connectionCreateSubject.next(observedConnection);
+    return observedConnection;
   }
 
   async test(config: ConnectionConfig): Promise<void> {
@@ -145,12 +151,6 @@ export class ConnectionsResource extends CachedMapResource<string, ConnectionInf
     return this.data;
   }
 
-  private async getNameTemplate(connection: AdminConnectionSearchInfo) {
-    const driver = await this.dbDriverResource.load(connection.defaultDriver);
-
-    return `${driver.name} (${connection.host}:${connection.port})`;
-  }
-
   private async deleteConnectionTask(key: ResourceKey<string>) {
     if (isResourceKeyList(key)) {
       for (let i = 0; i < key.list.length; i++) {
diff --git a/webapp/packages/core-connections/src/ConnectionInfoResource.ts b/webapp/packages/core-connections/src/ConnectionInfoResource.ts
index ca404ee168..404c2a759b 100644
--- a/webapp/packages/core-connections/src/ConnectionInfoResource.ts
+++ b/webapp/packages/core-connections/src/ConnectionInfoResource.ts
@@ -6,6 +6,8 @@
  * you may not use this file except in compliance with the License.
  */
 
+import { Observable, Subject } from 'rxjs';
+
 import { injectable } from '@cloudbeaver/core-di';
 import {
   ConnectionInfo,
@@ -14,7 +16,7 @@ import {
   ObjectPropertyInfo,
   ResourceKey,
   isResourceKeyList,
-  resourceKeyList
+  resourceKeyList, ConnectionConfig
 } from '@cloudbeaver/core-sdk';
 
 import { ConnectionsResource } from './Administration/ConnectionsResource';
@@ -35,11 +37,16 @@ export type Connection = Pick<
 
 @injectable()
 export class ConnectionInfoResource extends CachedMapResource<string, Connection> {
+  readonly onConnectionCreate: Observable<Connection>;
+  private connectionCreateSubject: Subject<Connection>;
   constructor(
     private graphQLService: GraphQLService,
     private connectionsResource: ConnectionsResource
   ) {
     super(new Map());
+    this.connectionCreateSubject = new Subject<Connection>();
+    this.onConnectionCreate = this.connectionCreateSubject.asObservable();
+    connectionsResource.onConnectionCreate.subscribe(this.createHandler.bind(this));
     connectionsResource.onItemAdd.subscribe(this.addHandler.bind(this));
     connectionsResource.onItemDelete.subscribe(this.delete.bind(this));
     connectionsResource.onDataOutdated.subscribe(this.markOutdated.bind(this));
@@ -49,7 +56,20 @@ export class ConnectionInfoResource extends CachedMapResource<string, Connection
     const { connection } = await this.graphQLService.sdk.createConnectionFromTemplate({ templateId });
     this.set(connection.id, connection);
 
-    return this.get(connection.id)!;
+    const observedConnection = this.get(connection.id)!;
+    this.connectionCreateSubject.next(observedConnection);
+    return observedConnection;
+  }
+
+  async createConnection(config: ConnectionConfig): Promise<Connection> {
+    const { connection } = await this.graphQLService.sdk.createConnection({
+      config,
+    });
+    this.set(connection.id, connection);
+
+    const observedConnection = this.get(connection.id)!;
+    this.connectionCreateSubject.next(observedConnection);
+    return observedConnection;
   }
 
   async init(id: string, credentials?: any): Promise<Connection> {
@@ -102,6 +122,16 @@ export class ConnectionInfoResource extends CachedMapResource<string, Connection
     return this.data;
   }
 
+  private async createHandler(connection: ConnectionInfo) {
+    if (connection.template) {
+      return;
+    }
+
+    await this.load(connection.id);
+    const observedConnection = this.get(connection.id) as Connection;
+    this.connectionCreateSubject.next(observedConnection);
+  }
+
   private async addHandler(key: ResourceKey<string>) {
     if (isResourceKeyList(key)) {
       this.load(resourceKeyList(key.list.filter(id => !this.connectionsResource.get(id)?.template)));
diff --git a/webapp/packages/core-sdk/src/queries/connections/createConnection.gql b/webapp/packages/core-sdk/src/queries/connections/createConnection.gql
index d9f9164d6e..7955283f69 100644
--- a/webapp/packages/core-sdk/src/queries/connections/createConnection.gql
+++ b/webapp/packages/core-sdk/src/queries/connections/createConnection.gql
@@ -1,5 +1,5 @@
 mutation createConnection($config: ConnectionConfig!) {
-  createConnection(config: $config) {
+  connection: createConnection(config: $config) {
     id
     name
     description
diff --git a/webapp/packages/core-sdk/src/sdk.ts b/webapp/packages/core-sdk/src/sdk.ts
index 83bc19152e..f2274c7733 100644
--- a/webapp/packages/core-sdk/src/sdk.ts
+++ b/webapp/packages/core-sdk/src/sdk.ts
@@ -1,6 +1,5 @@
 /* eslint-disable max-len */
 import { GraphQLClient } from 'graphql-request';
-
 export type Maybe<T> = T;
 export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
 /** All built-in and custom scalars, mapped to their actual values */
@@ -14,6 +13,8 @@ export type Scalars = {
   DateTime: any;
 };
 
+
+
 export type Query = {
   allConnections: Array<ConnectionInfo>;
   authLogin: UserAuthInfo;
@@ -65,41 +66,50 @@ export type Query = {
   updateConnectionConfiguration: ConnectionInfo;
 };
 
+
 export type QueryAuthLoginArgs = {
   provider: Scalars['ID'];
   credentials: Scalars['Object'];
 };
 
+
 export type QueryConfigureServerArgs = {
   configuration: ServerConfigInput;
 };
 
+
 export type QueryConnectionInfoArgs = {
   id: Scalars['ID'];
 };
 
+
 export type QueryConnectionStateArgs = {
   id: Scalars['ID'];
 };
 
+
 export type QueryCreateConnectionConfigurationArgs = {
   config: ConnectionConfig;
 };
 
+
 export type QueryCreateRoleArgs = {
   roleId: Scalars['ID'];
 };
 
+
 export type QueryCreateUserArgs = {
   userId: Scalars['ID'];
 };
 
+
 export type QueryDataTransferExportDataFromContainerArgs = {
   connectionId: Scalars['ID'];
   containerNodePath: Scalars['ID'];
   parameters: DataTransferParameters;
 };
 
+
 export type QueryDataTransferExportDataFromResultsArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -107,57 +117,70 @@ export type QueryDataTransferExportDataFromResultsArgs = {
   parameters: DataTransferParameters;
 };
 
+
 export type QueryDataTransferRemoveDataFileArgs = {
   dataFileId: Scalars['String'];
 };
 
+
 export type QueryDeleteConnectionConfigurationArgs = {
   id: Scalars['ID'];
 };
 
+
 export type QueryDeleteRoleArgs = {
   roleId: Scalars['ID'];
 };
 
+
 export type QueryDeleteUserArgs = {
   userId: Scalars['ID'];
 };
 
+
 export type QueryDriverListArgs = {
   id?: Maybe<Scalars['ID']>;
 };
 
+
 export type QueryGetConnectionSubjectAccessArgs = {
   connectionId?: Maybe<Scalars['ID']>;
 };
 
+
 export type QueryGetSubjectConnectionAccessArgs = {
   subjectId?: Maybe<Scalars['ID']>;
 };
 
+
 export type QueryGrantUserRoleArgs = {
   userId: Scalars['ID'];
   roleId: Scalars['ID'];
 };
 
+
 export type QueryListRolesArgs = {
   roleId?: Maybe<Scalars['ID']>;
 };
 
+
 export type QueryListUsersArgs = {
   userId?: Maybe<Scalars['ID']>;
 };
 
+
 export type QueryMetadataGetNodeDdlArgs = {
   nodeId: Scalars['ID'];
   options?: Maybe<Scalars['Object']>;
 };
 
+
 export type QueryNavGetStructContainersArgs = {
   connectionId: Scalars['ID'];
   catalog?: Maybe<Scalars['ID']>;
 };
 
+
 export type QueryNavNodeChildrenArgs = {
   parentPath: Scalars['ID'];
   offset?: Maybe<Scalars['Int']>;
@@ -165,53 +188,64 @@ export type QueryNavNodeChildrenArgs = {
   onlyFolders?: Maybe<Scalars['Boolean']>;
 };
 
+
 export type QueryNavNodeInfoArgs = {
   nodePath: Scalars['ID'];
 };
 
+
 export type QueryNavRefreshNodeArgs = {
   nodePath: Scalars['ID'];
 };
 
+
 export type QueryReadSessionLogArgs = {
   maxEntries?: Maybe<Scalars['Int']>;
   clearEntries?: Maybe<Scalars['Boolean']>;
 };
 
+
 export type QueryRevokeUserRoleArgs = {
   userId: Scalars['ID'];
   roleId: Scalars['ID'];
 };
 
+
 export type QuerySearchConnectionsArgs = {
   hostNames: Array<Scalars['String']>;
 };
 
+
 export type QuerySetConnectionSubjectAccessArgs = {
   connectionId: Scalars['ID'];
   subjects: Array<Scalars['ID']>;
 };
 
+
 export type QuerySetDefaultNavigatorSettingsArgs = {
   settings: NavigatorSettingsInput;
 };
 
+
 export type QuerySetSubjectConnectionAccessArgs = {
   subjectId: Scalars['ID'];
   connections: Array<Scalars['ID']>;
 };
 
+
 export type QuerySetSubjectPermissionsArgs = {
   roleId: Scalars['ID'];
   permissions: Array<Scalars['ID']>;
 };
 
+
 export type QuerySetUserCredentialsArgs = {
   userId: Scalars['ID'];
   providerId: Scalars['ID'];
   credentials: Scalars['Object'];
 };
 
+
 export type QuerySqlCompletionProposalsArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -220,14 +254,17 @@ export type QuerySqlCompletionProposalsArgs = {
   maxResults?: Maybe<Scalars['Int']>;
 };
 
+
 export type QuerySqlDialectInfoArgs = {
   connectionId: Scalars['ID'];
 };
 
+
 export type QuerySqlListContextsArgs = {
   connectionId: Scalars['ID'];
 };
 
+
 export type QueryUpdateConnectionConfigurationArgs = {
   id: Scalars['ID'];
   config: ConnectionConfig;
@@ -264,6 +301,7 @@ export type Mutation = {
   updateResultsDataBatch?: Maybe<SqlExecuteInfo>;
 };
 
+
 export type MutationAsyncSqlExecuteQueryArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -272,52 +310,64 @@ export type MutationAsyncSqlExecuteQueryArgs = {
   dataFormat?: Maybe<ResultDataFormat>;
 };
 
+
 export type MutationAsyncSqlExecuteResultsArgs = {
   taskId: Scalars['ID'];
 };
 
+
 export type MutationAsyncTaskCancelArgs = {
   id: Scalars['String'];
 };
 
+
 export type MutationAsyncTaskInfoArgs = {
   id: Scalars['String'];
   removeOnFinish: Scalars['Boolean'];
 };
 
+
 export type MutationAsyncTaskStatusArgs = {
   id: Scalars['String'];
 };
 
+
 export type MutationChangeSessionLanguageArgs = {
   locale?: Maybe<Scalars['String']>;
 };
 
+
 export type MutationCloseConnectionArgs = {
   id: Scalars['ID'];
 };
 
+
 export type MutationCreateConnectionArgs = {
   config: ConnectionConfig;
 };
 
+
 export type MutationCreateConnectionFromTemplateArgs = {
   templateId: Scalars['ID'];
 };
 
+
 export type MutationDeleteConnectionArgs = {
   id: Scalars['ID'];
 };
 
+
 export type MutationInitConnectionArgs = {
   id: Scalars['ID'];
   credentials?: Maybe<Scalars['Object']>;
 };
 
+
 export type MutationOpenConnectionArgs = {
   config: ConnectionConfig;
 };
 
+
 export type MutationReadDataFromContainerArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -326,22 +376,26 @@ export type MutationReadDataFromContainerArgs = {
   dataFormat?: Maybe<ResultDataFormat>;
 };
 
+
 export type MutationSetConnectionNavigatorSettingsArgs = {
   id: Scalars['ID'];
   settings: NavigatorSettingsInput;
 };
 
+
 export type MutationSqlContextCreateArgs = {
   connectionId: Scalars['ID'];
   defaultCatalog?: Maybe<Scalars['String']>;
   defaultSchema?: Maybe<Scalars['String']>;
 };
 
+
 export type MutationSqlContextDestroyArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
 };
 
+
 export type MutationSqlContextSetDefaultsArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -349,6 +403,7 @@ export type MutationSqlContextSetDefaultsArgs = {
   defaultSchema?: Maybe<Scalars['ID']>;
 };
 
+
 export type MutationSqlExecuteQueryArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -357,16 +412,19 @@ export type MutationSqlExecuteQueryArgs = {
   dataFormat?: Maybe<ResultDataFormat>;
 };
 
+
 export type MutationSqlResultCloseArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
   resultId: Scalars['ID'];
 };
 
+
 export type MutationTestConnectionArgs = {
   config: ConnectionConfig;
 };
 
+
 export type MutationUpdateResultsDataArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -375,6 +433,7 @@ export type MutationUpdateResultsDataArgs = {
   updateValues?: Maybe<Scalars['Object']>;
 };
 
+
 export type MutationUpdateResultsDataBatchArgs = {
   connectionId: Scalars['ID'];
   contextId: Scalars['ID'];
@@ -607,6 +666,7 @@ export type DatabaseObjectInfo = {
   editors?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
+
 export type DatabaseObjectInfoPropertiesArgs = {
   filter?: Maybe<ObjectPropertyFilter>;
 };
@@ -834,6 +894,7 @@ export type AsyncTaskCancelMutationVariables = Exact<{
   taskId: Scalars['String'];
 }>;
 
+
 export type AsyncTaskCancelMutation = { result: Mutation['asyncTaskCancel'] };
 
 export type AuthLoginQueryVariables = Exact<{
@@ -841,14 +902,17 @@ export type AuthLoginQueryVariables = Exact<{
   credentials: Scalars['Object'];
 }>;
 
+
 export type AuthLoginQuery = { user: Pick<UserAuthInfo, 'userId' | 'displayName' | 'authProvider' | 'loginTime' | 'message'> };
 
 export type AuthLogoutQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type AuthLogoutQuery = Pick<Query, 'authLogout'>;
 
 export type GetAuthProvidersQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type GetAuthProvidersQuery = { providers: Array<(
     Pick<AuthProviderInfo, 'id' | 'label' | 'icon' | 'description' | 'defaultProvider'>
     & { credentialParameters: Array<Pick<AuthCredentialInfo, 'id' | 'displayName' | 'description' | 'admin' | 'user' | 'possibleValues' | 'encryption'>> }
@@ -856,42 +920,49 @@ export type GetAuthProvidersQuery = { providers: Array<(
 
 export type GetSessionUserQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type GetSessionUserQuery = { user?: Maybe<Pick<UserAuthInfo, 'userId' | 'displayName' | 'authProvider' | 'loginTime' | 'message'>> };
 
 export type CreateUserQueryVariables = Exact<{
   userId: Scalars['ID'];
 }>;
 
+
 export type CreateUserQuery = { user: Pick<AdminUserInfo, 'userId' | 'grantedRoles'> };
 
 export type DeleteUserQueryVariables = Exact<{
   userId: Scalars['ID'];
 }>;
 
+
 export type DeleteUserQuery = Pick<Query, 'deleteUser'>;
 
 export type GetPermissionsListQueryVariables = Exact<{
   roleId?: Maybe<Scalars['ID']>;
 }>;
 
+
 export type GetPermissionsListQuery = { permissions: Array<Maybe<Pick<AdminPermissionInfo, 'id' | 'label' | 'description' | 'provider' | 'category'>>> };
 
 export type GetRolesListQueryVariables = Exact<{
   roleId?: Maybe<Scalars['ID']>;
 }>;
 
+
 export type GetRolesListQuery = { roles: Array<Maybe<Pick<AdminRoleInfo, 'roleId' | 'roleName'>>> };
 
 export type GetUserGrantedConnectionsQueryVariables = Exact<{
   userId?: Maybe<Scalars['ID']>;
 }>;
 
+
 export type GetUserGrantedConnectionsQuery = { grantedConnections: Array<Pick<AdminConnectionGrantInfo, 'connectionId' | 'subjectId' | 'subjectType'>> };
 
 export type GetUsersListQueryVariables = Exact<{
   userId?: Maybe<Scalars['ID']>;
 }>;
 
+
 export type GetUsersListQuery = { users: Array<Maybe<Pick<AdminUserInfo, 'userId' | 'grantedRoles'>>> };
 
 export type GrantUserRoleQueryVariables = Exact<{
@@ -899,6 +970,7 @@ export type GrantUserRoleQueryVariables = Exact<{
   roleId: Scalars['ID'];
 }>;
 
+
 export type GrantUserRoleQuery = Pick<Query, 'grantUserRole'>;
 
 export type RevokeUserRoleQueryVariables = Exact<{
@@ -906,6 +978,7 @@ export type RevokeUserRoleQueryVariables = Exact<{
   roleId: Scalars['ID'];
 }>;
 
+
 export type RevokeUserRoleQuery = Pick<Query, 'revokeUserRole'>;
 
 export type SetConnectionsQueryVariables = Exact<{
@@ -913,6 +986,7 @@ export type SetConnectionsQueryVariables = Exact<{
   connections: Array<Scalars['ID']>;
 }>;
 
+
 export type SetConnectionsQuery = { grantedConnections: Query['setSubjectConnectionAccess'] };
 
 export type SetUserCredentialsQueryVariables = Exact<{
@@ -921,12 +995,14 @@ export type SetUserCredentialsQueryVariables = Exact<{
   credentials: Scalars['Object'];
 }>;
 
+
 export type SetUserCredentialsQuery = Pick<Query, 'setUserCredentials'>;
 
 export type CreateConnectionConfigurationQueryVariables = Exact<{
   config: ConnectionConfig;
 }>;
 
+
 export type CreateConnectionConfigurationQuery = { connection: (
     Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'template' | 'connected' | 'readOnly' | 'host' | 'port' | 'databaseName' | 'url' | 'properties' | 'features' | 'authNeeded' | 'authModel'>
     & { authProperties: Array<Pick<ObjectPropertyInfo, 'id' | 'value' | 'features'>> }
@@ -936,16 +1012,19 @@ export type DeleteConnectionConfigurationQueryVariables = Exact<{
   id: Scalars['ID'];
 }>;
 
+
 export type DeleteConnectionConfigurationQuery = Pick<Query, 'deleteConnectionConfiguration'>;
 
 export type GetConnectionAccessQueryVariables = Exact<{
   connectionId?: Maybe<Scalars['ID']>;
 }>;
 
+
 export type GetConnectionAccessQuery = { subjects: Array<Pick<AdminConnectionGrantInfo, 'connectionId' | 'subjectId' | 'subjectType'>> };
 
 export type GetConnectionsQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type GetConnectionsQuery = { connections: Array<(
     Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'template' | 'connected' | 'readOnly' | 'host' | 'port' | 'databaseName' | 'url' | 'properties' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'>
     & { authProperties: Array<Pick<ObjectPropertyInfo, 'id' | 'value' | 'features'>> }
@@ -955,6 +1034,7 @@ export type SearchDatabasesQueryVariables = Exact<{
   hosts: Array<Scalars['String']>;
 }>;
 
+
 export type SearchDatabasesQuery = { databases: Array<Pick<AdminConnectionSearchInfo, 'host' | 'port' | 'possibleDrivers' | 'defaultDriver'>> };
 
 export type SetConnectionAccessQueryVariables = Exact<{
@@ -962,6 +1042,7 @@ export type SetConnectionAccessQueryVariables = Exact<{
   subjects: Array<Scalars['ID']>;
 }>;
 
+
 export type SetConnectionAccessQuery = Pick<Query, 'setConnectionSubjectAccess'>;
 
 export type UpdateConnectionConfigurationQueryVariables = Exact<{
@@ -969,6 +1050,7 @@ export type UpdateConnectionConfigurationQueryVariables = Exact<{
   config: ConnectionConfig;
 }>;
 
+
 export type UpdateConnectionConfigurationQuery = { connection: (
     Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'template' | 'connected' | 'readOnly' | 'host' | 'port' | 'databaseName' | 'url' | 'properties' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'>
     & { authProperties: Array<Pick<ObjectPropertyInfo, 'id' | 'value' | 'features'>> }
@@ -978,46 +1060,54 @@ export type CloseConnectionMutationVariables = Exact<{
   id: Scalars['ID'];
 }>;
 
+
 export type CloseConnectionMutation = { connection: Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'> };
 
 export type ConnectionAuthPropertiesQueryVariables = Exact<{
   id: Scalars['ID'];
 }>;
 
+
 export type ConnectionAuthPropertiesQuery = { connection: { authProperties: Array<Pick<ObjectPropertyInfo, 'id' | 'displayName' | 'description' | 'category' | 'dataType' | 'value' | 'validValues' | 'defaultValue' | 'features'>> } };
 
 export type ConnectionInfoQueryVariables = Exact<{
   id: Scalars['ID'];
 }>;
 
+
 export type ConnectionInfoQuery = { connection: Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'> };
 
 export type CreateConnectionMutationVariables = Exact<{
   config: ConnectionConfig;
 }>;
 
-export type CreateConnectionMutation = { createConnection: Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'> };
+
+export type CreateConnectionMutation = { connection: Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'> };
 
 export type CreateConnectionFromTemplateMutationVariables = Exact<{
   templateId: Scalars['ID'];
 }>;
 
+
 export type CreateConnectionFromTemplateMutation = { connection: Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'> };
 
 export type DeleteConnectionMutationVariables = Exact<{
   id: Scalars['ID'];
 }>;
 
+
 export type DeleteConnectionMutation = Pick<Mutation, 'deleteConnection'>;
 
 export type DriverListQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type DriverListQuery = { driverList: Array<Pick<DriverInfo, 'id' | 'name' | 'icon' | 'description' | 'defaultPort' | 'defaultDatabase' | 'defaultServer' | 'defaultUser' | 'sampleURL' | 'embedded' | 'anonymousAccess' | 'promotedScore' | 'defaultAuthModel'>> };
 
 export type DriverPropertiesQueryVariables = Exact<{
   driverId: Scalars['ID'];
 }>;
 
+
 export type DriverPropertiesQuery = { driver: Array<(
     Pick<DriverInfo, 'driverParameters'>
     & { driverProperties?: Maybe<Array<Pick<ObjectPropertyInfo, 'id' | 'displayName' | 'description' | 'category' | 'dataType' | 'defaultValue' | 'validValues'>>> }
@@ -1025,6 +1115,7 @@ export type DriverPropertiesQuery = { driver: Array<(
 
 export type GetAuthModelsQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type GetAuthModelsQuery = { models: Array<(
     Pick<DatabaseAuthModel, 'id' | 'displayName' | 'description' | 'icon'>
     & { properties: Array<Pick<ObjectPropertyInfo, 'id' | 'displayName' | 'description' | 'category' | 'dataType' | 'value' | 'validValues' | 'defaultValue' | 'features'>> }
@@ -1034,6 +1125,7 @@ export type GetDriverByIdQueryVariables = Exact<{
   driverId: Scalars['ID'];
 }>;
 
+
 export type GetDriverByIdQuery = { driverList: Array<Pick<DriverInfo, 'id' | 'name' | 'icon'>> };
 
 export type InitConnectionMutationVariables = Exact<{
@@ -1041,20 +1133,24 @@ export type InitConnectionMutationVariables = Exact<{
   credentials?: Maybe<Scalars['Object']>;
 }>;
 
+
 export type InitConnectionMutation = { connection: Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'> };
 
 export type RefreshSessionConnectionsMutationVariables = Exact<{ [key: string]: never; }>;
 
+
 export type RefreshSessionConnectionsMutation = Pick<Mutation, 'refreshSessionConnections'>;
 
 export type GetTemplateConnectionsQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type GetTemplateConnectionsQuery = { connections: Array<Pick<ConnectionInfo, 'id' | 'name' | 'description' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'>> };
 
 export type TestConnectionMutationVariables = Exact<{
   config: ConnectionConfig;
 }>;
 
+
 export type TestConnectionMutation = { testConnection: Pick<ConnectionInfo, 'id'> };
 
 export type ExportDataFromContainerQueryVariables = Exact<{
@@ -1063,6 +1159,7 @@ export type ExportDataFromContainerQueryVariables = Exact<{
   parameters: DataTransferParameters;
 }>;
 
+
 export type ExportDataFromContainerQuery = { taskInfo: (
     Pick<AsyncTaskInfo, 'id' | 'running' | 'taskResult'>
     & { error?: Maybe<Pick<ServerError, 'message' | 'errorCode' | 'stackTrace'>> }
@@ -1075,6 +1172,7 @@ export type ExportDataFromResultsQueryVariables = Exact<{
   parameters: DataTransferParameters;
 }>;
 
+
 export type ExportDataFromResultsQuery = { taskInfo: (
     Pick<AsyncTaskInfo, 'id' | 'running' | 'taskResult'>
     & { error?: Maybe<Pick<ServerError, 'message' | 'errorCode' | 'stackTrace'>> }
@@ -1082,6 +1180,7 @@ export type ExportDataFromResultsQuery = { taskInfo: (
 
 export type GetDataTransferProcessorsQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type GetDataTransferProcessorsQuery = { processors: Array<(
     Pick<DataTransferProcessorInfo, 'id' | 'name' | 'description' | 'fileExtension' | 'appFileExtension' | 'appName' | 'order' | 'icon' | 'isBinary' | 'isHTML'>
     & { properties?: Maybe<Array<Maybe<Pick<ObjectPropertyInfo, 'id' | 'displayName' | 'description' | 'category' | 'dataType' | 'defaultValue' | 'validValues' | 'features'>>>> }
@@ -1091,6 +1190,7 @@ export type RemoveDataTransferFileQueryVariables = Exact<{
   dataFileId: Scalars['String'];
 }>;
 
+
 export type RemoveDataTransferFileQuery = { result: Query['dataTransferRemoveDataFile'] };
 
 export type NavGetStructContainersQueryVariables = Exact<{
@@ -1098,6 +1198,7 @@ export type NavGetStructContainersQueryVariables = Exact<{
   catalogId?: Maybe<Scalars['ID']>;
 }>;
 
+
 export type NavGetStructContainersQuery = { navGetStructContainers: { catalogList: Array<Pick<DatabaseObjectInfo, 'name' | 'description' | 'type' | 'features'>>, schemaList: Array<Pick<DatabaseObjectInfo, 'name' | 'description' | 'type' | 'features'>> } };
 
 export type GetAsyncTaskInfoMutationVariables = Exact<{
@@ -1105,6 +1206,7 @@ export type GetAsyncTaskInfoMutationVariables = Exact<{
   removeOnFinish: Scalars['Boolean'];
 }>;
 
+
 export type GetAsyncTaskInfoMutation = { taskInfo: (
     Pick<AsyncTaskInfo, 'id' | 'name' | 'running' | 'status' | 'taskResult'>
     & { error?: Maybe<Pick<ServerError, 'message' | 'errorCode' | 'stackTrace'>> }
@@ -1118,6 +1220,7 @@ export type AsyncSqlExecuteQueryMutationVariables = Exact<{
   dataFormat?: Maybe<ResultDataFormat>;
 }>;
 
+
 export type AsyncSqlExecuteQueryMutation = { taskInfo: (
     Pick<AsyncTaskInfo, 'id' | 'name' | 'running' | 'status' | 'taskResult'>
     & { error?: Maybe<Pick<ServerError, 'message' | 'errorCode' | 'stackTrace'>> }
@@ -1127,6 +1230,7 @@ export type GetSqlExecuteTaskResultsMutationVariables = Exact<{
   taskId: Scalars['ID'];
 }>;
 
+
 export type GetSqlExecuteTaskResultsMutation = { result: (
     Pick<SqlExecuteInfo, 'duration' | 'statusMessage'>
     & { results: Array<(
@@ -1146,6 +1250,7 @@ export type ReadDataFromContainerMutationVariables = Exact<{
   dataFormat?: Maybe<ResultDataFormat>;
 }>;
 
+
 export type ReadDataFromContainerMutation = { readDataFromContainer?: Maybe<(
     Pick<SqlExecuteInfo, 'duration' | 'statusMessage'>
     & { results: Array<(
@@ -1165,6 +1270,7 @@ export type UpdateResultsDataMutationVariables = Exact<{
   values?: Maybe<Scalars['Object']>;
 }>;
 
+
 export type UpdateResultsDataMutation = { result?: Maybe<(
     Pick<SqlExecuteInfo, 'duration'>
     & { results: Array<(
@@ -1182,6 +1288,7 @@ export type UpdateResultsDataBatchMutationVariables = Exact<{
   addedRows?: Maybe<Array<SqlResultRow>>;
 }>;
 
+
 export type UpdateResultsDataBatchMutation = { result?: Maybe<(
     Pick<SqlExecuteInfo, 'duration'>
     & { results: Array<(
@@ -1194,6 +1301,7 @@ export type MetadataGetNodeDdlQueryVariables = Exact<{
   nodeId: Scalars['ID'];
 }>;
 
+
 export type MetadataGetNodeDdlQuery = Pick<Query, 'metadataGetNodeDDL'>;
 
 export type GetChildrenDbObjectInfoQueryVariables = Exact<{
@@ -1201,6 +1309,7 @@ export type GetChildrenDbObjectInfoQueryVariables = Exact<{
   filter?: Maybe<ObjectPropertyFilter>;
 }>;
 
+
 export type GetChildrenDbObjectInfoQuery = { dbObjects: Array<(
     Pick<NavigatorNodeInfo, 'id'>
     & { object?: Maybe<(
@@ -1214,6 +1323,7 @@ export type GetDbObjectInfoQueryVariables = Exact<{
   filter?: Maybe<ObjectPropertyFilter>;
 }>;
 
+
 export type GetDbObjectInfoQuery = { objectInfo: { object?: Maybe<(
       Pick<DatabaseObjectInfo, 'features'>
       & { properties?: Maybe<Array<Maybe<Pick<ObjectPropertyInfo, 'id' | 'category' | 'dataType' | 'description' | 'displayName' | 'features' | 'value'>>>> }
@@ -1223,6 +1333,7 @@ export type NavNodeChildrenQueryVariables = Exact<{
   parentPath: Scalars['ID'];
 }>;
 
+
 export type NavNodeChildrenQuery = { navNodeChildren: Array<(
     Pick<NavigatorNodeInfo, 'id' | 'name' | 'hasChildren' | 'nodeType' | 'icon' | 'folder' | 'inline' | 'navigable' | 'features'>
     & { object?: Maybe<Pick<DatabaseObjectInfo, 'features'>> }
@@ -1235,6 +1346,7 @@ export type NavNodeInfoQueryVariables = Exact<{
   nodePath: Scalars['ID'];
 }>;
 
+
 export type NavNodeInfoQuery = { navNodeInfo: (
     Pick<NavigatorNodeInfo, 'id' | 'name' | 'hasChildren' | 'nodeType' | 'icon' | 'folder' | 'inline' | 'navigable' | 'features'>
     & { object?: Maybe<Pick<DatabaseObjectInfo, 'features'>> }
@@ -1244,6 +1356,7 @@ export type NavRefreshNodeQueryVariables = Exact<{
   nodePath: Scalars['ID'];
 }>;
 
+
 export type NavRefreshNodeQuery = Pick<Query, 'navRefreshNode'>;
 
 export type QuerySqlCompletionProposalsQueryVariables = Exact<{
@@ -1254,34 +1367,40 @@ export type QuerySqlCompletionProposalsQueryVariables = Exact<{
   maxResults?: Maybe<Scalars['Int']>;
 }>;
 
+
 export type QuerySqlCompletionProposalsQuery = { sqlCompletionProposals?: Maybe<Array<Maybe<Pick<SqlCompletionProposal, 'cursorPosition' | 'displayString' | 'icon' | 'nodePath' | 'replacementLength' | 'replacementOffset' | 'replacementString' | 'score' | 'type'>>>> };
 
 export type QuerySqlDialectInfoQueryVariables = Exact<{
   connectionId: Scalars['ID'];
 }>;
 
+
 export type QuerySqlDialectInfoQuery = { dialect?: Maybe<Pick<SqlDialectInfo, 'name' | 'dataTypes' | 'functions' | 'reservedWords' | 'quoteStrings' | 'singleLineComments' | 'multiLineComments' | 'catalogSeparator' | 'structSeparator' | 'scriptDelimiter'>> };
 
 export type ConfigureServerQueryVariables = Exact<{
   configuration: ServerConfigInput;
 }>;
 
+
 export type ConfigureServerQuery = Pick<Query, 'configureServer'>;
 
 export type SetDefaultNavigatorSettingsQueryVariables = Exact<{
   settings: NavigatorSettingsInput;
 }>;
 
+
 export type SetDefaultNavigatorSettingsQuery = Pick<Query, 'setDefaultNavigatorSettings'>;
 
 export type ChangeSessionLanguageMutationVariables = Exact<{
   locale: Scalars['String'];
 }>;
 
+
 export type ChangeSessionLanguageMutation = Pick<Mutation, 'changeSessionLanguage'>;
 
 export type OpenSessionMutationVariables = Exact<{ [key: string]: never; }>;
 
+
 export type OpenSessionMutation = { session: (
     Pick<SessionInfo, 'createTime' | 'lastAccessTime' | 'cacheExpired' | 'locale'>
     & { connections: Array<Pick<ConnectionInfo, 'id' | 'name' | 'driverId' | 'connected' | 'readOnly' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'>> }
@@ -1292,10 +1411,12 @@ export type ReadSessionLogQueryVariables = Exact<{
   clearEntries: Scalars['Boolean'];
 }>;
 
+
 export type ReadSessionLogQuery = { log: Array<Pick<LogEntry, 'time' | 'type' | 'message' | 'stackTrace'>> };
 
 export type ServerConfigQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type ServerConfigQuery = { serverConfig: (
     Pick<ServerConfig, 'name' | 'version' | 'productConfiguration' | 'supportsCustomConnections' | 'supportsConnectionBrowser' | 'supportsWorkspaces' | 'anonymousAccessEnabled' | 'authenticationEnabled' | 'configurationMode' | 'developmentMode'>
     & { supportedLanguages: Array<Pick<ServerLanguage, 'isoCode' | 'displayName' | 'nativeName'>>, defaultNavigatorSettings: Pick<NavigatorSettings, 'showSystemObjects' | 'showUtilityObjects' | 'showOnlyEntities' | 'mergeEntities' | 'hideFolders' | 'hideSchemas' | 'hideVirtualModel'> }
@@ -1303,10 +1424,12 @@ export type ServerConfigQuery = { serverConfig: (
 
 export type SessionPermissionsQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type SessionPermissionsQuery = { permissions: Query['sessionPermissions'] };
 
 export type SessionStateQueryVariables = Exact<{ [key: string]: never; }>;
 
+
 export type SessionStateQuery = { sessionState: (
     Pick<SessionInfo, 'createTime' | 'lastAccessTime' | 'locale' | 'cacheExpired'>
     & { connections: Array<Pick<ConnectionInfo, 'id' | 'name' | 'driverId' | 'connected' | 'authNeeded' | 'authModel' | 'features' | 'supportedDataFormats'>> }
@@ -1314,6 +1437,7 @@ export type SessionStateQuery = { sessionState: (
 
 export type TouchSessionMutationVariables = Exact<{ [key: string]: never; }>;
 
+
 export type TouchSessionMutation = Pick<Mutation, 'touchSession'>;
 
 export type SqlContextCreateMutationVariables = Exact<{
@@ -1322,6 +1446,7 @@ export type SqlContextCreateMutationVariables = Exact<{
   defaultSchema?: Maybe<Scalars['String']>;
 }>;
 
+
 export type SqlContextCreateMutation = { context: Pick<SqlContextInfo, 'id' | 'defaultCatalog' | 'defaultSchema'> };
 
 export type SqlContextDestroyMutationVariables = Exact<{
@@ -1329,6 +1454,7 @@ export type SqlContextDestroyMutationVariables = Exact<{
   contextId: Scalars['ID'];
 }>;
 
+
 export type SqlContextDestroyMutation = Pick<Mutation, 'sqlContextDestroy'>;
 
 export type SqlContextSetDefaultsMutationVariables = Exact<{
@@ -1338,6 +1464,7 @@ export type SqlContextSetDefaultsMutationVariables = Exact<{
   defaultSchema?: Maybe<Scalars['ID']>;
 }>;
 
+
 export type SqlContextSetDefaultsMutation = { context: Mutation['sqlContextSetDefaults'] };
 
 export type SqlResultCloseMutationVariables = Exact<{
@@ -1346,8 +1473,10 @@ export type SqlResultCloseMutationVariables = Exact<{
   resultId: Scalars['ID'];
 }>;
 
+
 export type SqlResultCloseMutation = { result: Mutation['sqlResultClose'] };
 
+
 export const AsyncTaskCancelDocument = `
     mutation asyncTaskCancel($taskId: String!) {
   result: asyncTaskCancel(id: $taskId)
@@ -1629,7 +1758,7 @@ export const ConnectionInfoDocument = `
     `;
 export const CreateConnectionDocument = `
     mutation createConnection($config: ConnectionConfig!) {
-  createConnection(config: $config) {
+  connection: createConnection(config: $config) {
     id
     name
     description
@@ -2238,6 +2367,7 @@ export const SqlResultCloseDocument = `
 
 export type SdkFunctionWrapper = <T>(action: () => Promise<T>) => Promise<T>;
 
+
 const defaultWrapper: SdkFunctionWrapper = sdkFunction => sdkFunction();
 export function getSdk(client: GraphQLClient, withWrapper: SdkFunctionWrapper = defaultWrapper) {
   return {
@@ -2447,4 +2577,4 @@ export function getSdk(client: GraphQLClient, withWrapper: SdkFunctionWrapper =
     },
   };
 }
-export type Sdk = ReturnType<typeof getSdk>;
+export type Sdk = ReturnType<typeof getSdk>;
\ No newline at end of file
diff --git a/webapp/packages/plugin-connection-custom/src/CustomConnectionService.ts b/webapp/packages/plugin-connection-custom/src/CustomConnectionService.ts
index 73328e48d5..0ef698d09e 100644
--- a/webapp/packages/plugin-connection-custom/src/CustomConnectionService.ts
+++ b/webapp/packages/plugin-connection-custom/src/CustomConnectionService.ts
@@ -6,7 +6,7 @@
  * you may not use this file except in compliance with the License.
  */
 
-import { ConnectionsManagerService, Connection } from '@cloudbeaver/core-connections';
+import { Connection, ConnectionInfoResource } from '@cloudbeaver/core-connections';
 import { injectable } from '@cloudbeaver/core-di';
 import { ConnectionConfig, GraphQLService } from '@cloudbeaver/core-sdk';
 
@@ -15,18 +15,12 @@ export class CustomConnectionService {
 
   constructor(
     private graphQLService: GraphQLService,
-    private connectionsManagerService: ConnectionsManagerService,
+    private connectionInfoResource: ConnectionInfoResource,
   ) {
   }
 
   async createConnectionAsync(config: ConnectionConfig): Promise<Connection> {
-    const response = await this.graphQLService.sdk.createConnection({
-      config,
-    });
-
-    this.connectionsManagerService.addOpenedConnection(response.createConnection);
-
-    return response.createConnection;
+    return this.connectionInfoResource.createConnection(config);
   }
 
   async testConnectionAsync(config: ConnectionConfig): Promise<void> {