@finos/legend-graph 4.0.2 → 6.0.0

package/src/graphManager/action/changeDetection/Test_ObserverHelper.ts

@@ -0,0 +1,210 @@
+/**
+ * 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 { computed, makeObservable, observable } from 'mobx';
+import { ServiceTest } from '../../../DSLService_Exports';
+import { ServiceTestSuite } from '../../../models/metamodels/pure/packageableElements/service/ServiceTestSuite';
+import { EqualTo } from '../../../models/metamodels/pure/test/assertion/EqualTo';
+import { EqualToJson } from '../../../models/metamodels/pure/test/assertion/EqualToJson';
+import { AssertFail } from '../../../models/metamodels/pure/test/assertion/status/AssertFail';
+import type { AssertionStatus } from '../../../models/metamodels/pure/test/assertion/status/AssertionStatus';
+import { AssertPass } from '../../../models/metamodels/pure/test/assertion/status/AssertPass';
+import { EqualToJsonAssertFail } from '../../../models/metamodels/pure/test/assertion/status/EqualToJsonAssertFail';
+import type { TestAssertion } from '../../../models/metamodels/pure/test/assertion/TestAssertion';
+import type { AtomicTestId } from '../../../models/metamodels/pure/test/result/AtomicTestId';
+import type { TestError } from '../../../models/metamodels/pure/test/result/TestError';
+import type { TestFailed } from '../../../models/metamodels/pure/test/result/TestFailed';
+import type { TestPassed } from '../../../models/metamodels/pure/test/result/TestPassed';
+import type { TestResult } from '../../../models/metamodels/pure/test/result/TestResult';
+import type {
+  AtomicTest,
+  TestSuite,
+} from '../../../models/metamodels/pure/test/Test';
+import { type ObserverContext, skipObserved } from './CoreObserverHelper';
+import { observe_ExternalFormatData } from './Data_ObserverHelper';
+import {
+  observe_ServiceTest,
+  observe_ServiceTestSuite,
+} from './DSLService_ObserverHelper';
+
+export const observe_AtomicTestId = skipObserved(
+  (metamodel: AtomicTestId): AtomicTestId => {
+    makeObservable(metamodel, {
+      testSuiteId: observable,
+      atomicTestId: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_AssertFail = skipObserved(
+  (metamodel: AssertFail): AssertFail => {
+    makeObservable(metamodel, {
+      id: observable,
+      message: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_AssertPass = skipObserved(
+  (metamodel: AssertPass): AssertPass => {
+    makeObservable(metamodel, {
+      id: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_EqualToJsonAssertFail = skipObserved(
+  (metamodel: EqualToJsonAssertFail): EqualToJsonAssertFail => {
+    makeObservable(metamodel, {
+      id: observable,
+      message: observable,
+      actual: observable,
+      expected: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+function observe_AssertionStatus(metamodel: AssertionStatus): AssertionStatus {
+  if (metamodel instanceof EqualToJsonAssertFail) {
+    return observe_EqualToJsonAssertFail(metamodel);
+  } else if (metamodel instanceof AssertFail) {
+    return observe_AssertFail(metamodel);
+  } else if (metamodel instanceof AssertPass) {
+    return observe_AssertPass(metamodel);
+  }
+  return metamodel;
+}
+
+export const observe_EqualTo = skipObserved((metamodel: EqualTo): EqualTo => {
+  makeObservable(metamodel, {
+    id: observable,
+    expected: observable,
+    hashCode: computed,
+  });
+
+  return metamodel;
+});
+
+export const observe_EqualToJson = skipObserved(
+  (metamodel: EqualToJson): EqualToJson => {
+    makeObservable(metamodel, {
+      id: observable,
+      expected: observable,
+      hashCode: computed,
+    });
+
+    observe_ExternalFormatData(metamodel.expected);
+
+    return metamodel;
+  },
+);
+
+export const observe_TestError = skipObserved(
+  (metamodel: TestError): TestError => {
+    makeObservable(metamodel, {
+      testable: observable,
+      atomicTestId: observable,
+      error: observable,
+      hashCode: computed,
+    });
+
+    observe_AtomicTestId(metamodel.atomicTestId);
+
+    return metamodel;
+  },
+);
+
+export const observe_TestFailed = skipObserved(
+  (metamodel: TestFailed): TestFailed => {
+    makeObservable(metamodel, {
+      testable: observable,
+      atomicTestId: observable,
+      assertStatuses: observable,
+      hashCode: computed,
+    });
+
+    metamodel.assertStatuses.forEach(observe_AssertionStatus);
+    observe_AtomicTestId(metamodel.atomicTestId);
+
+    return metamodel;
+  },
+);
+
+export const observe_TestPassed = skipObserved(
+  (metamodel: TestPassed): TestPassed => {
+    makeObservable(metamodel, {
+      testable: observable,
+      atomicTestId: observable,
+      hashCode: computed,
+    });
+
+    observe_AtomicTestId(metamodel.atomicTestId);
+
+    return metamodel;
+  },
+);
+
+export const observe_TestResult = skipObserved(
+  (metamodel: TestResult): TestResult => {
+    makeObservable(metamodel, {
+      testable: observable,
+      atomicTestId: observable,
+      hashCode: computed,
+    });
+
+    observe_AtomicTestId(metamodel.atomicTestId);
+
+    return metamodel;
+  },
+);
+
+export function observe_AtomicTest(metamodel: AtomicTest): AtomicTest {
+  if (metamodel instanceof ServiceTest) {
+    return observe_ServiceTest(metamodel);
+  }
+  return metamodel;
+}
+
+export function observe_TestAssertion(metamodel: TestAssertion): TestAssertion {
+  if (metamodel instanceof EqualTo) {
+    return observe_EqualTo(metamodel);
+  } else if (metamodel instanceof EqualToJson) {
+    return observe_EqualToJson(metamodel);
+  }
+  return metamodel;
+}
+
+export function observe_TestSuite(
+  metamodel: TestSuite,
+  context: ObserverContext,
+): TestSuite {
+  if (metamodel instanceof ServiceTestSuite) {
+    return observe_ServiceTestSuite(metamodel, context);
+  }
+  return metamodel;
+}

package/src/graphManager/action/changeDetection/ValueSpecificationObserver.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { isType, Pair } from '@finos/legend-shared';
+import { filterByType, Pair } from '@finos/legend-shared';
 import { computed, makeObservable, observable } from 'mobx';
 import { PackageableElementReference } from '../../../models/metamodels/pure/packageableElements/PackageableElementReference';
 import { Runtime } from '../../../models/metamodels/pure/packageableElements/runtime/Runtime';
@@ -45,6 +45,7 @@ import {
   type FunctionType,
   LambdaFunction,
 } from '../../../models/metamodels/pure/valueSpecification/LambdaFunction';
+import type { INTERNAL__PropagatedValue } from '../../../models/metamodels/pure/valueSpecification/INTERNAL__PropagatedValue';
 import type {
   FunctionExpression,
   SimpleFunctionExpression,
@@ -172,7 +173,7 @@ export const observe_PropertyGraphFetchTreeInstanceValue =
       observe_Abstract_InstanceValue(metamodel, context);
 
       metamodel.values
-        .filter((value) => isType(value, PropertyGraphFetchTree))
+        .filter(filterByType(PropertyGraphFetchTree))
         .forEach((value) => observe_PropertyGraphFetchTree(value, context));
 
       return metamodel;
@@ -218,7 +219,7 @@ const observe_AlloySerializationConfigInstanceValue = skipObservedWithContext(
     observe_Abstract_InstanceValue(metamodel, context);
 
     metamodel.values
-      .filter((value) => isType(value, AlloySerializationConfig))
+      .filter(filterByType(AlloySerializationConfig))
       .forEach((value) => observe_AlloySerializationConfig(value));
     return metamodel;
   },
@@ -234,7 +235,7 @@ const observe_LambdaFunctionInstanceValue = skipObservedWithContext(
     observe_Abstract_InstanceValue(metamodel, context);
 
     metamodel.values
-      .filter((value) => isType(value, LambdaFunction))
+      .filter(filterByType(LambdaFunction))
       .forEach((value) => observe_LambdaFunction(value, context));
 
     return metamodel;
@@ -278,7 +279,7 @@ const observe_RuntimeInstanceValue = skipObservedWithContext(
     observe_Abstract_InstanceValue(metamodel, context);
 
     metamodel.values
-      .filter((value) => isType(value, Runtime))
+      .filter(filterByType(Runtime))
       .forEach((value) => observe_Runtime(value, context));
 
     return metamodel;
@@ -294,7 +295,7 @@ const observe_MappingInstanceValue = skipObservedWithContext(
     observe_Abstract_InstanceValue(metamodel, context);
 
     metamodel.values
-      .filter((value) => isType(value, PackageableElementReference))
+      .filter(filterByType(PackageableElementReference))
       .forEach(observe_PackageableElementReference);
 
     return metamodel;
@@ -426,6 +427,12 @@ class ValueSpecificationObserver implements ValueSpecificationVisitor<void> {
   ): void {
     observe_INTERNAL__UnknownValueSpecification(valueSpecification);
   }
+
+  visit_INTERNAL__PropagatedValue(
+    valueSpecification: INTERNAL__PropagatedValue,
+  ): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
 }
 
 export const observe_ValueSpecification = skipObservedWithContext(
@@ -520,10 +527,7 @@ function observe_Abstract_InstanceValue(
   });
 
   metamodel.values
-    .filter(
-      (value): value is ValueSpecification =>
-        value instanceof ValueSpecification,
-    )
+    .filter(filterByType(ValueSpecification))
     .forEach((value) => observe_ValueSpecification(value, context));
 }
 
@@ -551,22 +555,20 @@ function _observe_PairInstanceValue(
 ): PairInstanceValue {
   observe_Abstract_InstanceValue(metamodel, context);
 
-  metamodel.values
-    .filter((value) => isType(value, Pair))
-    .forEach((value) => {
-      makeObservable(value, {
-        first: observable,
-        second: observable,
-      });
-
-      if (value.first instanceof ValueSpecification) {
-        observe_ValueSpecification(value.first, context);
-      }
-      if (value.second instanceof ValueSpecification) {
-        observe_ValueSpecification(value.second, context);
-      }
+  metamodel.values.filter(filterByType(Pair)).forEach((value) => {
+    makeObservable(value, {
+      first: observable,
+      second: observable,
     });
 
+    if (value.first instanceof ValueSpecification) {
+      observe_ValueSpecification(value.first, context);
+    }
+    if (value.second instanceof ValueSpecification) {
+      observe_ValueSpecification(value.second, context);
+    }
+  });
+
   return metamodel;
 }
 

package/src/graphManager/action/execution/ExecutionResult.ts

@@ -76,7 +76,7 @@ export class TdsBuilder extends ResultBuilder {
 }
 
 export class TdsRow {
-  values: (string | number)[] = [];
+  values: (string | number | boolean | null)[] = [];
 }
 
 export class TabularDataSet {

package/src/helpers/DomainHelper.ts

@@ -16,7 +16,12 @@
 
 import type { PureModel } from '../graph/PureModel';
 import { Class } from '../models/metamodels/pure/packageableElements/domain/Class';
-import { CORE_PURE_PATH, MILESTONING_STEROTYPES } from '../MetaModelConst';
+import {
+  CORE_PURE_PATH,
+  ELEMENT_PATH_DELIMITER,
+  RESERVERD_PACKAGE_NAMES,
+  MILESTONING_STEREOTYPE,
+} from '../MetaModelConst';
 import { Profile } from '../models/metamodels/pure/packageableElements/domain/Profile';
 import { Tag } from '../models/metamodels/pure/packageableElements/domain/Tag';
 import { Enum } from '../models/metamodels/pure/packageableElements/domain/Enum';
@@ -24,20 +29,27 @@ import { Stereotype } from '../models/metamodels/pure/packageableElements/domain
 import { TaggedValue } from '../models/metamodels/pure/packageableElements/domain/TaggedValue';
 import { TagExplicitReference } from '../models/metamodels/pure/packageableElements/domain/TagReference';
 import type { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration';
-import type { Package } from '../models/metamodels/pure/packageableElements/domain/Package';
+import { Package } from '../models/metamodels/pure/packageableElements/domain/Package';
 import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement';
+import {
+  AssertionError,
+  assertNonEmptyString,
+  assertTrue,
+  guaranteeType,
+} from '@finos/legend-shared';
+import { createPath } from '../MetaModelUtils';
+import type { BasicModel } from '../graph/BasicModel';
 
-export const _package_addElement = (
+export const addElementToPackage = (
   parent: Package,
   element: PackageableElement,
 ): void => {
-  // NOTE: here we directly push the element to the children array without any checks rather than use `addUniqueEntry` to improve performance.
-  // Duplication checks should be handled separately
+  // To improve performance we won't do duplication check here
   parent.children.push(element);
   element.package = parent;
 };
 
-export const _package_deleteElement = (
+export const deleteElementFromPackage = (
   parent: Package,
   packageableElement: PackageableElement,
 ): void => {
@@ -46,6 +58,136 @@ export const _package_deleteElement = (
   );
 };
 
+export const getElementRootPackage = (element: PackageableElement): Package =>
+  !element.package
+    ? guaranteeType(element, Package)
+    : getElementRootPackage(element.package);
+
+/**
+ * If package name is a path, continue to recursively
+ * traverse the package chain to find the leaf package
+ *
+ * NOTE: if we do not allow create new packages, errorcould be
+ * thrown if a package with the specified path is not found
+ */
+const _getOrCreatePackage = (
+  parentPackage: Package,
+  relativePackagePath: string,
+  createNewPackageIfNotFound: boolean,
+  cache: Map<string, Package> | undefined,
+): Package => {
+  const index = relativePackagePath.indexOf(ELEMENT_PATH_DELIMITER);
+  const packageName =
+    index === -1
+      ? relativePackagePath
+      : relativePackagePath.substring(0, index);
+
+  // try to resolve when there is a cache miss
+  let pkg: Package | undefined;
+  pkg = parentPackage.children.find(
+    (child: PackageableElement): child is Package =>
+      child instanceof Package && child.name === packageName,
+  );
+  if (!pkg) {
+    if (!createNewPackageIfNotFound) {
+      throw new AssertionError(
+        `Can't find child package '${packageName}' in package '${parentPackage.path}'`,
+      );
+    }
+    // create the node if it is not in parent package
+    assertTrue(
+      !RESERVERD_PACKAGE_NAMES.includes(packageName),
+      `Can't create package with reserved name '${packageName}'`,
+    );
+    pkg = new Package(packageName);
+    pkg.package = parentPackage;
+    // NOTE: here we directly push the element to the children array without any checks rather than use `addUniqueEntry` to improve performance.
+    // Duplication checks should be handled separately for speed
+    parentPackage.children.push(pkg);
+  }
+
+  // populate cache after resolving the package
+  if (cache) {
+    cache.set(createPath(parentPackage.fullPath, packageName), pkg);
+  }
+
+  // traverse the package chain
+  if (index !== -1) {
+    return _getOrCreatePackage(
+      pkg,
+      relativePackagePath.substring(index + ELEMENT_PATH_DELIMITER.length),
+      createNewPackageIfNotFound,
+      cache,
+    );
+  }
+
+  return pkg;
+};
+
+export const getOrCreatePackage = (
+  parentPackage: Package,
+  relativePackagePath: string,
+  createNewPackageIfNotFound: boolean,
+  cache: Map<string, Package> | undefined,
+): Package => {
+  // check cache to find the shortest chain of packages to find/build
+  if (cache) {
+    // short-circuit
+    const cachedPackage = cache.get(
+      createPath(parentPackage.fullPath, relativePackagePath),
+    );
+    if (cachedPackage) {
+      return cachedPackage;
+    }
+
+    // NOTE: to check the cache, we need to traverse from the full package path
+    // up its ancestor chain till we find a cache hit
+    let immediateParentPackageRelativePath = relativePackagePath;
+    while (immediateParentPackageRelativePath !== '') {
+      const fullPath = createPath(
+        parentPackage.fullPath,
+        immediateParentPackageRelativePath,
+      );
+      const cachedParentPackage = cache.get(fullPath);
+      if (cachedParentPackage) {
+        return _getOrCreatePackage(
+          cachedParentPackage,
+          relativePackagePath.substring(
+            immediateParentPackageRelativePath.length +
+              ELEMENT_PATH_DELIMITER.length,
+            relativePackagePath.length,
+          ),
+          createNewPackageIfNotFound,
+          cache,
+        );
+      }
+      const index = immediateParentPackageRelativePath.lastIndexOf(
+        ELEMENT_PATH_DELIMITER,
+      );
+      immediateParentPackageRelativePath =
+        index !== -1
+          ? immediateParentPackageRelativePath.substring(0, index)
+          : '';
+    }
+  }
+
+  return _getOrCreatePackage(
+    parentPackage,
+    relativePackagePath,
+    createNewPackageIfNotFound,
+    cache,
+  );
+};
+
+export const getOrCreateGraphPackage = (
+  graph: BasicModel,
+  packagePath: string | undefined,
+  cache: Map<string, Package> | undefined,
+): Package => {
+  assertNonEmptyString(packagePath, 'Package path is required');
+  return getOrCreatePackage(graph.root, packagePath, true, cache);
+};
+
 export const createStubTag = (profile: Profile): Tag => new Tag(profile, '');
 export const createStubTaggedValue = (tag: Tag): TaggedValue =>
   new TaggedValue(TagExplicitReference.create(tag), '');
@@ -58,13 +200,13 @@ export const createStubEnum = (enumeration: Enumeration): Enum =>
 export const getMilestoneTemporalStereotype = (
   val: Class,
   graph: PureModel,
-): MILESTONING_STEROTYPES | undefined => {
+): MILESTONING_STEREOTYPE | undefined => {
   const milestonedProfile = graph.getProfile(CORE_PURE_PATH.PROFILE_TEMPORAL);
   let stereotype;
   const profile = val.stereotypes.find(
     (st) => st.ownerReference.value === milestonedProfile,
   );
-  stereotype = Object.values(MILESTONING_STEROTYPES).find(
+  stereotype = Object.values(MILESTONING_STEREOTYPE).find(
     (value) => value === profile?.value.value,
   );
   if (stereotype !== undefined) {
@@ -78,7 +220,7 @@ export const getMilestoneTemporalStereotype = (
         graph,
       );
       if (milestonedStereotype !== undefined) {
-        stereotype = Object.values(MILESTONING_STEROTYPES).find(
+        stereotype = Object.values(MILESTONING_STEREOTYPE).find(
           (value) => value === milestonedStereotype,
         );
       }

package/src/helpers/MappingHelper.ts

@@ -14,7 +14,12 @@
  * limitations under the License.
  */
 
-import { findLast, guaranteeNonNullable, uniq } from '@finos/legend-shared';
+import {
+  filterByType,
+  findLast,
+  guaranteeNonNullable,
+  uniq,
+} from '@finos/legend-shared';
 import type { EnumerationMapping } from '../models/metamodels/pure/packageableElements/mapping/EnumerationMapping';
 import type { SetImplementation } from '../models/metamodels/pure/packageableElements/mapping/SetImplementation';
 import type { Class } from '../models/metamodels/pure/packageableElements/domain/Class';
@@ -45,10 +50,7 @@ export const extractClassMappingsFromAggregationAwareClassMappings = (
   mapping: Mapping,
 ): SetImplementation[] => {
   const aggregationAwareClassMappings = mapping.classMappings.filter(
-    (
-      classMapping: SetImplementation,
-    ): classMapping is AggregationAwareSetImplementation =>
-      classMapping instanceof AggregationAwareSetImplementation,
+    filterByType(AggregationAwareSetImplementation),
   );
   return [
     ...aggregationAwareClassMappings.map(

package/src/helpers/PureLanguageHelper.ts

@@ -21,6 +21,45 @@ import { PrimitiveType } from '../models/metamodels/pure/packageableElements/dom
 import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration';
 import format from 'date-fns/format';
 
+export enum PURE_ELEMENT_NAME {
+  PROFILE = 'Profile',
+  CLASS = 'Class',
+  ENUMERATION = 'Enum',
+  MEASURE = 'Measure',
+  ASSOCIATION = 'Association',
+  FUNCTION = 'function',
+  MAPPING = 'Mapping',
+  FLAT_DATA = 'FlatData',
+  DATABASE = 'Database',
+  SERVICE = 'Service',
+  RUNTIME = 'Runtime',
+  CONNECTION = 'Connection',
+  FILE_GENERATION = 'FileGeneration',
+  GENERATION_SPECIFICATION = 'GenerationSpecification',
+  DATA_ELEMENT = 'Data',
+}
+
+export enum PURE_CONNECTION_NAME {
+  JSON_MODEL_CONNECTION = 'JsonModelConnection',
+  XML_MODEL_CONNECTION = 'XmlModelConnection',
+  MODEL_CHAIN_CONNECTION = 'ModelChainConnection',
+  RELATIONAL_DATABASE_CONNECTION = 'RelationalDatabaseConnection',
+  FLAT_DATA_CONNECTION = 'FlatDataConnection',
+}
+
+export enum PURE_PARSER {
+  PURE = 'Pure',
+  CONNECTION = 'Connection',
+  RUNTIME = 'Runtime',
+  MAPPING = 'Mapping',
+  SERVICE = 'Service',
+  FLATDATA = 'FlatData',
+  RELATIONAL = 'Relational',
+  GENERATION_SPECIFICATION = 'GenerationSpecification',
+  FILE_GENERATION = 'FileGeneration',
+  DATA = 'Data',
+}
+
 export const generateDefaultParameterValueForType = (
   type: Type | undefined,
   index: number,

package/src/index.ts

@@ -18,6 +18,7 @@
 
 // metamodels
 export * from './models/metamodels/pure/Reference';
+export * from './models/metamodels/pure/packageableElements/connection/Connection';
 export * from './models/metamodels/pure/packageableElements/PackageableElement';
 export * from './models/metamodels/pure/packageableElements/PackageableElementReference';
 export { SectionIndex } from './models/metamodels/pure/packageableElements/section/SectionIndex';
@@ -83,6 +84,7 @@ export { ExternalFormatConnection } from './models/metamodels/pure/packageableEl
 export { UrlStream } from './models/metamodels/pure/packageableElements/externalFormat/connection/DSLExternalFormat_UrlStream';
 export { DSLExternalFormat_GraphPreset } from './graph/DSLExternalFormat_Extension';
 export { BindingTransformer } from './models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_BindingTransformer';
+export * from './graphManager/DSLExternalFormat_PureGraphManagerPlugin';
 // V1 protocols
 export * from './models/protocols/pure/v1/model/packageableElements/V1_PackageableElement';
 export { V1_StereotypePtr } from './models/protocols/pure/v1/model/packageableElements/domain/V1_StereotypePtr';
@@ -118,6 +120,7 @@ export {
   CollectionInstanceValue,
   PrimitiveInstanceValue,
 } from './models/metamodels/pure/valueSpecification/InstanceValue';
+export { INTERNAL__PropagatedValue } from './models/metamodels/pure/valueSpecification/INTERNAL__PropagatedValue';
 export {
   ValueSpecification,
   type ValueSpecificationVisitor,
@@ -223,6 +226,9 @@ export * from './models/protocols/pure/PureProtocolProcessorPlugin';
 
 // --------------------------------------------- TRANSFORMATION --------------------------------------------------
 
+export { V1_transformConnection } from './models/protocols/pure/v1/transformation/pureGraph/from/V1_ConnectionTransformer';
+export { V1_transformRuntime } from './models/protocols/pure/v1/transformation/pureGraph/from/V1_RuntimeTransformer';
+export { V1_transformPackageableElement } from './models/protocols/pure/v1/transformation/pureGraph/from/V1_PackageableElementTransformer';
 export {
   V1_transformStereotype,
   V1_transformTaggedValue,
@@ -230,9 +236,11 @@ export {
 export { V1_buildTaggedValue } from './models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_DomainBuilderHelper';
 export { V1_PureModelContextData } from './models/protocols/pure/v1/model/context/V1_PureModelContextData';
 export * from './models/protocols/pure/v1/transformation/pureGraph/to/V1_GraphBuilderContext';
+export * from './models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_ValueSpecificationPathResolver';
 export * from './models/protocols/pure/v1/transformation/pureGraph/to/V1_ElementBuilder';
 export { V1_RawLambda } from './models/protocols/pure/v1/model/rawValueSpecification/V1_RawLambda';
 export { V1_ProcessingContext } from './models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_ProcessingContext';
+export { V1_ProtocolToMetaModelConnectionBuilder } from './models/protocols/pure/v1/transformation/pureGraph/to/V1_ProtocolToMetaModelConnectionBuilder';
 export * from './models/protocols/pure/v1/transformation/pureGraph/from/V1_GraphTransformerContext';
 export {
   V1_initPackageableElement,
@@ -242,12 +250,18 @@ export {
   V1_RawValueSpecificationTransformer,
   V1_transformRawLambda,
 } from './models/protocols/pure/v1/transformation/pureGraph/from/V1_RawValueSpecificationTransformer';
+export {
+  V1_deserializeConnectionValue,
+  V1_serializeConnectionValue,
+} from './models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_ConnectionSerializationHelper';
+export { V1_runtimePointerModelSchema } from './models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_RuntimeSerializationHelper';
 export {
   V1_rawLambdaModelSchema,
   V1_deserializeRawValueSpecification,
   V1_serializeRawValueSpecification,
 } from './models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_RawValueSpecificationSerializationHelper';
 export { V1_transformPropertyReference } from './models/protocols/pure/v1/transformation/pureGraph/from/V1_MappingTransformer';
+export { V1_buildEngineRuntime } from './models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_RuntimeBuilderHelper';
 export { V1_EngineServerClient } from './models/protocols/pure/v1/engine/V1_EngineServerClient';
 export { V1_Engine } from './models/protocols/pure/v1/engine/V1_Engine';
 export * from './models/protocols/pure/v1/engine/V1_EngineEvent';
@@ -289,3 +303,4 @@ export * from './DSLService_Exports';
 export * from './DSLGenerationSpecification_Exports';
 export * from './StoreFlatData_Exports';
 export * from './StoreRelational_Exports';
+export * from './DSLData_Exports';