@finos/legend-graph 4.0.3 → 6.0.1

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 {
@@ -86,15 +88,6 @@ export abstract class PackageableElement implements Hashable, Stubable {
     this._isDeleted = value;
   }
 
-  /**
-   * TODO: move this out to `DomainHelper` and make this method return `Package` instead of `PackageableElement`.
-   * Get root element. In the ideal case, this method is important for finding the root package, but
-   * if we do something like `this instanceof Package` that would case circular dependency.
-   */
-  getRoot(): PackageableElement {
-    return !this.package ? this : this.package.getRoot();
-  }
-
   get path(): string {
     if (!this.package) {
       return this.name;
@@ -150,6 +143,7 @@ export abstract class PackageableElement implements Hashable, Stubable {
   ): T;
 }
 
+// TODO: to be moved out of metamodel
 export enum PACKAGEABLE_ELEMENT_TYPE {
   PRIMITIVE = 'PRIMITIVE',
   PACKAGE = 'PACKAGE',
@@ -170,8 +164,10 @@ 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
 export enum PACKAGEABLE_ELEMENT_POINTER_TYPE {
   STORE = 'STORE',
   MAPPING = 'MAPPING',
@@ -180,7 +176,7 @@ export enum PACKAGEABLE_ELEMENT_POINTER_TYPE {
 }
 
 export const getElementPointerHashCode = (
-  pointerType: PACKAGEABLE_ELEMENT_POINTER_TYPE,
+  pointerType: string,
   path: string,
 ): string =>
   [CORE_HASH_STRUCTURE.PACKAGEABLE_ELEMENT_POINTER, pointerType, path]

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) {
@@ -228,6 +236,7 @@ export class Class extends Type implements Hashable, Stubable {
   }
 }
 
+// TODO: to be moved out of metamodel
 export enum CLASS_PROPERTY_TYPE {
   CLASS = 'CLASS',
   ENUMERATION = 'ENUMERATION',
@@ -236,6 +245,7 @@ export enum CLASS_PROPERTY_TYPE {
   PRIMITIVE = 'PRIMITIVE',
 }
 
+// TODO: to be moved out of metamodel
 export const getClassPropertyType = (type: Type): CLASS_PROPERTY_TYPE => {
   if (type instanceof PrimitiveType) {
     return CLASS_PROPERTY_TYPE.PRIMITIVE;

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/domain/Package.ts

@@ -18,32 +18,15 @@ import {
   CORE_HASH_STRUCTURE,
   ELEMENT_PATH_DELIMITER,
 } from '../../../../../MetaModelConst';
-import {
-  type Hashable,
-  hashArray,
-  assertTrue,
-  AssertionError,
-} from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import {
   type PackageableElementVisitor,
   PackageableElement,
 } from '../PackageableElement';
 
-export const RESERVERD_PACKAGE_NAMES = ['$implicit'];
-
 export class Package extends PackageableElement implements Hashable {
   children: PackageableElement[] = [];
 
-  static createPackageFromParent(name: string, parent: Package): Package {
-    assertTrue(
-      !RESERVERD_PACKAGE_NAMES.includes(name),
-      `Can't create package with reserved name '${name}'`,
-    );
-    const newPackage = new Package(name);
-    newPackage.package = parent;
-    return newPackage;
-  }
-
   get fullPath(): string {
     if (!this.package) {
       return '';
@@ -54,44 +37,6 @@ export class Package extends PackageableElement implements Hashable {
       : `${parentPackageName}${ELEMENT_PATH_DELIMITER}${this.name}`;
   }
 
-  /**
-   * If package name is a path, continue to recursively traverse the package chain to find the leaf package
-   * NOTE: if we do not allow insertion, error could be thrown if a package in the path is not found
-   */
-  static getOrCreatePackage(
-    parent: Package,
-    packagePath: string,
-    insert: boolean,
-  ): Package {
-    const index = packagePath.indexOf(ELEMENT_PATH_DELIMITER);
-    const str = index === -1 ? packagePath : packagePath.substring(0, index);
-    let node: Package | undefined;
-    node = parent.children.find(
-      (child: PackageableElement): child is Package =>
-        child instanceof Package && child.name === str,
-    );
-    if (!node) {
-      if (!insert) {
-        throw new AssertionError(
-          `Can't find packageable element '${str}' in package '${packagePath}'`,
-        );
-      }
-      // create the node if it is not in parent package
-      node = Package.createPackageFromParent(str, parent);
-      // 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
-      parent.children.push(node);
-    }
-    if (index !== -1) {
-      return Package.getOrCreatePackage(
-        node,
-        packagePath.substring(index + 2),
-        insert,
-      );
-    }
-    return node;
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PACKAGE,

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

@@ -15,7 +15,6 @@
  */
 
 import { hashArray, type Hashable } from '@finos/legend-shared';
-import { fromElementPathToMappingElementId } from '../../../../../MetaModelUtils';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import type {
   PackageableElementExplicitReference,
@@ -23,7 +22,7 @@ import type {
 } from '../PackageableElementReference';
 import type { PropertyMappingsImplementation } from './PropertyMappingsImplementation';
 import type { Association } from '../domain/Association';
-import type { Mapping, MappingElementLabel } from './Mapping';
+import type { Mapping } from './Mapping';
 import type { Store } from '../store/Store';
 import type { PropertyMapping } from './PropertyMapping';
 import type { InferableMappingElementIdValue } from './InferableMappingElementId';
@@ -31,9 +30,9 @@ import type { InferableMappingElementIdValue } from './InferableMappingElementId
 export abstract class AssociationImplementation
   implements PropertyMappingsImplementation, Hashable
 {
+  readonly parent: Mapping;
   association: PackageableElementReference<Association>;
   id: InferableMappingElementIdValue;
-  parent: Mapping;
   stores: PackageableElementReference<Store>[] = [];
   propertyMappings: PropertyMapping[] = [];
 
@@ -47,19 +46,6 @@ export abstract class AssociationImplementation
     this.association = association;
   }
 
-  get label(): MappingElementLabel {
-    return {
-      value: `${
-        fromElementPathToMappingElementId(this.association.value.path) ===
-        this.id.value
-          ? this.association.value.name
-          : `${this.association.value.name} [${this.id.value}]`
-      }`,
-      root: false,
-      tooltip: this.association.value.path,
-    };
-  }
-
   get isStub(): boolean {
     return !this.id.value;
   }

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

@@ -15,7 +15,6 @@
  */
 
 import { hashArray, type Hashable } from '@finos/legend-shared';
-import { fromElementPathToMappingElementId } from '../../../../../MetaModelUtils';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import {
   type PackageableElementReference,
@@ -23,7 +22,7 @@ import {
   PackageableElementExplicitReference,
   OptionalPackageableElementExplicitReference,
 } from '../PackageableElementReference';
-import type { Mapping, MappingElementLabel } from './Mapping';
+import type { Mapping } from './Mapping';
 import type { Enumeration } from '../domain/Enumeration';
 import type { EnumValueMapping } from './EnumValueMapping';
 import type { Type } from '../domain/Type';
@@ -34,7 +33,7 @@ import {
 } from './InferableMappingElementId';
 
 export class EnumerationMapping implements Hashable, Stubable {
-  parent: Mapping;
+  readonly parent: Mapping;
   enumeration: PackageableElementReference<Enumeration>;
   id: InferableMappingElementIdValue;
   sourceType: OptionalPackageableElementReference<Type>;
@@ -52,19 +51,6 @@ export class EnumerationMapping implements Hashable, Stubable {
     this.sourceType = sourceType;
   }
 
-  get label(): MappingElementLabel {
-    return {
-      value: `${
-        fromElementPathToMappingElementId(this.enumeration.value.path) ===
-        this.id.value
-          ? this.enumeration.value.name
-          : `${this.enumeration.value.name} [${this.id.value}]`
-      }`,
-      root: false,
-      tooltip: this.enumeration.value.path,
-    };
-  }
-
   static createStub = (
     enumeration: Enumeration,
     mapping: Mapping,

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);
   }
 

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

@@ -18,8 +18,6 @@ import type { Hashable } from '@finos/legend-shared';
 import type { ValidationIssue } from '../../../../../helpers/ValidationHelper';
 
 export abstract class InputData implements Hashable {
-  private readonly _$nominalTypeBrand!: 'InputData';
-
   abstract get validationResult(): ValidationIssue | undefined;
   abstract get hashCode(): string;
 }

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

@@ -91,9 +91,3 @@ export class Mapping extends PackageableElement implements Hashable, Stubable {
     return visitor.visit_Mapping(this);
   }
 }
-
-export interface MappingElementLabel {
-  value: string;
-  root: boolean;
-  tooltip: string;
-}

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

@@ -28,7 +28,12 @@ export class MappingTest implements Hashable {
   readonly uuid = uuid();
 
   name: string;
-  query: 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
+   */
+  query: RawLambda;
   inputData: InputData[] = [];
   assert: MappingTestAssert;
 

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

@@ -18,8 +18,6 @@ import type { Hashable } from '@finos/legend-shared';
 import type { ValidationIssue } from '../../../../../helpers/ValidationHelper';
 
 export abstract class MappingTestAssert implements Hashable {
-  private readonly _$nominalTypeBrand!: 'MappingTestAssert';
-
   abstract get validationResult(): ValidationIssue | undefined;
   abstract get hashCode(): string;
 }

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

@@ -39,6 +39,7 @@ export enum OperationType {
   MERGE = 'MERGE',
 }
 
+// TODO: to be moved out of metamodel
 export const getClassMappingOperationType = (value: string): OperationType =>
   guaranteeNonNullable(
     Object.values(OperationType).find((type) => type === value),