@finos/legend-graph 10.1.2 → 13.0.0

package/lib/graphManager/protocol/pure/v1/transformation/pureGraph/from/V1_MappingTransformer.js

@@ -0,0 +1,708 @@
+/**
+ * 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 { guaranteeNonEmptyString, IllegalStateError, isNonNullable, UnsupportedOperationError, } from '@finos/legend-shared';
+import { PurePropertyMapping } from '../../../../../../../graph/metamodel/pure/packageableElements/store/modelToModel/mapping/PurePropertyMapping.js';
+import { Enum } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Enum.js';
+import { ObjectInputData, ObjectInputType, } from '../../../../../../../graph/metamodel/pure/packageableElements/store/modelToModel/mapping/ObjectInputData.js';
+import { FlatDataInputData } from '../../../../../../../graph/metamodel/pure/packageableElements/store/flatData/mapping/FlatDataInputData.js';
+import { ExpectedOutputMappingTestAssert } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/ExpectedOutputMappingTestAssert.js';
+import { extractLine } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/model/RelationalOperationElement.js';
+import { FlatDataPropertyMapping } from '../../../../../../../graph/metamodel/pure/packageableElements/store/flatData/mapping/FlatDataPropertyMapping.js';
+import { OperationType, } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/OperationSetImplementation.js';
+import { RelationalPropertyMapping } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/mapping/RelationalPropertyMapping.js';
+import { RelationalAssociationImplementation } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/RelationalAssociationImplementation.js';
+import { V1_initPackageableElement, V1_transformElementReferencePointer, V1_transformMultiplicity, } from './V1_CoreTransformerHelper.js';
+import { V1_Mapping } from '../../../model/packageableElements/mapping/V1_Mapping.js';
+import { V1_EnumValueMapping, V1_EnumValueMappingEnumSourceValue, V1_EnumValueMappingIntegerSourceValue, V1_EnumValueMappingStringSourceValue, } from '../../../model/packageableElements/mapping/V1_EnumValueMapping.js';
+import { V1_RelationalAssociationMapping } from '../../../model/packageableElements/store/relational/mapping/V1_RelationalAssociationMapping.js';
+import { V1_ObjectInputData, V1_ObjectInputType, } from '../../../model/packageableElements/store/modelToModel/mapping/V1_ObjectInputData.js';
+import { V1_FlatDataInputData } from '../../../model/packageableElements/store/flatData/mapping/V1_FlatDataInputData.js';
+import { V1_ExpectedOutputMappingTestAssert } from '../../../model/packageableElements/mapping/V1_ExpectedOutputMappingTestAssert.js';
+import { V1_MappingTest } from '../../../model/packageableElements/mapping/V1_MappingTest.js';
+import { V1_RawValueSpecificationTransformer } from './V1_RawValueSpecificationTransformer.js';
+import { V1_MappingInclude } from '../../../model/packageableElements/mapping/V1_MappingInclude.js';
+import { V1_EnumerationMapping } from '../../../model/packageableElements/mapping/V1_EnumerationMapping.js';
+import { V1_FlatDataPropertyMapping } from '../../../model/packageableElements/store/flatData/mapping/V1_FlatDataPropertyMapping.js';
+import { V1_PropertyPointer } from '../../../model/packageableElements/domain/V1_PropertyPointer.js';
+import { V1_EmbeddedFlatDataPropertyMapping } from '../../../model/packageableElements/store/flatData/mapping/V1_EmbeddedFlatDataPropertyMapping.js';
+import { V1_PurePropertyMapping } from '../../../model/packageableElements/store/modelToModel/mapping/V1_PurePropertyMapping.js';
+import { V1_RelationalPropertyMapping } from '../../../model/packageableElements/store/relational/mapping/V1_RelationalPropertyMapping.js';
+import { V1_transformRelationalOperationElement, V1_transformTableAliasToTablePointer, } from './V1_DatabaseTransformer.js';
+import { V1_EmbeddedRelationalPropertyMapping } from '../../../model/packageableElements/store/relational/mapping/V1_EmbeddedRelationalPropertyMapping.js';
+import { V1_InlineEmbeddedPropertyMapping } from '../../../model/packageableElements/store/relational/mapping/V1_InlineEmbeddedPropertyMapping.js';
+import { V1_OtherwiseEmbeddedRelationalPropertyMapping } from '../../../model/packageableElements/store/relational/mapping/V1_OtherwiseEmbeddedRelationalPropertyMapping.js';
+import { V1_RelationalClassMapping } from '../../../model/packageableElements/store/relational/mapping/V1_RelationalClassMapping.js';
+import { V1_MappingOperationType, V1_OperationClassMapping, } from '../../../model/packageableElements/mapping/V1_OperationClassMapping.js';
+import { V1_PureInstanceClassMapping } from '../../../model/packageableElements/store/modelToModel/mapping/V1_PureInstanceClassMapping.js';
+import { V1_RootFlatDataClassMapping } from '../../../model/packageableElements/store/flatData/mapping/V1_RootFlatDataClassMapping.js';
+import { V1_RootRelationalClassMapping } from '../../../model/packageableElements/store/relational/mapping/V1_RootRelationalClassMapping.js';
+import { V1_AggregationAwareClassMapping } from '../../../model/packageableElements/store/relational/mapping/aggregationAware/V1_AggregationAwareClassMapping.js';
+import { V1_AggregationAwarePropertyMapping } from '../../../model/packageableElements/store/relational/mapping/aggregationAware/V1_AggregationAwarePropertyMapping.js';
+import { V1_AggregateSetImplementationContainer } from '../../../model/packageableElements/store/relational/mapping/aggregationAware/V1_AggregateSetImplementationContainer.js';
+import { V1_AggregateSpecification } from '../../../model/packageableElements/store/relational/mapping/aggregationAware/V1_AggregateSpecification.js';
+import { V1_AggregateFunction } from '../../../model/packageableElements/store/relational/mapping/aggregationAware/V1_AggregateFunction.js';
+import { V1_GroupByFunction } from '../../../model/packageableElements/store/relational/mapping/aggregationAware/V1_GroupByFunction.js';
+import { V1_XStorePropertyMapping } from '../../../model/packageableElements/mapping/xStore/V1_XStorePropertyMapping.js';
+import { XStoreAssociationImplementation } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/xStore/XStoreAssociationImplementation.js';
+import { V1_XStoreAssociationMapping } from '../../../model/packageableElements/mapping/xStore/V1_XStoreAssociationMapping.js';
+import { V1_LocalMappingPropertyInfo } from '../../../model/packageableElements/mapping/V1_LocalMappingPropertyInfo.js';
+import { V1_FilterMapping } from '../../../model/packageableElements/store/relational/mapping/V1_FilterMapping.js';
+import { V1_FilterPointer } from '../../../model/packageableElements/store/relational/mapping/V1_FilterPointer.js';
+import { V1_JoinPointer } from '../../../model/packageableElements/store/relational/model/V1_JoinPointer.js';
+import { RelationalInputData } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/mapping/RelationalInputData.js';
+import { V1_RelationalInputData } from '../../../model/packageableElements/store/relational/mapping/V1_RelationalInputData.js';
+import { PackageableElementPointerType } from '../../../../../../../graph/MetaModelConst.js';
+import { V1_BindingTransformer } from '../../../model/packageableElements/externalFormat/store/V1_BindingTransformer.js';
+import { V1_MergeOperationClassMapping } from '../../../model/packageableElements/mapping/V1_MergeOperationClassMapping.js';
+import { MergeOperationSetImplementation } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/MergeOperationSetImplementation.js';
+import { isStubbed_EnumValueMapping } from '../../../../../../../graph/helpers/creator/DSLMapping_ModelCreatorHelper.js';
+import { isStubbed_RawLambda } from '../../../../../../../graph/helpers/creator/RawValueSpecificationCreatorHelper.js';
+import { isStubbed_RawRelationalOperationElement } from '../../../../../../../graph/helpers/creator/StoreRelational_ModelCreatorHelper.js';
+import { pruneSourceInformation } from '../../../../../../../graph/MetaModelUtils.js';
+export const V1_transformPropertyReference = (element, options) => {
+    const property = new V1_PropertyPointer();
+    property.class =
+        options?.isTransformingEmbeddedPropertyMapping ||
+            options?.isTransformingLocalPropertyMapping
+            ? undefined
+            : element.ownerReference.valueForSerialization ?? '';
+    property.property = element.value.name;
+    return property;
+};
+const mappingElementIdSerializer = (value) => value.valueForSerialization;
+const transformLocalPropertyInfo = (value) => {
+    const localPropertyInfo = new V1_LocalMappingPropertyInfo();
+    localPropertyInfo.type =
+        value.localMappingPropertyType.valueForSerialization ?? '';
+    localPropertyInfo.multiplicity = V1_transformMultiplicity(value.localMappingPropertyMultiplicity);
+    return localPropertyInfo;
+};
+const transformEnumValueMapping = (element) => {
+    const enumValueMapping = new V1_EnumValueMapping();
+    enumValueMapping.enumValue = element.enum.value.name;
+    enumValueMapping.sourceValues = element.sourceValues
+        .filter(isNonNullable)
+        .map((value) => {
+        if (typeof value.value === 'string') {
+            const _string = new V1_EnumValueMappingStringSourceValue();
+            _string.value = value.value;
+            return _string;
+        }
+        else if (typeof value.value === 'number') {
+            const _integer = new V1_EnumValueMappingIntegerSourceValue();
+            _integer.value = value.value;
+            return _integer;
+        }
+        else if (value.value instanceof Enum) {
+            const _enum = new V1_EnumValueMappingEnumSourceValue();
+            _enum.value = value.value.name;
+            _enum.enumeration = value.value._OWNER.path;
+            return _enum;
+        }
+        throw new UnsupportedOperationError(`Can't transform enum value mapping`, value);
+    });
+    return enumValueMapping;
+};
+const transformEnumerationMapping = (element) => {
+    const enumerationMapping = new V1_EnumerationMapping();
+    enumerationMapping.enumValueMappings = element.enumValueMappings
+        .filter((e) => !isStubbed_EnumValueMapping(e))
+        .map(transformEnumValueMapping);
+    enumerationMapping.enumeration =
+        element.enumeration.valueForSerialization ?? '';
+    enumerationMapping.id = mappingElementIdSerializer(element.id);
+    return enumerationMapping;
+};
+// Mapping Test
+export const V1_getObjectInputType = (type) => {
+    switch (type) {
+        case ObjectInputType.JSON:
+            return V1_ObjectInputType.JSON;
+        case ObjectInputType.XML:
+            return V1_ObjectInputType.XML;
+        default:
+            throw new UnsupportedOperationError(`Encountered unsupported object input type '${type}'`);
+    }
+};
+const transformObjectInputData = (element) => {
+    const inputData = new V1_ObjectInputData();
+    inputData.data = element.data;
+    inputData.inputType = V1_getObjectInputType(element.inputType);
+    inputData.sourceClass = element.sourceClass.valueForSerialization ?? '';
+    return inputData;
+};
+const transformFlatDataInputData = (element) => {
+    const inputData = new V1_FlatDataInputData();
+    inputData.data = element.data;
+    inputData.sourceFlatData = V1_transformElementReferencePointer(PackageableElementPointerType.STORE, element.sourceFlatData);
+    return inputData;
+};
+const transformRelationalInputData = (element) => {
+    const inputData = new V1_RelationalInputData();
+    inputData.data = element.data;
+    inputData.inputType = element.inputType;
+    inputData.database = element.database.valueForSerialization ?? '';
+    return inputData;
+};
+const transformExpectedOutputMappingTestAssert = (element) => {
+    const assert = new V1_ExpectedOutputMappingTestAssert();
+    assert.expectedOutput = element.expectedOutput;
+    return assert;
+};
+const transformMappingTestInputData = (inputData) => {
+    if (inputData instanceof ObjectInputData) {
+        return transformObjectInputData(inputData);
+    }
+    else if (inputData instanceof FlatDataInputData) {
+        return transformFlatDataInputData(inputData);
+    }
+    else if (inputData instanceof RelationalInputData) {
+        return transformRelationalInputData(inputData);
+    }
+    throw new UnsupportedOperationError(`Can't transform mapping test input data`, inputData);
+};
+const transformTestAssert = (mappingTestAssert) => {
+    if (mappingTestAssert instanceof ExpectedOutputMappingTestAssert) {
+        return transformExpectedOutputMappingTestAssert(mappingTestAssert);
+    }
+    throw new UnsupportedOperationError(`Can't transform mapping test assert`, mappingTestAssert);
+};
+const transformMappingTest = (element, context) => {
+    const test = new V1_MappingTest();
+    test.assert = transformTestAssert(element.assert);
+    test.inputData = element.inputData.map(transformMappingTestInputData);
+    test.name = element.name;
+    test.query = element.query.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    return test;
+};
+// Include Mapping
+const transformMappingInclude = (element) => {
+    const mappingInclude = new V1_MappingInclude();
+    mappingInclude.includedMapping = element.included.valueForSerialization ?? '';
+    mappingInclude.sourceDatabasePath = element.storeSubstitutions.length
+        ? element.storeSubstitutions[0].original
+            .valueForSerialization ?? ''
+        : undefined;
+    mappingInclude.targetDatabasePath = element.storeSubstitutions.length
+        ? element.storeSubstitutions[0].substitute
+            .valueForSerialization ?? ''
+        : undefined;
+    return mappingInclude;
+};
+// Class Mapping
+const transformClassMappingPropertyMappings = (values, isTransformingEmbeddedPropertyMapping, context) => values
+    .filter((value) => {
+    if (value instanceof PurePropertyMapping) {
+        return !isStubbed_RawLambda(value.transform);
+    }
+    else if (value instanceof FlatDataPropertyMapping) {
+        return !isStubbed_RawLambda(value.transform);
+    }
+    else if (value instanceof RelationalPropertyMapping) {
+        return !isStubbed_RawRelationalOperationElement(value.relationalOperation);
+    }
+    const checkerResult = context.plugins
+        .flatMap((plugin) => plugin.getExtraPropertyMappingTransformationExcludabilityCheckers?.() ??
+        [])
+        .map((checker) => checker(value))
+        .filter(isNonNullable);
+    return !checkerResult.length || checkerResult.some(Boolean);
+})
+    .map((value) => transformProperyMapping(value, isTransformingEmbeddedPropertyMapping, context));
+const transformSimpleFlatDataPropertyMapping = (element, context) => {
+    const flatDataPropertyMapping = new V1_FlatDataPropertyMapping();
+    flatDataPropertyMapping.enumMappingId =
+        element.transformer?.valueForSerialization;
+    flatDataPropertyMapping.property = V1_transformPropertyReference(element.property);
+    flatDataPropertyMapping.source =
+        element.sourceSetImplementation.valueForSerialization;
+    flatDataPropertyMapping.target =
+        element.targetSetImplementation?.valueForSerialization;
+    if (!isStubbed_RawLambda(element.transform)) {
+        flatDataPropertyMapping.transform =
+            element.transform.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    return flatDataPropertyMapping;
+};
+const transformEmbeddedFlatDataPropertyMapping = (element, context) => {
+    const embedded = new V1_EmbeddedFlatDataPropertyMapping();
+    const id = mappingElementIdSerializer(element.id);
+    if (id) {
+        embedded.id = id;
+    }
+    embedded.class = element.class.valueForSerialization ?? '';
+    embedded.property = V1_transformPropertyReference(element.property); // TODO: we might ned to turn 'isTransformingEmbeddedPropertyMapping' on in the future once we start working on the gramar roundtrip for flat-data
+    embedded.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, false, // TODO: we might ned to turn this on in the future once we start working on the gramar roundtrip for flat-data
+    context);
+    embedded.root = false;
+    embedded.source = element.sourceSetImplementation.valueForSerialization;
+    embedded.target = element.targetSetImplementation?.valueForSerialization;
+    return embedded;
+};
+const transformPurePropertyMapping = (element, context) => {
+    const purePropertyMapping = new V1_PurePropertyMapping();
+    purePropertyMapping.enumMappingId =
+        element.transformer?.valueForSerialization;
+    purePropertyMapping.property = V1_transformPropertyReference(element.property, {
+        isTransformingLocalPropertyMapping: Boolean(element.localMappingProperty),
+    });
+    purePropertyMapping.source =
+        element.sourceSetImplementation.valueForSerialization;
+    purePropertyMapping.target =
+        element.targetSetImplementation?.valueForSerialization;
+    if (!isStubbed_RawLambda(element.transform)) {
+        purePropertyMapping.transform =
+            element.transform.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    if (element.localMappingProperty) {
+        purePropertyMapping.localMappingProperty = transformLocalPropertyInfo(element.localMappingProperty);
+    }
+    purePropertyMapping.explodeProperty = element.explodeProperty;
+    return purePropertyMapping;
+};
+const transformRelationalPropertyMapping = (element, isTransformingEmbeddedPropertyMapping, context) => {
+    const propertyMapping = new V1_RelationalPropertyMapping();
+    propertyMapping.enumMappingId = element.transformer?.valueForSerialization;
+    propertyMapping.property = V1_transformPropertyReference(element.property, {
+        isTransformingEmbeddedPropertyMapping: isTransformingEmbeddedPropertyMapping,
+        isTransformingLocalPropertyMapping: Boolean(element.localMappingProperty),
+    });
+    // Prune source information from the operation
+    // NOTE: if in the future, source information is stored under different key,
+    // e.g. { "classPointerSourceInformation": ... }
+    // we need to use the prune source information method from `V1_PureGraphManager`
+    propertyMapping.relationalOperation = (context.keepSourceInformation
+        ? element.relationalOperation
+        : pruneSourceInformation(element.relationalOperation));
+    propertyMapping.source =
+        element.sourceSetImplementation.valueForSerialization;
+    propertyMapping.target =
+        element.targetSetImplementation?.valueForSerialization;
+    if (element.bindingTransformer?.binding) {
+        const bindingTransformer = new V1_BindingTransformer();
+        bindingTransformer.binding = guaranteeNonEmptyString(element.bindingTransformer.binding.valueForSerialization);
+        propertyMapping.bindingTransformer = bindingTransformer;
+    }
+    if (element.localMappingProperty) {
+        propertyMapping.localMappingProperty = transformLocalPropertyInfo(element.localMappingProperty);
+    }
+    return propertyMapping;
+};
+const transformEmbeddedRelationalPropertyMapping = (element, isTransformingEmbeddedPropertyMapping, context) => {
+    const embedded = new V1_EmbeddedRelationalPropertyMapping();
+    embedded.property = V1_transformPropertyReference(element.property, {
+        isTransformingEmbeddedPropertyMapping: isTransformingEmbeddedPropertyMapping,
+    });
+    embedded.source = element.sourceSetImplementation.valueForSerialization;
+    embedded.target = element.targetSetImplementation?.valueForSerialization;
+    const classMapping = new V1_RelationalClassMapping();
+    classMapping.primaryKey = element.primaryKey.map((pk) => V1_transformRelationalOperationElement(pk, context));
+    classMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, true, context);
+    classMapping.root = element.root.valueForSerialization;
+    /**
+     * Omit this information during protocol transformation as it can be
+     * interpreted while building the graph; and will help grammar-roundtrip
+     * tests (involving engine) to pass. Ideally, this requires grammar parser
+     * and composer in engine to be more consistent.
+     *
+     * @discrepancy grammar-roundtrip
+     */
+    classMapping.class = undefined;
+    embedded.classMapping = classMapping;
+    if (element.localMappingProperty) {
+        embedded.localMappingProperty = transformLocalPropertyInfo(element.localMappingProperty);
+    }
+    return embedded;
+};
+const transformInlineEmbeddedRelationalPropertyMapping = (element, isTransformingEmbeddedPropertyMapping) => {
+    const embedded = new V1_InlineEmbeddedPropertyMapping();
+    embedded.property = V1_transformPropertyReference(element.property, {
+        isTransformingEmbeddedPropertyMapping: isTransformingEmbeddedPropertyMapping,
+    });
+    embedded.source = element.sourceSetImplementation.valueForSerialization;
+    embedded.target = element.targetSetImplementation?.valueForSerialization;
+    embedded.setImplementationId = element.inlineSetImplementation.id.value;
+    if (element.localMappingProperty) {
+        embedded.localMappingProperty = transformLocalPropertyInfo(element.localMappingProperty);
+    }
+    return embedded;
+};
+const transformOtherwiseEmbeddedRelationalPropertyMapping = (element, isTransformingEmbeddedPropertyMapping, context) => {
+    const embedded = new V1_OtherwiseEmbeddedRelationalPropertyMapping();
+    embedded.property = V1_transformPropertyReference(element.property, {
+        isTransformingEmbeddedPropertyMapping: isTransformingEmbeddedPropertyMapping,
+    });
+    embedded.source = element.sourceSetImplementation.valueForSerialization;
+    embedded.target = element.targetSetImplementation?.valueForSerialization;
+    const classMapping = new V1_RelationalClassMapping();
+    classMapping.primaryKey = element.primaryKey.map((pk) => V1_transformRelationalOperationElement(pk, context));
+    classMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, true, context);
+    classMapping.root = element.root.valueForSerialization;
+    /**
+     * Omit this information during protocol transformation as it can be
+     * interpreted while building the graph; and will help grammar-roundtrip
+     * tests (involving engine) to pass. Ideally, this requires grammar parser
+     * and composer in engine to be more consistent.
+     *
+     * @discrepancy grammar-roundtrip
+     */
+    classMapping.class = undefined;
+    embedded.classMapping = classMapping;
+    embedded.otherwisePropertyMapping = transformProperyMapping(element.otherwisePropertyMapping, true, context);
+    // use the same property as the parent otherwise
+    embedded.otherwisePropertyMapping.property = embedded.property;
+    if (element.localMappingProperty) {
+        embedded.localMappingProperty = transformLocalPropertyInfo(element.localMappingProperty);
+    }
+    return embedded;
+};
+const transformXStorePropertyMapping = (element, context) => {
+    const xstore = new V1_XStorePropertyMapping();
+    xstore.property = V1_transformPropertyReference(element.property);
+    xstore.source = element.sourceSetImplementation.valueForSerialization;
+    xstore.target = element.targetSetImplementation?.valueForSerialization;
+    if (!isStubbed_RawLambda(element.crossExpression)) {
+        xstore.crossExpression =
+            element.crossExpression.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    if (element.localMappingProperty) {
+        xstore.localMappingProperty = transformLocalPropertyInfo(element.localMappingProperty);
+    }
+    return xstore;
+};
+const transformAggregationAwarePropertyMapping = (element) => {
+    const propertyMapping = new V1_AggregationAwarePropertyMapping();
+    propertyMapping.property = V1_transformPropertyReference(element.property);
+    propertyMapping.source =
+        element.sourceSetImplementation.valueForSerialization;
+    propertyMapping.target =
+        element.targetSetImplementation?.valueForSerialization;
+    if (element.localMappingProperty) {
+        propertyMapping.localMappingProperty = transformLocalPropertyInfo(element.localMappingProperty);
+    }
+    return propertyMapping;
+};
+class PropertyMappingTransformer {
+    isTransformingEmbeddedPropertyMapping = false;
+    context;
+    constructor(isTransformingEmbeddedPropertyMapping, context) {
+        this.isTransformingEmbeddedPropertyMapping =
+            isTransformingEmbeddedPropertyMapping;
+        this.context = context;
+    }
+    visit_PropertyMapping(propertyMapping) {
+        const extraPropertyMappingTransformers = this.context.plugins.flatMap((plugin) => plugin.V1_getExtraPropertyMappingTransformers?.() ?? []);
+        for (const transformer of extraPropertyMappingTransformers) {
+            const propertyMappingProtocol = transformer(propertyMapping, this.context);
+            if (propertyMappingProtocol) {
+                return propertyMappingProtocol;
+            }
+        }
+        throw new UnsupportedOperationError(`Can't transform property mapping: no compatible transformer available from plugins`, propertyMapping);
+    }
+    visit_PurePropertyMapping(propertyMapping) {
+        return transformPurePropertyMapping(propertyMapping, this.context);
+    }
+    visit_FlatDataPropertyMapping(propertyMapping) {
+        return transformSimpleFlatDataPropertyMapping(propertyMapping, this.context);
+    }
+    visit_EmbeddedFlatDataPropertyMapping(propertyMapping) {
+        return transformEmbeddedFlatDataPropertyMapping(propertyMapping, this.context);
+    }
+    visit_RelationalPropertyMapping(propertyMapping) {
+        return transformRelationalPropertyMapping(propertyMapping, this.isTransformingEmbeddedPropertyMapping, this.context);
+    }
+    visit_EmbeddedRelationalPropertyMapping(propertyMapping) {
+        return transformEmbeddedRelationalPropertyMapping(propertyMapping, this.isTransformingEmbeddedPropertyMapping, this.context);
+    }
+    visit_InlineEmbeddedRelationalPropertyMapping(propertyMapping) {
+        return transformInlineEmbeddedRelationalPropertyMapping(propertyMapping, this.isTransformingEmbeddedPropertyMapping);
+    }
+    visit_OtherwiseEmbeddedRelationalPropertyMapping(propertyMapping) {
+        return transformOtherwiseEmbeddedRelationalPropertyMapping(propertyMapping, this.isTransformingEmbeddedPropertyMapping, this.context);
+    }
+    visit_XStorePropertyMapping(propertyMapping) {
+        return transformXStorePropertyMapping(propertyMapping, this.context);
+    }
+    visit_AggregationAwarePropertyMapping(propertyMapping) {
+        return transformAggregationAwarePropertyMapping(propertyMapping);
+    }
+}
+const transformOperationType = (value) => {
+    switch (value) {
+        case OperationType.ROUTER_UNION:
+            return V1_MappingOperationType.ROUTER_UNION;
+        case OperationType.STORE_UNION:
+            return V1_MappingOperationType.STORE_UNION;
+        case OperationType.INHERITANCE:
+            return V1_MappingOperationType.INHERITANCE;
+        case OperationType.MERGE:
+            return V1_MappingOperationType.MERGE;
+        default:
+            throw new UnsupportedOperationError(`Can't transform operation type`, value);
+    }
+};
+const transformOperationSetImplementation = (element) => {
+    const classMapping = new V1_OperationClassMapping();
+    classMapping.class = element.class.valueForSerialization ?? '';
+    classMapping.id = mappingElementIdSerializer(element.id);
+    classMapping.operation = transformOperationType(element.operation);
+    classMapping.parameters = element.parameters.map((e) => e.setImplementation.value.id.value);
+    classMapping.root = element.root.valueForSerialization;
+    classMapping.extendsClassMappingId = element.superSetImplementationId;
+    return classMapping;
+};
+const transformMergeOperationSetImplementation = (element, context) => {
+    const classMapping = new V1_MergeOperationClassMapping();
+    classMapping.class = element.class.valueForSerialization ?? '';
+    classMapping.id = mappingElementIdSerializer(element.id);
+    classMapping.operation = transformOperationType(element.operation);
+    classMapping.validationFunction =
+        element.validationFunction.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    classMapping.parameters = element.parameters.map((e) => e.setImplementation.value.id.value);
+    classMapping.extendsClassMappingId = element.superSetImplementationId;
+    classMapping.root = element.root.valueForSerialization;
+    return classMapping;
+};
+const transformPureInstanceSetImplementation = (element, context) => {
+    const classMapping = new V1_PureInstanceClassMapping();
+    classMapping.class = element.class.valueForSerialization ?? '';
+    if (element.filter) {
+        classMapping.filter = element.filter.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    classMapping.id = mappingElementIdSerializer(element.id);
+    classMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, true, context);
+    classMapping.extendsClassMappingId = element.superSetImplementationId;
+    classMapping.root = element.root.valueForSerialization;
+    classMapping.srcClass = element.srcClass?.valueForSerialization;
+    return classMapping;
+};
+const transformFlatDataInstanceSetImpl = (element, context) => {
+    const classMapping = new V1_RootFlatDataClassMapping();
+    classMapping.class = element.class.valueForSerialization ?? '';
+    if (element.filter) {
+        classMapping.filter = element.filter.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    classMapping.flatData =
+        element.sourceRootRecordType.ownerReference.valueForSerialization ?? '';
+    classMapping.id = mappingElementIdSerializer(element.id);
+    classMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, true, context);
+    classMapping.root = element.root.valueForSerialization;
+    classMapping.extendsClassMappingId = element.superSetImplementationId;
+    classMapping.sectionName = element.sourceRootRecordType.value._OWNER.name;
+    return classMapping;
+};
+const transformRootRelationalSetImpl = (element, context) => {
+    const classMapping = new V1_RootRelationalClassMapping();
+    classMapping.class = element.class.valueForSerialization ?? '';
+    classMapping.distinct = element.distinct ?? false;
+    classMapping.id = mappingElementIdSerializer(element.id);
+    if (element.mainTableAlias) {
+        classMapping.mainTable = V1_transformTableAliasToTablePointer(element.mainTableAlias);
+    }
+    classMapping.extendsClassMappingId = element.superSetImplementationId;
+    classMapping.primaryKey = element.primaryKey.map((pk) => V1_transformRelationalOperationElement(pk, context));
+    if (element.filter) {
+        const filter = new V1_FilterMapping();
+        const filterPointer = new V1_FilterPointer();
+        filterPointer.db = element.filter.database.path;
+        filterPointer.name = element.filter.filterName;
+        filter.filter = filterPointer;
+        filter.joins = element.filter.joinTreeNode
+            ? extractLine(element.filter.joinTreeNode).map((node) => {
+                const joinPtr = new V1_JoinPointer();
+                joinPtr.db = node.join.ownerReference.valueForSerialization ?? '';
+                joinPtr.joinType = node.joinType;
+                joinPtr.name = node.join.value.name;
+                return joinPtr;
+            })
+            : [];
+        classMapping.filter = filter;
+    }
+    classMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, false, context);
+    classMapping.root = element.root.valueForSerialization;
+    return classMapping;
+};
+const transformRelationalInstanceSetImpl = (element, context) => {
+    const classMapping = new V1_RelationalClassMapping();
+    classMapping.primaryKey = element.primaryKey.map((pk) => V1_transformRelationalOperationElement(pk, context));
+    classMapping.extendsClassMappingId = element.superSetImplementationId;
+    classMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, true, context);
+    classMapping.root = element.root.valueForSerialization;
+    /**
+     * Omit this information during protocol transformation as it can be
+     * interpreted while building the graph; and will help grammar-roundtrip
+     * tests (involving engine) to pass. Ideally, this requires grammar parser
+     * and composer in engine to be more consistent.
+     *
+     * @discrepancy grammar-roundtrip
+     */
+    classMapping.class = undefined;
+    return classMapping;
+};
+const transformAggregationFunctionSpecification = (element, context) => {
+    const func = new V1_AggregateFunction();
+    if (!isStubbed_RawLambda(element.mapFn)) {
+        func.mapFn = element.mapFn.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    if (!isStubbed_RawLambda(element.aggregateFn)) {
+        func.aggregateFn = element.aggregateFn.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    return func;
+};
+const transformGroupByFunctionSpec = (element, context) => {
+    const func = new V1_GroupByFunction();
+    if (!isStubbed_RawLambda(element.groupByFn)) {
+        func.groupByFn = element.groupByFn.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(context));
+    }
+    return func;
+};
+const transformAggregateSpecification = (element, context) => {
+    const aggregateSpec = new V1_AggregateSpecification();
+    aggregateSpec.canAggregate = element.canAggregate;
+    aggregateSpec.groupByFunctions = element.groupByFunctions.map((groupByFunc) => transformGroupByFunctionSpec(groupByFunc, context));
+    aggregateSpec.aggregateValues = element.aggregateValues.map((aggregateValue) => transformAggregationFunctionSpecification(aggregateValue, context));
+    return aggregateSpec;
+};
+const transformAggSetImplContainer = (element, context) => {
+    const setImplContainer = new V1_AggregateSetImplementationContainer();
+    setImplContainer.index = element.index;
+    const classMapping = transformSetImplementation(element.setImplementation, context);
+    if (classMapping) {
+        setImplContainer.setImplementation = classMapping;
+    }
+    setImplContainer.aggregateSpecification = transformAggregateSpecification(element.aggregateSpecification, context);
+    return setImplContainer;
+};
+const transformAggregationAwareSetImplementation = (element, context) => {
+    const classMapping = new V1_AggregationAwareClassMapping();
+    classMapping.id = mappingElementIdSerializer(element.id);
+    classMapping.class = element.class.valueForSerialization ?? '';
+    classMapping.root = element.root.valueForSerialization;
+    const mainSetImplementation = transformSetImplementation(element.mainSetImplementation, context);
+    if (mainSetImplementation) {
+        classMapping.mainSetImplementation = mainSetImplementation;
+    }
+    classMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, false, context);
+    classMapping.extendsClassMappingId = element.superSetImplementationId;
+    classMapping.aggregateSetImplementations =
+        element.aggregateSetImplementations.map((aggregateSetImpl) => transformAggSetImplContainer(aggregateSetImpl, context));
+    return classMapping;
+};
+// NOTE: this needs to be a function to avoid error with using before declaration for embedded property mappings due to the hoisting behavior in ES
+function transformProperyMapping(propertyMapping, isTransformingEmbeddedPropertyMapping, context) {
+    return propertyMapping.accept_PropertyMappingVisitor(new PropertyMappingTransformer(isTransformingEmbeddedPropertyMapping, context));
+}
+export class V1_SetImplementationTransformer {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    visit_SetImplementation(setImplementation) {
+        const extraClassMappingTransformers = this.context.plugins.flatMap((plugin) => plugin.V1_getExtraClassMappingTransformers?.() ?? []);
+        for (const transformer of extraClassMappingTransformers) {
+            const classMapping = transformer(setImplementation, this.context);
+            if (classMapping) {
+                return classMapping;
+            }
+        }
+        throw new UnsupportedOperationError(`Can't transform class mapping: no compatible transformer available from plugins`, setImplementation);
+    }
+    visit_OperationSetImplementation(setImplementation) {
+        if (setImplementation instanceof MergeOperationSetImplementation) {
+            return transformMergeOperationSetImplementation(setImplementation, this.context);
+        }
+        else {
+            return transformOperationSetImplementation(setImplementation);
+        }
+    }
+    visit_MergeOperationSetImplementation(setImplementation) {
+        return transformMergeOperationSetImplementation(setImplementation, this.context);
+    }
+    visit_PureInstanceSetImplementation(setImplementation) {
+        return transformPureInstanceSetImplementation(setImplementation, this.context);
+    }
+    visit_FlatDataInstanceSetImplementation(setImplementation) {
+        return transformFlatDataInstanceSetImpl(setImplementation, this.context);
+    }
+    visit_EmbeddedFlatDataSetImplementation(setImplementation) {
+        // NOTE: we currently don't support this and flat-data would probably be deprecated
+        // in the future in favor of schema-set/binding
+        return undefined;
+    }
+    visit_RootRelationalInstanceSetImplementation(setImplementation) {
+        return transformRootRelationalSetImpl(setImplementation, this.context);
+    }
+    visit_RelationalInstanceSetImplementation(setImplementation) {
+        return transformRelationalInstanceSetImpl(setImplementation, this.context);
+    }
+    visit_AggregationAwareSetImplementation(setImplementation) {
+        return transformAggregationAwareSetImplementation(setImplementation, this.context);
+    }
+    /**
+     * This test is skipped because we want to temporarily relax graph building algorithm
+     * to ease Pure -> Legend migration push.
+     * See https://github.com/finos/legend-studio/issues/880
+     *
+     * @discrepancy graph-building
+     */
+    visit_TEMPORARY__UnresolvedSetImplementation(setImplementation) {
+        throw new IllegalStateError(`Can't transform unresolved set implementation. This type of set implementation should only show up in references.`);
+    }
+}
+function transformSetImplementation(setImplementation, context) {
+    return setImplementation.accept_SetImplementationVisitor(new V1_SetImplementationTransformer(context));
+}
+// Association V1_Mapping
+const transformRelationalAssociationImplementation = (element, context) => {
+    const relationalMapping = new V1_RelationalAssociationMapping();
+    relationalMapping.stores = element.stores.map((store) => store.valueForSerialization ?? '');
+    relationalMapping.association =
+        element.association.valueForSerialization ?? '';
+    relationalMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, true, context);
+    relationalMapping.id = mappingElementIdSerializer(element.id);
+    return relationalMapping;
+};
+const transformXStorelAssociationImplementation = (element, context) => {
+    const xStoreMapping = new V1_XStoreAssociationMapping();
+    xStoreMapping.stores = element.stores.map((store) => store.valueForSerialization ?? '');
+    xStoreMapping.association = element.association.valueForSerialization ?? '';
+    xStoreMapping.propertyMappings = transformClassMappingPropertyMappings(element.propertyMappings, false, context);
+    xStoreMapping.id = mappingElementIdSerializer(element.id);
+    return xStoreMapping;
+};
+const transformAssociationImplementation = (element, context) => {
+    if (element instanceof RelationalAssociationImplementation) {
+        return transformRelationalAssociationImplementation(element, context);
+    }
+    else if (element instanceof XStoreAssociationImplementation) {
+        return transformXStorelAssociationImplementation(element, context);
+    }
+    throw new UnsupportedOperationError(`Can't transform association implementation`, element);
+};
+export const V1_transformMapping = (element, context) => {
+    const mapping = new V1_Mapping();
+    V1_initPackageableElement(mapping, element);
+    mapping.includedMappings = element.includes.map(transformMappingInclude);
+    mapping.enumerationMappings = element.enumerationMappings.map(transformEnumerationMapping);
+    mapping.classMappings = element.classMappings
+        .map((classMapping) => transformSetImplementation(classMapping, context))
+        .filter(isNonNullable);
+    mapping.associationMappings = element.associationMappings.map((associationMapping) => transformAssociationImplementation(associationMapping, context));
+    mapping.tests = element.tests.map((test) => transformMappingTest(test, context));
+    return mapping;
+};
+//# sourceMappingURL=V1_MappingTransformer.js.map