@finos/legend-graph 29.0.1 → 29.0.3

package/src/graph-manager/protocol/pure/v1/engine/V1_Engine.ts

@@ -114,6 +114,9 @@ import { V1_INTERNAL__PackageableElementWithSourceInformation } from '../transfo
 import { ELEMENT_PATH_DELIMITER } from '../../../../../graph/MetaModelConst.js';
 import { V1_serializeExecutionResult } from './execution/V1_ExecutionHelper.js';
 import type { ClassifierPathMapping } from '../../../../action/protocol/ClassifierPathMapping.js';
+import { V1_FunctionActivatorInfo } from './functionActivator/V1_FunctionActivatorInfo.js';
+import { V1_FunctionActivatorError } from './functionActivator/V1_FunctionActivatorError.js';
+import { V1_FunctionActivatorInput } from './functionActivator/V1_FunctionActivatorInput.js';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -808,7 +811,7 @@ export class V1_Engine {
   }
 
   async cancelUserExecutions(broadcastToCluster: boolean): Promise<string> {
-    return this.engineServerClient.cancelUserExecutions(
+    return this.engineServerClient.INTERNAL__cancelUserExecutions(
       guaranteeNonNullable(this.getCurrentUserId()),
       broadcastToCluster,
     );
@@ -854,8 +857,6 @@ export class V1_Engine {
     ).reports;
   }
 
-  // --------------------------------------------- Utilities ---------------------------------------------
-
   async buildDatabase(
     input: V1_DatabaseBuilderInput,
   ): Promise<V1_PureModelContextData> {
@@ -865,4 +866,53 @@ export class V1_Engine {
       ),
     );
   }
+
+  // ------------------------------------------- Function -------------------------------------------
+
+  async getAvailableFunctionActivators(): Promise<V1_FunctionActivatorInfo[]> {
+    try {
+      return (
+        await this.engineServerClient.getAvailableFunctionActivators()
+      ).map((info) => V1_FunctionActivatorInfo.serialization.fromJson(info));
+    } catch {
+      return [];
+    }
+  }
+
+  async validateFunctionActivator(
+    input: V1_FunctionActivatorInput,
+  ): Promise<void> {
+    const errors = await this.engineServerClient.validateFunctionActivator(
+      V1_FunctionActivatorInput.serialization.toJson(input),
+    );
+    if (errors.length) {
+      throw new Error(
+        `Function activator validation failed:\n${errors
+          .map((error) =>
+            V1_FunctionActivatorError.serialization.fromJson(error),
+          )
+          .map((error) => `- ${error.message}`)
+          .join('\n')}`,
+      );
+    }
+  }
+
+  async publishFunctionActivatorToSandbox(
+    input: V1_FunctionActivatorInput,
+  ): Promise<void> {
+    const errors =
+      await this.engineServerClient.publishFunctionActivatorToSandbox(
+        V1_FunctionActivatorInput.serialization.toJson(input),
+      );
+    if (errors.length) {
+      throw new Error(
+        `Function activator validation failed:\n${errors
+          .map((error) =>
+            V1_FunctionActivatorError.serialization.fromJson(error),
+          )
+          .map((error) => `- ${error.message}`)
+          .join('\n')}`,
+      );
+    }
+  }
 }

package/src/graph-manager/protocol/pure/v1/engine/V1_EngineServerClient.ts

@@ -63,8 +63,10 @@ import type {
   V1_SurveyDatasetsResult,
 } from './analytics/V1_StoreEntitlementAnalysis.js';
 import type { V1_RunTestsResult } from './test/V1_RunTestsResult.js';
-import type { V1_TEMPORARY__SnowflakeServiceDeploymentInput } from './service/V1_TEMPORARY__SnowflakeServiceDeploymentInput.js';
 import type { ClassifierPathMapping } from '../../../../action/protocol/ClassifierPathMapping.js';
+import type { V1_FunctionActivatorInfo } from './functionActivator/V1_FunctionActivatorInfo.js';
+import type { V1_FunctionActivatorError } from './functionActivator/V1_FunctionActivatorError.js';
+import type { V1_FunctionActivatorInput } from './functionActivator/V1_FunctionActivatorInput.js';
 
 enum CORE_ENGINE_ACTIVITY_TRACE {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -124,19 +126,13 @@ export class V1_EngineServerClient extends AbstractServerClient {
   // getting the user from the main engine server, which seems problematic.
   private queryBaseUrl?: string | undefined;
 
-  // NOTE: this is temporary solution to allow us test out the Snowflake service deployment flow
-  private TEMPORARY__snowflakeServiceDeploymentUrl?: string | undefined;
-
   constructor(
     config: ServerClientConfig & {
       queryBaseUrl?: string | undefined;
-      TEMPORARY__snowflakeServiceDeploymentUrl?: string | undefined;
     },
   ) {
     super(config);
     this.queryBaseUrl = config.queryBaseUrl;
-    this.TEMPORARY__snowflakeServiceDeploymentUrl =
-      config.TEMPORARY__snowflakeServiceDeploymentUrl;
   }
 
   setEnv = (value: string | undefined): void => {
@@ -161,7 +157,6 @@ export class V1_EngineServerClient extends AbstractServerClient {
   // ------------------------------------------- Server -------------------------------------------
 
   _server = (): string => `${this.baseUrl}/server/v1`;
-  _executionManager = (): string => `${this._server()}/executionManager`;
   getCurrentUserId = (): Promise<string> =>
     this.get(`${this._server()}/currentUser`);
 
@@ -466,6 +461,7 @@ export class V1_EngineServerClient extends AbstractServerClient {
   // ------------------------------------------- Execute -------------------------------------------
 
   _execution = (): string => `${this._pure()}/execution`;
+  _executionManager = (): string => `${this._server()}/executionManager`;
 
   execute = (
     input: PlainObject<V1_ExecuteInput>,
@@ -528,6 +524,60 @@ export class V1_EngineServerClient extends AbstractServerClient {
       { enableCompression: true },
     );
 
+  /**
+   * TODO: this is an internal API that should me refactored out using extension mechanism
+   */
+  INTERNAL__cancelUserExecutions = (
+    userID: string,
+    broadcastToCluster: boolean,
+  ): Promise<string> =>
+    this.deleteWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.CANCEL_USER_EXECUTIONS),
+      `${this._executionManager()}/cancelUserExecution`,
+      {},
+      {},
+      {},
+      { userID, broadcastToCluster },
+      { enableCompression: true },
+    );
+
+  // ------------------------------------------- Query -------------------------------------------
+
+  _query = (queryId?: string): string =>
+    `${this.queryBaseUrl ?? this.baseUrl}/pure/v1/query${
+      queryId ? `/${encodeURIComponent(queryId)}` : ''
+    }`;
+  searchQueries = (
+    searchSpecification: PlainObject<V1_QuerySearchSpecification>,
+  ): Promise<PlainObject<V1_LightQuery>[]> =>
+    this.post(`${this._query()}/search`, searchSpecification, undefined);
+  getQueries = (queryIds: string[]): Promise<PlainObject<V1_LightQuery>[]> =>
+    this.get(`${this._query()}/batch`, {}, undefined, { queryIds: queryIds });
+  getQuery = (queryId: string): Promise<PlainObject<V1_Query>> =>
+    this.get(this._query(queryId));
+  createQuery = (
+    query: PlainObject<V1_Query>,
+  ): Promise<PlainObject<V1_Query>> =>
+    this.postWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.CREATE_QUERY),
+      this._query(),
+      query,
+    );
+  updateQuery = (
+    queryId: string,
+    query: PlainObject<V1_Query>,
+  ): Promise<PlainObject<V1_Query>> =>
+    this.putWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.UPDATE_QUERY),
+      this._query(queryId),
+      query,
+    );
+  deleteQuery = (queryId: string): Promise<PlainObject<V1_Query>> =>
+    this.deleteWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.DELETE_QUERY),
+      this._query(queryId),
+    );
+
   // --------------------------------------- Analysis ---------------------------------------
 
   analyzeMappingModelCoverage = (
@@ -571,11 +621,7 @@ export class V1_EngineServerClient extends AbstractServerClient {
       { enableCompression: true },
     );
 
-  // ------------------------------------------- Utilities -------------------------------------------
-
-  _utilities = (): string => `${this._pure()}/utilities`;
-  _databaseUtilities = (): string => `${this._utilities()}/database`;
-
+  _databaseUtilities = (): string => `${this._pure()}/utilities/database`;
   buildDatabase = (
     input: PlainObject<V1_ExecuteInput>,
   ): Promise<PlainObject<V1_PureModelContextData>> =>
@@ -585,6 +631,28 @@ export class V1_EngineServerClient extends AbstractServerClient {
       input,
     );
 
+  // ------------------------------------------- Function ---------------------------------------
+
+  _functionActivator = (): string => `${this.baseUrl}/functionActivator`;
+
+  getAvailableFunctionActivators(): Promise<
+    PlainObject<V1_FunctionActivatorInfo>[]
+  > {
+    return this.get(`${this._functionActivator()}/list`);
+  }
+
+  validateFunctionActivator(
+    input: PlainObject<V1_FunctionActivatorInput>,
+  ): Promise<PlainObject<V1_FunctionActivatorError>[]> {
+    return this.post(`${this._functionActivator()}/validate`, input);
+  }
+
+  publishFunctionActivatorToSandbox(
+    input: PlainObject<V1_FunctionActivatorInput>,
+  ): Promise<PlainObject<V1_FunctionActivatorError>[]> {
+    return this.post(`${this._functionActivator()}/publishToSandbox`, input);
+  }
+
   // ------------------------------------------- Service -------------------------------------------
 
   _service = (serviceServerUrl?: string): string =>
@@ -654,66 +722,4 @@ export class V1_EngineServerClient extends AbstractServerClient {
       {},
       { skipProcessing: true },
     );
-
-  // ------------------------------------------- Query -------------------------------------------
-
-  _query = (queryId?: string): string =>
-    `${this.queryBaseUrl ?? this.baseUrl}/pure/v1/query${
-      queryId ? `/${encodeURIComponent(queryId)}` : ''
-    }`;
-  searchQueries = (
-    searchSpecification: PlainObject<V1_QuerySearchSpecification>,
-  ): Promise<PlainObject<V1_LightQuery>[]> =>
-    this.post(`${this._query()}/search`, searchSpecification, undefined);
-  getQueries = (queryIds: string[]): Promise<PlainObject<V1_LightQuery>[]> =>
-    this.get(`${this._query()}/batch`, {}, undefined, { queryIds: queryIds });
-  getQuery = (queryId: string): Promise<PlainObject<V1_Query>> =>
-    this.get(this._query(queryId));
-  createQuery = (
-    query: PlainObject<V1_Query>,
-  ): Promise<PlainObject<V1_Query>> =>
-    this.postWithTracing(
-      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.CREATE_QUERY),
-      this._query(),
-      query,
-    );
-  updateQuery = (
-    queryId: string,
-    query: PlainObject<V1_Query>,
-  ): Promise<PlainObject<V1_Query>> =>
-    this.putWithTracing(
-      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.UPDATE_QUERY),
-      this._query(queryId),
-      query,
-    );
-  deleteQuery = (queryId: string): Promise<PlainObject<V1_Query>> =>
-    this.deleteWithTracing(
-      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.DELETE_QUERY),
-      this._query(queryId),
-    );
-
-  // ------------------------------------------- Snowflake Service -------------------------------------------
-
-  TEMPORARY__deploySnowflakeService = (
-    input: PlainObject<V1_TEMPORARY__SnowflakeServiceDeploymentInput>,
-  ): Promise<PlainObject> =>
-    this.post(
-      `${this.TEMPORARY__snowflakeServiceDeploymentUrl ?? this.baseUrl}`,
-      input,
-      undefined,
-    );
-
-  cancelUserExecutions = (
-    userID: string,
-    broadcastToCluster: boolean,
-  ): Promise<string> =>
-    this.deleteWithTracing(
-      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.CANCEL_USER_EXECUTIONS),
-      `${this._executionManager()}/cancelUserExecution`,
-      {},
-      {},
-      { [HttpHeader.ACCEPT]: ContentType.TEXT_PLAIN },
-      { userID, broadcastToCluster },
-      { enableCompression: true },
-    );
 }

package/src/graph-manager/protocol/pure/v1/engine/functionActivator/V1_FunctionActivatorError.ts

@@ -0,0 +1,28 @@
+/**
+ * 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, createModelSchema } from 'serializr';
+import { SerializationFactory } from '@finos/legend-shared';
+
+export class V1_FunctionActivatorError {
+  message!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_FunctionActivatorError, {
+      message: primitive(),
+    }),
+  );
+}

package/src/graph-manager/protocol/pure/v1/engine/functionActivator/V1_FunctionActivatorInfo.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 { list, primitive, createModelSchema } from 'serializr';
+import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
+import type { V1_Class } from '../../model/packageableElements/domain/V1_Class.js';
+import { V1_classModelSchema } from '../../transformation/pureProtocol/serializationHelpers/V1_DomainSerializationHelper.js';
+
+export class V1_FunctionActivatorConfigurationInfo {
+  topElement!: string;
+  packageableElementJSONType!: string;
+  model: V1_Class[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_FunctionActivatorConfigurationInfo, {
+      packageableElementJSONType: primitive(),
+      topElement: primitive(),
+      model: list(usingModelSchema(V1_classModelSchema)),
+    }),
+  );
+}
+
+export class V1_FunctionActivatorInfo {
+  name!: string;
+  description!: string;
+  configuration!: V1_FunctionActivatorConfigurationInfo;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_FunctionActivatorInfo, {
+      description: primitive(),
+      name: primitive(),
+      configuration: usingModelSchema(
+        V1_FunctionActivatorConfigurationInfo.serialization.schema,
+      ),
+    }),
+  );
+}

package/src/graph-manager/protocol/pure/v1/engine/{service/V1_TEMPORARY__SnowflakeServiceDeploymentInput.ts → functionActivator/V1_FunctionActivatorInput.ts}

@@ -14,38 +14,21 @@
  * limitations under the License.
  */
 
-import {
-  SKIP,
-  createModelSchema,
-  custom,
-  optional,
-  primitive,
-  serialize,
-} from 'serializr';
+import { primitive, createModelSchema, optional } from 'serializr';
 import { SerializationFactory } from '@finos/legend-shared';
-import type { V1_RawLambda } from '../../model/rawValueSpecification/V1_RawLambda.js';
 import type { V1_PureModelContext } from '../../model/context/V1_PureModelContext.js';
 import { V1_pureModelContextPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization.js';
-import { V1_rawLambdaModelSchema } from '../../transformation/pureProtocol/serializationHelpers/V1_RawValueSpecificationSerializationHelper.js';
 
-export class V1_TEMPORARY__SnowflakeServiceDeploymentInput {
-  clientVersion: string | undefined;
-  /**
-   * Studio does not process value specification, they are left in raw JSON form
-   *
-   * @discrepancy model
-   */
-  query!: V1_RawLambda;
+export class V1_FunctionActivatorInput {
+  clientVersion!: string | undefined;
+  functionActivator!: string;
   model!: V1_PureModelContext;
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_TEMPORARY__SnowflakeServiceDeploymentInput, {
+    createModelSchema(V1_FunctionActivatorInput, {
       clientVersion: optional(primitive()),
       model: V1_pureModelContextPropSchema,
-      query: custom(
-        (val) => serialize(V1_rawLambdaModelSchema, val),
-        () => SKIP,
-      ),
+      functionActivator: primitive(),
     }),
   );
 }

package/src/graph-manager/protocol/pure/v1/model/packageableElements/V1_PackageableElement.ts

@@ -35,12 +35,16 @@ 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';
 import type { V1_INTERNAL__UnknownPackageableElement } from './V1_INTERNAL__UnknownPackageableElement.js';
+import type { V1_INTERNAL__UnknownFunctionActivator } from './function/V1_INTERNAL__UnknownFunctionActivator.js';
 
 export interface V1_PackageableElementVisitor<T> {
   visit_PackageableElement(element: V1_PackageableElement): T;
   visit_INTERNAL__UnknownPackageableElement(
     element: V1_INTERNAL__UnknownPackageableElement,
   ): T;
+  visit_INTERNAL__UnknownFunctionActivator(
+    element: V1_INTERNAL__UnknownFunctionActivator,
+  ): T;
 
   visit_SectionIndex(element: V1_SectionIndex): T;
   visit_Profile(element: V1_Profile): T;

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/V1_FunctionActivator.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 } from '@finos/legend-shared';
+import { V1_PackageableElement } from '../../../model/packageableElements/V1_PackageableElement.js';
+
+export abstract class V1_FunctionActivator
+  extends V1_PackageableElement
+  implements Hashable
+{
+  function!: string;
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/V1_INTERNAL__UnknownFunctionActivator.ts

@@ -0,0 +1,49 @@
+/**
+ * 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,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { V1_FunctionActivator } from './V1_FunctionActivator.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../../../graph/Core_HashUtils.js';
+import type { V1_PackageableElementVisitor } from '../V1_PackageableElement.js';
+
+export class V1_INTERNAL__UnknownFunctionActivator
+  extends V1_FunctionActivator
+  implements Hashable
+{
+  content!: PlainObject;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_FUNCTION_ACTIVATOR,
+      this.path,
+      this.function,
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_INTERNAL__UnknownFunctionActivator(this);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/mapping/V1_INTERNAL__UnknownMappingInclude.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 PlainObject } from '@finos/legend-shared';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../../../graph/Core_HashUtils.js';
+import { V1_MappingInclude } from './V1_MappingInclude.js';
+
+export class V1_INTERNAL__UnknownMappingInclude extends V1_MappingInclude {
+  content!: PlainObject;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_MAPPING_INCLUDE,
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/mapping/V1_MappingInclude.ts

@@ -17,14 +17,19 @@
 import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.js';
 
-export class V1_MappingInclude implements Hashable {
+export abstract class V1_MappingInclude implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_MappingIncludeMapping extends V1_MappingInclude {
   includedMapping!: string;
+
   sourceDatabasePath?: string | undefined;
   targetDatabasePath?: string | undefined;
 
-  get hashCode(): string {
+  override get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.MAPPING_INCLUDE,
+      CORE_HASH_STRUCTURE.MAPPING_INCLUDE_MAPPING,
       this.includedMapping,
       this.sourceDatabasePath ?? '',
       this.targetDatabasePath ?? '',

package/src/graph-manager/protocol/pure/v1/model/packageableElements/store/relational/connection/V1_RelationalDatabaseConnection.ts

@@ -67,6 +67,12 @@ export class V1_RelationalDatabaseConnection
   authenticationStrategy!: V1_AuthenticationStrategy;
   postProcessors: V1_PostProcessor[] = [];
 
+  /**
+   * HACKY: this is done to quickly add support for local connection
+   * See https://github.com/finos/legend-engine/pull/1807
+   */
+  localMode?: boolean | undefined;
+
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.RELATIONAL_DATABASE_CONNECTION,
@@ -75,6 +81,7 @@ export class V1_RelationalDatabaseConnection
       this.quoteIdentifiers?.toString() ?? '',
       this.datasourceSpecification,
       this.authenticationStrategy,
+      this.localMode?.toString() ?? '',
       hashArray(this.postProcessors),
     ]);
   }

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/from/V1_ConnectionTransformer.ts

@@ -355,6 +355,7 @@ export const V1_transformRelationalDatabaseConnection = (
     metamodel.datasourceSpecification,
     context,
   );
+  connection.localMode = metamodel.localMode;
   connection.type = metamodel.type;
   connection.databaseType = connection.type;
   connection.timeZone = metamodel.timeZone;

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/from/V1_DomainTransformer.ts

@@ -27,7 +27,7 @@ import type { TaggedValue } from '../../../../../../../graph/metamodel/pure/pack
 import type { Enumeration } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Enumeration.js';
 import type { Class } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Class.js';
 import type { Association } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Association.js';
-import type { ConcreteFunctionDefinition } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import type { ConcreteFunctionDefinition } from '../../../../../../../graph/metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
 import type { Property } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Property.js';
 import { V1_Profile } from '../../../model/packageableElements/domain/V1_Profile.js';
 import { V1_StereotypePtr } from '../../../model/packageableElements/domain/V1_StereotypePtr.js';