@finos/legend-application-studio 28.19.8 → 28.19.9

package/src/stores/editor/editor-state/element-editor-state/mapping/RelationFunctionInstanceSetImplementationState.ts

@@ -0,0 +1,172 @@
+/**
+ * Copyright (c) 2025-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 { observable, action, computed, makeObservable } from 'mobx';
+import { type GeneratorFn, isNonNullable } from '@finos/legend-shared';
+import {
+  type PropertyMapping,
+  buildSourceInformationSourceId,
+  RelationColumn,
+  RelationFunctionPropertyMapping,
+  type RelationFunctionInstanceSetImplementation,
+} from '@finos/legend-graph';
+import type { EditorStore } from '../../../EditorStore.js';
+import { MAPPING_ELEMENT_TYPE } from './MappingEditorState.js';
+import { MappingElementDecorator } from './MappingElementDecorator.js';
+import {
+  PropertyMappingState,
+  InstanceSetImplementationState,
+} from './MappingElementState.js';
+import { isStubbed_RelationColumn } from '../../../../graph-modifier/STO_RelationFunction_GraphModifierHelper.js';
+
+export class RelationFunctionPropertyMappingState extends PropertyMappingState {
+  editorStore: EditorStore;
+  declare instanceSetImplementationState: RelationFunctionInstanceSetImplementationState;
+  declare propertyMapping: RelationFunctionPropertyMapping;
+
+  constructor(
+    editorStore: EditorStore,
+    instanceSetImplementationState: RelationFunctionInstanceSetImplementationState,
+    propertyMapping: RelationFunctionPropertyMapping,
+  ) {
+    super(instanceSetImplementationState, propertyMapping, '', '');
+    this.propertyMapping = propertyMapping;
+    this.editorStore = editorStore;
+  }
+
+  // NOTE: `operationId` is properly the more appropriate term to use, but we are just following what we
+  // do for other property mapping for consistency
+  get lambdaId(): string {
+    // NOTE: Added the index here just in case but the order needs to be checked carefully as bugs may result from inaccurate orderings
+    return buildSourceInformationSourceId(
+      [
+        this.propertyMapping._OWNER._PARENT.path,
+        MAPPING_ELEMENT_TYPE.CLASS,
+        this.propertyMapping._OWNER.id.value,
+        this.propertyMapping.property.value.name,
+        this.propertyMapping.targetSetImplementation?.value.id.value,
+        this.uuid, // in case of duplications
+      ].filter(isNonNullable),
+    );
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    if (this.lambdaString !== '') {
+      this.propertyMapping.column = new RelationColumn(
+        this.lambdaString,
+        this.propertyMapping.property.value.genericType.value.rawType,
+      );
+    } else {
+      this.clearErrors();
+      this.propertyMapping.column = {} as RelationColumn;
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(options?: {
+    pretty?: boolean | undefined;
+    preserveCompilationError?: boolean | undefined;
+  }): GeneratorFn<void> {
+    if (!isStubbed_RelationColumn(this.propertyMapping.column)) {
+      this.setLambdaString(this.propertyMapping.column.name);
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+
+export class RelationFunctionInstanceSetImplementationState extends InstanceSetImplementationState {
+  declare mappingElement: RelationFunctionInstanceSetImplementation;
+  declare propertyMappingStates: RelationFunctionPropertyMappingState[];
+  isConvertingTransformLambdaObjects = false;
+
+  constructor(
+    editorStore: EditorStore,
+    setImplementation: RelationFunctionInstanceSetImplementation,
+  ) {
+    super(editorStore, setImplementation);
+
+    makeObservable(this, {
+      isConvertingTransformLambdaObjects: observable,
+      hasParserError: computed,
+      setPropertyMappingStates: action,
+    });
+
+    this.mappingElement = setImplementation;
+    this.propertyMappingStates = this.getPropertyMappingStates(
+      setImplementation.propertyMappings,
+    );
+  }
+
+  getPropertyMappingStates(
+    propertyMappings: PropertyMapping[],
+  ): RelationFunctionPropertyMappingState[] {
+    return propertyMappings
+      .map((pm) => {
+        if (pm instanceof RelationFunctionPropertyMapping) {
+          return new RelationFunctionPropertyMappingState(
+            this.editorStore,
+            this,
+            pm,
+          );
+        }
+        return undefined;
+      })
+      .filter(isNonNullable);
+  }
+
+  get hasParserError(): boolean {
+    return this.propertyMappingStates.some(
+      (propertyMappingState) => propertyMappingState.parserError,
+    );
+  }
+  setPropertyMappingStates(
+    propertyMappingState: RelationFunctionPropertyMappingState[],
+  ): void {
+    this.propertyMappingStates = propertyMappingState;
+  }
+
+  /**
+   * When we decorate, we might lose the error (parser/compiler) on each of the property mapping state
+   * so here we make sure that we reuse existing state and only add new decorated ones
+   */
+  decorate(): void {
+    this.mappingElement.accept_SetImplementationVisitor(
+      new MappingElementDecorator(this.editorStore),
+    );
+    const newPropertyMappingStates: RelationFunctionPropertyMappingState[] = [];
+    const propertyMappingstatesAfterDecoration = this.getPropertyMappingStates(
+      this.mappingElement.propertyMappings,
+    );
+    propertyMappingstatesAfterDecoration.forEach((propertyMappingState) => {
+      const existingPropertyMappingState = this.propertyMappingStates.find(
+        (p) => p.propertyMapping === propertyMappingState.propertyMapping,
+      );
+      newPropertyMappingStates.push(
+        existingPropertyMappingState ?? propertyMappingState,
+      );
+    });
+    this.setPropertyMappingStates(newPropertyMappingStates);
+  }
+
+  *convertPropertyMappingTransformObjects(): GeneratorFn<void> {
+    this.propertyMappingStates.forEach((pm) => {
+      if (!isStubbed_RelationColumn(pm.propertyMapping.column)) {
+        pm.setLambdaString(pm.propertyMapping.column.name);
+      }
+    });
+  }
+}

package/src/stores/editor/editor-state/element-editor-state/mapping/testable/MappingTestingHelper.ts

@@ -127,6 +127,7 @@ export const isRelationalMappingTestSuite = (
     .some((e) => isRelationalMappingTest(e));
 };
 
+//TODO: relation function support needs to be added
 export const generateStoreTestDataFromSetImpl = (
   setImpl: SetImplementation,
   editorStore: EditorStore,

package/src/stores/graph-modifier/STO_RelationFunction_GraphModifierHelper.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2025-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 ConcreteFunctionDefinition,
+  type ObserverContext,
+  type RelationColumn,
+  type RelationFunctionInstanceSetImplementation,
+  observe_ConcreteFunctionDefinition,
+} from '@finos/legend-graph';
+import { action } from 'mobx';
+
+export const relationFunction_setRelationFunction = action(
+  (
+    setImplementation: RelationFunctionInstanceSetImplementation,
+    relationFunction: ConcreteFunctionDefinition,
+    context: ObserverContext,
+  ): void => {
+    setImplementation.relationFunction = observe_ConcreteFunctionDefinition(
+      relationFunction,
+      context,
+    );
+  },
+);
+
+export const isStubbed_RelationColumn = (column: RelationColumn): boolean =>
+  !column.name && !column.type;

package/tsconfig.json

@@ -147,6 +147,7 @@
     "./src/stores/editor/editor-state/element-editor-state/mapping/MappingExecutionState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/MappingTabManagerState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/PureInstanceSetImplementationState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/mapping/RelationFunctionInstanceSetImplementationState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/UnsupportedInstanceSetImplementationState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/legacy/DEPRECATED__MappingTestState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/legacy/MappingTestMigrationState.ts",
@@ -206,6 +207,7 @@
     "./src/stores/graph-modifier/GraphModifierHelper.ts",
     "./src/stores/graph-modifier/RawValueSpecificationGraphModifierHelper.ts",
     "./src/stores/graph-modifier/STO_FlatData_GraphModifierHelper.ts",
+    "./src/stores/graph-modifier/STO_RelationFunction_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/STO_Relational_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/Testable_GraphModifierHelper.ts",
     "./src/stores/lazy-text-editor/LazyTextEditorStore.ts",
@@ -292,6 +294,8 @@
     "./src/components/editor/editor-group/mapping-editor/OperationSetImplementationEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/PropertyMappingsEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/PurePropertyMappingEditor.tsx",
+    "./src/components/editor/editor-group/mapping-editor/RelationFunctionPropertyMappingEditor.tsx",
+    "./src/components/editor/editor-group/mapping-editor/RelationTypeTree.tsx",
     "./src/components/editor/editor-group/mapping-editor/TypeTree.tsx",
     "./src/components/editor/editor-group/mapping-editor/legacy/DEPRECATED__MappingTestEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/legacy/MappingTestMigrationTool.tsx",