@finos/legend-graph 5.0.0 → 7.0.0

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

@@ -14,16 +14,11 @@
  * limitations under the License.
  */
 
-import {
-  UnsupportedOperationError,
-  hashArray,
-  type Hashable,
-} from '@finos/legend-shared';
+import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import type { PropertyReference } from '../domain/PropertyReference';
 import type { PropertyMappingsImplementation } from './PropertyMappingsImplementation';
 import type { SetImplementation } from './SetImplementation';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { PurePropertyMapping } from '../store/modelToModel/mapping/PurePropertyMapping';
 import type { FlatDataPropertyMapping } from '../store/flatData/mapping/FlatDataPropertyMapping';
 import type { EmbeddedFlatDataPropertyMapping } from '../store/flatData/mapping/EmbeddedFlatDataPropertyMapping';
@@ -60,17 +55,29 @@ export interface PropertyMappingVisitor<T> {
   visit_XStorePropertyMapping(propertyMapping: XStorePropertyMapping): T;
 }
 
-export abstract class PropertyMapping implements Hashable, Stubable {
-  readonly isEmbedded: boolean = false;
+export abstract class PropertyMapping implements Hashable {
+  /**
+   * the immediate parent instance set implementation that holds the property mappings
+   */
+  readonly _OWNER: PropertyMappingsImplementation;
+  readonly _isEmbedded: boolean = false;
+
   property: PropertyReference;
-  owner: PropertyMappingsImplementation; // the immediate parent instance set implementation that holds the property mappings
-  // NOTE: in case the holder of this property mapping is an embedded property mapping, that embedded property mapping is considered the source
-  // otherwise, it is always the top/root `InstanceSetImplementation` that is considered the source implementation
-  // TODO: change this to use `SetImplemenetationReference`
+  /**
+   * NOTE: in case the holder of this property mapping is an embedded property mapping,
+   * that embedded property mapping is considered the source otherwise, it is always
+   * the top/root `InstanceSetImplementation` that is considered the source implementation
+   *
+   * TODO: change this to use `SetImplemenetationReference`
+   */
   sourceSetImplementation: SetImplementation;
-  // NOTE: in Pure, we actually only store `targetId` and `sourceId` instead of the reference
-  // but for convenience and graph completeness validation purpose we will resolve to the actual set implementations here
-  // TODO: change this to use `OptionalSetImplemenetationReference`
+  /**
+   * NOTE: in Pure, we actually only store `targetId` and `sourceId` instead of the
+   * reference but for convenience and graph completeness validation purpose we will
+   * resolve to the actual set implementations here
+   *
+   * TODO: change this to use `OptionalSetImplemenetationReference`
+   */
   targetSetImplementation?: SetImplementation | undefined;
   localMappingProperty?: LocalMappingPropertyInfo | undefined;
   // store?: Store | undefined;
@@ -81,16 +88,12 @@ export abstract class PropertyMapping implements Hashable, Stubable {
     source: SetImplementation,
     target?: SetImplementation,
   ) {
-    this.owner = owner;
+    this._OWNER = owner;
     this.sourceSetImplementation = source;
     this.targetSetImplementation = target;
     this.property = property;
   }
 
-  get isStub(): boolean {
-    throw new UnsupportedOperationError();
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PROPERTY_MAPPING,

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

@@ -21,5 +21,5 @@ export interface PropertyOwnerImplementation {
   id: InferableMappingElementIdValue;
   // TODO: consider changing this to object ref instead of ID
   // superSetImplementationId?: string | undefined;
-  parent: Mapping;
+  _PARENT: Mapping;
 }

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

@@ -19,7 +19,6 @@ import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import type { PackageableElementReference } from '../PackageableElementReference';
 import type { PropertyOwnerImplementation } from './PropertyOwnerImplementation';
 import type { Mapping } from './Mapping';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { OperationSetImplementation } from './OperationSetImplementation';
 import type { PureInstanceSetImplementation } from '../store/modelToModel/mapping/PureInstanceSetImplementation';
 import type { FlatDataInstanceSetImplementation } from '../store/flatData/mapping/FlatDataInstanceSetImplementation';
@@ -67,10 +66,11 @@ export interface SetImplementationVisitor<T> {
 }
 
 export abstract class SetImplementation
-  implements PropertyOwnerImplementation, Hashable, Stubable
+  implements PropertyOwnerImplementation, Hashable
 {
-  readonly parent: Mapping;
-  readonly isEmbedded: boolean = false;
+  readonly _PARENT: Mapping;
+  readonly _isEmbedded: boolean = false;
+
   id: InferableMappingElementIdValue;
   class: PackageableElementReference<Class>;
   root: InferableMappingElementRoot;
@@ -82,15 +82,11 @@ export abstract class SetImplementation
     root: InferableMappingElementRoot,
   ) {
     this.id = id;
-    this.parent = parent;
+    this._PARENT = parent;
     this.class = _class;
     this.root = root;
   }
 
-  get isStub(): boolean {
-    return !this.id.value;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.SET_IMPLEMENTATION,
@@ -104,21 +100,3 @@ export abstract class SetImplementation
     visitor: SetImplementationVisitor<T>,
   ): T;
 }
-
-// TODO: to be moved out of metamodel
-export enum BASIC_SET_IMPLEMENTATION_TYPE {
-  OPERATION = 'operation',
-  INSTANCE = 'instance',
-}
-
-// TODO: to be moved out of metamodel
-export enum SET_IMPLEMENTATION_TYPE {
-  OPERATION = 'operation',
-  MERGE_OPERATION = 'mergeOperation',
-  PUREINSTANCE = 'pureInstance',
-  FLAT_DATA = 'flatData',
-  EMBEDDED_FLAT_DATA = 'embeddedFlatData',
-  RELATIONAL = 'relational',
-  EMBEDDED_RELATIONAL = 'embeddedRelational',
-  AGGREGATION_AWARE = 'aggregationAware',
-}

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

@@ -16,18 +16,13 @@
 
 import { uuid } from '@finos/legend-shared';
 import type { SetImplementationReference } from './SetImplementationReference';
-import type { Stubable } from '../../../../../helpers/Stubable';
 
-export class SetImplementationContainer implements Stubable {
-  readonly uuid = uuid();
+export class SetImplementationContainer {
+  readonly _UUID = uuid();
 
   setImplementation: SetImplementationReference;
 
   constructor(setImplementation: SetImplementationReference) {
     this.setImplementation = setImplementation;
   }
-
-  get isStub(): boolean {
-    return !this.setImplementation.value.id;
-  }
 }

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

@@ -15,13 +15,19 @@
  */
 
 import {
-  PackageableElementExplicitReference,
-  type PackageableElementReference,
   type PackageableElementImplicitReference,
+  type OptionalPackageableElementImplicitReference,
+  type PackageableElementReference,
+  type OptionalPackageableElementReference,
+  PackageableElementExplicitReference,
+  OptionalPackageableElementExplicitReference,
 } from '../PackageableElementReference';
 import type { Mapping } from './Mapping';
 import type { SetImplementation } from './SetImplementation';
-import { ReferenceWithOwner } from '../../Reference';
+import {
+  OptionalReferenceWithOwner,
+  ReferenceWithOwner,
+} from '../../Reference';
 
 export abstract class SetImplementationReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<Mapping>;
@@ -42,7 +48,7 @@ export class SetImplementationExplicitReference extends SetImplementationReferen
 
   private constructor(value: SetImplementation) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.parent,
+      value._PARENT,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;
@@ -71,3 +77,57 @@ export class SetImplementationImplicitReference extends SetImplementationReferen
     return new SetImplementationImplicitReference(ownerReference, value);
   }
 }
+
+export abstract class OptionalSetImplementationReference extends OptionalReferenceWithOwner {
+  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
+  value?: SetImplementation | undefined;
+
+  protected constructor(
+    ownerReference: OptionalPackageableElementReference<Mapping>,
+    value: SetImplementation | undefined,
+  ) {
+    super(ownerReference);
+    this.ownerReference = ownerReference;
+    this.value = value;
+  }
+}
+
+export class OptionalSetImplementationExplicitReference extends OptionalSetImplementationReference {
+  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
+
+  private constructor(value: SetImplementation | undefined) {
+    const ownerReference = OptionalPackageableElementExplicitReference.create(
+      value?._PARENT,
+    );
+    super(ownerReference, value);
+    this.ownerReference = ownerReference;
+  }
+
+  static create(
+    value: SetImplementation,
+  ): OptionalSetImplementationExplicitReference {
+    return new OptionalSetImplementationExplicitReference(value);
+  }
+}
+
+export class OptionalSetImplementationImplicitReference extends OptionalSetImplementationReference {
+  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
+
+  private constructor(
+    ownerReference: OptionalPackageableElementImplicitReference<Mapping>,
+    value: SetImplementation | undefined,
+  ) {
+    super(ownerReference, value);
+    this.ownerReference = ownerReference;
+  }
+
+  static create(
+    ownerReference: PackageableElementImplicitReference<Mapping>,
+    value: SetImplementation,
+  ): OptionalSetImplementationImplicitReference {
+    return new OptionalSetImplementationImplicitReference(
+      ownerReference,
+      value,
+    );
+  }
+}

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

@@ -19,7 +19,8 @@ import type { PackageableElementReference } from '../PackageableElementReference
 import type { MappingInclude } from './MappingInclude';
 
 export class SubstituteStore {
-  owner: MappingInclude;
+  readonly _OWNER: MappingInclude;
+
   original: PackageableElementReference<Store>;
   substitute: PackageableElementReference<Store>;
 
@@ -28,7 +29,7 @@ export class SubstituteStore {
     original: PackageableElementReference<Store>,
     substitue: PackageableElementReference<Store>,
   ) {
-    this.owner = owner;
+    this._OWNER = owner;
     this.original = original;
     this.substitute = substitue;
   }

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

@@ -24,7 +24,6 @@ import {
   type SetImplementationVisitor,
 } from './SetImplementation';
 
-/* @MARKER: RELAXED GRAPH CHECK - See https://github.com/finos/legend-studio/issues/941 */
 /**
  * When set implementation cannot be resolved by ID,
  * we try to avoid failing graph building for now
@@ -34,6 +33,8 @@ import {
  *
  * See https://github.com/finos/legend-studio/issues/880
  * See https://github.com/finos/legend-studio/issues/941
+ *
+ * @discrepancy graph-building
  */
 export class TEMPORARY__UnresolvedSetImplementation extends SetImplementation {
   constructor(id: string, parent: Mapping) {

package/src/models/metamodels/pure/packageableElements/mapping/aggregationAware/AggregationAwarePropertyMapping.ts

@@ -23,9 +23,4 @@ export class AggregationAwarePropertyMapping extends PropertyMapping {
   accept_PropertyMappingVisitor<T>(visitor: PropertyMappingVisitor<T>): T {
     return visitor.visit_AggregationAwarePropertyMapping(this);
   }
-
-  override get isStub(): boolean {
-    // TODO figure out isStub conditions
-    return false;
-  }
 }

package/src/models/metamodels/pure/packageableElements/mapping/aggregationAware/AggregationAwareSetImplementation.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import type { PropertyMapping } from '../PropertyMapping';
 import { InstanceSetImplementation } from '../InstanceSetImplementation';
 import type { SetImplementationVisitor } from '../SetImplementation';
 import type { InferableMappingElementIdValue } from '../InferableMappingElementId';
@@ -41,30 +40,6 @@ export class AggregationAwareSetImplementation extends InstanceSetImplementation
     this.mainSetImplementation = mainSetImplementation;
   }
 
-  getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
-    return [];
-  }
-  findPropertyMapping(
-    propertyName: string,
-    targetId: string | undefined,
-  ): PropertyMapping | undefined {
-    let properties = undefined;
-    properties = this.propertyMappings.filter(
-      (propertyMapping) => propertyMapping.property.value.name === propertyName,
-    );
-    if (targetId === undefined || properties.length === 1) {
-      return properties[0];
-    }
-    return properties.find(
-      (propertyMapping) =>
-        propertyMapping.targetSetImplementation &&
-        propertyMapping.targetSetImplementation.id.value === targetId,
-    );
-  }
-  accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
-    return visitor.visit_AggregationAwareSetImplementation(this);
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.AGGREGATION_AWARE_MAPPING,
@@ -74,4 +49,8 @@ export class AggregationAwareSetImplementation extends InstanceSetImplementation
       hashArray(this.propertyMappings),
     ]);
   }
+
+  accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
+    return visitor.visit_AggregationAwareSetImplementation(this);
+  }
 }

package/src/models/metamodels/pure/packageableElements/mapping/aggregationAware/AggregationFunctionSpecification.ts

@@ -20,8 +20,18 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../MetaModelConst';
 import { hashLambda } from '../../../../../../MetaModelUtils';
 
 export class AggregationFunctionSpecification implements Hashable {
-  mapFn: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
-  aggregateFn: 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
+   */
+  mapFn: RawLambda;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  aggregateFn: RawLambda;
 
   constructor(mapFn: RawLambda, aggregateFn: RawLambda) {
     this.mapFn = mapFn;

package/src/models/metamodels/pure/packageableElements/mapping/aggregationAware/GroupByFunctionSpecification.ts

@@ -20,7 +20,12 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../MetaModelConst';
 import { hashLambda } from '../../../../../../MetaModelUtils';
 
 export class GroupByFunctionSpecification implements Hashable {
-  groupByFn: 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
+   */
+  groupByFn: RawLambda;
 
   constructor(groupByFn: RawLambda) {
     this.groupByFn = groupByFn;

package/src/models/metamodels/pure/packageableElements/mapping/xStore/XStorePropertyMapping.ts

@@ -17,17 +17,18 @@
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../MetaModelConst';
 import type { RawLambda } from '../../../rawValueSpecification/RawLambda';
-import type { Stubable } from '../../../../../../helpers/Stubable';
 import {
   type PropertyMappingVisitor,
   PropertyMapping,
 } from '../PropertyMapping';
 
-export class XStorePropertyMapping
-  extends PropertyMapping
-  implements Hashable, Stubable
-{
-  crossExpression!: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+export class XStorePropertyMapping extends PropertyMapping implements Hashable {
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  crossExpression!: RawLambda;
 
   override get hashCode(): string {
     return hashArray([
@@ -37,11 +38,6 @@ export class XStorePropertyMapping
     ]);
   }
 
-  override get isStub(): boolean {
-    // TODO figure out isStub conditions
-    return false;
-  }
-
   accept_PropertyMappingVisitor<T>(visitor: PropertyMappingVisitor<T>): T {
     return visitor.visit_XStorePropertyMapping(this);
   }

package/src/models/metamodels/pure/packageableElements/runtime/Runtime.ts

@@ -14,26 +14,20 @@
  * limitations under the License.
  */
 
+import { type Hashable, hashArray, uuid } from '@finos/legend-shared';
 import {
-  type Hashable,
-  hashArray,
-  generateEnumerableNameFromToken,
-  assertTrue,
-  uuid,
-} from '@finos/legend-shared';
-import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+  CORE_HASH_STRUCTURE,
+  PackageableElementPointerType,
+} from '../../../../../MetaModelConst';
 import type { Connection } from '../connection/Connection';
 import type { PackageableRuntime } from './PackageableRuntime';
 import type { Mapping } from '../mapping/Mapping';
 import type { Store } from '../store/Store';
-import {
-  getElementPointerHashCode,
-  PACKAGEABLE_ELEMENT_POINTER_TYPE,
-} from '../PackageableElement';
 import type { PackageableElementReference } from '../PackageableElementReference';
+import { hashElementPointer } from '../../../../../MetaModelUtils';
 
 export class IdentifiedConnection implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
   id: string;
   connection: Connection;
@@ -60,15 +54,11 @@ export class StoreConnections implements Hashable {
     this.store = store;
   }
 
-  get isStub(): boolean {
-    return !this.storeConnections.length;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.STORE_CONNECTIONS,
-      getElementPointerHashCode(
-        PACKAGEABLE_ELEMENT_POINTER_TYPE.STORE,
+      hashElementPointer(
+        PackageableElementPointerType.STORE,
         this.store.hashValue,
       ),
       hashArray(this.storeConnections),
@@ -84,40 +74,23 @@ export class EngineRuntime extends Runtime implements Hashable {
   mappings: PackageableElementReference<Mapping>[] = [];
   connections: StoreConnections[] = [];
 
-  get allIdentifiedConnections(): IdentifiedConnection[] {
-    return this.connections.flatMap(
-      (storeConnections) => storeConnections.storeConnections,
-    );
-  }
-
-  generateIdentifiedConnectionId(): string {
-    const generatedId = generateEnumerableNameFromToken(
-      this.allIdentifiedConnections.map(
-        (identifiedConnection) => identifiedConnection.id,
-      ),
-      'connection',
-    );
-    assertTrue(
-      !this.allIdentifiedConnections.find(
-        (identifiedConnection) => identifiedConnection.id === generatedId,
-      ),
-      `Can't auto-generate connection ID with value '${generatedId}'`,
-    );
-    return generatedId;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.ENGINE_RUNTIME,
       hashArray(
         this.mappings.map((mapping) =>
-          getElementPointerHashCode(
-            PACKAGEABLE_ELEMENT_POINTER_TYPE.MAPPING,
+          hashElementPointer(
+            PackageableElementPointerType.MAPPING,
             mapping.hashValue,
           ),
         ),
       ),
-      hashArray(this.connections.filter((connection) => !connection.isStub)),
+      hashArray(
+        this.connections.filter(
+          // TODO: use `isStubbed_StoreConnections` when we refactor hashing
+          (connection) => connection.storeConnections.length,
+        ),
+      ),
     ]);
   }
 }

package/src/models/metamodels/pure/packageableElements/section/Section.ts

@@ -22,13 +22,14 @@ import type { SectionIndex } from './SectionIndex';
 import type { PackageableElementExplicitReference } from '../PackageableElementReference';
 
 export abstract class Section implements Hashable {
-  readonly parent: SectionIndex;
+  readonly _OWNER: SectionIndex;
+
   parserName: string;
   elements: PackageableElementExplicitReference<PackageableElement>[] = [];
 
-  constructor(parserName: string, parent: SectionIndex) {
+  constructor(parserName: string, owner: SectionIndex) {
     this.parserName = parserName;
-    this.parent = parent;
+    this._OWNER = owner;
   }
 
   get hashCode(): string {

package/src/models/metamodels/pure/packageableElements/service/ConnectionTestData.ts

@@ -0,0 +1,32 @@
+/**
+ * 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';
+
+export class ConnectionTestData implements Hashable {
+  connectionId!: string;
+  testData!: EmbeddedData;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SERVICE_CONNECTION_TEST_DATA,
+      this.connectionId,
+      this.testData,
+    ]);
+  }
+}