@finos/legend-graph 5.0.0 → 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

@@ -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,
@@ -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(

package/src/helpers/DomainHelper.ts

@@ -20,7 +20,7 @@ import {
   CORE_PURE_PATH,
   ELEMENT_PATH_DELIMITER,
   RESERVERD_PACKAGE_NAMES,
-  MILESTONING_STEROTYPES,
+  MILESTONING_STEREOTYPE,
 } from '../MetaModelConst';
 import { Profile } from '../models/metamodels/pure/packageableElements/domain/Profile';
 import { Tag } from '../models/metamodels/pure/packageableElements/domain/Tag';
@@ -200,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) {
@@ -220,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/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

@@ -84,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';
@@ -119,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,
@@ -225,6 +227,8 @@ 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,
@@ -250,12 +254,14 @@ 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';
@@ -297,3 +303,4 @@ export * from './DSLService_Exports';
 export * from './DSLGenerationSpecification_Exports';
 export * from './StoreFlatData_Exports';
 export * from './StoreRelational_Exports';
+export * from './DSLData_Exports';

package/src/models/metamodels/pure/data/EmbeddedData.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../MetaModelConst';
+import { hashObjectWithoutSourceInformation } from '../../../../MetaModelUtils';
+import type { DataElement } from '../packageableElements/data/DataElement';
+import type { Class } from '../packageableElements/domain/Class';
+import type { PackageableElementReference } from '../packageableElements/PackageableElementReference';
+
+export interface EmbeddedDataVisitor<T> {
+  visit_EmbeddedData(embeddedData: EmbeddedData): T;
+  visit_ExternalFormatData(externalFormatData: ExternalFormatData): T;
+  visit_ModelStoreData(modelStoreData: ModelStoreData): T;
+  visit_DataElementReference(dataElementReference: DataElementReference): T;
+}
+
+export abstract class EmbeddedData implements Hashable {
+  abstract get hashCode(): string;
+  abstract accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T;
+}
+
+export class DataElementReference extends EmbeddedData implements Hashable {
+  dataElement!: PackageableElementReference<DataElement>;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_ELEMENT_REFERENCE,
+      this.dataElement.hashValue,
+    ]);
+  }
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_DataElementReference(this);
+  }
+}
+
+export class ExternalFormatData extends EmbeddedData implements Hashable {
+  contentType!: string;
+  data!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EXTERNAL_FORMAT_DATA,
+      this.contentType,
+      this.data,
+    ]);
+  }
+
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_ExternalFormatData(this);
+  }
+}
+
+export class ModelStoreData extends EmbeddedData implements Hashable {
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   * TODO: we may want to build out the instance `objects` once we build out the form
+   *
+   * @discrepancy model
+   */
+  instances!: Map<Class, object>;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MODEL_STORE_DATA,
+      hashArray(Array.from(this.instances.keys()).map((e) => e.path)),
+      hashObjectWithoutSourceInformation(Array.from(this.instances.values())),
+    ]);
+  }
+
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_ModelStoreData(this);
+  }
+}

package/src/models/metamodels/pure/packageableElements/PackageableElement.ts

@@ -43,6 +43,7 @@ import type { FileGenerationSpecification } from './fileGeneration/FileGeneratio
 import type { GenerationSpecification } from './generationSpecification/GenerationSpecification';
 import type { Measure } from './domain/Measure';
 import type { SectionIndex } from './section/SectionIndex';
+import type { DataElement } from './data/DataElement';
 
 export interface PackageableElementVisitor<T> {
   visit_PackageableElement(element: PackageableElement): T;
@@ -64,6 +65,7 @@ export interface PackageableElementVisitor<T> {
   visit_Service(element: Service): T;
   visit_FileGenerationSpecification(element: FileGenerationSpecification): T;
   visit_GenerationSpecification(element: GenerationSpecification): T;
+  visit_DataElement(element: DataElement): T;
 }
 
 export abstract class PackageableElement implements Hashable, Stubable {
@@ -162,6 +164,7 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
   FILE_GENERATION = 'FILE_GENERATION',
   GENERATION_SPECIFICATION = 'GENERATION_SPECIFICATION',
   SECTION_INDEX = 'SECTION_INDEX',
+  DATA = 'Data',
 }
 
 // TODO: to be moved out of metamodel

package/src/models/metamodels/pure/packageableElements/data/DataElement.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+import type { EmbeddedData } from '../../data/EmbeddedData';
+import type { StereotypeReference } from '../domain/StereotypeReference';
+import type { TaggedValue } from '../domain/TaggedValue';
+import {
+  PackageableElement,
+  type PackageableElementVisitor,
+} from '../PackageableElement';
+
+export class DataElement extends PackageableElement implements Hashable {
+  stereotypes: StereotypeReference[] = [];
+  taggedValues: TaggedValue[] = [];
+  data!: EmbeddedData;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_ELEMENT,
+      this.path,
+      hashArray(
+        this.stereotypes.map((stereotype) => stereotype.pointerHashCode),
+      ),
+      hashArray(this.taggedValues),
+      this.data,
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_DataElement(this);
+  }
+}

package/src/models/metamodels/pure/packageableElements/domain/Association.ts

@@ -74,6 +74,12 @@ export class Association
   taggedValues: TaggedValue[] = [];
   derivedProperties: DerivedProperty[] = [];
 
+  /**
+   * To store the abstract properties generated while processing the milestoning properties. The properties
+   * generated are `allVersions`, `allVersionsInRange` and derived property with date parameter.
+   */
+  _generatedMilestonedProperties: AbstractProperty[] = [];
+
   getFirstProperty = (): Property => guaranteeNonNullable(this.properties[0]);
   getSecondProperty = (): Property => guaranteeNonNullable(this.properties[1]);
   getOtherProperty = (property: Property): Property => {

package/src/models/metamodels/pure/packageableElements/domain/Class.ts

@@ -49,15 +49,22 @@ export class Class extends Type implements Hashable, Stubable {
   /**
    * We can also call this `specifications` (i.e. vs. `generalizations`)
    *
-   * @MARKER MEMORY-SENSITIVE
-   * if this belongs to immutable elements: i.e. in system, project dependency, etc.
+   * If this belongs to immutable elements: i.e. in system, project dependency, etc.
    * we have to make sure to remove of disposed classes from this when we reprocess the graph
+   *
+   * @risk memory-leak
    */
   subclasses: Class[] = [];
   constraints: Constraint[] = [];
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
 
+  /**
+   * To store the abstract properties generated while processing the milestoning properties. The properties
+   * generated are `allVersions`, `allVersionsInRange` and derived property with date parameter.
+   */
+  _generatedMilestonedProperties: AbstractProperty[] = [];
+
   /**
    * Get class and its supertypes' properties recursively, duplications and loops are handled (Which should be caught by compiler)
    */
@@ -144,9 +151,10 @@ export class Class extends Type implements Hashable, Stubable {
    * Get all subclasses of a class, accounted for loop and duplication (which should be caught by compiler)
    * NOTE: we intentionally leave out `Any`
    *
-   * @MARKER MEMORY-SENSITIVE
    * When this is an immutable class such as project dependency or system we need to remember to remove the classes from the sub-types array.
    * And rerun this computation to avoid potenial memory leak
+   *
+   * @risk memory-leak
    */
   get allSubclasses(): Class[] {
     if (this._isDisposed) {

package/src/models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition.ts

@@ -33,8 +33,18 @@ export class ConcreteFunctionDefinition
 {
   returnType: PackageableElementReference<Type>;
   returnMultiplicity: Multiplicity;
-  parameters: RawVariableExpression[] = []; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
-  body: object[] = []; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  parameters: RawVariableExpression[] = [];
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  body: object[] = [];
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
 

package/src/models/metamodels/pure/packageableElements/domain/Constraint.ts

@@ -25,10 +25,20 @@ export class Constraint implements Hashable, Stubable {
   owner: Class;
 
   name: string;
-  functionDefinition: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  functionDefinition: RawLambda;
   externalId?: string | undefined;
   enforcementLevel?: string | undefined;
-  messageFunction?: RawLambda | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  messageFunction?: RawLambda | undefined;
 
   constructor(name: string, owner: Class, functionDefinition: RawLambda) {
     this.name = name;

package/src/models/metamodels/pure/packageableElements/domain/DerivedProperty.ts

@@ -42,8 +42,18 @@ export class DerivedProperty
   multiplicity: Multiplicity;
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
-  body?: object | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
-  parameters?: object | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  body?: object | undefined;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  parameters?: object | undefined;
 
   constructor(
     name: string,

package/src/models/metamodels/pure/packageableElements/domain/Measure.ts

@@ -27,7 +27,12 @@ import type { RawLambda } from '../../rawValueSpecification/RawLambda';
 
 export class Unit extends DataType implements Hashable {
   measure: Measure;
-  conversionFunction?: RawLambda | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  conversionFunction?: RawLambda | undefined;
 
   constructor(
     name: string,

package/src/models/metamodels/pure/packageableElements/mapping/ExpectedOutputMappingTestAssert.ts

@@ -36,7 +36,9 @@ export class ExpectedOutputMappingTestAssert
 
   constructor(expectedOutput: string) {
     super();
-    /* @MARKER: Workaround for https://github.com/finos/legend-studio/issues/68 */
+    /**
+     * @workaround https://github.com/finos/legend-studio/issues/68
+     */
     this.expectedOutput = tryToMinifyLosslessJSONString(expectedOutput);
   }