@finos/legend-application-studio 13.0.0

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

@@ -0,0 +1,349 @@
+/**
+ * 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 { observable, action, computed, makeObservable, flow } from 'mobx';
+import {
+  InstanceSetImplementationState,
+  PropertyMappingState,
+} from './MappingElementState.js';
+import type { EditorStore } from '../../../EditorStore.js';
+import { MappingElementDecorator } from './MappingElementDecorator.js';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  isNonNullable,
+} from '@finos/legend-shared';
+import { MAPPING_ELEMENT_TYPE } from './MappingEditorState.js';
+import {
+  type PurePropertyMapping,
+  type PureInstanceSetImplementation,
+  type RawLambda,
+  LAMBDA_PIPE,
+  GRAPH_MANAGER_EVENT,
+  ParserError,
+  buildSourceInformationSourceId,
+  stub_RawLambda,
+  isStubbed_RawLambda,
+} from '@finos/legend-graph';
+import { LambdaEditorState } from '@finos/legend-application';
+import { pureInstanceSetImpl_setMappingFilter } from '../../../graphModifier/DSLMapping_GraphModifierHelper.js';
+
+export class PurePropertyMappingState extends PropertyMappingState {
+  editorStore: EditorStore;
+  declare instanceSetImplementationState: PureInstanceSetImplementationState;
+  declare propertyMapping: PurePropertyMapping;
+
+  constructor(
+    editorStore: EditorStore,
+    instanceSetImplementationState: PureInstanceSetImplementationState,
+    propertyMapping: PurePropertyMapping,
+  ) {
+    super(instanceSetImplementationState, propertyMapping, '', LAMBDA_PIPE);
+    this.propertyMapping = propertyMapping;
+    this.editorStore = editorStore;
+  }
+
+  get lambdaId(): string {
+    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> {
+    const emptyLambda = stub_RawLambda();
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        this.propertyMapping.transform = lambda;
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.propertyMapping.transform = emptyLambda;
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(pretty: boolean): GeneratorFn<void> {
+    if (!isStubbed_RawLambda(this.propertyMapping.transform)) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(this.lambdaId, this.propertyMapping.transform);
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        this.setLambdaString(
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '',
+        );
+        this.clearErrors();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+
+export class PureInstanceSetImplementationFilterState extends LambdaEditorState {
+  editorStore: EditorStore;
+  instanceSetImplementation: PureInstanceSetImplementation;
+  constructor(
+    instanceSetImplementation: PureInstanceSetImplementation,
+    editorStore: EditorStore,
+  ) {
+    super('true', LAMBDA_PIPE);
+
+    makeObservable(this, {
+      editorStore: observable,
+    });
+
+    this.editorStore = editorStore;
+    this.instanceSetImplementation = instanceSetImplementation;
+  }
+
+  get lambdaId(): string {
+    // TODO: we need to fix this when we need to properly reveal compilation error for filter
+    // or when we refactor error reveal in form mode
+    // See https://github.com/finos/legend-studio/issues/1168
+    return buildSourceInformationSourceId([
+      this.instanceSetImplementation._PARENT.path,
+      this.uuid,
+    ]);
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    const emptyFunctionDefinition = stub_RawLambda();
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        pureInstanceSetImpl_setMappingFilter(
+          this.instanceSetImplementation,
+          lambda,
+        );
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+        GRAPH_MANAGER_EVENT;
+      }
+    } else {
+      this.clearErrors();
+      if (this.instanceSetImplementation.filter) {
+        pureInstanceSetImpl_setMappingFilter(
+          this.instanceSetImplementation,
+          emptyFunctionDefinition,
+        );
+      }
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(pretty: boolean): GeneratorFn<void> {
+    if (this.instanceSetImplementation.filter) {
+      try {
+        const grammarText =
+          (yield this.editorStore.graphManagerState.graphManager.lambdaToPureCode(
+            this.instanceSetImplementation.filter,
+            pretty,
+          )) as string;
+        this.setLambdaString(this.extractLambdaString(grammarText));
+        this.clearErrors();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+        GRAPH_MANAGER_EVENT;
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+export class PureInstanceSetImplementationState extends InstanceSetImplementationState {
+  declare mappingElement: PureInstanceSetImplementation;
+  declare propertyMappingStates: PurePropertyMappingState[];
+  mappingFilterState: PureInstanceSetImplementationFilterState | undefined;
+
+  isConvertingTransformLambdaObjects = false;
+
+  constructor(
+    editorStore: EditorStore,
+    setImplementation: PureInstanceSetImplementation,
+  ) {
+    super(editorStore, setImplementation);
+
+    makeObservable(this, {
+      isConvertingTransformLambdaObjects: observable,
+      mappingFilterState: observable,
+      hasParserError: computed,
+      setPropertyMappingStates: action,
+      setMappingFilterState: action,
+      convertFilter: flow,
+    });
+
+    this.mappingElement = setImplementation;
+    this.propertyMappingStates = setImplementation.propertyMappings.map(
+      (pm) => new PurePropertyMappingState(this.editorStore, this, pm),
+    );
+    this.mappingFilterState = new PureInstanceSetImplementationFilterState(
+      this.mappingElement,
+      editorStore,
+    );
+  }
+
+  get hasParserError(): boolean {
+    return this.propertyMappingStates.some(
+      (propertyMappingState) => propertyMappingState.parserError,
+    );
+  }
+  setPropertyMappingStates(
+    propertyMappingState: PurePropertyMappingState[],
+  ): void {
+    this.propertyMappingStates = propertyMappingState;
+  }
+  setMappingFilterState(
+    mappingFilterState: PureInstanceSetImplementationFilterState,
+  ): void {
+    this.mappingFilterState = mappingFilterState;
+  }
+
+  /**
+   * 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: PurePropertyMappingState[] = [];
+    const propertyMappingstatesAfterDecoration =
+      this.mappingElement.propertyMappings.map(
+        (pm) => new PurePropertyMappingState(this.editorStore, this, pm),
+      );
+    propertyMappingstatesAfterDecoration.forEach((propertyMappingState) => {
+      const existingPropertyMappingState = this.propertyMappingStates.find(
+        (p) => p.propertyMapping === propertyMappingState.propertyMapping,
+      );
+      newPropertyMappingStates.push(
+        existingPropertyMappingState ?? propertyMappingState,
+      );
+    });
+    this.setPropertyMappingStates(newPropertyMappingStates);
+  }
+
+  *convertPropertyMappingTransformObjects(): GeneratorFn<void> {
+    const lambdas = new Map<string, RawLambda>();
+    const index = new Map<string, PurePropertyMappingState>();
+    this.propertyMappingStates.forEach((pm) => {
+      if (!isStubbed_RawLambda(pm.propertyMapping.transform)) {
+        lambdas.set(pm.lambdaId, pm.propertyMapping.transform);
+        index.set(pm.lambdaId, pm);
+      }
+    });
+    if (lambdas.size) {
+      this.isConvertingTransformLambdaObjects = true;
+      try {
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+          )) as Map<string, string>;
+        isolatedLambdas.forEach((grammarText, key) => {
+          const purePropertyMapping = index.get(key);
+          purePropertyMapping?.setLambdaString(
+            purePropertyMapping.extractLambdaString(grammarText),
+          );
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+        GRAPH_MANAGER_EVENT;
+      } finally {
+        this.isConvertingTransformLambdaObjects = false;
+      }
+    }
+  }
+
+  *convertFilter(): GeneratorFn<void> {
+    const lambda = this.mappingElement.filter;
+    if (lambda) {
+      this.isConvertingTransformLambdaObjects = true;
+      try {
+        const isolatedLambda =
+          (yield this.editorStore.graphManagerState.graphManager.lambdaToPureCode(
+            lambda,
+          )) as string;
+        this.mappingFilterState?.setLambdaString(
+          this.mappingFilterState.extractLambdaString(isolatedLambda),
+        );
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+        GRAPH_MANAGER_EVENT;
+      } finally {
+        this.isConvertingTransformLambdaObjects = false;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * 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 { GeneratorFn } from '@finos/legend-shared';
+import { InstanceSetImplementationState } from './MappingElementState.js';
+
+export class UnsupportedInstanceSetImplementationState extends InstanceSetImplementationState {
+  decorate(): void {
+    // do nothing
+  }
+  *convertPropertyMappingTransformObjects(): GeneratorFn<void> {
+    // do nothing
+  }
+}

package/src/stores/editor-state/element-editor-state/mapping/relational/DatabaseEditorHelper.tsx

@@ -0,0 +1,134 @@
+/**
+ * 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 {
+  BinaryTypeIcon,
+  ToggleIcon,
+  ClockIcon,
+  HashtagIcon,
+  QuestionCircleIcon,
+  StringTypeIcon,
+  ShapeTriangleIcon,
+} from '@finos/legend-art';
+import {
+  type RelationalDataType,
+  Real,
+  Binary,
+  Bit,
+  Other,
+  Date,
+  Timestamp,
+  Numeric,
+  Decimal,
+  VarBinary,
+  Char,
+  VarChar,
+  Double,
+  Float,
+  Integer,
+  TinyInt,
+  SmallInt,
+  BigInt,
+  SemiStructured,
+} from '@finos/legend-graph';
+
+export const generateColumnTypeLabel = (type: RelationalDataType): string => {
+  if (type instanceof VarChar) {
+    return `VARCHAR(${type.size})`;
+  } else if (type instanceof Char) {
+    return `CHAR(${type.size})`;
+  } else if (type instanceof VarBinary) {
+    return `VARBINARY(${type.size})`;
+  } else if (type instanceof Binary) {
+    return `BINARY(${type.size})`;
+  } else if (type instanceof Bit) {
+    return `BIT`;
+  } else if (type instanceof Numeric) {
+    return `NUMERIC(${type.precision},${type.scale})`;
+  } else if (type instanceof Decimal) {
+    return `DECIMAL(${type.precision},${type.scale})`;
+  } else if (type instanceof Double) {
+    return `DOUBLE`;
+  } else if (type instanceof Float) {
+    return `FLOAT`;
+  } else if (type instanceof Real) {
+    return `REAL`;
+  } else if (type instanceof Integer) {
+    return `INT`;
+  } else if (type instanceof BigInt) {
+    return `BIGINT`;
+  } else if (type instanceof SmallInt) {
+    return `SMALLINT`;
+  } else if (type instanceof TinyInt) {
+    return `TINYINT`;
+  } else if (type instanceof Date) {
+    return `DATE`;
+  } else if (type instanceof Timestamp) {
+    return `TIMESTAMP`;
+  } else if (type instanceof Other) {
+    return `OTHER`;
+  } else if (type instanceof SemiStructured) {
+    return 'SEMI-STRUCTURED';
+  }
+  return '(UNKNOWN)';
+};
+
+export const renderColumnTypeIcon = (
+  type: RelationalDataType,
+): React.ReactNode => {
+  if (type instanceof VarChar || type instanceof Char) {
+    return (
+      <StringTypeIcon className="relation-source-tree__icon relation-source-tree__icon__string" />
+    );
+  } else if (type instanceof VarBinary || type instanceof Binary) {
+    return (
+      <BinaryTypeIcon className="relation-source-tree__icon relation-source-tree__icon__binary" />
+    );
+  } else if (type instanceof Bit) {
+    return (
+      <ToggleIcon className="relation-source-tree__icon relation-source-tree__icon__boolean" />
+    );
+  } else if (
+    type instanceof Numeric ||
+    type instanceof Decimal ||
+    type instanceof Double ||
+    type instanceof Float ||
+    type instanceof Real ||
+    type instanceof Integer ||
+    type instanceof BigInt ||
+    type instanceof SmallInt ||
+    type instanceof TinyInt
+  ) {
+    return (
+      <HashtagIcon className="relation-source-tree__icon relation-source-tree__icon__number" />
+    );
+  } else if (type instanceof Date || type instanceof Timestamp) {
+    return (
+      <ClockIcon className="relation-source-tree__icon relation-source-tree__icon__time" />
+    );
+  } else if (type instanceof SemiStructured) {
+    return (
+      <ShapeTriangleIcon className="relation-source-tree__icon relation-source-tree__icon__semi-structured" />
+    );
+  } else if (type instanceof Other) {
+    return (
+      <QuestionCircleIcon className="relation-source-tree__icon relation-source-tree__icon__unknown" />
+    );
+  }
+  return (
+    <QuestionCircleIcon className="relation-source-tree__icon relation-source-tree__icon__unknown" />
+  );
+};