@finos/legend-graph 31.10.65 → 32.0.1

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

@@ -342,7 +342,10 @@ import type { RelationTypeMetadata } from '../../../action/relation/RelationType
 import type { CodeCompletionResult } from '../../../action/compilation/Completion.js';
 import { V1_CompleteCodeInput } from './engine/compilation/V1_CompleteCodeInput.js';
 import type { DeploymentResult } from '../../../action/DeploymentResult.js';
-import type { PersistentDataCubeQuery } from '../../../action/query/PersistentDataCubeQuery.js';
+import type {
+  LightPersistentDataCubeQuery,
+  PersistentDataCubeQuery,
+} from '../../../action/query/PersistentDataCubeQuery.js';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -1769,7 +1772,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const graphData = this.graphToPureModelContextData(graph, {
       excludeUnknown: options?.excludeUnknown,
     });
-    const grammarToJson = await this.engine.pureModelContextDataToPureCode(
+    const grammarToJson = await this.engine.transformPureModelContextDataToCode(
       graphData,
       Boolean(options?.pretty),
     );
@@ -1792,7 +1795,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     options?: { pretty?: boolean | undefined },
   ): Promise<string> {
     const startTime = Date.now();
-    const grammarToJson = await this.engine.pureModelContextDataToPureCode(
+    const grammarToJson = await this.engine.transformPureModelContextDataToCode(
       await this.entitiesToPureModelContextData(entities),
       Boolean(options?.pretty),
     );
@@ -1814,7 +1817,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     },
   ): Promise<Entity[]> {
     const index = new Map<string, V1_SourceInformation>();
-    const pmcd = await this.engine.pureCodeToPureModelContextData(code, {
+    const pmcd = await this.engine.transformCodeToPureModelContextData(code, {
       sourceInformationIndex: options?.sourceInformationIndex
         ? index
         : undefined,
@@ -1877,21 +1880,27 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     lambdas.forEach((val, key) => {
       input[key] = this.serializeValueSpecification(val);
     });
-    return this.engine.transformValueSpecsToCode(input, Boolean(pretty));
+    return this.engine.transformValueSpecificationsToCode(
+      input,
+      Boolean(pretty),
+    );
   }
 
   async valueSpecificationToPureCode(
     valSpec: PlainObject<ValueSpecification>,
     pretty?: boolean | undefined,
   ): Promise<string> {
-    return this.engine.transformValueSpecToCode(valSpec, Boolean(pretty));
+    return this.engine.transformValueSpecificationToCode(
+      valSpec,
+      Boolean(pretty),
+    );
   }
 
   async pureCodeToValueSpecification(
     valSpec: string,
     returnSourceInformation?: boolean,
   ): Promise<PlainObject<ValueSpecification>> {
-    return this.engine.transformCodeToValueSpec(
+    return this.engine.transformCodeToValueSpecification(
       valSpec,
       returnSourceInformation,
     );
@@ -1911,7 +1920,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         returnSourceInformation: false,
       };
     });
-    const specs = await this.engine.transformCodeToValueSpeces(
+    const specs = await this.engine.transformCodeToValueSpecifications(
       pureCodeToValueSpecInput,
     );
     const result = new Map<string, ValueSpecification>();
@@ -3250,7 +3259,21 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     }
   }
 
-  // --------------------------------------------- Data Cube Query ---------------------------------------------
+  // --------------------------------------------- DataCube Query ---------------------------------------------
+
+  override searchDataCubeQueries(
+    searchSpecification: QuerySearchSpecification,
+  ): Promise<LightPersistentDataCubeQuery[]> {
+    return this.engine.searchDataCubeQueries(
+      V1_transformQuerySearchSpecification(searchSpecification),
+    );
+  }
+
+  override getDataCubeQueries(
+    queryIds: string[],
+  ): Promise<LightPersistentDataCubeQuery[]> {
+    return this.engine.getDataCubeQueries(queryIds);
+  }
 
   override async getDataCubeQuery(
     queryId: string,
@@ -3258,11 +3281,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const query = await this.engine.getDataCubeQuery(queryId);
     return query;
   }
-  override async createQueryDataCube(
-    dataCubeQuery: PersistentDataCubeQuery,
+
+  override async createDataCubeQuery(
+    query: PersistentDataCubeQuery,
   ): Promise<PersistentDataCubeQuery> {
-    const query = await this.engine.createDataCubeQuery(dataCubeQuery);
-    return query;
+    return this.engine.createDataCubeQuery(query);
+  }
+
+  override updateDataCubeQuery(
+    query: PersistentDataCubeQuery,
+  ): Promise<PersistentDataCubeQuery> {
+    return this.engine.updateDataCubeQuery(query);
   }
 
   override async deleteDataCubeQuery(queryId: string): Promise<void> {

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

@@ -21,6 +21,7 @@ import {
   type ServerClientConfig,
   type TraceData,
   HttpHeader,
+  NetworkClient,
 } from '@finos/legend-shared';
 import type { V1_PureModelContextData } from '../model/context/V1_PureModelContextData.js';
 import type {
@@ -164,6 +165,13 @@ export const V1_getEngineSerializationFormat = (
   }
 };
 
+// eslint-disable-next-line @finos/legend/enforce-protocol-export-prefix
+export async function getCurrentUserIDFromEngineServer(
+  engineServerUrl: string,
+): Promise<string> {
+  return new NetworkClient().get(`${engineServerUrl}/server/v1/currentUser`);
+}
+
 export class V1_EngineServerClient extends AbstractServerClient {
   currentUserId?: string | undefined;
   private env?: string | undefined;

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

@@ -91,7 +91,10 @@ import type { RelationTypeMetadata } from '../../../../action/relation/RelationT
 import type { V1_CompleteCodeInput } from './compilation/V1_CompleteCodeInput.js';
 import type { CodeCompletionResult } from '../../../../action/compilation/Completion.js';
 import type { DeploymentResult } from '../../../../action/DeploymentResult.js';
-import type { PersistentDataCubeQuery } from '../../../../action/query/PersistentDataCubeQuery.js';
+import type {
+  LightPersistentDataCubeQuery,
+  PersistentDataCubeQuery,
+} from '../../../../action/query/PersistentDataCubeQuery.js';
 
 export interface V1_GraphManagerEngine {
   config: TEMPORARY__AbstractEngineConfig;
@@ -106,12 +109,12 @@ export interface V1_GraphManagerEngine {
 
   // ------------------------------------------- Grammar -------------------------------------------
 
-  pureModelContextDataToPureCode: (
+  transformPureModelContextDataToCode: (
     graph: V1_PureModelContextData,
     pretty: boolean,
   ) => Promise<string>;
 
-  pureCodeToPureModelContextData: (
+  transformCodeToPureModelContextData: (
     code: string,
     options?: {
       sourceInformationIndex?: Map<string, V1_SourceInformation> | undefined;
@@ -125,22 +128,22 @@ export interface V1_GraphManagerEngine {
     plugins: PureProtocolProcessorPlugin[],
   ) => Promise<Map<string, string>>;
 
-  transformValueSpecsToCode: (
+  transformValueSpecificationsToCode: (
     input: Record<string, PlainObject<V1_ValueSpecification>>,
     pretty: boolean,
   ) => Promise<Map<string, string>>;
 
-  transformValueSpecToCode: (
+  transformValueSpecificationToCode: (
     input: PlainObject<V1_ValueSpecification>,
     pretty: boolean,
   ) => Promise<string>;
 
-  transformCodeToValueSpeces: (
+  transformCodeToValueSpecifications: (
     input: Record<string, V1_GrammarParserBatchInputEntry>,
   ) => Promise<Map<string, PlainObject>>;
 
-  transformCodeToValueSpec: (
-    input: string,
+  transformCodeToValueSpecification: (
+    code: string,
     returnSourceInformation?: boolean,
   ) => Promise<PlainObject<V1_ValueSpecification>>;
 
@@ -338,7 +341,15 @@ export interface V1_GraphManagerEngine {
 
   getCurrentUserId: () => string | undefined;
 
-  // ------------------------------------------- Data Cube Querys -------------------------------------------
+  // ------------------------------------------- DataCube Query -------------------------------------------
+
+  searchDataCubeQueries: (
+    searchSpecification: V1_QuerySearchSpecification,
+  ) => Promise<LightPersistentDataCubeQuery[]>;
+
+  getDataCubeQueries: (
+    queryIds: string[],
+  ) => Promise<LightPersistentDataCubeQuery[]>;
 
   getDataCubeQuery: (id: string) => Promise<PersistentDataCubeQuery>;
 
@@ -346,6 +357,10 @@ export interface V1_GraphManagerEngine {
     query: PersistentDataCubeQuery,
   ) => Promise<PersistentDataCubeQuery>;
 
+  updateDataCubeQuery: (
+    query: PersistentDataCubeQuery,
+  ) => Promise<PersistentDataCubeQuery>;
+
   deleteDataCubeQuery: (id: string) => Promise<void>;
 
   // ------------------------------------------ Analysis ------------------------------------------

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

@@ -127,7 +127,7 @@ import {
 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 { V1_deserializeExecutionResult } from './execution/V1_ExecutionHelper.js';
 import type {
   ClassifierPathMapping,
   SubtypeInfo,
@@ -154,7 +154,7 @@ import { V1_RelationalConnectionBuilder } from './relational/V1_RelationalConnec
 import type { PostValidationAssertionResult } from '../../../../../DSL_Service_Exports.js';
 import { V1_DebugTestsResult } from './test/V1_DebugTestsResult.js';
 import type { V1_GraphManagerEngine } from './V1_GraphManagerEngine.js';
-import { V1_RelationType } from '../model/packageableElements/type/V1_RelationType.js';
+import { type V1_RelationType } from '../model/packageableElements/type/V1_RelationType.js';
 import {
   RelationTypeColumnMetadata,
   RelationTypeMetadata,
@@ -162,7 +162,12 @@ import {
 import { V1_CompleteCodeInput } from './compilation/V1_CompleteCodeInput.js';
 import { CodeCompletionResult } from '../../../../action/compilation/Completion.js';
 import { DeploymentResult } from '../../../../action/DeploymentResult.js';
-import { PersistentDataCubeQuery } from '../../../../action/query/PersistentDataCubeQuery.js';
+import {
+  LightPersistentDataCubeQuery,
+  PersistentDataCubeQuery,
+} from '../../../../action/query/PersistentDataCubeQuery.js';
+import { V1_getGenericTypeFullPath } from '../helpers/V1_DomainHelper.js';
+import { V1_relationTypeModelSchema } from '../transformation/pureProtocol/serializationHelpers/V1_TypeSerializationHelper.js';
 
 class V1_RemoteEngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_RemoteEngine;
@@ -329,7 +334,7 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     return sourceInformationIndex;
   }
 
-  pureModelContextDataToPureCode(
+  transformPureModelContextDataToCode(
     graph: V1_PureModelContextData,
     pretty: boolean,
   ): Promise<string> {
@@ -339,7 +344,7 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     );
   }
 
-  async pureCodeToPureModelContextData(
+  async transformCodeToPureModelContextData(
     code: string,
     options?: {
       sourceInformationIndex?: Map<string, V1_SourceInformation> | undefined;
@@ -413,7 +418,7 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     );
   }
 
-  async transformValueSpecsToCode(
+  async transformValueSpecificationsToCode(
     input: Record<string, PlainObject<V1_ValueSpecification>>,
     pretty: boolean,
   ): Promise<Map<string, string>> {
@@ -426,7 +431,7 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     );
   }
 
-  async transformValueSpecToCode(
+  async transformValueSpecificationToCode(
     input: PlainObject<V1_ValueSpecification>,
     pretty: boolean,
   ): Promise<string> {
@@ -437,7 +442,7 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     return code;
   }
 
-  async transformCodeToValueSpeces(
+  async transformCodeToValueSpecifications(
     input: Record<string, V1_GrammarParserBatchInputEntry>,
   ): Promise<Map<string, PlainObject>> {
     const batchResults =
@@ -454,7 +459,7 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     return finalResults;
   }
 
-  async transformCodeToValueSpec(
+  async transformCodeToValueSpecification(
     input: string,
     returnSourceInformation?: boolean,
   ): Promise<PlainObject<V1_ValueSpecification>> {
@@ -720,27 +725,32 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
   async getLambdaRelationTypeFromRawInput(
     rawInput: V1_LambdaReturnTypeInput,
   ): Promise<RelationTypeMetadata> {
-    const res = V1_RelationType.serialization.fromJson(
+    const result = deserialize(
+      V1_relationTypeModelSchema,
       (await this.engineServerClient.lambdaRelationType(
         V1_LambdaReturnTypeInput.serialization.toJson(rawInput),
       )) as unknown as PlainObject<V1_RelationType>,
     );
-    const result = new RelationTypeMetadata();
-    result.columns = res.columns.map(
-      (e) => new RelationTypeColumnMetadata(e.type, e.name),
+    const relationType = new RelationTypeMetadata();
+    relationType.columns = result.columns.map(
+      (column) =>
+        new RelationTypeColumnMetadata(
+          V1_getGenericTypeFullPath(column.genericType),
+          column.name,
+        ),
     );
-    return result;
+    return relationType;
   }
 
   async getCodeCompletion(
     rawInput: V1_CompleteCodeInput,
   ): Promise<CodeCompletionResult> {
-    const res = CodeCompletionResult.serialization.fromJson(
+    const result = CodeCompletionResult.serialization.fromJson(
       (await this.engineServerClient.completeCode(
         V1_CompleteCodeInput.serialization.toJson(rawInput),
       )) as unknown as PlainObject<CodeCompletionResult>,
     );
-    return res;
+    return result;
   }
 
   // --------------------------------------------- Execution ---------------------------------------------
@@ -763,7 +773,7 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
         returnUndefOnError(() =>
           this.parseExecutionResults(executionResultInText, options),
         ) ?? executionResultInText;
-      const executionResult = V1_serializeExecutionResult(rawExecutionResult);
+      const executionResult = V1_deserializeExecutionResult(rawExecutionResult);
       const executionTraceId = executionResultMap.get(V1_ZIPKIN_TRACE_HEADER);
       if (executionTraceId) {
         return { executionResult, executionTraceId };
@@ -989,7 +999,10 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     // from the front end to engine would take up a lot of bandwidth.
     const textModel = new V1_PureModelContextText();
     textModel.serializer = model.serializer;
-    textModel.code = await this.pureModelContextDataToPureCode(model, false);
+    textModel.code = await this.transformPureModelContextDataToCode(
+      model,
+      false,
+    );
     return (
       await this.engineServerClient.generateFile(
         generationMode,
@@ -1108,12 +1121,12 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
       await this.engineServerClient.searchQueries(
         V1_QuerySearchSpecification.serialization.toJson(searchSpecification),
       )
-    ).map((v) => V1_LightQuery.serialization.fromJson(v));
+    ).map((query) => V1_LightQuery.serialization.fromJson(query));
   }
 
   async getQueries(queryIds: string[]): Promise<V1_LightQuery[]> {
-    return (await this.engineServerClient.getQueries(queryIds)).map((v) =>
-      V1_LightQuery.serialization.fromJson(v),
+    return (await this.engineServerClient.getQueries(queryIds)).map((query) =>
+      V1_LightQuery.serialization.fromJson(query),
     );
   }
 
@@ -1159,7 +1172,27 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
       broadcastToCluster,
     );
   }
-  // ------------------------------------------ Query Data Cube ------------------------------------------
+  // ------------------------------------------ QueryData Cube ------------------------------------------
+
+  async searchDataCubeQueries(
+    searchSpecification: V1_QuerySearchSpecification,
+  ): Promise<LightPersistentDataCubeQuery[]> {
+    return (
+      await this.engineServerClient.searchDataCubeQueries(
+        V1_QuerySearchSpecification.serialization.toJson(searchSpecification),
+      )
+    ).map((query) =>
+      LightPersistentDataCubeQuery.serialization.fromJson(query),
+    );
+  }
+
+  async getDataCubeQueries(
+    queryIds: string[],
+  ): Promise<LightPersistentDataCubeQuery[]> {
+    return (await this.engineServerClient.getDataCubeQueries(queryIds)).map(
+      (query) => LightPersistentDataCubeQuery.serialization.fromJson(query),
+    );
+  }
 
   async getDataCubeQuery(id: string): Promise<PersistentDataCubeQuery> {
     return PersistentDataCubeQuery.serialization.fromJson(
@@ -1177,6 +1210,17 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     );
   }
 
+  async updateDataCubeQuery(
+    query: PersistentDataCubeQuery,
+  ): Promise<PersistentDataCubeQuery> {
+    return PersistentDataCubeQuery.serialization.fromJson(
+      await this.engineServerClient.updateDataCubeQuery(
+        query.id,
+        PersistentDataCubeQuery.serialization.toJson(query),
+      ),
+    );
+  }
+
   async deleteDataCubeQuery(queryId: string): Promise<void> {
     await this.engineServerClient.deleteDataCubeQuery(queryId);
   }

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

@@ -22,7 +22,7 @@ import { V1_pureModelContextPropSchema } from '../../transformation/pureProtocol
 export class V1_CompleteCodeInput {
   model!: V1_PureModelContext;
   codeBlock!: string;
-  offset: number | undefined;
+  offset?: number | undefined;
 
   constructor(
     codeBlock: string,

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

@@ -168,7 +168,7 @@ export const V1_buildExecutionResult = (
   throw new UnsupportedOperationError(`Can't build execution result`, protocol);
 };
 
-export const V1_serializeExecutionResult = (
+export const V1_deserializeExecutionResult = (
   json: PlainObject<V1_ExecutionResult> | string | null | boolean | number,
 ): V1_ExecutionResult => {
   if (json === null || isString(json) || isNumber(json) || isBoolean(json)) {

package/src/graph-manager/protocol/pure/v1/helpers/V1_DomainHelper.ts

@@ -36,7 +36,7 @@ export const V1_getGenericTypeFullPath = (val: V1_GenericType): string => {
     return val.rawType.fullPath;
   }
   throw new UnsupportedOperationError(
-    'Failed to get full path from generic type',
+    `Can't extract type path from generic type`,
   );
 };
 
@@ -152,6 +152,6 @@ export function V1_createRelationTypeColumn(
 ): V1_RelationTypeColumn {
   const column = new V1_RelationTypeColumn();
   column.name = name;
-  column.type = type;
+  column.genericType = V1_createGenericTypeWithElementPath(type);
   return column;
 }

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

@@ -14,43 +14,27 @@
  * limitations under the License.
  */
 
-import {
-  hashArray,
-  SerializationFactory,
-  usingModelSchema,
-  type Hashable,
-} from '@finos/legend-shared';
-import { createModelSchema, list, primitive } from 'serializr';
+import { hashArray, type Hashable } from '@finos/legend-shared';
 import type { V1_Type } from './V1_Type.js';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.js';
+import type { V1_GenericType } from './V1_GenericType.js';
 
 export class V1_RelationTypeColumn implements Hashable {
   name!: string;
-  type!: string;
-
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_RelationTypeColumn, {
-      name: primitive(),
-      type: primitive(),
-    }),
-  );
+  genericType!: V1_GenericType;
 
   get hashCode(): string {
-    return hashArray([CORE_HASH_STRUCTURE.RELATION_TYPE, this.name, this.type]);
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATION_TYPE,
+      this.name,
+      this.genericType,
+    ]);
   }
 }
 
 export class V1_RelationType implements V1_Type {
   columns: V1_RelationTypeColumn[] = [];
 
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_RelationType, {
-      columns: list(
-        usingModelSchema(V1_RelationTypeColumn.serialization.schema),
-      ),
-    }),
-  );
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.RELATION_TYPE,

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

@@ -89,7 +89,7 @@ import { V1_CByteArray } from '../../../model/valueSpecification/raw/V1_CByteArr
 import type { ColSpecArrayInstance } from '../../../../../../../graph/metamodel/pure/valueSpecification/RelationValueSpecification.js';
 import { V1_ColSpecArray } from '../../../model/valueSpecification/raw/classInstance/relation/V1_ColSpecArray.js';
 import { V1_ColSpec } from '../../../model/valueSpecification/raw/classInstance/relation/V1_ColSpec.js';
-import { Relation_RelationalColumn } from '../../../../../../../graph/metamodel/pure/packageableElements/relation/Relation_RelationType.js';
+import { RelationColumn } from '../../../../../../../graph/metamodel/pure/packageableElements/relation/RelationType.js';
 import { V1_createGenericTypeWithElementPath } from '../../../helpers/V1_DomainHelper.js';
 
 class V1_ValueSpecificationTransformer
@@ -134,7 +134,7 @@ class V1_ValueSpecificationTransformer
     valueSpecification: FunctionExpression,
   ): V1_ValueSpecification {
     // handle relational column
-    if (valueSpecification.func instanceof Relation_RelationalColumn) {
+    if (valueSpecification.func instanceof RelationColumn) {
       const _property = new V1_AppliedProperty();
       _property.property = valueSpecification.func.name;
       _property.parameters = valueSpecification.parametersValues.map((value) =>

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/V1_ClassMappingFirstPassBuilder.ts

@@ -183,7 +183,7 @@ export class V1_ClassMappingFirstPassBuilder
     );
     const targetClass = this.context.resolveClass(classMapping.class);
     const srcClassReference = classMapping.srcClass
-      ? this.context.resolveClass(classMapping.srcClass)
+      ? this.context.resolveType(classMapping.srcClass)
       : undefined;
     const pureInstanceSetImplementation = new PureInstanceSetImplementation(
       V1_getInferredClassMappingId(targetClass.value, classMapping),

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper.ts

@@ -109,7 +109,7 @@ import {
 import { V1_SubTypeGraphFetchTree } from '../../../../model/valueSpecification/raw/classInstance/graph/V1_SubTypeGraphFetchTree.js';
 import { findMappingLocalProperty } from '../../../../../../../../graph/helpers/DSL_Mapping_Helper.js';
 import { getRelationTypeGenericType } from '../../../../../../../../graph/helpers/ValueSpecificationHelper.js';
-import { Relation_RelationType } from '../../../../../../../../graph/metamodel/pure/packageableElements/relation/Relation_RelationType.js';
+import { RelationType } from '../../../../../../../../graph/metamodel/pure/packageableElements/relation/RelationType.js';
 import {
   V1_getGenericTypeFullPath,
   V1_createGenericTypeWithElementPath,
@@ -585,7 +585,7 @@ export function V1_processProperty(
       EnumValueExplicitReference.create(getEnumValue(inferredType, property)),
     ];
     return enumValueInstanceValue;
-  } else if (inferredType instanceof Relation_RelationType) {
+  } else if (inferredType instanceof RelationType) {
     const col = guaranteeNonNullable(
       inferredType.columns.find((e) => property === e.name),
       `Can't find property ${property} in relation`,

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/serializationHelpers/V1_DomainSerializationHelper.ts

@@ -86,7 +86,7 @@ import { V1_DefaultValue } from '../../../model/packageableElements/domain/V1_De
 import { V1_HostedService } from '../../../model/packageableElements/function/V1_HostedService.js';
 import {
   V1_deserializeGenericType,
-  V1_GenericTypeModelSchema,
+  V1_genericTypeModelSchema,
 } from './V1_TypeSerializationHelper.js';
 import { PackageableElementPointerType } from '../../../../../../../graph/MetaModelConst.js';
 import type { V1_PackageableElementPointer } from '../../../model/packageableElements/V1_PackageableElement.js';
@@ -256,7 +256,7 @@ export const V1_propertyModelSchema = createModelSchema(V1_Property, {
   aggregation: optional(primitive()),
   defaultValue: optional(usingModelSchema(V1_defaultValueModelSchema)),
   genericType: custom(
-    (val) => serialize(V1_GenericTypeModelSchema, val),
+    (val) => serialize(V1_genericTypeModelSchema, val),
     (val) => V1_deserializeGenericType(val),
     {
       beforeDeserialize: function (callback, jsonValue, jsonParentValue) {
@@ -289,7 +289,7 @@ export const V1_derivedPropertyModelSchema = createModelSchema(
     name: primitive(),
     parameters: raw(),
     returnGenericType: custom(
-      (val) => serialize(V1_GenericTypeModelSchema, val),
+      (val) => serialize(V1_genericTypeModelSchema, val),
       (val) => V1_deserializeGenericType(val),
       {
         beforeDeserialize: function (callback, jsonValue, jsonParentValue) {
@@ -423,7 +423,7 @@ export const V1_functionModelSchema = (
     postConstraints: list(primitive()), // NOTE: these are not currently supported and just added to pass roundtrip test
     preConstraints: list(primitive()), // NOTE: these are not currently supported and just added to pass roundtrip test
     returnGenericType: custom(
-      (val) => serialize(V1_GenericTypeModelSchema, val),
+      (val) => serialize(V1_genericTypeModelSchema, val),
       (val) => V1_deserializeGenericType(val),
       {
         beforeDeserialize: function (callback, jsonValue, jsonParentValue) {