@finos/legend-graph 13.0.2 → 14.0.0

package/src/graphManager/AbstractPureGraphManager.ts

@@ -279,6 +279,16 @@ export abstract class AbstractPureGraphManager {
     rawValueSpecification: RawValueSpecification,
   ): Record<PropertyKey, unknown>;
 
+  // These methods are utilities that we could use to quickly construct compilable
+  // raw lambdas.
+  // NOTE: As of now, to simplify the code, these methods are implemented in quite a hacky way, as we create
+  // the lambdas from a templated JSON object. Formally, we could remove these method by building them
+  // in metamodel form and convert to raw form as these are relatively simple lambda to construct
+  abstract createGetAllRawLambda(_class: Class): RawLambda;
+  abstract createDefaultBasicRawLambda(options?: {
+    addDummyParameter?: boolean;
+  }): RawLambda;
+
   // ------------------------------------------- Generation -------------------------------------------
 
   abstract getAvailableGenerationConfigurationDescriptions(): Promise<
@@ -420,6 +430,10 @@ export abstract class AbstractPureGraphManager {
     input: RawMappingModelCoverageAnalysisResult,
   ): MappingModelCoverageAnalysisResult;
 
+  // ------------------------------------------- Change detection -------------------------------------------
+
+  abstract buildHashesIndex(entities: Entity[]): Promise<Map<string, string>>;
+
   // ------------------------------------------- Utilities -------------------------------------------
 
   abstract elementToEntity(
@@ -448,24 +462,4 @@ export abstract class AbstractPureGraphManager {
     );
     return graph;
   }
-
-  // ------------------------------------------- Change detection -------------------------------------------
-
-  abstract buildHashesIndex(entities: Entity[]): Promise<Map<string, string>>;
-
-  // --------------------------------------------- HACKY ---------------------------------------------
-  // As the name suggested, these methods are temporary hacks since we don't handle value-specification
-  // structurally in Studio
-
-  // Eventually, we could remove these method by building them in metamodel form and convert to raw form
-  // as these are relatively simple lambda to construct
-  abstract HACKY__createGetAllLambda(_class: Class): RawLambda;
-  abstract HACKY__createDefaultBlankLambda(): RawLambda;
-
-  // NOTE: after we refactor service, we probably can remove these methods
-  // See https://github.com/finos/legend-studio/issues/1077
-  abstract HACKY__createServiceTestAssertLambda(assertData: string): RawLambda;
-  abstract HACKY__extractServiceTestAssertionData(
-    query: RawLambda,
-  ): string | undefined;
 }

package/src/graphManager/GraphManagerState.ts

@@ -14,12 +14,7 @@
  * limitations under the License.
  */
 
-import {
-  type Log,
-  uniq,
-  ActionState,
-  assertErrorThrown,
-} from '@finos/legend-shared';
+import { type Log, ActionState, assertErrorThrown } from '@finos/legend-shared';
 import { action, makeObservable, observable } from 'mobx';
 import { DependencyManager } from '../graph/DependencyManager.js';
 import {
@@ -33,22 +28,14 @@ import type {
   GraphBuilderOptions,
 } from '../graphManager/AbstractPureGraphManager.js';
 import type { GraphManagerPluginManager } from './GraphManagerPluginManager.js';
-import { getElementRootPackage } from '../graph/helpers/DomainHelper.js';
-import { getLeafSetImplementations } from '../graph/helpers/DSLMapping_Helper.js';
-import { ROOT_PACKAGE_NAME } from '../graph/MetaModelConst.js';
-import { AssociationImplementation } from '../graph/metamodel/pure/packageableElements/mapping/AssociationImplementation.js';
 import type { EnumerationMapping } from '../graph/metamodel/pure/packageableElements/mapping/EnumerationMapping.js';
 import { InstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/InstanceSetImplementation.js';
-import { OperationSetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/OperationSetImplementation.js';
-import type { PropertyMapping } from '../graph/metamodel/pure/packageableElements/mapping/PropertyMapping.js';
 import type { SetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/SetImplementation.js';
 import type { PackageableElement } from '../graph/metamodel/pure/packageableElements/PackageableElement.js';
 import { EmbeddedFlatDataPropertyMapping } from '../graph/metamodel/pure/packageableElements/store/flatData/mapping/EmbeddedFlatDataPropertyMapping.js';
 import { EmbeddedRelationalInstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/store/relational/mapping/EmbeddedRelationalInstanceSetImplementation.js';
-import { InlineEmbeddedRelationalInstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/store/relational/mapping/InlineEmbeddedRelationalInstanceSetImplementation.js';
-import { OtherwiseEmbeddedRelationalInstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/store/relational/mapping/OtherwiseEmbeddedRelationalInstanceSetImplementation.js';
 import { buildPureGraphManager } from '../graphManager/protocol/pure/PureGraphManagerBuilder.js';
-import { PrimitiveType } from '../graph/metamodel/pure/packageableElements/domain/PrimitiveType.js';
+import type { AssociationImplementation } from '../graph/metamodel/pure/packageableElements/mapping/AssociationImplementation.js';
 
 export class BasicGraphManagerState {
   pluginManager: GraphManagerPluginManager;
@@ -63,49 +50,17 @@ export class BasicGraphManagerState {
   }
 
   // -------------------------------------------------- UTILITIES -----------------------------------------------------
+
   /**
-   * NOTE: Notice how this utility draws resources from all of metamodels and uses `instanceof` to classify behavior/response.
-   * As such, methods in this utility cannot be placed in place they should belong to.
+   * Check if a mapping element is an instance set implementation
    *
-   * For example: `getSetImplemetnationType` cannot be placed in `SetImplementation` because of circular module dependency
-   * So this utility is born for such purpose, to avoid circular module dependency, and it should just be used for only that
-   * Other utilities that really should reside in the domain-specific meta model should be placed in the meta model module.
+   * NOTE: This would account for embedded property mappings as well
+   * these are technically instance of `InstanceSetImplementation`
+   * but since unlike Pure, Typescript cannot do multiple inheritance
+   * we only can make embedded property mapping extends `PropertyMapping`
    *
-   * NOTE: We expect the need for these methods will eventually go away as we complete modularization. But we need these
-   * methods here so that we can load plugins.
+   * Potentially, we might need to apply an extension mechanism on this
    */
-
-  isDependencyElement(
-    element: PackageableElement,
-  ): element is PackageableElement {
-    return (
-      getElementRootPackage(element).name ===
-      ROOT_PACKAGE_NAME.PROJECT_DEPENDENCY_ROOT
-    );
-  }
-
-  isGeneratedElement(
-    element: PackageableElement,
-  ): element is PackageableElement {
-    return (
-      getElementRootPackage(element).name === ROOT_PACKAGE_NAME.MODEL_GENERATION
-    );
-  }
-
-  isSystemElement(element: PackageableElement): element is PackageableElement {
-    return (
-      element instanceof PrimitiveType ||
-      getElementRootPackage(element).name === ROOT_PACKAGE_NAME.SYSTEM ||
-      getElementRootPackage(element).name === ROOT_PACKAGE_NAME.CORE
-    );
-  }
-
-  isMainGraphElement(
-    element: PackageableElement,
-  ): element is PackageableElement {
-    return getElementRootPackage(element).name === ROOT_PACKAGE_NAME.MAIN;
-  }
-
   isInstanceSetImplementation(
     setImplementation:
       | EnumerationMapping
@@ -119,67 +74,13 @@ export class BasicGraphManagerState {
     );
   }
 
-  getInstanceSetImplementationPropertyMappings(
-    instanceSetImpl: InstanceSetImplementation,
-  ): PropertyMapping[] {
-    if (
-      instanceSetImpl instanceof
-      InlineEmbeddedRelationalInstanceSetImplementation
-    ) {
-      return this.getMappingElementPropertyMappings(
-        instanceSetImpl.inlineSetImplementation,
-      );
-    } else if (
-      instanceSetImpl instanceof
-      OtherwiseEmbeddedRelationalInstanceSetImplementation
-    ) {
-      // NOTE: for now we will grab all property mappings from the main otherwise embedded mapping and the otherwise property mapping.
-      // In the future we may want to incorporate some smartness as to when the otherwise set implementation isinvoked.
-      const otherwisePropertyMappings = instanceSetImpl.otherwisePropertyMapping
-        .targetSetImplementation?.value
-        ? this.getMappingElementPropertyMappings(
-            instanceSetImpl.otherwisePropertyMapping.targetSetImplementation
-              .value,
-          )
-        : [];
-      return [
-        ...instanceSetImpl.propertyMappings,
-        ...otherwisePropertyMappings,
-      ];
-    }
-    return instanceSetImpl.propertyMappings;
-  }
-
-  getMappingElementPropertyMappings(
-    mappingElement:
-      | EnumerationMapping
-      | SetImplementation
-      | AssociationImplementation,
-  ): PropertyMapping[] {
-    let mappedProperties: PropertyMapping[] = [];
-    if (this.isInstanceSetImplementation(mappingElement)) {
-      mappedProperties =
-        this.getInstanceSetImplementationPropertyMappings(mappingElement);
-    } else if (mappingElement instanceof AssociationImplementation) {
-      mappedProperties = mappingElement.propertyMappings;
-    } else if (mappingElement instanceof OperationSetImplementation) {
-      mappedProperties = getLeafSetImplementations(mappingElement)
-        .filter((me): me is InstanceSetImplementation =>
-          this.isInstanceSetImplementation(me),
-        )
-        .map((si) => si.propertyMappings)
-        .flat();
-    }
-    return uniq(mappedProperties);
-  }
-
   /**
    * Filter the list of system elements that will be shown in selection options
    * to users. This is helpful to avoid overwhelming and confusing users in form
    * mode since many system elements are needed to build the graph, but should
    * not present at all as selection options in form mode.
    */
-  filterSystemElementOptions<T extends PackageableElement>(
+  collectExposedSystemElements<T extends PackageableElement>(
     systemElements: T[],
   ): T[] {
     const allowedSystemElements = this.pluginManager
@@ -189,10 +90,6 @@ export class BasicGraphManagerState {
       allowedSystemElements.includes(element.path),
     );
   }
-
-  isElementReadOnly(element: PackageableElement): boolean {
-    return getElementRootPackage(element).name !== ROOT_PACKAGE_NAME.MAIN;
-  }
 }
 
 export class GraphManagerState extends BasicGraphManagerState {

package/src/graphManager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -30,7 +30,6 @@ import {
   getClass,
   guaranteeNonNullable,
   UnsupportedOperationError,
-  assertTrue,
   assertErrorThrown,
   promisify,
   StopWatch,
@@ -1721,7 +1720,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     }
   }
 
-  // ------------------------------------------- ValueSpecification -------------------------------------------
+  // ------------------------------------------- Value Specification -------------------------------------------
 
   buildValueSpecification(
     json: Record<PropertyKey, unknown>,
@@ -1780,7 +1779,41 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  createGetAllRawLambda(_class: Class): RawLambda {
+    return new RawLambda(
+      [],
+      [
+        {
+          _type: 'func',
+          function: 'getAll',
+          parameters: [
+            {
+              _type: 'packageableElementPtr',
+              fullPath: _class.path,
+            },
+          ],
+        },
+      ],
+    );
+  }
+
+  createDefaultBasicRawLambda(options?: {
+    addDummyParameter?: boolean;
+  }): RawLambda {
+    return new RawLambda(
+      options?.addDummyParameter ? [{ _type: 'var', name: 'x' }] : undefined,
+      [
+        {
+          _type: 'string',
+          multiplicity: { lowerBound: 1, upperBound: 1 },
+          values: [''],
+        },
+      ],
+    );
+  }
+
   // ------------------------------------------- External Format --------------------------------
+
   getAvailableExternalFormatsDescriptions(): Promise<
     ExternalFormatDescription[]
   > {
@@ -1987,7 +2020,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       testDataGenerationExecuteInput,
     );
     testDataGenerationExecuteInput.parameters = parameters;
-    testDataGenerationExecuteInput.hashStrings = Boolean(
+    testDataGenerationExecuteInput.hashValues = Boolean(
       options?.anonymizeGeneratedData,
     );
     return this.engine.generateExecuteTestData(testDataGenerationExecuteInput);
@@ -2346,116 +2379,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  // --------------------------------------------- HACKY ---------------------------------------------
-
-  HACKY__createGetAllLambda(_class: Class): RawLambda {
-    return new RawLambda(
-      [],
-      [
-        {
-          _type: 'func',
-          function: 'getAll',
-          parameters: [
-            {
-              _type: 'packageableElementPtr',
-              fullPath: _class.path,
-            },
-          ],
-        },
-      ],
-    );
-  }
-
-  HACKY__createServiceTestAssertLambda(assertData: string): RawLambda {
-    return new RawLambda(
-      [
-        {
-          _type: 'var',
-          class: 'meta::pure::mapping::Result',
-          multiplicity: { lowerBound: 1, upperBound: 1 },
-          name: 'res',
-        },
-      ],
-      [
-        {
-          _type: 'func',
-          function: 'equalJsonStrings',
-          parameters: [
-            {
-              _type: 'func',
-              function: 'toString',
-              parameters: [
-                {
-                  _type: 'func',
-                  function: 'toOne',
-                  parameters: [
-                    {
-                      _type: 'property',
-                      parameters: [
-                        {
-                          _type: 'var',
-                          name: 'res',
-                        },
-                      ],
-                      property: 'values',
-                    },
-                  ],
-                },
-              ],
-            },
-            {
-              _type: 'string',
-              multiplicity: {
-                lowerBound: 1,
-                upperBound: 1,
-              },
-              values: [assertData],
-            },
-          ],
-        },
-      ],
-    );
-  }
-
-  HACKY__extractServiceTestAssertionData(query: RawLambda): string | undefined {
-    let json: string | undefined;
-    try {
-      json = (
-        (
-          ((query.body as unknown[])[0] as Record<PropertyKey, unknown>) // FunctionValue
-            .parameters as unknown[]
-        )[1] as {
-          values: (string | undefined)[];
-        }
-      ).values[0];
-      assertTrue(typeof json === 'string', `Expected value of type 'string'`);
-    } catch (error) {
-      assertErrorThrown(error);
-      this.log.warn(
-        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
-        `Can't extract assertion result`,
-      );
-      json = undefined;
-    }
-    if (!json) {
-      /* Add other assertion cases if we read others */
-    }
-    return json;
-  }
-
-  HACKY__createDefaultBlankLambda(): RawLambda {
-    return new RawLambda(
-      [{ _type: 'var', name: 'x' }],
-      [
-        {
-          _type: 'string',
-          multiplicity: { lowerBound: 1, upperBound: 1 },
-          values: [''],
-        },
-      ],
-    );
-  }
-
   // --------------------------------------------- Utilities ---------------------------------------------
 
   elementToEntity = (

package/src/graphManager/protocol/pure/v1/engine/execution/V1_ExecuteInput.ts

@@ -64,7 +64,7 @@ export class V1_ExecuteInput {
 
 export class V1_TestDataGenerationExecutionInput extends V1_ExecuteInput {
   parameters: (string | number | boolean)[] = [];
-  hashStrings = false;
+  hashValues = false;
 
   static override readonly serialization = new SerializationFactory(
     createModelSchema(V1_TestDataGenerationExecutionInput, {
@@ -77,7 +77,7 @@ export class V1_TestDataGenerationExecutionInput extends V1_ExecuteInput {
         () => SKIP,
       ),
       context: usingModelSchema(V1_rawBaseExecutionContextModelSchema),
-      hashStrings: primitive(),
+      hashValues: primitive(),
       parameters: list(primitive()),
     }),
   );

package/src/graphManager/protocol/pure/v1/model/packageableElements/store/flatData/model/V1_FlatDataProperty.ts

@@ -17,9 +17,11 @@
 import { CORE_HASH_STRUCTURE } from '../../../../../../../../../graph/Core_HashUtils.js';
 import { type Hashable, hashArray } from '@finos/legend-shared';
 
+type V1_FlatDataPropertyValue = boolean | string | number;
+
 export class V1_FlatDataProperty implements Hashable {
   name!: string;
-  value!: boolean | string | number;
+  value!: V1_FlatDataPropertyValue;
 
   get hashCode(): string {
     return hashArray([