@finos/legend-graph 27.0.3 → 28.0.0

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

@@ -0,0 +1,171 @@
+/**
+ * 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 PlainObject,
+  SerializationFactory,
+  usingModelSchema,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  list,
+  optional,
+  primitive,
+  serialize,
+} from 'serializr';
+import type { Mapping } from '../../../../../../graph/metamodel/pure/packageableElements/mapping/Mapping.js';
+import {
+  EntityMappedProperty,
+  EnumMappedProperty,
+  MappedEntity,
+  MappedProperty,
+  MappingModelCoverageAnalysisResult,
+} from '../../../../../../graph-manager/action/analytics/MappingModelCoverageAnalysis.js';
+import type { V1_PureModelContext } from '../../model/context/V1_PureModelContext.js';
+import { V1_pureModelContextPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization.js';
+
+enum V1_MappedPropertyType {
+  ENUM = 'enum',
+  ENTITY = 'entity',
+}
+
+class V1_MappedProperty {
+  name!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappedProperty, {
+      name: primitive(),
+    }),
+  );
+}
+
+class V1_EntityMappedProperty extends V1_MappedProperty {
+  entityPath!: string;
+  subType: string | undefined;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_EntityMappedProperty, {
+      name: primitive(),
+      entityPath: primitive(),
+      subType: optional(primitive()),
+    }),
+  );
+}
+
+class V1_EnumMappedProperty extends V1_MappedProperty {
+  enumPath!: string;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_EnumMappedProperty, {
+      name: primitive(),
+      enumPath: primitive(),
+    }),
+  );
+}
+
+const V1_serializeMappedProperty = (
+  prop: V1_MappedProperty,
+): V1_MappedProperty =>
+  V1_MappedProperty instanceof V1_EnumMappedProperty
+    ? serialize(V1_EnumMappedProperty.serialization.schema, prop)
+    : V1_MappedProperty instanceof V1_EntityMappedProperty
+    ? serialize(V1_EntityMappedProperty.serialization.schema, prop)
+    : serialize(V1_MappedProperty.serialization.schema, prop);
+
+const V1_deserializeMappedProperty = (
+  json: PlainObject<V1_MappedProperty>,
+): V1_MappedProperty => {
+  switch (json._type) {
+    case V1_MappedPropertyType.ENTITY:
+      return deserialize(V1_EntityMappedProperty.serialization.schema, json);
+    case V1_MappedPropertyType.ENUM:
+      return deserialize(V1_EnumMappedProperty.serialization.schema, json);
+    default: {
+      return deserialize(V1_MappedProperty.serialization.schema, json);
+    }
+  }
+};
+
+class V1_MappedEntity {
+  path!: string;
+  properties: V1_MappedProperty[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappedEntity, {
+      path: primitive(),
+      properties: list(
+        custom(
+          (prop) => V1_serializeMappedProperty(prop),
+          (prop) => V1_deserializeMappedProperty(prop),
+        ),
+      ),
+    }),
+  );
+}
+
+export class V1_MappingModelCoverageAnalysisInput {
+  clientVersion!: string;
+  mapping!: string;
+  model!: V1_PureModelContext;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappingModelCoverageAnalysisInput, {
+      clientVersion: primitive(),
+      mapping: primitive(),
+      model: V1_pureModelContextPropSchema,
+    }),
+  );
+}
+
+export class V1_MappingModelCoverageAnalysisResult {
+  mappedEntities: V1_MappedEntity[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_MappingModelCoverageAnalysisResult, {
+      mappedEntities: list(
+        usingModelSchema(V1_MappedEntity.serialization.schema),
+      ),
+    }),
+  );
+}
+
+const buildMappedProperty = (protocol: V1_MappedProperty): MappedProperty =>
+  protocol instanceof V1_EntityMappedProperty
+    ? new EntityMappedProperty(
+        protocol.name,
+        protocol.entityPath,
+        protocol.subType,
+      )
+    : protocol instanceof V1_EnumMappedProperty
+    ? new EnumMappedProperty(protocol.name, protocol.enumPath)
+    : new MappedProperty(protocol.name);
+
+const buildMappedEntity = (protocol: V1_MappedEntity): MappedEntity =>
+  new MappedEntity(
+    protocol.path,
+    protocol.properties.map((p) => buildMappedProperty(p)),
+  );
+
+export const V1_buildModelCoverageAnalysisResult = (
+  protocol: V1_MappingModelCoverageAnalysisResult,
+  mapping: Mapping,
+): MappingModelCoverageAnalysisResult =>
+  new MappingModelCoverageAnalysisResult(
+    protocol.mappedEntities.map((p) => buildMappedEntity(p)),
+    mapping,
+  );

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

@@ -0,0 +1,368 @@
+/**
+ * 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 {
+  SKIP,
+  createModelSchema,
+  custom,
+  deserialize,
+  optional,
+  primitive,
+  type ModelSchema,
+  serialize,
+  list,
+} from 'serializr';
+import type { V1_PureModelContext } from '../../model/context/V1_PureModelContext.js';
+import type { V1_RawLambda } from '../../model/rawValueSpecification/V1_RawLambda.js';
+import { V1_pureModelContextPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization.js';
+import {
+  SerializationFactory,
+  type PlainObject,
+  usingConstantValueSchema,
+  UnsupportedOperationError,
+  optionalCustom,
+  usingModelSchema,
+} from '@finos/legend-shared';
+import { V1_rawLambdaModelSchema } from '../../transformation/pureProtocol/serializationHelpers/V1_RawValueSpecificationSerializationHelper.js';
+import type { PureProtocolProcessorPlugin } from '../../../PureProtocolProcessorPlugin.js';
+import {
+  type DatasetEntitlementReport,
+  DatasetSpecification,
+  DatasetEntitlementAccessGrantedReport,
+  DatasetEntitlementAccessApprovedReport,
+  DatasetEntitlementAccessRequestedReport,
+  DatasetEntitlementAccessNotGrantedReport,
+  DatasetEntitlementUnsupportedReport,
+} from '../../../../../action/analytics/StoreEntitlementAnalysis.js';
+
+export class V1_StoreEntitlementAnalysisInput {
+  clientVersion: string | undefined;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  query?: V1_RawLambda | undefined;
+  mapping!: string;
+  runtime!: string;
+  model!: V1_PureModelContext;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_StoreEntitlementAnalysisInput, {
+      clientVersion: optional(primitive()),
+      mapping: primitive(),
+      model: V1_pureModelContextPropSchema,
+      query: optionalCustom(
+        (val) => serialize(V1_rawLambdaModelSchema, val),
+        () => SKIP,
+      ),
+      runtime: primitive(),
+    }),
+  );
+}
+
+export enum V1_DatasetSpecificationType {
+  DATASET_SPECIFICATION = 'datasetSpecification',
+}
+
+export class V1_DatasetSpecification {
+  name!: string;
+  type!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DatasetSpecification, {
+      _type: usingConstantValueSchema(
+        V1_DatasetSpecificationType.DATASET_SPECIFICATION,
+      ),
+      name: primitive(),
+      type: primitive(),
+    }),
+  );
+}
+
+const V1_deserializeDatasetSpecification = (
+  json: PlainObject<V1_DatasetSpecification>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_DatasetSpecification => {
+  switch (json._type) {
+    case V1_DatasetSpecificationType.DATASET_SPECIFICATION:
+      return deserialize(V1_DatasetSpecification.serialization.schema, json);
+    default: {
+      const extraDeserializers = plugins.flatMap(
+        (plugin) =>
+          plugin.V1_getExtraDatasetSpecificationProtocolDeserializers?.() ?? [],
+      );
+      for (const deserializer of extraDeserializers) {
+        const protocol = deserializer(json, plugins);
+        if (protocol) {
+          return protocol;
+        }
+      }
+      throw new UnsupportedOperationError(
+        `Can't deserialize data specification of type '${json._type}': no compatible deserializer available from plugins`,
+      );
+    }
+  }
+};
+
+export class V1_EntitlementReportAnalyticsInput {
+  storeEntitlementAnalyticsInput!: V1_StoreEntitlementAnalysisInput;
+  reports: V1_DatasetSpecification[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_EntitlementReportAnalyticsInput, {
+      storeEntitlementAnalyticsInput: usingModelSchema(
+        V1_StoreEntitlementAnalysisInput.serialization.schema,
+      ),
+      reports: list(
+        custom(
+          (val) => serialize(V1_DatasetSpecification.serialization.schema, val),
+          (val) =>
+            deserialize(V1_DatasetSpecification.serialization.schema, val),
+        ),
+      ),
+    }),
+  );
+}
+
+export class V1_SurveyDatasetsResult {
+  datasets: V1_DatasetSpecification[] = [];
+}
+
+export const V1_surveyDatasetsResultModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_SurveyDatasetsResult> =>
+  createModelSchema(V1_SurveyDatasetsResult, {
+    datasets: list(
+      custom(
+        () => SKIP,
+        (val) => V1_deserializeDatasetSpecification(val, plugins),
+      ),
+    ),
+  });
+
+export const V1_buildDatasetSpecification = (
+  protocol: V1_DatasetSpecification,
+  plugins: PureProtocolProcessorPlugin[],
+): DatasetSpecification => {
+  const extraBuilders = plugins.flatMap(
+    (plugin) => plugin.V1_getExtraDatasetSpecificationBuilders?.() ?? [],
+  );
+  for (const builder of extraBuilders) {
+    const metamodel = builder(protocol, plugins);
+    if (metamodel) {
+      return metamodel;
+    }
+  }
+  const metamodel = new DatasetSpecification();
+  metamodel.name = protocol.name;
+  metamodel.type = protocol.type;
+  return metamodel;
+};
+
+export abstract class V1_DatasetEntitlementReport {
+  dataset!: V1_DatasetSpecification;
+}
+
+export enum V1_DatasetEntitlementReportType {
+  ACCESS_GRANTED = 'accessGranted',
+  ACCESS_APPROVED = 'accessApproved',
+  ACCESS_REQUESTED = 'accessRequested',
+  ACCESS_NOT_GRANTED = 'accessNotGranted',
+  UNSUPPORTED = 'unsupported',
+}
+
+export class V1_DatasetEntitlementAccessGrantedReport extends V1_DatasetEntitlementReport {}
+
+const V1_datasetEntitlementAccessGrantedReportModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DatasetEntitlementAccessGrantedReport> =>
+  createModelSchema(V1_DatasetEntitlementAccessGrantedReport, {
+    _type: usingConstantValueSchema(
+      V1_DatasetEntitlementReportType.ACCESS_GRANTED,
+    ),
+    dataset: custom(
+      () => SKIP,
+      (val) => V1_deserializeDatasetSpecification(val, plugins),
+    ),
+  });
+
+export class V1_DatasetEntitlementAccessApprovedReport extends V1_DatasetEntitlementReport {}
+
+const V1_datasetEntitlementAccessApprovedReportModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DatasetEntitlementAccessApprovedReport> =>
+  createModelSchema(V1_DatasetEntitlementAccessApprovedReport, {
+    _type: usingConstantValueSchema(
+      V1_DatasetEntitlementReportType.ACCESS_APPROVED,
+    ),
+    dataset: custom(
+      () => SKIP,
+      (val) => V1_deserializeDatasetSpecification(val, plugins),
+    ),
+  });
+
+export class V1_DatasetEntitlementAccessRequestedReport extends V1_DatasetEntitlementReport {}
+
+const V1_datasetEntitlementAccessRequestedReportModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DatasetEntitlementAccessRequestedReport> =>
+  createModelSchema(V1_DatasetEntitlementAccessRequestedReport, {
+    _type: usingConstantValueSchema(
+      V1_DatasetEntitlementReportType.ACCESS_REQUESTED,
+    ),
+    dataset: custom(
+      () => SKIP,
+      (val) => V1_deserializeDatasetSpecification(val, plugins),
+    ),
+  });
+
+export class V1_DatasetEntitlementAccessNotGrantedReport extends V1_DatasetEntitlementReport {}
+
+const V1_datasetEntitlementAccessNotGrantedReportModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DatasetEntitlementAccessNotGrantedReport> =>
+  createModelSchema(V1_DatasetEntitlementAccessNotGrantedReport, {
+    _type: usingConstantValueSchema(
+      V1_DatasetEntitlementReportType.ACCESS_NOT_GRANTED,
+    ),
+    dataset: custom(
+      () => SKIP,
+      (val) => V1_deserializeDatasetSpecification(val, plugins),
+    ),
+  });
+
+export class V1_DatasetEntitlementUnsupportedReport extends V1_DatasetEntitlementReport {}
+
+const V1_datasetEntitlementUnsupportedReportModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DatasetEntitlementUnsupportedReport> =>
+  createModelSchema(V1_DatasetEntitlementUnsupportedReport, {
+    _type: usingConstantValueSchema(
+      V1_DatasetEntitlementReportType.UNSUPPORTED,
+    ),
+    dataset: custom(
+      () => SKIP,
+      (val) => V1_deserializeDatasetSpecification(val, plugins),
+    ),
+  });
+
+const V1_deserializeDatasetEntitlementReport = (
+  json: PlainObject<V1_DatasetEntitlementReport>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_DatasetEntitlementReport => {
+  switch (json._type) {
+    case V1_DatasetEntitlementReportType.ACCESS_GRANTED:
+      return deserialize(
+        V1_datasetEntitlementAccessGrantedReportModelSchema(plugins),
+        json,
+      );
+    case V1_DatasetEntitlementReportType.ACCESS_APPROVED:
+      return deserialize(
+        V1_datasetEntitlementAccessApprovedReportModelSchema(plugins),
+        json,
+      );
+    case V1_DatasetEntitlementReportType.ACCESS_REQUESTED:
+      return deserialize(
+        V1_datasetEntitlementAccessRequestedReportModelSchema(plugins),
+        json,
+      );
+    case V1_DatasetEntitlementReportType.ACCESS_NOT_GRANTED:
+      return deserialize(
+        V1_datasetEntitlementAccessNotGrantedReportModelSchema(plugins),
+        json,
+      );
+    case V1_DatasetEntitlementReportType.UNSUPPORTED:
+      return deserialize(
+        V1_datasetEntitlementUnsupportedReportModelSchema(plugins),
+        json,
+      );
+    default: {
+      const extraDeserializers = plugins.flatMap(
+        (plugin) =>
+          plugin.V1_getExtraDatasetEntitlementReportProtocolDeserializers?.() ??
+          [],
+      );
+      for (const deserializer of extraDeserializers) {
+        const protocol = deserializer(json, plugins);
+        if (protocol) {
+          return protocol;
+        }
+      }
+      throw new UnsupportedOperationError(
+        `Can't deserialize dataset entitlement report of type '${json._type}': no compatible deserializer available from plugins`,
+      );
+    }
+  }
+};
+
+export class V1_CheckEntitlementsResult {
+  reports: V1_DatasetEntitlementReport[] = [];
+}
+
+export const V1_checkEntitlementsResultModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_CheckEntitlementsResult> =>
+  createModelSchema(V1_CheckEntitlementsResult, {
+    reports: list(
+      custom(
+        () => SKIP,
+        (val) => V1_deserializeDatasetEntitlementReport(val, plugins),
+      ),
+    ),
+  });
+
+export const V1_buildDatasetEntitlementReport = (
+  protocol: V1_DatasetEntitlementReport,
+  plugins: PureProtocolProcessorPlugin[],
+): DatasetEntitlementReport => {
+  const extraBuilders = plugins.flatMap(
+    (plugin) => plugin.V1_getExtraDatasetEntitlementReportBuilders?.() ?? [],
+  );
+  for (const builder of extraBuilders) {
+    const metamodel = builder(protocol, plugins);
+    if (metamodel) {
+      return metamodel;
+    }
+  }
+
+  if (protocol instanceof V1_DatasetEntitlementAccessGrantedReport) {
+    const metamodel = new DatasetEntitlementAccessGrantedReport();
+    metamodel.dataset = V1_buildDatasetSpecification(protocol.dataset, plugins);
+    return metamodel;
+  } else if (protocol instanceof V1_DatasetEntitlementAccessApprovedReport) {
+    const metamodel = new DatasetEntitlementAccessApprovedReport();
+    metamodel.dataset = V1_buildDatasetSpecification(protocol.dataset, plugins);
+    return metamodel;
+  } else if (protocol instanceof V1_DatasetEntitlementAccessRequestedReport) {
+    const metamodel = new DatasetEntitlementAccessRequestedReport();
+    metamodel.dataset = V1_buildDatasetSpecification(protocol.dataset, plugins);
+    return metamodel;
+  } else if (protocol instanceof V1_DatasetEntitlementAccessNotGrantedReport) {
+    const metamodel = new DatasetEntitlementAccessNotGrantedReport();
+    metamodel.dataset = V1_buildDatasetSpecification(protocol.dataset, plugins);
+    return metamodel;
+  } else if (protocol instanceof V1_DatasetEntitlementUnsupportedReport) {
+    const metamodel = new DatasetEntitlementUnsupportedReport();
+    metamodel.dataset = V1_buildDatasetSpecification(protocol.dataset, plugins);
+    return metamodel;
+  }
+
+  throw new UnsupportedOperationError(
+    `Can't build dataset entitlement report: no compatible builder available from plugins`,
+    protocol,
+  );
+};

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

@@ -0,0 +1,129 @@
+/**
+ * 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 {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import {
+  type ExecutionResult,
+  TDSRow,
+  INTERNAL__UnknownExecutionResult,
+  ClassExecutionResult,
+  JsonExecutionResult,
+  TDSExecutionResult,
+  TDSBuilder,
+  INTERNAL__TDSColumn,
+  RawExecutionResult,
+} from '../../../../../../graph-manager/action/execution/ExecutionResult.js';
+import {
+  type V1_ExecutionResult,
+  type V1_TDSBuilder,
+  type V1_INTERNAL__TDSColumn,
+  V1_ClassExecutionResult,
+  V1_JsonExecutionResult,
+  V1_INTERNAL__UnknownExecutionResult,
+  V1_TDSExecutionResult,
+  V1_RawExecutionResult,
+} from './V1_ExecutionResult.js';
+
+const buildJSONExecutionResult = (
+  protocol: V1_JsonExecutionResult,
+): JsonExecutionResult => {
+  const metamodel = new JsonExecutionResult();
+  metamodel.values = guaranteeNonNullable(
+    protocol.values,
+    `JSON execution result 'values' field is missing`,
+  );
+  return metamodel;
+};
+
+const INTERNAL__buildTDSColumn = (
+  protocol: V1_INTERNAL__TDSColumn,
+): INTERNAL__TDSColumn => {
+  const metamodel = new INTERNAL__TDSColumn();
+  metamodel.name = guaranteeNonNullable(
+    protocol.name,
+    `TDS column 'name' field is missing`,
+  );
+  metamodel.type = protocol.type;
+  metamodel.doc = protocol.doc;
+  metamodel.relationalType = protocol.relationalType;
+  return metamodel;
+};
+
+const buildTDSBuilder = (protocol: V1_TDSBuilder): TDSBuilder => {
+  const builder = new TDSBuilder();
+  builder.columns = protocol.columns.map(INTERNAL__buildTDSColumn);
+  return builder;
+};
+
+const buildTDSExecutionResult = (
+  protocol: V1_TDSExecutionResult,
+): TDSExecutionResult => {
+  const metamodel = new TDSExecutionResult();
+  metamodel.builder = buildTDSBuilder(
+    guaranteeNonNullable(
+      protocol.builder,
+      `TDS execution result 'builder' field is missing`,
+    ),
+  );
+  metamodel.activities = protocol.activities;
+  metamodel.result.columns = (
+    protocol.result as {
+      columns: string[];
+    }
+  ).columns;
+  metamodel.result.rows = (
+    protocol.result as {
+      rows: { values: (string | number)[] }[];
+    }
+  ).rows.map((_row) => {
+    const row = new TDSRow();
+    row.values = _row.values;
+    return row;
+  });
+  return metamodel;
+};
+
+const buildClassExecutionResult = (
+  protocol: V1_ClassExecutionResult,
+): ClassExecutionResult => {
+  const metamodel = new ClassExecutionResult();
+  metamodel.objects = guaranteeNonNullable(
+    protocol.objects,
+    `Class execution result 'objects' field is missing`,
+  );
+  metamodel.activities = protocol.activities;
+  return metamodel;
+};
+
+export const V1_buildExecutionResult = (
+  protocol: V1_ExecutionResult,
+): ExecutionResult => {
+  if (protocol instanceof V1_ClassExecutionResult) {
+    return buildClassExecutionResult(protocol);
+  } else if (protocol instanceof V1_TDSExecutionResult) {
+    return buildTDSExecutionResult(protocol);
+  } else if (protocol instanceof V1_JsonExecutionResult) {
+    return buildJSONExecutionResult(protocol);
+  } else if (protocol instanceof V1_RawExecutionResult) {
+    return new RawExecutionResult(protocol.value);
+  } else if (protocol instanceof V1_INTERNAL__UnknownExecutionResult) {
+    return new INTERNAL__UnknownExecutionResult(protocol.content);
+  }
+  throw new UnsupportedOperationError(`Can't build execution result`, protocol);
+};