@finos/legend-graph 2.1.3 → 4.0.1

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

@@ -0,0 +1,362 @@
+/**
+ * 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 type { AlloySerializationConfigInstanceValue } from '../../../models/metamodels/pure/valueSpecification/AlloySerializationConfig';
+import {
+  type RootGraphFetchTreeInstanceValue,
+  type PropertyGraphFetchTreeInstanceValue,
+  type GraphFetchTree,
+  PropertyGraphFetchTree,
+  RootGraphFetchTree,
+} from '../../../models/metamodels/pure/valueSpecification/GraphFetchTree';
+import type {
+  PrimitiveInstanceValue,
+  EnumValueInstanceValue,
+  RuntimeInstanceValue,
+  PairInstanceValue,
+  MappingInstanceValue,
+  PureListInstanceValue,
+  CollectionInstanceValue,
+  InstanceValue,
+} from '../../../models/metamodels/pure/valueSpecification/InstanceValue';
+import type { INTERNAL__UnknownValueSpecification } from '../../../models/metamodels/pure/valueSpecification/INTERNAL__UnknownValueSpecification';
+import type { LambdaFunctionInstanceValue } from '../../../models/metamodels/pure/valueSpecification/LambdaFunction';
+import type {
+  FunctionExpression,
+  SimpleFunctionExpression,
+  AbstractPropertyExpression,
+} from '../../../models/metamodels/pure/valueSpecification/SimpleFunctionExpression';
+import type {
+  ValueSpecification,
+  ValueSpecificationVisitor,
+} from '../../../models/metamodels/pure/valueSpecification/ValueSpecification';
+import type { VariableExpression } from '../../../models/metamodels/pure/valueSpecification/VariableExpression';
+import {
+  type ObserverContext,
+  skipObservedWithContext,
+  skipObserved,
+  observe_OptionalPackageableElementReference,
+} from './CoreObserverHelper';
+import {
+  observe_EnumValueReference,
+  observe_GenericTypeReference,
+  observe_PropertyReference,
+} from './DomainObserverHelper';
+
+const observe_Abstract_ValueSpecification = (
+  metamodel: ValueSpecification,
+): void => {
+  makeObservable<ValueSpecification>(metamodel, {
+    multiplicity: observable,
+  });
+};
+
+export const observe_VariableExpression = skipObserved(
+  (metamodel: VariableExpression): VariableExpression => {
+    observe_Abstract_ValueSpecification(metamodel);
+
+    makeObservable<VariableExpression>(metamodel, {
+      name: observable,
+      genericType: observable,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_FunctionExpression = skipObservedWithContext(
+  observe_Abstract_FunctionExpression,
+);
+export const observe_SimpleFunctionExpression = skipObservedWithContext(
+  observe_Abstract_FunctionExpression,
+);
+export const observe_AbstractPropertyExpression = skipObservedWithContext(
+  observe_Abstract_FunctionExpression,
+);
+
+export const observe_PrimitiveInstanceValue = skipObserved(
+  (metamodel: PrimitiveInstanceValue): PrimitiveInstanceValue => {
+    observe_Abstract_ValueSpecification(metamodel);
+
+    makeObservable<PrimitiveInstanceValue>(metamodel, {
+      genericType: observable,
+      values: observable,
+    });
+
+    observe_GenericTypeReference(metamodel.genericType);
+
+    return metamodel;
+  },
+);
+
+export const observe_EnumValueInstanceValue = skipObserved(
+  (metamodel: EnumValueInstanceValue): EnumValueInstanceValue => {
+    observe_Abstract_ValueSpecification(metamodel);
+
+    makeObservable<EnumValueInstanceValue>(metamodel, {
+      genericType: observable,
+      values: observable,
+    });
+
+    metamodel.values.forEach(observe_EnumValueReference);
+
+    return metamodel;
+  },
+);
+
+export const observe_CollectionInstanceValue = skipObservedWithContext(
+  _observe_CollectionInstanceValue,
+);
+
+export const observe_GraphFetchTree = skipObservedWithContext(
+  observe_Abstract_GraphFetchTree,
+);
+export const observe_PropertyGraphFetchTree = skipObservedWithContext(
+  _observe_PropertyGraphFetchTree,
+);
+export const observe_RootGraphFetchTree = skipObservedWithContext(
+  observe_Abstract_GraphFetchTree,
+);
+
+export const observe_PropertyGraphFetchTreeInstanceValue =
+  skipObservedWithContext(
+    (
+      metamodel: PropertyGraphFetchTreeInstanceValue,
+      context: ObserverContext,
+    ): PropertyGraphFetchTreeInstanceValue => {
+      observe_Abstract_ValueSpecification(metamodel);
+
+      metamodel.values.forEach((value) =>
+        observe_PropertyGraphFetchTree(value, context),
+      );
+
+      return metamodel;
+    },
+  );
+
+export const observe_RootGraphFetchTreeInstanceValue = skipObservedWithContext(
+  (
+    metamodel: RootGraphFetchTreeInstanceValue,
+    context: ObserverContext,
+  ): RootGraphFetchTreeInstanceValue => {
+    observe_Abstract_ValueSpecification(metamodel);
+
+    metamodel.values.forEach((value) =>
+      observe_RootGraphFetchTree(value, context),
+    );
+
+    return metamodel;
+  },
+);
+
+class ValueSpecificationObserver implements ValueSpecificationVisitor<void> {
+  observerContext: ObserverContext;
+
+  constructor(observerContext: ObserverContext) {
+    this.observerContext = observerContext;
+  }
+
+  visit_RootGraphFetchTreeInstanceValue(
+    valueSpecification: RootGraphFetchTreeInstanceValue,
+  ): void {
+    observe_RootGraphFetchTreeInstanceValue(
+      valueSpecification,
+      this.observerContext,
+    );
+  }
+
+  visit_PropertyGraphFetchTreeInstanceValue(
+    valueSpecification: PropertyGraphFetchTreeInstanceValue,
+  ): void {
+    observe_PropertyGraphFetchTreeInstanceValue(
+      valueSpecification,
+      this.observerContext,
+    );
+  }
+
+  visit_AlloySerializationConfigInstanceValue(
+    valueSpecification: AlloySerializationConfigInstanceValue,
+  ): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+
+  visit_PrimitiveInstanceValue(
+    valueSpecification: PrimitiveInstanceValue,
+  ): void {
+    observe_PrimitiveInstanceValue(valueSpecification);
+  }
+
+  visit_EnumValueInstanceValue(
+    valueSpecification: EnumValueInstanceValue,
+  ): void {
+    observe_EnumValueInstanceValue(valueSpecification);
+  }
+
+  visit_RuntimeInstanceValue(valueSpecification: RuntimeInstanceValue): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+
+  visit_PairInstanceValue(valueSpecification: PairInstanceValue): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+
+  visit_MappingInstanceValue(valueSpecification: MappingInstanceValue): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+
+  visit_PureListInsanceValue(valueSpecification: PureListInstanceValue): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+
+  visit_CollectionInstanceValue(
+    valueSpecification: CollectionInstanceValue,
+  ): void {
+    observe_CollectionInstanceValue(valueSpecification, this.observerContext);
+  }
+
+  visit_FunctionExpression(valueSpecification: FunctionExpression): void {
+    observe_FunctionExpression(valueSpecification, this.observerContext);
+  }
+
+  visit_SimpleFunctionExpression(
+    valueSpecification: SimpleFunctionExpression,
+  ): void {
+    observe_SimpleFunctionExpression(valueSpecification, this.observerContext);
+  }
+
+  visit_VariableExpression(valueSpecification: VariableExpression): void {
+    observe_VariableExpression(valueSpecification);
+  }
+
+  visit_LambdaFunctionInstanceValue(
+    valueSpecification: LambdaFunctionInstanceValue,
+  ): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+
+  visit_AbstractPropertyExpression(
+    valueSpecification: AbstractPropertyExpression,
+  ): void {
+    observe_AbstractPropertyExpression(
+      valueSpecification,
+      this.observerContext,
+    );
+  }
+
+  visit_InstanceValue(valueSpecification: InstanceValue): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+
+  visit_INTERNAL__UnknownValueSpecification(
+    valueSpecification: INTERNAL__UnknownValueSpecification,
+  ): void {
+    observe_Abstract_ValueSpecification(valueSpecification);
+  }
+}
+
+export const observe_ValueSpecification = skipObservedWithContext(
+  (
+    valueSpecification: ValueSpecification,
+    context: ObserverContext,
+  ): ValueSpecification => {
+    valueSpecification.accept_ValueSpecificationVisitor(
+      new ValueSpecificationObserver(context),
+    );
+
+    return valueSpecification;
+  },
+);
+
+function _observe_CollectionInstanceValue(
+  metamodel: CollectionInstanceValue,
+  context: ObserverContext,
+): CollectionInstanceValue {
+  observe_Abstract_ValueSpecification(metamodel);
+
+  makeObservable<CollectionInstanceValue>(metamodel, {
+    genericType: observable,
+    values: observable,
+  });
+
+  metamodel.values.forEach((value) =>
+    observe_ValueSpecification(value, context),
+  );
+
+  return metamodel;
+}
+
+function observe_Abstract_FunctionExpression(
+  metamodel: FunctionExpression,
+  context: ObserverContext,
+): FunctionExpression {
+  observe_Abstract_ValueSpecification(metamodel);
+
+  makeObservable(metamodel, {
+    functionName: observable,
+    parametersValues: observable,
+    classifierGenericType: observable,
+  });
+
+  metamodel.parametersValues.forEach((value) =>
+    observe_ValueSpecification(value, context),
+  );
+
+  return metamodel;
+}
+
+function observe_Abstract_GraphFetchTree(
+  metamodel: GraphFetchTree,
+  context: ObserverContext,
+): GraphFetchTree {
+  makeObservable(metamodel, {
+    subTrees: observable,
+    isEmpty: computed,
+  });
+
+  metamodel.subTrees.forEach((subTree) => {
+    if (subTree instanceof PropertyGraphFetchTree) {
+      observe_PropertyGraphFetchTree(subTree, context);
+    } else if (subTree instanceof RootGraphFetchTree) {
+      observe_RootGraphFetchTree(subTree, context);
+    } else {
+      observe_GraphFetchTree(subTree, context);
+    }
+  });
+
+  return metamodel;
+}
+
+function _observe_PropertyGraphFetchTree(
+  metamodel: PropertyGraphFetchTree,
+  context: ObserverContext,
+): PropertyGraphFetchTree {
+  observe_Abstract_GraphFetchTree(metamodel, context);
+
+  makeObservable(metamodel, {
+    alias: observable,
+    parameters: observable,
+    subType: observable,
+  });
+
+  observe_PropertyReference(metamodel.property);
+  metamodel.parameters.forEach((value) =>
+    observe_ValueSpecification(value, context),
+  );
+  observe_OptionalPackageableElementReference(metamodel.subType);
+
+  return metamodel;
+}

package/src/graphManager/action/generation/DatabaseBuilderInput.ts

@@ -68,6 +68,7 @@ export class DatabaseBuilderConfig {
 export class TargetDatabase {
   name: string;
   package: string;
+
   constructor(_package: string, name: string) {
     makeObservable(this, {
       name: observable,

package/src/helpers/DomainHelper.ts

@@ -17,6 +17,43 @@
 import type { PureModel } from '../graph/PureModel';
 import { Class } from '../models/metamodels/pure/packageableElements/domain/Class';
 import { CORE_PURE_PATH, MILESTONING_STEROTYPES } 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';
+import { Stereotype } from '../models/metamodels/pure/packageableElements/domain/Stereotype';
+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 type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement';
+
+export const _package_addElement = (
+  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
+  parent.children.push(element);
+  element.package = parent;
+};
+
+export const _package_deleteElement = (
+  parent: Package,
+  packageableElement: PackageableElement,
+): void => {
+  parent.children = parent.children.filter(
+    (child) => child !== packageableElement,
+  );
+};
+
+export const createStubTag = (profile: Profile): Tag => new Tag(profile, '');
+export const createStubTaggedValue = (tag: Tag): TaggedValue =>
+  new TaggedValue(TagExplicitReference.create(tag), '');
+export const createStubStereotype = (profile: Profile): Stereotype =>
+  new Stereotype(profile, '');
+export const createStubProfile = (): Profile => new Profile('');
+export const createStubEnum = (enumeration: Enumeration): Enum =>
+  new Enum('', enumeration);
 
 export const getMilestoneTemporalStereotype = (
   val: Class,

package/src/helpers/MappingHelper.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { guaranteeNonNullable, uniq } from '@finos/legend-shared';
+import { 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';
@@ -138,3 +138,28 @@ export const getAllSuperSetImplementations = (
     return [];
   }
 };
+
+export const findRootSetImplementation = (
+  classMappingsWithSimilarTarget: SetImplementation[],
+): SetImplementation | undefined => {
+  // NOTE: we use find last so that we can be sure we're picking the root set implementation of the current mapping first,
+  // not the root set implementation of one of the included mappings, in case there's no root, we would prefer the root
+  // of one of the included mappings (whichever comes later),
+  // if there is not root set, and only one set implementation is found, we assume that is the root
+  if (
+    classMappingsWithSimilarTarget.length === 1 &&
+    classMappingsWithSimilarTarget[0]?.root.value === false
+  ) {
+    return classMappingsWithSimilarTarget[0];
+  }
+  return findLast(
+    classMappingsWithSimilarTarget,
+    (setImp: SetImplementation) => setImp.root.value,
+  );
+};
+
+export const getRootSetImplementation = (
+  mapping: Mapping,
+  _class: Class,
+): SetImplementation | undefined =>
+  findRootSetImplementation(getClassMappingsByClass(mapping, _class));

package/src/helpers/Stubable.ts

@@ -22,9 +22,6 @@
  * and omit them from let's say transformer or hash computation
  */
 export interface Stubable {
-  // NOTE: since we cannot have static member for an interface, we leave this comment to remind user of
-  // this interface to implement a static `createStub()` method
-  // static createStub: (...args: any) => T;
   isStub: boolean;
 }
 

package/src/helpers/ValueSpecificationHelper.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { RawLambda } from '../models/metamodels/pure/rawValueSpecification/RawLambda';
+
+export const createStubRawLambda = (): RawLambda =>
+  new RawLambda(undefined, undefined);

package/src/index.ts

@@ -82,7 +82,7 @@ export { Schema as ExternalFormatSchema } from './models/metamodels/pure/package
 export { ExternalFormatConnection } from './models/metamodels/pure/packageableElements/externalFormat/connection/DSLExternalFormat_ExternalFormatConnection';
 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/BindingTransformer';
+export { BindingTransformer } from './models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_BindingTransformer';
 // 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';
@@ -161,12 +161,10 @@ export * from './MetaModelConst';
 export * from './helpers/ServiceHelper';
 export * from './helpers/DatabaseHelper';
 export * from './helpers/MappingHelper';
-export * from './helpers/MappingResolutionHelper';
 export * from './helpers/ValidationHelper';
 export * from './helpers/Stubable'; // TODO: to be removed
 export * from './helpers/DomainHelper';
 export * from './helpers/PureLanguageHelper';
-export * from './models/GraphModifierHelper';
 
 // --------------------------------------------- GRAPH --------------------------------------------------
 
@@ -223,7 +221,8 @@ export { SourceInformation } from './graphManager/action/SourceInformation';
 export { getGraphManager } from './models/protocols/pure/Pure';
 export * from './models/protocols/pure/PureProtocolProcessorPlugin';
 
-// V1 transformation
+// --------------------------------------------- TRANSFORMATION --------------------------------------------------
+
 export {
   V1_transformStereotype,
   V1_transformTaggedValue,
@@ -268,6 +267,21 @@ export * from './models/protocols/pure/v1/transformation/pureGraph/to/V1_DSLExte
 export * from './models/ModelGenerationConfiguration';
 export * from './models/protocols/pure/MappingGeneration_PureProtocolProcessorPlugin_Extension';
 
+// --------------------------------------------- OBSERVER --------------------------------------------------
+
+export * from './graphManager/action/changeDetection/PackageableElementObserver';
+export * from './graphManager/action/changeDetection/CoreObserverHelper';
+export * from './graphManager/action/changeDetection/DomainObserverHelper';
+export * from './graphManager/action/changeDetection/DSLMapping_ObserverHelper';
+export * from './graphManager/action/changeDetection/RawValueSpecificationObserver';
+export * from './graphManager/action/changeDetection/ValueSpecificationObserver';
+export * from './graphManager/action/changeDetection/StoreRelational_ObserverHelper';
+export * from './graphManager/action/changeDetection/StoreFlatData_ObserverHelper';
+export * from './graphManager/action/changeDetection/GraphObserverHelper';
+export * from './graphManager/action/changeDetection/DSLExternalFormat_ObserverHelper';
+export * from './graphManager/action/changeDetection/DSLService_ObserverHelper';
+export * from './graphManager/action/changeDetection/DSLGenerationSpecification_ObserverHelper';
+
 // --------------------------------------------- TO BE MODULARIZED --------------------------------------------------
 
 export * from './DSLMapping_Exports';

package/src/models/metamodels/pure/InferableValue.ts

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, action, makeObservable } from 'mobx';
-
 /**
  * Sometimes people can give us corrupted protocol or ones with missing information, it is then the job
  * of the graph builder (in Studio) or the compiler (in the execution server) to do inference
@@ -45,17 +43,8 @@ export abstract class InferableValue<T, V> {
   value: T;
 
   constructor(value: T) {
-    makeObservable(this, {
-      value: observable,
-      setValue: action,
-    });
-
     this.value = value;
   }
 
-  setValue(val: T): void {
-    this.value = val;
-  }
-
   abstract get valueForSerialization(): V;
 }