@finos/legend-graph 29.0.5 → 30.0.1

package/src/graph-manager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -158,7 +158,6 @@ import {
   V1_DatabaseBuilderConfig,
   V1_DatabaseBuilderInput,
   V1_DatabasePattern,
-  V1_setupDatabaseBuilderInputSerialization,
   V1_TargetDatabase,
 } from './engine/generation/V1_DatabaseBuilderInput.js';
 import { V1_transformRelationalDatabaseConnection } from './transformation/pureGraph/from/V1_ConnectionTransformer.js';
@@ -310,6 +309,10 @@ import { FunctionActivatorConfiguration } from '../../../action/functionActivato
 import { V1_FunctionActivatorInput } from './engine/functionActivator/V1_FunctionActivatorInput.js';
 import { V1_FunctionActivator } from './model/packageableElements/function/V1_FunctionActivator.js';
 import { V1_INTERNAL__UnknownFunctionActivator } from './model/packageableElements/function/V1_INTERNAL__UnknownFunctionActivator.js';
+import type { RelationalDatabaseConnection } from '../../../../STO_Relational_Exports.js';
+import { V1_RawSQLExecuteInput } from './engine/execution/V1_RawSQLExecuteInput.js';
+import type { SubtypeInfo } from '../../../action/protocol/ProtocolInfo.js';
+import { V1_INTERNAL__UnknownStore } from './model/packageableElements/store/V1_INTERNAL__UnknownStore.js';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -355,10 +358,12 @@ const mergePureModelContextData = (
   const mergedData = new V1_PureModelContextData();
   for (const _data of data) {
     mergedData.elements = mergedData.elements.concat(_data.elements);
-    mergedData.INTERNAL__rawDependencyEntities =
-      mergedData.INTERNAL__rawDependencyEntities.concat(
-        _data.INTERNAL__rawDependencyEntities,
-      );
+    const rawDependencyEntities = (
+      mergedData.INTERNAL__rawDependencyEntities ?? []
+    ).concat(_data.INTERNAL__rawDependencyEntities ?? []);
+    mergedData.INTERNAL__rawDependencyEntities = rawDependencyEntities.length
+      ? rawDependencyEntities
+      : undefined;
     mergedData.serializer = _data.serializer ?? mergedData.serializer;
     mergedData.origin = _data.origin ?? mergedData.origin;
   }
@@ -509,6 +514,10 @@ interface ServiceRegistrationInput {
 
 export class V1_PureGraphManager extends AbstractPureGraphManager {
   private readonly elementClassifierPathMap = new Map<string, string>();
+  private readonly subtypeInfo: SubtypeInfo = {
+    storeSubtypes: [],
+    functionActivatorSubtypes: [],
+  };
 
   // Pure Client Version represent the version of the pure protocol.
   // Most Engine APIs will interrupt an undefined pure client version to mean
@@ -532,10 +541,33 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     this.graphBuilderExtensions = new V1_GraphBuilderExtensions(
       this.pluginManager.getPureProtocolProcessorPlugins(),
     );
+  }
+
+  TEMPORARY__getEngineConfig(): TEMPORARY__AbstractEngineConfig {
+    return this.engine.config;
+  }
+
+  async initialize(
+    config: TEMPORARY__EngineSetupConfig,
+    options?: {
+      tracerService?: TracerService | undefined;
+    },
+  ): Promise<void> {
+    this.engine = new V1_Engine(config.clientConfig, this.logService);
+    this.engine
+      .getEngineServerClient()
+      .setTracerService(options?.tracerService ?? new TracerService());
+
+    await Promise.all([
+      this.engine.setup(config),
+      this.configureElementClassifierPathMap(config),
+      this.configureSubtypeInfoMap(config),
+    ]);
 
     // setup serialization plugins
     V1_setupPureModelContextDataSerialization(
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
     );
     V1_setupDatabaseSerialization(
       this.pluginManager.getPureProtocolProcessorPlugins(),
@@ -546,27 +578,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     V1_setupLegacyRuntimeSerialization(
       this.pluginManager.getPureProtocolProcessorPlugins(),
     );
-    V1_setupDatabaseBuilderInputSerialization(
-      this.pluginManager.getPureProtocolProcessorPlugins(),
-    );
-  }
-
-  TEMPORARY__getEngineConfig(): TEMPORARY__AbstractEngineConfig {
-    return this.engine.config;
   }
 
-  async initialize(
+  private async configureElementClassifierPathMap(
     config: TEMPORARY__EngineSetupConfig,
-    options?: {
-      tracerService?: TracerService | undefined;
-    },
   ): Promise<void> {
-    this.engine = new V1_Engine(config.clientConfig, this.logService);
-    this.engine
-      .getEngineServerClient()
-      .setTracerService(options?.tracerService ?? new TracerService());
-    await this.engine.setup(config);
-
     const classifierPathMapEntries =
       config.TEMPORARY__classifierPathMapping ??
       (await this.engine.getClassifierPathMapping());
@@ -575,6 +591,18 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     });
   }
 
+  private async configureSubtypeInfoMap(
+    config: TEMPORARY__EngineSetupConfig,
+  ): Promise<void> {
+    const subtypeInfo =
+      config.TEMPORARY__subtypeInfo ?? (await this.engine.getSubtypeInfo());
+    this.subtypeInfo.storeSubtypes = subtypeInfo.storeSubtypes;
+    this.subtypeInfo.functionActivatorSubtypes =
+      subtypeInfo.functionActivatorSubtypes;
+  }
+
+  // --------------------------------------------- Generic ---------------------------------------------
+
   getSupportedProtocolVersion(): string {
     return PureClientVersion.V1_0_0;
   }
@@ -703,6 +731,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
               entitiesWithOrigin.entities,
               projectModelData,
               this.pluginManager.getPureProtocolProcessorPlugins(),
+              this.subtypeInfo,
             );
           },
         ),
@@ -781,6 +810,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         entities,
         data,
         this.pluginManager.getPureProtocolProcessorPlugins(),
+        this.subtypeInfo,
       );
       stopWatch.record(
         GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS,
@@ -866,6 +896,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         entities,
         data,
         this.pluginManager.getPureProtocolProcessorPlugins(),
+        this.subtypeInfo,
       );
       stopWatch.record(
         GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS,
@@ -957,6 +988,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
               entities,
               generatedData,
               this.pluginManager.getPureProtocolProcessorPlugins(),
+              this.subtypeInfo,
             );
           },
         ),
@@ -2940,7 +2972,28 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
     dbBuilderInput.config = config;
     return this.pureModelContextDataToEntities(
-      await this.engine.buildDatabase(dbBuilderInput),
+      await this.engine.buildDatabase(
+        dbBuilderInput,
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ),
+    );
+  }
+
+  override async executeRawSQL(
+    connection: RelationalDatabaseConnection,
+    sql: string,
+  ): Promise<string> {
+    const input = new V1_RawSQLExecuteInput();
+    input.connection = V1_transformRelationalDatabaseConnection(
+      connection,
+      new V1_GraphTransformerContextBuilder(
+        this.pluginManager.getPureProtocolProcessorPlugins(),
+      ).build(),
+    );
+    input.sql = sql;
+    return this.engine.executeRawSQL(
+      input,
+      this.pluginManager.getPureProtocolProcessorPlugins(),
     );
   }
 
@@ -3352,6 +3405,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       entities,
       pureModelContextData,
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
       TEMPORARY__entityPathIndex,
     );
     await Promise.all(
@@ -3398,7 +3452,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       elementFilter ? elementFilter(element) : true,
     );
     prunedGraphData.INTERNAL__rawDependencyEntities =
-      data.INTERNAL__rawDependencyEntities.filter((entity) =>
+      data.INTERNAL__rawDependencyEntities?.filter((entity) =>
         entityFilter ? entityFilter(entity) : true,
       );
     return prunedGraphData;
@@ -3461,6 +3515,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ),
       data,
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
     );
     const mainGraphBuilderInput: V1_PureGraphBuilderInput[] = [
       {
@@ -3498,6 +3553,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
               ),
             projectModelData,
             this.pluginManager.getPureProtocolProcessorPlugins(),
+            this.subtypeInfo,
           );
         },
       ),
@@ -3547,10 +3603,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       ...contextData1.elements,
       ...contextData2.elements,
     ];
-    contextData1.INTERNAL__rawDependencyEntities = [
-      ...contextData1.INTERNAL__rawDependencyEntities,
-      ...contextData2.INTERNAL__rawDependencyEntities,
+    const rawDependencyEntities = [
+      ...(contextData1.INTERNAL__rawDependencyEntities ?? []),
+      ...(contextData2.INTERNAL__rawDependencyEntities ?? []),
     ];
+    contextData1.INTERNAL__rawDependencyEntities = rawDependencyEntities.length
+      ? rawDependencyEntities
+      : undefined;
     return contextData1;
   }
 
@@ -3580,6 +3639,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       entities,
       graphData,
       this.pluginManager.getPureProtocolProcessorPlugins(),
+      this.subtypeInfo,
     );
     return graphData;
   }
@@ -3606,7 +3666,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   ): string => {
     if (
       protocol instanceof V1_INTERNAL__UnknownPackageableElement ||
-      protocol instanceof V1_INTERNAL__UnknownFunctionActivator
+      protocol instanceof V1_INTERNAL__UnknownFunctionActivator ||
+      protocol instanceof V1_INTERNAL__UnknownStore
     ) {
       const _type = protocol.content._type;
       const classifierPath = isString(_type)

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

@@ -65,7 +65,10 @@ import {
   V1_buildParserError,
 } from './V1_EngineHelper.js';
 import { V1_LightQuery, V1_Query } from './query/V1_Query.js';
-import { V1_DatabaseBuilderInput } from './generation/V1_DatabaseBuilderInput.js';
+import {
+  type V1_DatabaseBuilderInput,
+  V1_serializeDatabaseBuilderInput,
+} from './generation/V1_DatabaseBuilderInput.js';
 import type { V1_ServiceConfigurationInfo } from './service/V1_ServiceConfiguration.js';
 import {
   V1_ExecuteInput,
@@ -113,10 +116,17 @@ import type { V1_SourceInformation } from '../model/V1_SourceInformation.js';
 import { V1_INTERNAL__PackageableElementWithSourceInformation } from '../transformation/pureProtocol/serializationHelpers/V1_CoreSerializationHelper.js';
 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 type {
+  ClassifierPathMapping,
+  SubtypeInfo,
+} from '../../../../action/protocol/ProtocolInfo.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';
+import {
+  V1_serializeRawSQLExecuteInput,
+  type V1_RawSQLExecuteInput,
+} from './execution/V1_RawSQLExecuteInput.js';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -228,6 +238,24 @@ export class V1_Engine {
     }
   }
 
+  async getSubtypeInfo(): Promise<SubtypeInfo> {
+    try {
+      return await this.engineServerClient.getSubtypeInfo();
+    } catch {
+      // NOTE: this is temporary until we have this API functional and released
+      // See https://github.com/finos/legend-engine/pull/1858
+      return {
+        functionActivatorSubtypes: ['snowflakeApp'],
+        storeSubtypes: [
+          'MongoDatabase',
+          'serviceStore',
+          'relational',
+          'binding',
+        ],
+      };
+    }
+  }
+
   // ------------------------------------------- Grammar -------------------------------------------
 
   private extractElementSourceInformationIndexFromPureModelContextDataJSON(
@@ -859,14 +887,24 @@ export class V1_Engine {
 
   async buildDatabase(
     input: V1_DatabaseBuilderInput,
+    plugins: PureProtocolProcessorPlugin[],
   ): Promise<V1_PureModelContextData> {
     return V1_deserializePureModelContextData(
       await this.engineServerClient.buildDatabase(
-        serialize(V1_DatabaseBuilderInput, input),
+        V1_serializeDatabaseBuilderInput(input, plugins),
       ),
     );
   }
 
+  async executeRawSQL(
+    input: V1_RawSQLExecuteInput,
+    plugins: PureProtocolProcessorPlugin[],
+  ): Promise<string> {
+    return this.engineServerClient.executeRawSQL(
+      V1_serializeRawSQLExecuteInput(input, plugins),
+    );
+  }
+
   // ------------------------------------------- Function -------------------------------------------
 
   async getAvailableFunctionActivators(): Promise<V1_FunctionActivatorInfo[]> {

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

@@ -63,10 +63,15 @@ import type {
   V1_SurveyDatasetsResult,
 } from './analytics/V1_StoreEntitlementAnalysis.js';
 import type { V1_RunTestsResult } from './test/V1_RunTestsResult.js';
-import type { ClassifierPathMapping } from '../../../../action/protocol/ClassifierPathMapping.js';
+import type {
+  ClassifierPathMapping,
+  SubtypeInfo,
+} from '../../../../action/protocol/ProtocolInfo.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';
+import type { V1_DatabaseBuilderInput } from './generation/V1_DatabaseBuilderInput.js';
+import type { V1_RawSQLExecuteInput } from './execution/V1_RawSQLExecuteInput.js';
 
 enum CORE_ENGINE_ACTIVITY_TRACE {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -99,6 +104,9 @@ enum CORE_ENGINE_ACTIVITY_TRACE {
   MAPPING_MODEL_COVERAGE_ANALYTICS = 'mapping model coverage analytics',
   SURVEY_DATASET_ANALYTICS = 'survey dataset analytics',
   STORE_ENTITLEMENT_ANALYTICS = 'store entitlement analytics',
+
+  DATABASE_SCHEMA_EXPLORATION = 'database schema exploration',
+  DATABASE_RAW_SQL_EXECUTION = 'database raw SQL execution',
 }
 
 type GrammarParserBatchInputEntry = {
@@ -165,6 +173,9 @@ export class V1_EngineServerClient extends AbstractServerClient {
   getClassifierPathMap = (): Promise<ClassifierPathMapping[]> =>
     this.get(`${this._pure()}/protocol/pure/getClassifierPathMap`);
 
+  getSubtypeInfo = (): Promise<SubtypeInfo> =>
+    this.get(`${this._pure()}/protocol/pure/getSubtypeInfo`);
+
   // ------------------------------------------- Grammar -------------------------------------------
 
   _grammarToJSON = (): string => `${this._pure()}/grammar/grammarToJson`;
@@ -622,15 +633,27 @@ export class V1_EngineServerClient extends AbstractServerClient {
     );
 
   _databaseUtilities = (): string => `${this._pure()}/utilities/database`;
+
   buildDatabase = (
-    input: PlainObject<V1_ExecuteInput>,
+    input: PlainObject<V1_DatabaseBuilderInput>,
   ): Promise<PlainObject<V1_PureModelContextData>> =>
     this.postWithTracing(
-      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.GENERATE_EXECUTION_PLAN),
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.DATABASE_SCHEMA_EXPLORATION),
       `${this._databaseUtilities()}/schemaExploration`,
       input,
     );
 
+  executeRawSQL = (
+    input: PlainObject<V1_RawSQLExecuteInput>,
+  ): Promise<string> =>
+    this.postWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.DATABASE_RAW_SQL_EXECUTION),
+      `${this._databaseUtilities()}/executeRawSQL`,
+      input,
+      {},
+      { [HttpHeader.ACCEPT]: ContentType.TEXT_PLAIN },
+    );
+
   // ------------------------------------------- Function ---------------------------------------
 
   _functionActivator = (): string => `${this.baseUrl}/functionActivator`;

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

@@ -0,0 +1,52 @@
+/**
+ * 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 {
+  createModelSchema,
+  primitive,
+  custom,
+  serialize,
+  type ModelSchema,
+} from 'serializr';
+import { type PlainObject } from '@finos/legend-shared';
+import {
+  V1_serializeConnectionValue,
+  V1_deserializeConnectionValue,
+} from '../../transformation/pureProtocol/serializationHelpers/V1_ConnectionSerializationHelper.js';
+import type { V1_RelationalDatabaseConnection } from '../../model/packageableElements/store/relational/connection/V1_RelationalDatabaseConnection.js';
+import type { PureProtocolProcessorPlugin } from '../../../PureProtocolProcessorPlugin.js';
+
+export class V1_RawSQLExecuteInput {
+  connection!: V1_RelationalDatabaseConnection;
+  sql!: string;
+}
+
+const createRawSQLExecuteInpuModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_RawSQLExecuteInput> =>
+  createModelSchema(V1_RawSQLExecuteInput, {
+    connection: custom(
+      (val) => V1_serializeConnectionValue(val, false, plugins),
+      (val) => V1_deserializeConnectionValue(val, false, plugins),
+    ),
+    sql: primitive(),
+  });
+
+export const V1_serializeRawSQLExecuteInput = (
+  value: V1_RawSQLExecuteInput,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_RawSQLExecuteInput> =>
+  serialize(createRawSQLExecuteInpuModelSchema(plugins), value);

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

@@ -20,8 +20,14 @@ import {
   custom,
   list,
   optional,
+  serialize,
+  type ModelSchema,
 } from 'serializr';
-import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
+import {
+  SerializationFactory,
+  usingModelSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
 import {
   V1_serializeConnectionValue,
   V1_deserializeConnectionValue,
@@ -81,9 +87,9 @@ export class V1_DatabaseBuilderInput {
   targetDatabase!: V1_TargetDatabase;
 }
 
-export const V1_setupDatabaseBuilderInputSerialization = (
+const createDatabaseBuilderInputModelSchema = (
   plugins: PureProtocolProcessorPlugin[],
-): void => {
+): ModelSchema<V1_DatabaseBuilderInput> =>
   createModelSchema(V1_DatabaseBuilderInput, {
     config: usingModelSchema(V1_DatabaseBuilderConfig.serialization.schema),
     connection: custom(
@@ -92,4 +98,9 @@ export const V1_setupDatabaseBuilderInputSerialization = (
     ),
     targetDatabase: usingModelSchema(V1_TargetDatabase.serialization.schema),
   });
-};
+
+export const V1_serializeDatabaseBuilderInput = (
+  value: V1_DatabaseBuilderInput,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_DatabaseBuilderInput> =>
+  serialize(createDatabaseBuilderInputModelSchema(plugins), value);

package/src/graph-manager/protocol/pure/v1/model/context/V1_PureModelContextData.ts

@@ -25,9 +25,9 @@ export class V1_PureModelContextData extends V1_PureModelContext {
   serializer?: V1_Protocol | undefined;
   elements: V1_PackageableElement[] = [];
   /**
-   * we use this to hold serialized elements as entities to save on transforming/serializing immutable entities
+   * We use this to hold serialized elements as entities to save on transforming/serializing immutable entities
    *
    * @discrepancy model
    */
-  INTERNAL__rawDependencyEntities: Entity[] = [];
+  INTERNAL__rawDependencyEntities?: Entity[] | undefined;
 }

package/src/graph-manager/protocol/pure/v1/model/executionPlan/V1_SimpleExecutionPlan.ts

@@ -24,5 +24,10 @@ export class V1_SimpleExecutionPlan extends V1_ExecutionPlan {
   serializer!: V1_Protocol;
   templateFunctions: string[] = [];
   rootExecutionNode!: V1_ExecutionNode;
-  // globalImplementationSupport!: V1_PlatformImplementation; // TODO: this is WIP for M2M case in engine
+  /**
+   * Studio does not process the platform implementation info
+   *
+   * @discrepancy model
+   */
+  globalImplementationSupport!: object;
 }

package/src/graph-manager/protocol/pure/v1/model/executionPlan/nodes/V1_ExecutionNode.ts

@@ -21,5 +21,10 @@ export abstract class V1_ExecutionNode {
   resultType!: V1_ResultType;
   executionNodes: V1_ExecutionNode[] = [];
   resultSizeRange?: V1_Multiplicity | undefined;
-  // globalImplementationSupport!: V1_PlatformImplementation; // TODO: this is WIP for M2M case in engine
+  /**
+   * Studio does not process the platform implementation info
+   *
+   * @discrepancy model
+   */
+  implementation!: object;
 }

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

@@ -36,6 +36,7 @@ import { ELEMENT_PATH_DELIMITER } from '../../../../../../graph/MetaModelConst.j
 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';
+import type { V1_INTERNAL__UnknownStore } from './store/V1_INTERNAL__UnknownStore.js';
 
 export interface V1_PackageableElementVisitor<T> {
   visit_PackageableElement(element: V1_PackageableElement): T;
@@ -45,6 +46,7 @@ export interface V1_PackageableElementVisitor<T> {
   visit_INTERNAL__UnknownFunctionActivator(
     element: V1_INTERNAL__UnknownFunctionActivator,
   ): T;
+  visit_INTERNAL__UnknownStore(element: V1_INTERNAL__UnknownStore): T;
 
   visit_SectionIndex(element: V1_SectionIndex): T;
   visit_Profile(element: V1_Profile): T;

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

@@ -20,14 +20,14 @@ import { V1_TestSuite } from '../../test/V1_TestSuite.js';
 import type { V1_TestData } from './V1_TestData.js';
 
 export class V1_ServiceTestSuite extends V1_TestSuite implements Hashable {
-  testData!: V1_TestData;
+  testData?: V1_TestData | undefined;
 
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.SERVICE_TEST_SUITE,
       this.id,
       hashArray(this.tests),
-      this.testData,
+      this.testData ?? '',
     ]);
   }
 }

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

@@ -0,0 +1,45 @@
+/**
+ * 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_Store } from './V1_Store.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../../../graph/Core_HashUtils.js';
+import type { V1_PackageableElementVisitor } from '../V1_PackageableElement.js';
+
+export class V1_INTERNAL__UnknownStore extends V1_Store implements Hashable {
+  content!: PlainObject;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_STORE,
+      this.path,
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_INTERNAL__UnknownStore(this);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/valueSpecification/raw/classInstance/graph/V1_GraphFetchTree.ts

@@ -16,16 +16,19 @@
 
 import type { V1_PropertyGraphFetchTree } from './V1_PropertyGraphFetchTree.js';
 import type { V1_RootGraphFetchTree } from './V1_RootGraphFetchTree.js';
+import type { V1_SubTypeGraphFetchTree } from './V1_SubTypeGraphFetchTree.js';
 
 export interface V1_GraphFetchTreeVisitor<T> {
   visit_RootGraphFetchTree(valueSpecification: V1_RootGraphFetchTree): T;
   visit_PropertyGraphFetchTree(
     valueSpecification: V1_PropertyGraphFetchTree,
   ): T;
+  visit_SubTypeGraphFetchTree(valueSpecification: V1_SubTypeGraphFetchTree): T;
 }
 
 export abstract class V1_GraphFetchTree {
   subTrees: V1_GraphFetchTree[] = [];
+  subTypeTrees: V1_SubTypeGraphFetchTree[] = [];
 
   abstract accept_GraphFetchTreeVisitor<T>(
     visitor: V1_GraphFetchTreeVisitor<T>,

package/src/graph-manager/protocol/pure/v1/model/valueSpecification/raw/classInstance/graph/V1_SubTypeGraphFetchTree.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 {
+  V1_GraphFetchTree,
+  type V1_GraphFetchTreeVisitor,
+} from './V1_GraphFetchTree.js';
+
+export class V1_SubTypeGraphFetchTree extends V1_GraphFetchTree {
+  subTypeClass!: string;
+
+  accept_GraphFetchTreeVisitor<T>(visitor: V1_GraphFetchTreeVisitor<T>): T {
+    return visitor.visit_SubTypeGraphFetchTree(this);
+  }
+}

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

@@ -447,7 +447,7 @@ class ConnectionTransformer implements ConnectionVisitor<V1_Connection> {
     connection: INTERNAL__UnknownConnection,
   ): V1_Connection {
     const protocol = new V1_INTERNAL__UnknownConnection();
-    protocol.store = undefined;
+    protocol.store = connection.store.valueForSerialization ?? '';
     protocol.content = connection.content;
     return protocol;
   }