@finos/legend-graph 2.1.3 → 4.0.1

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

@@ -0,0 +1,165 @@
+/**
+ * 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 type {
+  PackageableElement,
+  PackageableElementVisitor,
+} from '../../../models/metamodels/pure/packageableElements/PackageableElement';
+import type { Profile } from '../../../models/metamodels/pure/packageableElements/domain/Profile';
+import type { Enumeration } from '../../../models/metamodels/pure/packageableElements/domain/Enumeration';
+import type { Measure } from '../../../models/metamodels/pure/packageableElements/domain/Measure';
+import type { Class } from '../../../models/metamodels/pure/packageableElements/domain/Class';
+import type { Association } from '../../../models/metamodels/pure/packageableElements/domain/Association';
+import type { ConcreteFunctionDefinition } from '../../../models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition';
+import type { FlatData } from '../../../models/metamodels/pure/packageableElements/store/flatData/model/FlatData';
+import type { Database } from '../../../models/metamodels/pure/packageableElements/store/relational/model/Database';
+import type { Mapping } from '../../../models/metamodels/pure/packageableElements/mapping/Mapping';
+import type { Service } from '../../../models/metamodels/pure/packageableElements/service/Service';
+import type { PackageableRuntime } from '../../../models/metamodels/pure/packageableElements/runtime/PackageableRuntime';
+import type { PackageableConnection } from '../../../models/metamodels/pure/packageableElements/connection/PackageableConnection';
+import type { FileGenerationSpecification } from '../../../models/metamodels/pure/packageableElements/fileGeneration/FileGenerationSpecification';
+import type { GenerationSpecification } from '../../../models/metamodels/pure/packageableElements/generationSpecification/GenerationSpecification';
+import type { Package } from '../../../models/metamodels/pure/packageableElements/domain/Package';
+import type { PrimitiveType } from '../../../models/metamodels/pure/packageableElements/domain/PrimitiveType';
+import type { SectionIndex } from '../../../models/metamodels/pure/packageableElements/section/SectionIndex';
+import {
+  observe_Association,
+  observe_Class,
+  observe_ConcreteFunctionDefinition,
+  observe_Enumeration,
+  observe_Measure,
+  observe_Package,
+  observe_Profile,
+  observe_SectionIndex,
+} from './DomainObserverHelper';
+import {
+  type ObserverContext,
+  skipObservedWithContext,
+} from './CoreObserverHelper';
+import {
+  observe_FileGenerationSpecification,
+  observe_GenerationSpecification,
+} from './DSLGenerationSpecification_ObserverHelper';
+import {
+  observe_Mapping,
+  observe_PackageableConnection,
+  observe_PackageableRuntime,
+} from './DSLMapping_ObserverHelper';
+import { observe_Service } from './DSLService_ObserverHelper';
+import { observe_FlatData } from './StoreFlatData_ObserverHelper';
+import { observe_Database } from './StoreRelational_ObserverHelper';
+
+class PackageableElementObserver implements PackageableElementVisitor<void> {
+  observerContext: ObserverContext;
+
+  constructor(observerContext: ObserverContext) {
+    this.observerContext = observerContext;
+  }
+
+  visit_PackageableElement(element: PackageableElement): void {
+    const extraElementObservers = this.observerContext.plugins.flatMap(
+      (plugin) => plugin.getExtraElementObservers?.() ?? [],
+    );
+    for (const observer of extraElementObservers) {
+      const observedElement = observer(element, this.observerContext);
+      if (observedElement) {
+        return;
+      }
+    }
+  }
+
+  visit_Package(element: Package): void {
+    observe_Package(element, this.observerContext);
+  }
+
+  visit_SectionIndex(element: SectionIndex): void {
+    observe_SectionIndex(element);
+  }
+
+  visit_PrimitiveType(element: PrimitiveType): void {
+    return;
+  }
+
+  visit_Profile(element: Profile): void {
+    observe_Profile(element);
+  }
+
+  visit_Enumeration(element: Enumeration): void {
+    observe_Enumeration(element);
+  }
+
+  visit_Measure(element: Measure): void {
+    observe_Measure(element);
+  }
+
+  visit_Class(element: Class): void {
+    observe_Class(element);
+  }
+
+  visit_Association(element: Association): void {
+    observe_Association(element);
+  }
+
+  visit_ConcreteFunctionDefinition(element: ConcreteFunctionDefinition): void {
+    observe_ConcreteFunctionDefinition(element);
+  }
+
+  visit_FlatData(element: FlatData): void {
+    observe_FlatData(element);
+  }
+
+  visit_Database(element: Database): void {
+    observe_Database(element, this.observerContext);
+  }
+
+  visit_Mapping(element: Mapping): void {
+    observe_Mapping(element, this.observerContext);
+  }
+
+  visit_Service(element: Service): void {
+    observe_Service(element, this.observerContext);
+  }
+
+  visit_PackageableRuntime(element: PackageableRuntime): void {
+    observe_PackageableRuntime(element, this.observerContext);
+  }
+
+  visit_PackageableConnection(element: PackageableConnection): void {
+    observe_PackageableConnection(element, this.observerContext);
+  }
+
+  visit_FileGenerationSpecification(
+    element: FileGenerationSpecification,
+  ): void {
+    observe_FileGenerationSpecification(element);
+  }
+
+  visit_GenerationSpecification(element: GenerationSpecification): void {
+    observe_GenerationSpecification(element);
+  }
+}
+
+export const observe_PackageabElement = skipObservedWithContext(
+  (
+    packageableElement: PackageableElement,
+    context: ObserverContext,
+  ): PackageableElement => {
+    packageableElement.accept_PackageableElementVisitor(
+      new PackageableElementObserver(context),
+    );
+    return packageableElement;
+  },
+);

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

@@ -0,0 +1,108 @@
+/**
+ * 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 { RawInstanceValue } from '../../../models/metamodels/pure/rawValueSpecification/RawInstanceValue';
+import type { RawLambda } from '../../../models/metamodels/pure/rawValueSpecification/RawLambda';
+import type {
+  RawValueSpecification,
+  RawValueSpecificationVisitor,
+} from '../../../models/metamodels/pure/rawValueSpecification/RawValueSpecification';
+import type { RawVariableExpression } from '../../../models/metamodels/pure/rawValueSpecification/RawVariableExpression';
+import {
+  observe_PackageableElementReference,
+  observe_Multiplicity,
+  skipObserved,
+  skipObservedWithContext,
+  type ObserverContext,
+} from './CoreObserverHelper';
+
+export const observe_RawInstanceValue = skipObserved(
+  (metamodel: RawInstanceValue): RawInstanceValue => {
+    makeObservable(metamodel, {
+      multiplicity: observable,
+      // TODO: check if we need this
+      // values: observable.ref,
+      hashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.type);
+    observe_Multiplicity(metamodel.multiplicity);
+
+    return metamodel;
+  },
+);
+
+export const observe_RawLambda = skipObserved(
+  (metamodel: RawLambda): RawLambda =>
+    makeObservable(metamodel, {
+      body: observable.ref, // only observe the reference, the object itself is not observed
+      parameters: observable.ref, // only observe the reference, the object itself is not observed
+      isStub: computed,
+      hashCode: computed,
+    }),
+);
+
+export const observe_RawVariableExpression = skipObserved(
+  (metamodel: RawVariableExpression): RawVariableExpression => {
+    makeObservable(metamodel, {
+      name: observable,
+      multiplicity: observable,
+      isStub: computed,
+      hashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.type);
+    observe_Multiplicity(metamodel.multiplicity);
+
+    return metamodel;
+  },
+);
+
+class RawValueSpecificationObserver
+  implements RawValueSpecificationVisitor<void>
+{
+  observerContext: ObserverContext;
+
+  constructor(observerContext: ObserverContext) {
+    this.observerContext = observerContext;
+  }
+
+  visit_RawLambda(valueSpecification: RawLambda): void {
+    observe_RawLambda(valueSpecification);
+  }
+
+  visit_RawVariableExpression(valueSpecification: RawVariableExpression): void {
+    observe_RawVariableExpression(valueSpecification);
+  }
+
+  visit_RawInstanceValue(valueSpecification: RawInstanceValue): void {
+    observe_RawInstanceValue(valueSpecification);
+  }
+}
+
+export const observe_RawValueSpecification = skipObservedWithContext(
+  (
+    rawValueSpecification: RawValueSpecification,
+    context: ObserverContext,
+  ): RawValueSpecification => {
+    rawValueSpecification.accept_RawValueSpecificationVisitor(
+      new RawValueSpecificationObserver(context),
+    );
+
+    return rawValueSpecification;
+  },
+);

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

@@ -0,0 +1,278 @@
+/**
+ * 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, override } from 'mobx';
+import type { FlatDataConnection } from '../../../models/metamodels/pure/packageableElements/store/flatData/connection/FlatDataConnection';
+import type { FlatDataInstanceSetImplementation } from '../../../models/metamodels/pure/packageableElements/store/flatData/mapping/FlatDataInstanceSetImplementation';
+import type { FlatData } from '../../../models/metamodels/pure/packageableElements/store/flatData/model/FlatData';
+import {
+  type FlatDataRecordField,
+  type FlatDataDataType,
+  FlatDataBoolean,
+  FlatDataRecordType,
+  FlatDataDate,
+  FlatDataNumber,
+  FlatDataString,
+} from '../../../models/metamodels/pure/packageableElements/store/flatData/model/FlatDataDataType';
+import type { FlatDataProperty } from '../../../models/metamodels/pure/packageableElements/store/flatData/model/FlatDataProperty';
+import type { FlatDataSection } from '../../../models/metamodels/pure/packageableElements/store/flatData/model/FlatDataSection';
+import type { RootFlatDataRecordTypeReference } from '../../../models/metamodels/pure/packageableElements/store/flatData/model/RootFlatDataRecordTypeReference';
+import type {
+  EmbeddedFlatDataPropertyMapping,
+  FlatDataInputData,
+  FlatDataPropertyMapping,
+  FlatDataSectionReference,
+} from '../../../StoreFlatData_Exports';
+import {
+  observe_Abstract_PackageableElement,
+  observe_PackageableElementReference,
+  skipObserved,
+  skipObservedWithContext,
+} from './CoreObserverHelper';
+import {
+  observe_Abstract_InstanceSetImplementation,
+  observe_Abstract_PropertyMapping,
+} from './DSLMapping_ObserverHelper';
+import { observe_RawLambda } from './RawValueSpecificationObserver';
+
+// ------------------------------------- Store -------------------------------------
+
+export const observe_FlatDataDataType = (
+  metamodel: FlatDataDataType,
+): FlatDataDataType => {
+  if (metamodel instanceof FlatDataBoolean) {
+    return makeObservable(metamodel, {
+      trueString: observable,
+      falseString: observable,
+      hashCode: computed,
+    });
+  } else if (metamodel instanceof FlatDataString) {
+    return makeObservable(metamodel, {
+      hashCode: computed,
+    });
+  } else if (metamodel instanceof FlatDataNumber) {
+    return makeObservable(metamodel, {
+      hashCode: computed,
+    });
+  } else if (metamodel instanceof FlatDataDate) {
+    return makeObservable(metamodel, {
+      dateFormat: observable,
+      timeZone: observable,
+      hashCode: computed,
+    });
+  } else if (metamodel instanceof FlatDataRecordType) {
+    return skipObserved(_observe_FlatDataRecordType)(metamodel);
+  }
+  return metamodel;
+};
+
+export const observe_FlatDataRecordField = skipObserved(
+  (metamodel: FlatDataRecordField): FlatDataRecordField => {
+    makeObservable(metamodel, {
+      label: observable,
+      flatDataDataType: observable,
+      optional: observable,
+      address: observable,
+      hashCode: computed,
+    });
+
+    observe_FlatDataDataType(metamodel.flatDataDataType);
+
+    return metamodel;
+  },
+);
+
+function _observe_FlatDataRecordType(
+  metamodel: FlatDataRecordType,
+): FlatDataRecordType {
+  makeObservable(metamodel, {
+    fields: observable,
+    hashCode: computed,
+  });
+
+  metamodel.fields.forEach(observe_FlatDataRecordField);
+
+  return metamodel;
+}
+
+export const observe_FlatDataRecordType = skipObserved(
+  _observe_FlatDataRecordType,
+);
+
+export const observe_RootFlatDataRecordType = skipObserved(
+  _observe_FlatDataRecordType,
+);
+
+export const observe_FlatDataProperty = skipObserved(
+  (metamodel: FlatDataProperty): FlatDataProperty => {
+    makeObservable(metamodel, {
+      name: observable,
+      value: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_FlatDataSection = skipObserved(
+  (metamodel: FlatDataSection): FlatDataSection => {
+    makeObservable(metamodel, {
+      driverId: observable,
+      name: observable,
+      sectionProperties: observable,
+      recordType: observable,
+      hashCode: computed,
+    });
+
+    metamodel.sectionProperties.forEach(observe_FlatDataProperty);
+    if (metamodel.recordType) {
+      observe_RootFlatDataRecordType(metamodel.recordType);
+    }
+
+    return metamodel;
+  },
+);
+
+export const observe_FlatDataSectionReference = skipObserved(
+  (metamodel: FlatDataSectionReference): FlatDataSectionReference => {
+    makeObservable(metamodel, {
+      value: observable,
+      pointerHashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.ownerReference);
+
+    return metamodel;
+  },
+);
+
+export const observe_FlatData = skipObserved(
+  (metamodel: FlatData): FlatData => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<FlatData, '_elementHashCode'>(metamodel, {
+      sections: observable,
+      recordTypes: computed,
+      _elementHashCode: override,
+    });
+
+    metamodel.sections.forEach(observe_FlatDataSection);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Mapping -------------------------------------
+
+export const observe_RootFlatDataRecordTypeReference = skipObserved(
+  (
+    metamodel: RootFlatDataRecordTypeReference,
+  ): RootFlatDataRecordTypeReference => {
+    makeObservable(metamodel, {
+      value: observable,
+    });
+
+    observe_PackageableElementReference(metamodel.ownerReference);
+
+    return metamodel;
+  },
+);
+
+export const observe_FlatDataInstanceSetImplementation =
+  skipObservedWithContext(
+    (
+      metamodel: FlatDataInstanceSetImplementation,
+      context,
+    ): FlatDataInstanceSetImplementation => {
+      observe_Abstract_InstanceSetImplementation(metamodel, context);
+
+      makeObservable(metamodel, {
+        filter: observable,
+        hashCode: computed,
+      });
+
+      observe_RootFlatDataRecordTypeReference(metamodel.sourceRootRecordType);
+      if (metamodel.filter) {
+        observe_RawLambda(metamodel.filter);
+      }
+
+      return metamodel;
+    },
+  );
+
+export const observe_EmbeddedFlatDataPropertyMapping = skipObservedWithContext(
+  (
+    metamodel: EmbeddedFlatDataPropertyMapping,
+    context,
+  ): EmbeddedFlatDataPropertyMapping => {
+    observe_Abstract_PropertyMapping(metamodel, context);
+    observe_Abstract_InstanceSetImplementation(metamodel, context);
+
+    makeObservable(metamodel, {
+      rootInstanceSetImplementation: observable,
+      isStub: computed,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_FlatDataPropertyMapping = skipObservedWithContext(
+  (metamodel: FlatDataPropertyMapping, context): FlatDataPropertyMapping => {
+    observe_Abstract_PropertyMapping(metamodel, context);
+
+    makeObservable(metamodel, {
+      transformer: observable,
+      transform: observable,
+      isStub: computed,
+      hashCode: computed,
+    });
+
+    // TODO transformer?: EnumerationMapping | undefined;
+    observe_RawLambda(metamodel.transform);
+
+    return metamodel;
+  },
+);
+
+export const observe_FlatDataInputData = skipObserved(
+  (metamodel: FlatDataInputData): FlatDataInputData => {
+    makeObservable(metamodel, {
+      data: observable,
+      validationResult: computed,
+      hashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.sourceFlatData);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Connection -------------------------------------
+
+export const observe_FlatDataConnection = skipObserved(
+  (metamodel: FlatDataConnection): FlatDataConnection => {
+    makeObservable(metamodel, {
+      url: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);