@finos/legend-graph 1.0.6 → 1.2.0

package/src/helpers/PureLanguageHelper.ts

@@ -0,0 +1,86 @@
+/**
+ * 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 { PRIMITIVE_TYPE } from '../MetaModelConst';
+import type { ConcreteFunctionDefinition } from '../models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition';
+import type { Type } from '../models/metamodels/pure/packageableElements/domain/Type';
+import { PrimitiveType } from '../models/metamodels/pure/packageableElements/domain/PrimitiveType';
+import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration';
+import format from 'date-fns/format';
+
+export const generateDefaultParameterValueForType = (
+  type: Type | undefined,
+  index: number,
+): string | number | boolean => {
+  if (!type) {
+    return `param${index}`;
+  }
+  if (type instanceof Enumeration) {
+    return type.values.length !== 0
+      ? `${type.path}.${type.values[0]?.name}`
+      : `param${index}`;
+  } else if (type instanceof PrimitiveType) {
+    switch (type.name) {
+      case PRIMITIVE_TYPE.BOOLEAN:
+        return true;
+      case PRIMITIVE_TYPE.FLOAT:
+      case PRIMITIVE_TYPE.DECIMAL:
+        return 0.0;
+      case PRIMITIVE_TYPE.NUMBER:
+      case PRIMITIVE_TYPE.INTEGER:
+        return 0;
+      case PRIMITIVE_TYPE.DATE:
+      case PRIMITIVE_TYPE.STRICTDATE:
+        return `%${format(new Date(), 'yyyy-MM-dd')}`;
+      case PRIMITIVE_TYPE.DATETIME:
+        return `%${format(new Date(), 'yyyy-MM-dd')}T00:00:00`;
+      case PRIMITIVE_TYPE.STRICTTIME:
+        return `%00:00:00`;
+      case PRIMITIVE_TYPE.STRING:
+        return "''";
+      default:
+        return `param${index}`;
+    }
+  }
+  // Other non-primitive types, e.g. Class
+  return `param${index}`;
+};
+
+export const generateFunctionCallString = (
+  element: ConcreteFunctionDefinition,
+): string => {
+  let lambdaString = '';
+  if (element.parameters.length > 0) {
+    for (let i = 0; i < element.parameters.length; i++) {
+      const paramType = element.parameters[i]?.type.value;
+      const separator = i !== element.parameters.length - 1 ? ', ' : '';
+      lambdaString =
+        lambdaString +
+        generateDefaultParameterValueForType(paramType, i) +
+        separator;
+    }
+  }
+  return `${element.path}(${lambdaString})`;
+};
+
+export const generateFunctionSignature = (
+  element: ConcreteFunctionDefinition,
+  fullPath: boolean,
+): string =>
+  `${fullPath ? element.path : element.name}(${element.parameters
+    .map((p) => `${p.name}: ${p.type.value.name}[${p.multiplicity.str}]`)
+    .join(', ')})` +
+  `: ${element.returnType.value.name}[${element.returnMultiplicity.str}]`;

package/src/index.ts

@@ -149,6 +149,7 @@ export * from './helpers/MappingResolutionHelper';
 export * from './helpers/ValidationHelper';
 export * from './helpers/Stubable'; // TODO: to be removed
 export * from './helpers/DomainHelper';
+export * from './helpers/PureLanguageHelper';
 
 // --------------------------------------------- GRAPH --------------------------------------------------
 
@@ -181,6 +182,8 @@ export * from './graphManager/DSLGenerationSpecification_PureGraphManagerPlugin_
 export {
   ExecutionResult,
   TdsExecutionResult,
+  RawExecutionResult,
+  EXECUTION_SERIALIZATION_FORMAT,
 } from './graphManager/action/execution/ExecutionResult';
 export * from './graphManager/action/execution/ExecutionResultHelper';
 export * from './graphManager/PureGraphManagerPlugin';

package/src/models/metamodels/pure/packageableElements/mapping/PropertyMapping.ts

@@ -67,9 +67,11 @@ export abstract class PropertyMapping implements Hashable, Stubable {
   owner: PropertyMappingsImplementation; // the immediate parent instance set implementation that holds the property mappings
   // NOTE: in case the holder of this property mapping is an embedded property mapping, that embedded property mapping is considered the source
   // otherwise, it is always the top/root `InstanceSetImplementation` that is considered the source implementation
+  // TODO: change this to use `SetImplemenetationReference`
   sourceSetImplementation: SetImplementation;
   // NOTE: in Pure, we actually only store `targetId` and `sourceId` instead of the reference
   // but for convenience and graph completeness validation purpose we will resolve to the actual set implementations here
+  // TODO: change this to use `OptionalSetImplemenetationReference`
   targetSetImplementation?: SetImplementation | undefined;
   localMappingProperty?: LocalMappingPropertyInfo | undefined;
   // store?: Store | undefined;

package/src/models/metamodels/pure/packageableElements/mapping/SetImplementation.ts

@@ -18,9 +18,12 @@ import { observable, action, computed, makeObservable } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { fromElementPathToMappingElementId } from '../../../../../MetaModelUtils';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
-import type { PackageableElementReference } from '../PackageableElementReference';
+import {
+  PackageableElementExplicitReference,
+  type PackageableElementReference,
+} from '../PackageableElementReference';
 import type { PropertyOwnerImplementation } from './PropertyOwnerImplementation';
-import type { Class } from '../domain/Class';
+import { Class } from '../domain/Class';
 import type { Mapping, MappingElementLabel } from './Mapping';
 import type { Stubable } from '../../../../../helpers/Stubable';
 import type { OperationSetImplementation } from './OperationSetImplementation';
@@ -29,8 +32,14 @@ import type { FlatDataInstanceSetImplementation } from '../store/flatData/mappin
 import type { EmbeddedFlatDataPropertyMapping } from '../store/flatData/mapping/EmbeddedFlatDataPropertyMapping';
 import type { RelationalInstanceSetImplementation } from '../store/relational/mapping/RelationalInstanceSetImplementation';
 import type { RootRelationalInstanceSetImplementation } from '../store/relational/mapping/RootRelationalInstanceSetImplementation';
-import type { InferableMappingElementIdValue } from './InferableMappingElementId';
-import type { InferableMappingElementRoot } from './InferableMappingElementRoot';
+import {
+  InferableMappingElementIdExplicitValue,
+  type InferableMappingElementIdValue,
+} from './InferableMappingElementId';
+import {
+  InferableMappingElementRootExplicitValue,
+  type InferableMappingElementRoot,
+} from './InferableMappingElementRoot';
 import type { AggregationAwareSetImplementation } from './aggregationAware/AggregationAwareSetImplementation';
 import type { InstanceSetImplementation } from './InstanceSetImplementation';
 
@@ -58,6 +67,9 @@ export interface SetImplementationVisitor<T> {
   visit_AggregationAwareSetImplementation(
     setImplementation: AggregationAwareSetImplementation,
   ): T;
+  visit_TEMPORARY__UnresolvedSetImplementation(
+    setImplementation: TEMPORARY__UnresolvedSetImplementation,
+  ): T;
 }
 
 export abstract class SetImplementation
@@ -143,3 +155,28 @@ export enum SET_IMPLEMENTATION_TYPE {
   EMBEDDED_RELATIONAL = 'embeddedRelational',
   AGGREGATION_AWARE = 'aggregationAware',
 }
+
+/* @MARKER: RELAXED GRAPH CHECK - See https://github.com/finos/legend-studio/issues/880 */
+/**
+ * When set implementation cannot be resolved by ID,
+ * we try to avoid failing graph building for now
+ * instead, we will leave this loose end unresolved.
+ *
+ * NOTE: this is just a temporary solutions until we make this a hard-fail post migration.
+ *
+ * See https://github.com/finos/legend-studio/issues/880
+ */
+export class TEMPORARY__UnresolvedSetImplementation extends SetImplementation {
+  constructor(id: string, parent: Mapping) {
+    super(
+      InferableMappingElementIdExplicitValue.create(id, ''),
+      parent,
+      PackageableElementExplicitReference.create(new Class('')),
+      InferableMappingElementRootExplicitValue.create(false),
+    );
+  }
+
+  accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
+    return visitor.visit_TEMPORARY__UnresolvedSetImplementation(this);
+  }
+}

package/src/models/metamodels/pure/packageableElements/store/relational/connection/AuthenticationStrategy.ts

@@ -67,21 +67,32 @@ export class DefaultH2AuthenticationStrategy
   }
 }
 
-export class TestDatabaseAuthenticationStrategy
-  extends DefaultH2AuthenticationStrategy
+export class ApiTokenAuthenticationStrategy
+  extends AuthenticationStrategy
   implements Hashable
 {
-  constructor() {
+  apiToken: string;
+
+  constructor(apiToken: string) {
     super();
 
     makeObservable(this, {
+      apiToken: observable,
+      setApiToken: action,
       hashCode: computed,
     });
+
+    this.apiToken = apiToken;
   }
 
-  override get hashCode(): string {
+  setApiToken(val: string): void {
+    this.apiToken = val;
+  }
+
+  get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.TEST_DATABASE_AUTHENTICATION_STRATEGY,
+      CORE_HASH_STRUCTURE.API_TOKEN_AUTHENTICATION_STRATEGY,
+      this.apiToken,
     ]);
   }
 }
@@ -176,45 +187,6 @@ export class SnowflakePublicAuthenticationStrategy
   }
 }
 
-export class UserPasswordAuthenticationStrategy
-  extends AuthenticationStrategy
-  implements Hashable
-{
-  userName: string;
-  passwordVaultReference: string;
-
-  constructor(userName: string, passwordVaultReference: string) {
-    super();
-
-    makeObservable(this, {
-      userName: observable,
-      passwordVaultReference: observable,
-      setUserName: action,
-      setPasswordVaultReference: action,
-      hashCode: computed,
-    });
-
-    this.userName = userName;
-    this.passwordVaultReference = passwordVaultReference;
-  }
-
-  setUserName(val: string): void {
-    this.userName = val;
-  }
-
-  setPasswordVaultReference(val: string): void {
-    this.passwordVaultReference = val;
-  }
-
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.USER_PASSWORD_AUTHENTICATION_STRATEGY,
-      this.userName,
-      this.passwordVaultReference,
-    ]);
-  }
-}
-
 export class GCPApplicationDefaultCredentialsAuthenticationStrategy
   extends AuthenticationStrategy
   implements Hashable

package/src/models/metamodels/pure/packageableElements/store/relational/connection/DatasourceSpecification.ts

@@ -71,6 +71,63 @@ export class StaticDatasourceSpecification
   }
 }
 
+export class DatabricksDatasourceSpecification
+  extends DatasourceSpecification
+  implements Hashable
+{
+  hostname: string;
+  port: string;
+  protocol: string;
+  httpPath: string;
+
+  constructor(
+    hostname: string,
+    port: string,
+    protocol: string,
+    httpPath: string,
+  ) {
+    super();
+
+    makeObservable(this, {
+      hostname: observable,
+      port: observable,
+      protocol: observable,
+      httpPath: observable,
+      hashCode: computed,
+    });
+    this.hostname = hostname;
+    this.port = port;
+    this.protocol = protocol;
+    this.httpPath = httpPath;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATABRICKS_DATASOURCE_SPECIFICATION,
+      this.hostname,
+      this.port,
+      this.protocol,
+      this.httpPath,
+    ]);
+  }
+
+  setHostName(val: string): void {
+    this.hostname = val;
+  }
+
+  setPort(val: string): void {
+    this.port = val;
+  }
+
+  setProtocol(val: string): void {
+    this.protocol = val;
+  }
+
+  setHttpPath(val: string): void {
+    this.httpPath = val;
+  }
+}
+
 export class EmbeddedH2DatasourceSpecification
   extends DatasourceSpecification
   implements Hashable

package/src/models/metamodels/pure/packageableElements/store/relational/connection/RelationalDatabaseConnection.ts

@@ -38,6 +38,7 @@ export enum DatabaseType {
   SqlServer = 'SqlServer',
   Hive = 'Hive',
   Snowflake = 'Snowflake',
+  Databricks = 'Databricks',
   Presto = 'Presto',
   Redshift = 'Redshift',
   BigQuery = 'BigQuery',

package/src/models/protocols/pure/v1/V1_PureGraphManager.ts

@@ -38,11 +38,12 @@ import {
   assertErrorThrown,
   promisify,
 } from '@finos/legend-shared';
-import type { TEMP__AbstractEngineConfig } from '../../../../graphManager/action/TEMP__AbstractEngineConfig';
+import type { TEMPORARY__AbstractEngineConfig } from '../../../../graphManager/action/TEMPORARY__AbstractEngineConfig';
 import {
   AbstractPureGraphManager,
-  type TEMP__EngineSetupConfig,
+  type TEMPORARY__EngineSetupConfig,
   type GraphBuilderOptions,
+  type ExecutionOptions,
 } from '../../../../graphManager/AbstractPureGraphManager';
 import type { Mapping } from '../../../metamodels/pure/packageableElements/mapping/Mapping';
 import type { Runtime } from '../../../metamodels/pure/packageableElements/runtime/Runtime';
@@ -406,12 +407,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  TEMP__getEngineConfig(): TEMP__AbstractEngineConfig {
+  TEMPORARY__getEngineConfig(): TEMPORARY__AbstractEngineConfig {
     return this.engine.config;
   }
 
   *initialize(
-    config: TEMP__EngineSetupConfig,
+    config: TEMPORARY__EngineSetupConfig,
     options?: {
       tracerService?: TracerService | undefined;
     },
@@ -1033,7 +1034,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
      * perserve the element path both resolved and unresolved
      */
     if (!options?.TEMPORARY__keepSectionIndex) {
-      graph.TEMP__deleteOwnSectionIndex();
+      graph.TEMPORARY__deleteOwnSectionIndex();
     }
   }
 
@@ -1852,7 +1853,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     lambda: RawLambda,
     runtime: Runtime,
     clientVersion: string,
-    useLosslessParse: boolean,
+    options?: ExecutionOptions,
   ): Promise<ExecutionResult> {
     return V1_buildExecutionResult(
       await this.engine.executeMapping(
@@ -1863,7 +1864,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           runtime,
           clientVersion,
         ),
-        useLosslessParse,
+        options,
       ),
     );
   }

package/src/models/protocols/pure/v1/engine/V1_Engine.ts

@@ -25,6 +25,7 @@ import {
   mergeObjects,
   HttpStatus,
   NetworkClientError,
+  returnUndefOnError,
 } from '@finos/legend-shared';
 import { GRAPH_MANAGER_LOG_EVENT } from '../../../../../graphManager/GraphManagerLogEvent';
 import {
@@ -36,7 +37,7 @@ import {
   GenerationMode,
   type GenerationConfigurationDescription,
 } from '../../../../../graphManager/action/generation/GenerationConfigurationDescription';
-import { TEMP__AbstractEngineConfig } from '../../../../../graphManager/action/TEMP__AbstractEngineConfig';
+import { TEMPORARY__AbstractEngineConfig } from '../../../../../graphManager/action/TEMPORARY__AbstractEngineConfig';
 import { V1_EngineServerClient } from './V1_EngineServerClient';
 import type { V1_PureModelContextData } from '../model/context/V1_PureModelContextData';
 import type { V1_LambdaReturnTypeResult } from '../engine/compilation/V1_LambdaReturnTypeResult';
@@ -90,8 +91,9 @@ import { serialize } from 'serializr';
 import { V1_ExecutionError } from './execution/V1_ExecutionError';
 import { V1_PureModelContextText } from '../model/context/V1_PureModelContextText';
 import { V1_QuerySearchSpecification } from './query/V1_QuerySearchSpecification';
+import type { ExecutionOptions } from '../../../../../graphManager/AbstractPureGraphManager';
 
-class V1_EngineConfig extends TEMP__AbstractEngineConfig {
+class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
 
   override setEnv(val: string | undefined): void {
@@ -403,20 +405,24 @@ export class V1_Engine {
 
   async executeMapping(
     input: V1_ExecuteInput,
-    useLosslessParse: boolean,
+    options?: ExecutionOptions,
   ): Promise<V1_ExecutionResult> {
     try {
       const executionResultInText = await (
         (await this.engineServerClient.execute(
           V1_ExecuteInput.serialization.toJson(input),
-          true,
+          {
+            returnResultAsText: true,
+            serializationFormat: options?.serializationFormat,
+          },
         )) as Response
       ).text();
-      return V1_serializeExecutionResult(
-        useLosslessParse
+      const rawExecutionResult = (returnUndefOnError(() =>
+        options?.useLosslessParse
           ? losslessParse(executionResultInText)
           : JSON.parse(executionResultInText),
-      );
+      ) ?? executionResultInText) as PlainObject<V1_ExecutionResult> | string;
+      return V1_serializeExecutionResult(rawExecutionResult);
     } catch (error) {
       assertErrorThrown(error);
       if (error instanceof NetworkClientError) {

package/src/models/protocols/pure/v1/engine/V1_EngineServerClient.ts

@@ -47,6 +47,7 @@ import type { V1_LightQuery, V1_Query } from './query/V1_Query';
 import type { V1_ServiceStorage } from './service/V1_ServiceStorage';
 import type { GenerationMode } from '../../../../../graphManager/action/generation/GenerationConfigurationDescription';
 import type { V1_QuerySearchSpecification } from './query/V1_QuerySearchSpecification';
+import type { EXECUTION_SERIALIZATION_FORMAT } from '../../../../../graphManager/action/execution/ExecutionResult';
 
 enum CORE_ENGINE_TRACER_SPAN {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -269,7 +270,10 @@ export class V1_EngineServerClient extends AbstractServerClient {
   _execution = (): string => `${this._pure()}/execution`;
   execute = (
     input: PlainObject<V1_ExecuteInput>,
-    returnResultAsText?: boolean,
+    options?: {
+      returnResultAsText?: boolean;
+      serializationFormat?: EXECUTION_SERIALIZATION_FORMAT | undefined;
+    },
   ): Promise<PlainObject<V1_ExecutionResult> | Response> =>
     this.postWithTracing(
       this.getTraceData(CORE_ENGINE_TRACER_SPAN.EXECUTE),
@@ -277,9 +281,11 @@ export class V1_EngineServerClient extends AbstractServerClient {
       input,
       {},
       undefined,
-      undefined,
+      {
+        serializationFormat: options?.serializationFormat,
+      },
       { enableCompression: true },
-      { skipProcessing: Boolean(returnResultAsText) },
+      { skipProcessing: Boolean(options?.returnResultAsText) },
     );
 
   generatePlan = (

package/src/models/protocols/pure/v1/engine/V1_ExecutionHelper.ts

@@ -27,6 +27,7 @@ import {
   TdsExecutionResult,
   TdsBuilder,
   TDSColumn,
+  RawExecutionResult,
 } from '../../../../../graphManager/action/execution/ExecutionResult';
 import {
   type V1_ExecutionResult,
@@ -35,6 +36,7 @@ import {
   V1_JsonExecutionResult,
   V1_INTERNAL__UnknownExecutionResult,
   V1_TdsExecutionResult,
+  V1_RawExecutionResult,
 } from './execution/V1_ExecutionResult';
 
 const buildJSONExecutionResult = (
@@ -113,6 +115,8 @@ export const V1_buildExecutionResult = (
     return buildTDSExecutionResult(protocol);
   } else if (protocol instanceof V1_JsonExecutionResult) {
     return buildJSONExecutionResult(protocol);
+  } else if (protocol instanceof V1_RawExecutionResult) {
+    return new RawExecutionResult(protocol.value);
   } else if (protocol instanceof V1_INTERNAL__UnknownExecutionResult) {
     return new INTERNAL__UnknownExecutionResult(protocol.content);
   }

package/src/models/protocols/pure/v1/engine/execution/V1_ExecutionResult.ts

@@ -19,6 +19,7 @@ import {
   type PlainObject,
   SerializationFactory,
   usingModelSchema,
+  isString,
 } from '@finos/legend-shared';
 import { BuilderType } from '../../../../../../graphManager/action/execution/ExecutionResult';
 
@@ -101,6 +102,15 @@ export class V1_ClassExecutionResult extends V1_ExecutionResult {
   );
 }
 
+export class V1_RawExecutionResult extends V1_ExecutionResult {
+  value: string;
+
+  constructor(value: string) {
+    super();
+    this.value = value;
+  }
+}
+
 export class V1_INTERNAL__UnknownExecutionResult extends V1_ExecutionResult {
   content: object;
 
@@ -111,8 +121,11 @@ export class V1_INTERNAL__UnknownExecutionResult extends V1_ExecutionResult {
 }
 
 export const V1_serializeExecutionResult = (
-  value: PlainObject<V1_ExecutionResult>,
+  value: PlainObject<V1_ExecutionResult> | string,
 ): V1_ExecutionResult => {
+  if (isString(value)) {
+    return new V1_RawExecutionResult(value);
+  }
   switch ((value.builder as PlainObject<V1_ResultBuilder>)._type) {
     case BuilderType.CLASS_BUILDER:
       return V1_ClassExecutionResult.serialization.fromJson(value);

package/src/models/protocols/pure/v1/model/packageableElements/store/relational/connection/V1_AuthenticationStrategy.ts

@@ -45,17 +45,6 @@ export class V1_DefaultH2AuthenticationStrategy
   }
 }
 
-export class V1_TestDatabaseAuthenticationStrategy
-  extends V1_DefaultH2AuthenticationStrategy
-  implements Hashable
-{
-  override get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.TEST_DATABASE_AUTHENTICATION_STRATEGY,
-    ]);
-  }
-}
-
 export class V1_OAuthAuthenticationStrategy
   extends V1_AuthenticationStrategy
   implements Hashable
@@ -72,36 +61,34 @@ export class V1_OAuthAuthenticationStrategy
   }
 }
 
-export class V1_SnowflakePublicAuthenticationStrategy
+export class V1_ApiTokenAuthenticationStrategy
   extends V1_AuthenticationStrategy
   implements Hashable
 {
-  privateKeyVaultReference!: string;
-  passPhraseVaultReference!: string;
-  publicUserName!: string;
+  apiToken!: string;
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.SNOWFLAKE_PUBLIC_AUTHENTICATION_STRATEGY,
-      this.privateKeyVaultReference,
-      this.passPhraseVaultReference,
-      this.publicUserName,
+      CORE_HASH_STRUCTURE.API_TOKEN_AUTHENTICATION_STRATEGY,
+      this.apiToken,
     ]);
   }
 }
 
-export class V1_UserPasswordAuthenticationStrategy
+export class V1_SnowflakePublicAuthenticationStrategy
   extends V1_AuthenticationStrategy
   implements Hashable
 {
-  userName!: string;
-  passwordVaultReference!: string;
+  privateKeyVaultReference!: string;
+  passPhraseVaultReference!: string;
+  publicUserName!: string;
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.USER_PASSWORD_AUTHENTICATION_STRATEGY,
-      this.userName,
-      this.passwordVaultReference,
+      CORE_HASH_STRUCTURE.SNOWFLAKE_PUBLIC_AUTHENTICATION_STRATEGY,
+      this.privateKeyVaultReference,
+      this.passPhraseVaultReference,
+      this.publicUserName,
     ]);
   }
 }

package/src/models/protocols/pure/v1/model/packageableElements/store/relational/connection/V1_DatasourceSpecification.ts

@@ -24,6 +24,7 @@ export enum V1_DatasourceSpecificationType {
   BIGQUERY = 'bigQuery',
   H2_LOCAL = 'h2Local',
   REDSHIFT = 'redshift',
+  DATABRICKS = 'databricks',
 }
 
 export abstract class V1_DatasourceSpecification implements Hashable {
@@ -68,6 +69,26 @@ export class V1_EmbeddedH2DatasourceSpecification
   }
 }
 
+export class V1_DatabricksDatasourceSpecification
+  extends V1_DatasourceSpecification
+  implements Hashable
+{
+  hostname!: string;
+  port!: string;
+  protocol!: string;
+  httpPath!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATABRICKS_DATASOURCE_SPECIFICATION,
+      this.hostname,
+      this.port,
+      this.protocol,
+      this.httpPath,
+    ]);
+  }
+}
+
 export class V1_SnowflakeDatasourceSpecification
   extends V1_DatasourceSpecification
   implements Hashable

package/src/models/protocols/pure/v1/model/packageableElements/store/relational/connection/V1_RelationalDatabaseConnection.ts

@@ -36,6 +36,7 @@ export enum V1_DatabaseType {
   Hive = 'Hive',
   Snowflake = 'Snowflake',
   BigQuery = 'BigQuery',
+  Databricks = 'Databricks',
   Presto = 'Presto',
   Redshift = 'Redshift',
 }