@finos/legend-graph 1.1.2 → 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 --------------------------------------------------
 

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,10 +38,10 @@ 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';
@@ -407,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;
     },
@@ -1034,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();
     }
   }
 

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

@@ -37,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';
@@ -93,7 +93,7 @@ import { V1_PureModelContextText } from '../model/context/V1_PureModelContextTex
 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 {

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',
 }

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_ConnectionTransformer.ts

@@ -33,9 +33,8 @@ import {
   DefaultH2AuthenticationStrategy,
   SnowflakePublicAuthenticationStrategy,
   GCPApplicationDefaultCredentialsAuthenticationStrategy,
+  ApiTokenAuthenticationStrategy,
   DelegatedKerberosAuthenticationStrategy,
-  TestDatabaseAuthenticationStrategy,
-  UserPasswordAuthenticationStrategy,
   OAuthAuthenticationStrategy,
   UsernamePasswordAuthenticationStrategy,
 } from '../../../../../../metamodels/pure/packageableElements/store/relational/connection/AuthenticationStrategy';
@@ -44,6 +43,7 @@ import {
   LocalH2DatasourceSpecification,
   StaticDatasourceSpecification,
   EmbeddedH2DatasourceSpecification,
+  DatabricksDatasourceSpecification,
   SnowflakeDatasourceSpecification,
   RedshiftDatasourceSpecification,
   BigQueryDatasourceSpecification,
@@ -60,6 +60,7 @@ import {
   V1_EmbeddedH2DatasourceSpecification,
   V1_SnowflakeDatasourceSpecification,
   V1_BigQueryDatasourceSpecification,
+  V1_DatabricksDatasourceSpecification,
   V1_StaticDatasourceSpecification,
   V1_RedshiftDatasourceSpecification,
 } from '../../../model/packageableElements/store/relational/connection/V1_DatasourceSpecification';
@@ -67,11 +68,10 @@ import {
   type V1_AuthenticationStrategy,
   V1_DefaultH2AuthenticationStrategy,
   V1_SnowflakePublicAuthenticationStrategy,
-  V1_UserPasswordAuthenticationStrategy,
   V1_GCPApplicationDefaultCredentialsAuthenticationStrategy,
   V1_UsernamePasswordAuthenticationStrategy,
+  V1_ApiTokenAuthenticationStrategy,
   V1_DelegatedKerberosAuthenticationStrategy,
-  V1_TestDatabaseAuthenticationStrategy,
   V1_OAuthAuthenticationStrategy,
 } from '../../../model/packageableElements/store/relational/connection/V1_AuthenticationStrategy';
 import type { V1_Connection } from '../../../model/packageableElements/connection/V1_Connection';
@@ -109,6 +109,17 @@ const transformEmbeddedH2DatasourceSpecification = (
   return source;
 };
 
+const transformDatabricksDatasourceSpecification = (
+  metamodel: DatabricksDatasourceSpecification,
+): V1_DatabricksDatasourceSpecification => {
+  const source = new V1_DatabricksDatasourceSpecification();
+  source.hostname = metamodel.hostname;
+  source.port = metamodel.port;
+  source.protocol = metamodel.protocol;
+  source.httpPath = metamodel.httpPath;
+  return source;
+};
+
 const transformSnowflakeDatasourceSpecification = (
   metamodel: SnowflakeDatasourceSpecification,
 ): V1_SnowflakeDatasourceSpecification => {
@@ -155,6 +166,8 @@ const transformDatasourceSpecification = (
     return transformStaticDatasourceSpecification(metamodel);
   } else if (metamodel instanceof EmbeddedH2DatasourceSpecification) {
     return transformEmbeddedH2DatasourceSpecification(metamodel);
+  } else if (metamodel instanceof DatabricksDatasourceSpecification) {
+    return transformDatabricksDatasourceSpecification(metamodel);
   } else if (metamodel instanceof SnowflakeDatasourceSpecification) {
     return transformSnowflakeDatasourceSpecification(metamodel);
   } else if (metamodel instanceof BigQueryDatasourceSpecification) {
@@ -205,21 +218,18 @@ const transformAuthenticationStrategy = (
     const auth = new V1_DelegatedKerberosAuthenticationStrategy();
     auth.serverPrincipal = metamodel.serverPrincipal;
     return auth;
-  } else if (metamodel instanceof TestDatabaseAuthenticationStrategy) {
-    return new V1_TestDatabaseAuthenticationStrategy();
   } else if (metamodel instanceof OAuthAuthenticationStrategy) {
     return transformOAuthtAuthenticationStrategy(metamodel);
+  } else if (metamodel instanceof ApiTokenAuthenticationStrategy) {
+    const auth = new V1_ApiTokenAuthenticationStrategy();
+    auth.apiToken = metamodel.apiToken;
+    return auth;
   } else if (metamodel instanceof SnowflakePublicAuthenticationStrategy) {
     const auth = new V1_SnowflakePublicAuthenticationStrategy();
     auth.privateKeyVaultReference = metamodel.privateKeyVaultReference;
     auth.passPhraseVaultReference = metamodel.passPhraseVaultReference;
     auth.publicUserName = metamodel.publicUserName;
     return auth;
-  } else if (metamodel instanceof UserPasswordAuthenticationStrategy) {
-    const auth = new V1_UserPasswordAuthenticationStrategy();
-    auth.userName = metamodel.userName;
-    auth.passwordVaultReference = metamodel.passwordVaultReference;
-    return auth;
   } else if (
     metamodel instanceof GCPApplicationDefaultCredentialsAuthenticationStrategy
   ) {

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_RelationalConnectionBuilderHelper.ts

@@ -25,6 +25,7 @@ import {
   LocalH2DatasourceSpecification,
   StaticDatasourceSpecification,
   EmbeddedH2DatasourceSpecification,
+  DatabricksDatasourceSpecification,
   SnowflakeDatasourceSpecification,
   RedshiftDatasourceSpecification,
   BigQueryDatasourceSpecification,
@@ -34,11 +35,10 @@ import {
   SnowflakePublicAuthenticationStrategy,
   GCPApplicationDefaultCredentialsAuthenticationStrategy,
   UsernamePasswordAuthenticationStrategy,
+  ApiTokenAuthenticationStrategy,
   OAuthAuthenticationStrategy,
   DefaultH2AuthenticationStrategy,
   DelegatedKerberosAuthenticationStrategy,
-  TestDatabaseAuthenticationStrategy,
-  UserPasswordAuthenticationStrategy,
 } from '../../../../../../../metamodels/pure/packageableElements/store/relational/connection/AuthenticationStrategy';
 import type { V1_GraphBuilderContext } from '../../../../transformation/pureGraph/to/V1_GraphBuilderContext';
 import {
@@ -46,6 +46,7 @@ import {
   V1_LocalH2DataSourceSpecification,
   V1_StaticDatasourceSpecification,
   V1_EmbeddedH2DatasourceSpecification,
+  V1_DatabricksDatasourceSpecification,
   V1_SnowflakeDatasourceSpecification,
   V1_RedshiftDatasourceSpecification,
   V1_BigQueryDatasourceSpecification,
@@ -56,9 +57,8 @@ import {
   V1_GCPApplicationDefaultCredentialsAuthenticationStrategy,
   V1_OAuthAuthenticationStrategy,
   V1_DefaultH2AuthenticationStrategy,
+  V1_ApiTokenAuthenticationStrategy,
   V1_DelegatedKerberosAuthenticationStrategy,
-  V1_TestDatabaseAuthenticationStrategy,
-  V1_UserPasswordAuthenticationStrategy,
   V1_UsernamePasswordAuthenticationStrategy,
 } from '../../../../model/packageableElements/store/relational/connection/V1_AuthenticationStrategy';
 import type { StoreRelational_PureProtocolProcessorPlugin_Extension } from '../../../../../StoreRelational_PureProtocolProcessorPlugin_Extension';
@@ -105,6 +105,30 @@ export const V1_buildDatasourceSpecification = (
       protocol.autoServerMode,
     );
     return embeddedSpec;
+  } else if (protocol instanceof V1_DatabricksDatasourceSpecification) {
+    assertNonEmptyString(
+      protocol.hostname,
+      'Databricks hostname specification is missing',
+    );
+    assertNonEmptyString(
+      protocol.port,
+      'Databricks port specification is missing',
+    );
+    assertNonEmptyString(
+      protocol.protocol,
+      'Databricks protocol specification is missing',
+    );
+    assertNonEmptyString(
+      protocol.httpPath,
+      'Databricks httpPath specification is missing',
+    );
+    const databricksSpec = new DatabricksDatasourceSpecification(
+      protocol.hostname,
+      protocol.port,
+      protocol.protocol,
+      protocol.httpPath,
+    );
+    return databricksSpec;
   } else if (protocol instanceof V1_SnowflakeDatasourceSpecification) {
     assertNonEmptyString(
       protocol.accountName,
@@ -202,6 +226,9 @@ export const V1_buildAuthenticationStrategy = (
     const metamodel = new DelegatedKerberosAuthenticationStrategy();
     metamodel.serverPrincipal = protocol.serverPrincipal;
     return metamodel;
+  } else if (protocol instanceof V1_ApiTokenAuthenticationStrategy) {
+    assertNonEmptyString(protocol.apiToken, 'API token is missing or empty');
+    return new ApiTokenAuthenticationStrategy(protocol.apiToken);
   } else if (protocol instanceof V1_SnowflakePublicAuthenticationStrategy) {
     assertNonEmptyString(
       protocol.privateKeyVaultReference,
@@ -225,8 +252,6 @@ export const V1_buildAuthenticationStrategy = (
     V1_GCPApplicationDefaultCredentialsAuthenticationStrategy
   ) {
     return new GCPApplicationDefaultCredentialsAuthenticationStrategy();
-  } else if (protocol instanceof V1_TestDatabaseAuthenticationStrategy) {
-    return new TestDatabaseAuthenticationStrategy();
   } else if (protocol instanceof V1_OAuthAuthenticationStrategy) {
     return new OAuthAuthenticationStrategy(
       guaranteeNonEmptyString(
@@ -238,19 +263,6 @@ export const V1_buildAuthenticationStrategy = (
         `OAuth authentication specification 'scopeName' field is missing or empty`,
       ),
     );
-  } else if (protocol instanceof V1_UserPasswordAuthenticationStrategy) {
-    assertNonEmptyString(
-      protocol.userName,
-      `User password authentication strategy 'userName' field is missing or empty`,
-    );
-    assertNonEmptyString(
-      protocol.passwordVaultReference,
-      `User password authentication strategy 'passwordVaultReference' field is missing or empty`,
-    );
-    return new UserPasswordAuthenticationStrategy(
-      protocol.userName,
-      protocol.passwordVaultReference,
-    );
   } else if (protocol instanceof V1_UsernamePasswordAuthenticationStrategy) {
     assertNonEmptyString(
       protocol.userNameVaultReference,