@finos/legend-graph 24.0.0 → 24.1.0

package/src/graph/metamodel/pure/packageableElements/PackageableElement.ts

@@ -41,6 +41,7 @@ import type { Measure } from './domain/Measure.js';
 import type { SectionIndex } from './section/SectionIndex.js';
 import type { DataElement } from './data/DataElement.js';
 import { AnnotatedElement } from './domain/AnnotatedElement.js';
+import type { ExecutionEnvironmentInstance } from './service/ExecutionEnvironmentInstance.js';
 
 export interface PackageableElementVisitor<T> {
   visit_PackageableElement(element: PackageableElement): T;
@@ -63,6 +64,7 @@ export interface PackageableElementVisitor<T> {
   visit_FileGenerationSpecification(element: FileGenerationSpecification): T;
   visit_GenerationSpecification(element: GenerationSpecification): T;
   visit_DataElement(element: DataElement): T;
+  visit_ExecutionEnvironmentInstance(element: ExecutionEnvironmentInstance): T;
 }
 
 class ModelElement extends AnnotatedElement {

package/src/graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.ts

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { hashArray, type Hashable } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../graph/Core_HashUtils.js';
+import type { Mapping } from '../mapping/Mapping.js';
+import type { Runtime } from '../runtime/Runtime.js';
+import {
+  type PackageableElementVisitor,
+  PackageableElement,
+} from '../PackageableElement.js';
+import type { PackageableElementReference } from '../PackageableElementReference.js';
+
+export class ExecutionEnvironmentInstance
+  extends PackageableElement
+  implements Hashable
+{
+  executionParameters: ExecutionParameters[] = [];
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EXECUTION_ENVIRONMENT_INSTANCE,
+      this.path,
+      hashArray(this.executionParameters),
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_ExecutionEnvironmentInstance(this);
+  }
+}
+
+export abstract class ExecutionParameters implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class SingleExecutionParameters implements Hashable {
+  key!: string;
+  mapping!: PackageableElementReference<Mapping>;
+  runtime!: Runtime;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SINGLE_EXECUTION_PARAMETER,
+      this.key,
+      this.mapping.valueForSerialization ?? '',
+      this.runtime,
+    ]);
+  }
+}
+
+export class MultiExecutionParameters implements Hashable {
+  masterKey!: string;
+  singleExecutionParameters: SingleExecutionParameters[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MULTI_EXECUTION_PARAMETER,
+      this.masterKey,
+      hashArray(this.singleExecutionParameters),
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/AuthenticationStrategy.ts

@@ -189,3 +189,28 @@ export class MiddleTierUsernamePasswordAuthenticationStrategy
     ]);
   }
 }
+
+export class TrinoDelegatedKerberosAuthenticationStrategy
+  extends AuthenticationStrategy
+  implements Hashable
+{
+  kerberosRemoteServiceName: string;
+  kerberosUseCanonicalHostname: boolean;
+
+  constructor(
+    kerberosRemoteServiceName: string,
+    kerberosUseCanonicalHostname: boolean,
+  ) {
+    super();
+    this.kerberosRemoteServiceName = kerberosRemoteServiceName;
+    this.kerberosUseCanonicalHostname = kerberosUseCanonicalHostname;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_DELEGATED_KERBEROS_AUTHENTICATION_STRATEGY,
+      this.kerberosRemoteServiceName,
+      this.kerberosUseCanonicalHostname.toString(),
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/DatasourceSpecification.ts

@@ -276,3 +276,56 @@ export class SpannerDatasourceSpecification
     ]);
   }
 }
+export class TrinoSslSpecification implements Hashable {
+  ssl: boolean;
+  trustStorePathVaultReference?: string | undefined;
+  trustStorePasswordVaultReference?: string | undefined;
+
+  constructor(ssl: boolean) {
+    this.ssl = ssl;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_SSL_SPECIFICATION,
+      this.ssl.toString(),
+      this.trustStorePathVaultReference ?? '',
+      this.trustStorePasswordVaultReference ?? '',
+    ]);
+  }
+}
+
+export class TrinoDatasourceSpecification
+  extends DatasourceSpecification
+  implements Hashable
+{
+  host: string;
+  port: number;
+  sslSpecification: TrinoSslSpecification;
+  catalog?: string | undefined;
+  schema?: string | undefined;
+  clientTags?: string | undefined;
+
+  constructor(
+    host: string,
+    port: number,
+    sslSpecification: TrinoSslSpecification,
+  ) {
+    super();
+    this.host = host;
+    this.port = port;
+    this.sslSpecification = sslSpecification;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_DATASOURCE_SPECIFICATION,
+      this.host,
+      this.port.toString(),
+      this.sslSpecification,
+      this.catalog ?? '',
+      this.schema ?? '',
+      this.clientTags ?? '',
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/RelationalDatabaseConnection.ts

@@ -49,6 +49,7 @@ export enum DatabaseType {
   Redshift = 'Redshift',
   BigQuery = 'BigQuery',
   Spanner = 'Spanner',
+  Trino = 'Trino',
 }
 
 export abstract class DatabaseConnection extends Connection {

package/src/graphManager/action/changeDetection/DSL_ExecutionEnvironment_ObseverHelper.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { makeObservable, override } from 'mobx';
+import type { ExecutionEnvironmentInstance } from '../../../graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
+import {
+  observe_Abstract_PackageableElement,
+  skipObservedWithContext,
+} from './CoreObserverHelper.js';
+
+export const observe_ExecutionEnvironmentInstance = skipObservedWithContext(
+  (
+    metamodel: ExecutionEnvironmentInstance,
+    context,
+  ): ExecutionEnvironmentInstance => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<ExecutionEnvironmentInstance, '_elementHashCode'>(
+      metamodel,
+      {
+        _elementHashCode: override,
+      },
+    );
+    // TODO once form is implemented
+    return metamodel;
+  },
+);

package/src/graphManager/action/changeDetection/GraphObserverHelper.ts

@@ -50,6 +50,7 @@ const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
     | 'generationSpecificationsIndex'
     | 'fileGenerationsIndex'
     | 'dataElementsIndex'
+    | 'executionEnvironmentIndex'
   >(metamodel, {
     elementSectionIndex: observable,
     extensions: observable,
@@ -67,6 +68,7 @@ const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
     generationSpecificationsIndex: observable,
     fileGenerationsIndex: observable,
     dataElementsIndex: observable,
+    executionEnvironmentIndex: observable,
 
     ownSectionIndices: computed,
     ownProfiles: computed,
@@ -86,6 +88,7 @@ const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
     ownFileGenerations: computed,
     ownGenerationSpecifications: computed,
     ownDataElements: computed,
+    ownExecutionEnvironments: computed,
 
     allOwnElements: computed,
   });
@@ -120,6 +123,7 @@ export const observe_DependencyManager = skipObserved(
       generationSpecifications: computed,
       fileGenerations: computed,
       dataElements: computed,
+      executionEnvironments: computed,
 
       allOwnElements: computed,
     }),
@@ -166,6 +170,7 @@ export const observe_Graph = (metamodel: PureModel): PureModel => {
     generationSpecifications: computed,
     fileGenerations: computed,
     dataElements: computed,
+    executionEnvironments: computed,
 
     allElements: computed,
     allOwnTestables: computed,

package/src/graphManager/action/changeDetection/PackageableElementObserver.ts

@@ -63,6 +63,8 @@ import { observe_FlatData } from './STO_FlatData_ObserverHelper.js';
 import { observe_Database } from './STO_Relational_ObserverHelper.js';
 import type { DataElement } from '../../../graph/metamodel/pure/packageableElements/data/DataElement.js';
 import { observe_DataElement } from './DSL_Data_ObserverHelper.js';
+import type { ExecutionEnvironmentInstance } from '../../../graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
+import { observe_ExecutionEnvironmentInstance } from './DSL_ExecutionEnvironment_ObseverHelper.js';
 
 class PackageableElementObserver implements PackageableElementVisitor<void> {
   observerContext: ObserverContext;
@@ -135,6 +137,12 @@ class PackageableElementObserver implements PackageableElementVisitor<void> {
     observe_Service(element, this.observerContext);
   }
 
+  visit_ExecutionEnvironmentInstance(
+    element: ExecutionEnvironmentInstance,
+  ): void {
+    observe_ExecutionEnvironmentInstance(element, this.observerContext);
+  }
+
   visit_PackageableRuntime(element: PackageableRuntime): void {
     observe_PackageableRuntime(element, this.observerContext);
   }

package/src/graphManager/action/changeDetection/STO_Relational_ObserverHelper.ts

@@ -26,9 +26,11 @@ import {
   UsernamePasswordAuthenticationStrategy,
   GCPWorkloadIdentityFederationAuthenticationStrategy,
   MiddleTierUsernamePasswordAuthenticationStrategy,
+  TrinoDelegatedKerberosAuthenticationStrategy,
 } from '../../../graph/metamodel/pure/packageableElements/store/relational/connection/AuthenticationStrategy.js';
 import {
   type DatasourceSpecification,
+  type TrinoSslSpecification,
   BigQueryDatasourceSpecification,
   DatabricksDatasourceSpecification,
   EmbeddedH2DatasourceSpecification,
@@ -37,6 +39,7 @@ import {
   SnowflakeDatasourceSpecification,
   StaticDatasourceSpecification,
   SpannerDatasourceSpecification,
+  TrinoDatasourceSpecification,
 } from '../../../graph/metamodel/pure/packageableElements/store/relational/connection/DatasourceSpecification.js';
 import {
   type Mapper,
@@ -841,6 +844,32 @@ export const observe_SpannerDatasourceSpecification = skipObserved(
     }),
 );
 
+export const observe_TrinoSslSpecification = skipObserved(
+  (metamodel: TrinoSslSpecification): TrinoSslSpecification =>
+    makeObservable(metamodel, {
+      ssl: observable,
+      trustStorePathVaultReference: observable,
+      trustStorePasswordVaultReference: observable,
+      hashCode: computed,
+    }),
+);
+
+export const observe_TrinoDatasourceSpecification = skipObserved(
+  (metamodel: TrinoDatasourceSpecification): TrinoDatasourceSpecification => {
+    makeObservable(metamodel, {
+      host: observable,
+      port: observable,
+      catalog: observable,
+      schema: observable,
+      clientTags: observable,
+      hashCode: computed,
+    });
+    observe_TrinoSslSpecification(metamodel.sslSpecification);
+
+    return metamodel;
+  },
+);
+
 export const observe_DatasourceSpecification = (
   metamodel: DatasourceSpecification,
   context: ObserverContext,
@@ -861,6 +890,8 @@ export const observe_DatasourceSpecification = (
     return observe_BigQueryDatasourceSpecification(metamodel);
   } else if (metamodel instanceof SpannerDatasourceSpecification) {
     return observe_SpannerDatasourceSpecification(metamodel);
+  } else if (metamodel instanceof TrinoDatasourceSpecification) {
+    return observe_TrinoDatasourceSpecification(metamodel);
   }
   const extraObservers = context.plugins.flatMap(
     (plugin) =>
@@ -970,6 +1001,18 @@ export const observe_MiddleTierUsernamePasswordAuthenticationStrategy =
       }),
   );
 
+export const observe_TrinoDelegatedKerberosAuthenticationStrategy =
+  skipObserved(
+    (
+      metamodel: TrinoDelegatedKerberosAuthenticationStrategy,
+    ): TrinoDelegatedKerberosAuthenticationStrategy =>
+      makeObservable(metamodel, {
+        hashCode: computed,
+        kerberosRemoteServiceName: observable,
+        kerberosUseCanonicalHostname: observable,
+      }),
+  );
+
 export const observe_AuthenticationStrategy = (
   metamodel: AuthenticationStrategy,
   context: ObserverContext,
@@ -1002,6 +1045,10 @@ export const observe_AuthenticationStrategy = (
     metamodel instanceof MiddleTierUsernamePasswordAuthenticationStrategy
   ) {
     return observe_MiddleTierUsernamePasswordAuthenticationStrategy(metamodel);
+  } else if (
+    metamodel instanceof TrinoDelegatedKerberosAuthenticationStrategy
+  ) {
+    return observe_TrinoDelegatedKerberosAuthenticationStrategy(metamodel);
   }
   const extraObservers = context.plugins.flatMap(
     (plugin) =>

package/src/graphManager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -279,6 +279,7 @@ import {
 import { MultiExecutionServiceTestResult } from '../../../../graph/metamodel/pure/packageableElements/service/MultiExecutionServiceTestResult.js';
 import type { ParameterValue } from '../../../../graph/metamodel/pure/packageableElements/service/ParameterValue.js';
 import type { Service } from '../../../../graph/metamodel/pure/packageableElements/service/Service.js';
+import { V1_ExecutionEnvironmentInstance } from './model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -305,6 +306,8 @@ class V1_PureModelContextDataIndex {
 
   dataElements: V1_DataElement[] = [];
 
+  executionEnvironments: V1_ExecutionEnvironmentInstance[] = [];
+
   otherElementsByBuilder: Map<
     V1_ElementBuilder<V1_PackageableElement>,
     V1_PackageableElement[]
@@ -369,6 +372,8 @@ export const V1_indexPureModelContextData = (
       index.generationSpecifications.push(el);
     } else if (el instanceof V1_DataElement) {
       index.dataElements.push(el);
+    } else if (el instanceof V1_ExecutionEnvironmentInstance) {
+      index.executionEnvironments.push(el);
     } else {
       const clazz = getClass<V1_PackageableElement>(el);
       if (otherElementsByClass.has(clazz)) {
@@ -985,7 +990,9 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
 
     // build services
-    graphBuilderState.setMessage(`Building services...`);
+    graphBuilderState.setMessage(
+      `Building services and execution environments...`,
+    );
     await this.buildServices(graph, inputs, options);
     stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_SERVICES__SUCCESS);
 
@@ -1381,6 +1388,18 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ),
       ),
     );
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.executionEnvironments.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
+    );
   }
 
   private async buildDataElements(
@@ -3212,6 +3231,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       return CORE_PURE_PATH.FLAT_DATA;
     } else if (protocol instanceof V1_Database) {
       return CORE_PURE_PATH.DATABASE;
+    } else if (protocol instanceof V1_ExecutionEnvironmentInstance) {
+      return CORE_PURE_PATH.EXECUTION_ENVIRONMENT;
     } else if (protocol instanceof V1_Service) {
       return CORE_PURE_PATH.SERVICE;
     } else if (protocol instanceof V1_FileGenerationSpecification) {

package/src/graphManager/protocol/pure/v1/model/packageableElements/V1_PackageableElement.ts

@@ -33,6 +33,7 @@ import type { V1_Measure } from './domain/V1_Measure.js';
 import type { V1_SectionIndex } from './section/V1_SectionIndex.js';
 import type { V1_DataElement } from './data/V1_DataElement.js';
 import { ELEMENT_PATH_DELIMITER } from '../../../../../../graph/MetaModelConst.js';
+import type { V1_ExecutionEnvironmentInstance } from './service/V1_ExecutionEnvironmentInstance.js';
 
 export interface V1_PackageableElementVisitor<T> {
   visit_PackageableElement(element: V1_PackageableElement): T;
@@ -53,6 +54,9 @@ export interface V1_PackageableElementVisitor<T> {
   visit_GenerationSpecification(element: V1_GenerationSpecification): T;
   visit_FileGeneration(element: V1_FileGenerationSpecification): T;
   visit_DataElement(element: V1_DataElement): T;
+  visit_ExecutionEnvironmentInstance(
+    element: V1_ExecutionEnvironmentInstance,
+  ): T;
 }
 
 export abstract class V1_PackageableElement implements Hashable {

package/src/graphManager/protocol/pure/v1/model/packageableElements/service/V1_ExecutionEnvironmentInstance.ts

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.js';
+import type { V1_Runtime } from '../runtime/V1_Runtime.js';
+import {
+  V1_PackageableElement,
+  type V1_PackageableElementVisitor,
+} from '../V1_PackageableElement.js';
+
+export class V1_ExecutionEnvironmentInstance
+  extends V1_PackageableElement
+  implements Hashable
+{
+  executionParameters: V1_ExecutionParameters[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EXECUTION_ENVIRONMENT_INSTANCE,
+      this.path,
+      hashArray(this.executionParameters),
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_ExecutionEnvironmentInstance(this);
+  }
+}
+
+export abstract class V1_ExecutionParameters implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_SingleExecutionParameters
+  extends V1_ExecutionParameters
+  implements Hashable
+{
+  key!: string;
+  mapping!: string;
+  runtime!: V1_Runtime;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SINGLE_EXECUTION_PARAMETER,
+      this.key,
+      this.mapping,
+      this.runtime,
+    ]);
+  }
+}
+
+export class V1_MultiExecutionParameters
+  extends V1_ExecutionParameters
+  implements Hashable
+{
+  masterKey!: string;
+  singleExecutionParameters: V1_SingleExecutionParameters[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MULTI_EXECUTION_PARAMETER,
+      this.masterKey,
+      hashArray(this.singleExecutionParameters),
+    ]);
+  }
+}

package/src/graphManager/protocol/pure/v1/model/packageableElements/store/relational/connection/V1_AuthenticationStrategy.ts

@@ -149,3 +149,19 @@ export class V1_MiddleTierUsernamePasswordAuthenticationStrategy
     ]);
   }
 }
+
+export class V1_TrinoDelegatedKerberosAuthenticationStrategy
+  extends V1_AuthenticationStrategy
+  implements Hashable
+{
+  kerberosRemoteServiceName!: string;
+  kerberosUseCanonicalHostname!: boolean;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_DELEGATED_KERBEROS_AUTHENTICATION_STRATEGY,
+      this.kerberosRemoteServiceName,
+      this.kerberosUseCanonicalHostname.toString(),
+    ]);
+  }
+}

package/src/graphManager/protocol/pure/v1/model/packageableElements/store/relational/connection/V1_DatasourceSpecification.ts

@@ -194,3 +194,42 @@ export class V1_LocalH2DataSourceSpecification
     ]);
   }
 }
+
+export class V1_TrinoSslSpecification implements Hashable {
+  ssl!: boolean;
+  trustStorePathVaultReference?: string | undefined;
+  trustStorePasswordVaultReference?: string | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_SSL_SPECIFICATION,
+      this.ssl.toString(),
+      this.trustStorePathVaultReference ?? '',
+      this.trustStorePasswordVaultReference ?? '',
+    ]);
+  }
+}
+
+export class V1_TrinoDatasourceSpecification
+  extends V1_DatasourceSpecification
+  implements Hashable
+{
+  host!: string;
+  port!: number;
+  sslSpecification!: V1_TrinoSslSpecification;
+  catalog?: string | undefined;
+  schema?: string | undefined;
+  clientTags?: string | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_DATASOURCE_SPECIFICATION,
+      this.host,
+      this.port.toString(),
+      this.sslSpecification,
+      this.catalog ?? '',
+      this.schema ?? '',
+      this.clientTags ?? '',
+    ]);
+  }
+}

package/src/graphManager/protocol/pure/v1/model/packageableElements/store/relational/connection/V1_RelationalDatabaseConnection.ts

@@ -47,6 +47,7 @@ export enum V1_DatabaseType {
   Presto = 'Presto',
   Redshift = 'Redshift',
   Spanner = 'Spanner',
+  Trino = 'Trino',
 }
 
 export abstract class V1_DatabaseConnection extends V1_Connection {