@finos/legend-graph 2.1.3 → 3.0.0

package/src/graphManager/action/EngineError.ts

@@ -24,6 +24,7 @@ export class EngineError extends ApplicationError {
   constructor(message: string | undefined) {
     super(message);
 
+    // TODO: check if we need this to be observable or not?
     makeObservable(this, {
       message: observable,
       sourceInformation: observable,

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

@@ -0,0 +1,109 @@
+/**
+ * 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 {
+  action,
+  computed,
+  isObservable,
+  makeObservable,
+  observable,
+} from 'mobx';
+import type { PackageableElement } from '../../../models/metamodels/pure/packageableElements/PackageableElement';
+import type {
+  OptionalPackageableElementReference,
+  PackageableElementReference,
+} from '../../../models/metamodels/pure/packageableElements/PackageableElementReference';
+import type { Multiplicity } from '../../../models/metamodels/pure/packageableElements/domain/Multiplicity';
+import type { InferableValue } from '../../../models/metamodels/pure/InferableValue';
+import type { PureGraphManagerPlugin } from '../../PureGraphManagerPlugin';
+
+export class ObserverContext {
+  plugins: PureGraphManagerPlugin[] = [];
+
+  constructor(plugins: PureGraphManagerPlugin[]) {
+    this.plugins = plugins;
+  }
+}
+
+export const skipObserved =
+  <T>(observer: (metamodel: T) => T): ((metamodel: T) => T) =>
+  (metamodel: T) =>
+    isObservable(metamodel) ? metamodel : observer(metamodel);
+
+export const skipObservedWithContext =
+  <T>(
+    observer: (metamodel: T, context: ObserverContext) => T,
+  ): ((metamodel: T, context: ObserverContext) => T) =>
+  (metamodel: T, context: ObserverContext) =>
+    isObservable(metamodel) ? metamodel : observer(metamodel, context);
+
+export const observe_Abstract_PackageableElement = (
+  metamodel: PackageableElement,
+): void => {
+  makeObservable<
+    PackageableElement,
+    '_isDeleted' | '_isDisposed' | '_elementHashCode'
+  >(metamodel, {
+    _isDeleted: observable,
+    _isDisposed: observable,
+    name: observable,
+    package: observable,
+    isDeleted: computed,
+    path: computed,
+    _elementHashCode: computed,
+    hashCode: computed,
+    setIsDeleted: action,
+    dispose: action,
+  });
+};
+
+export const observe_PackageableElementReference = skipObserved(
+  <T extends PackageableElement>(
+    metamodel: PackageableElementReference<T>,
+  ): PackageableElementReference<T> =>
+    makeObservable(metamodel, {
+      value: observable,
+      valueForSerialization: computed,
+    }),
+);
+
+export const observe_OptionalPackageableElementReference = skipObserved(
+  <T extends PackageableElement>(
+    metamodel: OptionalPackageableElementReference<T>,
+  ): OptionalPackageableElementReference<T> =>
+    makeObservable(metamodel, {
+      value: observable,
+      valueForSerialization: computed,
+    }),
+);
+
+export const observe_Multiplicity = skipObserved(
+  (metamodel: Multiplicity): Multiplicity =>
+    makeObservable(metamodel, {
+      lowerBound: observable,
+      upperBound: observable,
+      str: computed,
+      hashCode: computed,
+    }),
+);
+
+export const observe_Abstract_InferableValue = <T, V>(
+  metamodel: InferableValue<T, V>,
+): void => {
+  makeObservable(metamodel, {
+    value: observable,
+  });
+};

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

@@ -0,0 +1,143 @@
+/**
+ * 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 { ExternalFormatConnection } from '../../../models/metamodels/pure/packageableElements/externalFormat/connection/DSLExternalFormat_ExternalFormatConnection';
+import type { UrlStream } from '../../../models/metamodels/pure/packageableElements/externalFormat/connection/DSLExternalFormat_UrlStream';
+import type { Schema } from '../../../models/metamodels/pure/packageableElements/externalFormat/schemaSet/DSLExternalFormat_Schema';
+import type { SchemaSet } from '../../../models/metamodels/pure/packageableElements/externalFormat/schemaSet/DSLExternalFormat_SchemaSet';
+import type { Binding } from '../../../models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_Binding';
+import type { BindingTransformer } from '../../../models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_BindingTransformer';
+import type { ModelUnit } from '../../../models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_ModelUnit';
+import {
+  observe_PackageableElementReference,
+  skipObserved,
+  observe_OptionalPackageableElementReference,
+  observe_Abstract_PackageableElement,
+} from './CoreObserverHelper';
+import {
+  observe_Abstract_Connection,
+  observe_Abstract_Store,
+} from './DSLMapping_ObserverHelper';
+
+// ------------------------------------- Store -------------------------------------
+
+export const observe_ModelUnit = skipObserved(
+  (metamodel: ModelUnit): ModelUnit => {
+    makeObservable(metamodel, {
+      packageableElementIncludes: observable,
+      packageableElementExcludes: observable,
+      hashCode: computed,
+    });
+
+    metamodel.packageableElementIncludes.forEach(
+      observe_PackageableElementReference,
+    );
+    metamodel.packageableElementExcludes.forEach(
+      observe_PackageableElementReference,
+    );
+
+    return metamodel;
+  },
+);
+
+export const observe_Binding = skipObserved((metamodel: Binding): Binding => {
+  observe_Abstract_Store(metamodel);
+
+  makeObservable<Binding, '_elementHashCode'>(metamodel, {
+    schemaSet: observable,
+    schemaId: observable,
+    contentType: observable,
+    modelUnit: observable,
+    _elementHashCode: override,
+  });
+
+  observe_OptionalPackageableElementReference(metamodel.schemaSet);
+  observe_ModelUnit(metamodel.modelUnit);
+
+  return metamodel;
+});
+
+// ------------------------------------- Mapping -------------------------------------
+
+export const observe_BindingTransformer = skipObserved(
+  (metamodel: BindingTransformer): BindingTransformer => {
+    makeObservable(metamodel, {
+      binding: observable,
+      hashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.binding);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Connection -------------------------------------
+
+export const observe_UrlStream = skipObserved(
+  (metamodel: UrlStream): UrlStream => {
+    makeObservable(metamodel, {
+      url: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_ExternalFormatConnection = skipObserved(
+  (metamodel: ExternalFormatConnection): ExternalFormatConnection => {
+    observe_Abstract_Connection(metamodel);
+
+    makeObservable(metamodel, {
+      externalSource: observable,
+      hashCode: computed,
+    });
+
+    observe_UrlStream(metamodel.externalSource);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Element -------------------------------------
+
+export const observe_ExternalFormatSchema = skipObserved(
+  (metamodel: Schema): Schema =>
+    makeObservable(metamodel, {
+      id: observable,
+      location: observable,
+      content: observable,
+      hashCode: computed,
+    }),
+);
+
+export const observe_SchemaSet = skipObserved(
+  (metamodel: SchemaSet): SchemaSet => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<SchemaSet, '_elementHashCode'>(metamodel, {
+      format: observable,
+      schemas: observable,
+      _elementHashCode: override,
+    });
+
+    metamodel.schemas.forEach(observe_ExternalFormatSchema);
+
+    return metamodel;
+  },
+);

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

@@ -0,0 +1,91 @@
+/**
+ * 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 {
+  ConfigurationProperty,
+  FileGenerationSpecification,
+  GenerationSpecification,
+  GenerationTreeNode,
+} from '../../../DSLGenerationSpecification_Exports';
+import { PackageableElementReference } from '../../../models/metamodels/pure/packageableElements/PackageableElementReference';
+import {
+  observe_Abstract_PackageableElement,
+  observe_PackageableElementReference,
+  skipObserved,
+} from './CoreObserverHelper';
+
+export const observe_ConfigurationProperty = skipObserved(
+  (metamodel: ConfigurationProperty): ConfigurationProperty =>
+    makeObservable(metamodel, {
+      name: observable,
+      value: observable.ref,
+      hashCode: computed,
+    }),
+);
+
+export const observe_FileGenerationSpecification = skipObserved(
+  (metamodel: FileGenerationSpecification): FileGenerationSpecification => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<FileGenerationSpecification, '_elementHashCode'>(metamodel, {
+      type: observable,
+      generationOutputPath: observable,
+      scopeElements: observable,
+      configurationProperties: observable,
+      _elementHashCode: override,
+    });
+
+    metamodel.scopeElements.forEach((scopeElement) => {
+      if (scopeElement instanceof PackageableElementReference) {
+        observe_PackageableElementReference(scopeElement);
+      }
+    });
+    metamodel.configurationProperties.forEach(observe_ConfigurationProperty);
+
+    return metamodel;
+  },
+);
+
+export const observe_GenerationTreeNode = skipObserved(
+  (metamodel: GenerationTreeNode): GenerationTreeNode => {
+    makeObservable(metamodel, {
+      id: observable,
+      hashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.generationElement);
+
+    return metamodel;
+  },
+);
+
+export const observe_GenerationSpecification = skipObserved(
+  (metamodel: GenerationSpecification): GenerationSpecification => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<GenerationSpecification, '_elementHashCode'>(metamodel, {
+      generationNodes: observable,
+      fileGenerations: observable,
+      _elementHashCode: override,
+    });
+
+    metamodel.generationNodes.forEach(observe_GenerationTreeNode);
+    metamodel.fileGenerations.forEach(observe_PackageableElementReference);
+
+    return metamodel;
+  },
+);