@finos/legend-graph 31.10.65 → 32.0.0

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/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) {

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

@@ -51,45 +51,7 @@ export enum V1_Type_Type {
   RELATION_TYPE = 'relationType',
 }
 
-const packageableTypeSchema = createModelSchema(V1_PackageableType, {
-  _type: usingConstantValueSchema(V1_Type_Type.PACKAGEABLE_TYPE),
-  fullPath: primitive(),
-});
-
-const relationTypeColumnSchema = createModelSchema(V1_RelationTypeColumn, {
-  name: primitive(),
-  type: primitive(),
-});
-
-const relationTypeSchema = createModelSchema(V1_RelationType, {
-  _type: usingConstantValueSchema(V1_Type_Type.RELATION_TYPE),
-  columns: list(usingModelSchema(relationTypeColumnSchema)),
-});
-
-export function V1_deserializeType(json: PlainObject<V1_Type>): V1_Type {
-  switch (json._type) {
-    case V1_Type_Type.PACKAGEABLE_TYPE:
-      return deserialize(packageableTypeSchema, json);
-    case V1_Type_Type.RELATION_TYPE:
-      return deserialize(relationTypeSchema, json);
-    default:
-      throw new UnsupportedOperationError(
-        `Can't deserialize type: '${json._type}'`,
-      );
-  }
-}
-
-export function V1_serializeType(protocol: V1_Type): PlainObject<V1_Type> {
-  if (protocol instanceof V1_PackageableType) {
-    return serialize(packageableTypeSchema, protocol);
-  } else if (protocol instanceof V1_RelationType) {
-    return serialize(relationTypeSchema, protocol);
-  }
-
-  throw new UnsupportedOperationError(`Can't serialize type`, protocol);
-}
-
-export const V1_GenericTypeModelSchema = createModelSchema(V1_GenericType, {
+export const V1_genericTypeModelSchema = createModelSchema(V1_GenericType, {
   multiplicityArguments: customList(
     (val: V1_Multiplicity) => serialize(V1_multiplicityModelSchema, val),
     (val) => deserialize(V1_multiplicityModelSchema, val),
@@ -120,6 +82,62 @@ export const V1_GenericTypeModelSchema = createModelSchema(V1_GenericType, {
   ),
 });
 
+const packageableTypeModelSchema = createModelSchema(V1_PackageableType, {
+  _type: usingConstantValueSchema(V1_Type_Type.PACKAGEABLE_TYPE),
+  fullPath: primitive(),
+});
+
+const V1_relationTypeColumnModelSchema = createModelSchema(
+  V1_RelationTypeColumn,
+  {
+    name: primitive(),
+    genericType: custom(
+      (val) => serialize(V1_genericTypeModelSchema, val),
+      (val) => V1_deserializeGenericType(val),
+      {
+        beforeDeserialize: function (callback, jsonValue, jsonParentValue) {
+          /** @backwardCompatibility */
+          if (
+            jsonParentValue.type !== undefined &&
+            jsonParentValue.genericType === undefined
+          ) {
+            callback(null, jsonParentValue.type);
+          } else {
+            callback(null, jsonParentValue.genericType);
+          }
+        },
+      },
+    ),
+  },
+);
+
+export const V1_relationTypeModelSchema = createModelSchema(V1_RelationType, {
+  _type: usingConstantValueSchema(V1_Type_Type.RELATION_TYPE),
+  columns: list(usingModelSchema(V1_relationTypeColumnModelSchema)),
+});
+
+export function V1_deserializeType(json: PlainObject<V1_Type>): V1_Type {
+  switch (json._type) {
+    case V1_Type_Type.PACKAGEABLE_TYPE:
+      return deserialize(packageableTypeModelSchema, json);
+    case V1_Type_Type.RELATION_TYPE:
+      return deserialize(V1_relationTypeModelSchema, json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize type: '${json._type}'`,
+      );
+  }
+}
+
+export function V1_serializeType(protocol: V1_Type): PlainObject<V1_Type> {
+  if (protocol instanceof V1_PackageableType) {
+    return serialize(packageableTypeModelSchema, protocol);
+  } else if (protocol instanceof V1_RelationType) {
+    return serialize(V1_relationTypeModelSchema, protocol);
+  }
+  throw new UnsupportedOperationError(`Can't serialize type`, protocol);
+}
+
 const appendAnyGenericType = (current: V1_GenericType): void => {
   current.multiplicityArguments = [new V1_Multiplicity(1, undefined)];
   const _anytype = new V1_PackageableType();
@@ -129,32 +147,32 @@ const appendAnyGenericType = (current: V1_GenericType): void => {
   current.typeArguments = [arGenType];
 };
 
-export const V1_deserializeGenericType = (
+export function V1_deserializeGenericType(
   val: PlainObject<V1_GenericType> | string,
-): V1_GenericType => {
+): V1_GenericType {
   /** @backwardCompatibility */
-  let genType: V1_GenericType;
+  let genericType: V1_GenericType;
   if (isString(val)) {
-    genType = new V1_GenericType();
+    genericType = new V1_GenericType();
     const packageableType = new V1_PackageableType();
     packageableType.fullPath = val;
-    genType.rawType = packageableType;
+    genericType.rawType = packageableType;
     if (matchFunctionName(val, CORE_PURE_PATH.TABULAR_RESULT)) {
-      appendAnyGenericType(genType);
+      appendAnyGenericType(genericType);
     }
   } else {
-    genType = deserialize(V1_GenericTypeModelSchema, val);
+    genericType = deserialize(V1_genericTypeModelSchema, val);
   }
   const classPath = returnUndefOnError(() =>
-    V1_getGenericTypeFullPath(genType),
+    V1_getGenericTypeFullPath(genericType),
   );
   if (
     classPath &&
     matchFunctionName(classPath, CORE_PURE_PATH.TABULAR_RESULT) &&
-    !genType.multiplicityArguments.length &&
-    !genType.typeArguments.length
+    !genericType.multiplicityArguments.length &&
+    !genericType.typeArguments.length
   ) {
-    appendAnyGenericType(genType);
+    appendAnyGenericType(genericType);
   }
-  return genType;
-};
+  return genericType;
+}

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

@@ -92,7 +92,7 @@ import { V1_ClassInstance } from '../../../model/valueSpecification/raw/V1_Class
 import { V1_CByteArray } from '../../../model/valueSpecification/raw/V1_CByteArray.js';
 import {
   V1_deserializeGenericType,
-  V1_GenericTypeModelSchema,
+  V1_genericTypeModelSchema,
 } from './V1_TypeSerializationHelper.js';
 import { V1_createGenericTypeWithElementPath } from '../../../helpers/V1_DomainHelper.js';
 
@@ -173,7 +173,7 @@ enum V1_ValueSpecificationType {
 export const V1_variableModelSchema = createModelSchema(V1_Variable, {
   _type: usingConstantValueSchema(V1_ValueSpecificationType.VARIABLE),
   genericType: optionalCustom(
-    (val) => serialize(V1_GenericTypeModelSchema, val),
+    (val) => serialize(V1_genericTypeModelSchema, val),
     (val) => V1_deserializeGenericType(val),
     {
       beforeDeserialize: function (callback, jsonValue, jsonParentValue) {
@@ -266,7 +266,7 @@ const genericTypeInstanceSchema = (plugins: PureProtocolProcessorPlugin[]) =>
       V1_ValueSpecificationType.GENERIC_TYPE_INSTANCE,
     ),
     genericType: custom(
-      (val) => serialize(V1_GenericTypeModelSchema, val),
+      (val) => serialize(V1_genericTypeModelSchema, val),
       (val) => V1_deserializeGenericType(val),
       {
         beforeDeserialize: function (callback, jsonValue, jsonParentValue) {