@finos/legend-graph 1.2.0 → 2.0.0

package/src/models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_Binding.ts

@@ -0,0 +1,80 @@
+/**
+ * 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, makeObservable, override } from 'mobx';
+import { hashArray, type Hashable } from '@finos/legend-shared';
+import type { SchemaSet } from '../schemaSet/DSLExternalFormat_SchemaSet';
+import { Store } from '../../store/Store';
+import type { OptionalPackageableElementReference } from '../../PackageableElementReference';
+import type { ModelUnit } from './DSLExternalFormat_ModelUnit';
+import type { PackageableElementVisitor } from '../../PackageableElement';
+import { DSL_EXTERNAL_FORMAT_HASH_STRUCTURE } from '../../../../../DSLExternalFormat_ModelUtils';
+
+export class Binding extends Store implements Hashable {
+  schemaSet!: OptionalPackageableElementReference<SchemaSet>;
+  schemaId?: string | undefined;
+  contentType!: string;
+  modelUnit!: ModelUnit;
+
+  constructor(name: string) {
+    super(name);
+
+    makeObservable<Binding, '_elementHashCode'>(this, {
+      schemaSet: observable,
+      schemaId: observable,
+      contentType: observable,
+      modelUnit: observable,
+      setSchemaSet: action,
+      setSchemaId: action,
+      setContentType: action,
+      setModelUnit: action,
+      _elementHashCode: override,
+    });
+  }
+
+  setSchemaSet(value: SchemaSet | undefined): void {
+    this.schemaSet.setValue(value);
+  }
+
+  setSchemaId(value: string | undefined): void {
+    this.schemaId = value;
+  }
+
+  setContentType(value: string): void {
+    this.contentType = value;
+  }
+
+  setModelUnit(value: ModelUnit): void {
+    this.modelUnit = value;
+  }
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      DSL_EXTERNAL_FORMAT_HASH_STRUCTURE.BINDING,
+      this.path,
+      this.schemaSet.valueForSerialization ?? '',
+      this.schemaId ?? '',
+      this.contentType,
+      this.modelUnit,
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}

package/src/models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_ModelUnit.ts

@@ -0,0 +1,98 @@
+/**
+ * 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, computed, makeObservable, action } from 'mobx';
+import {
+  type Hashable,
+  addUniqueEntry,
+  changeEntry,
+  deleteEntry,
+  hashArray,
+} from '@finos/legend-shared';
+import type { PackageableElementReference } from '../../PackageableElementReference';
+import type { PackageableElement } from '../../PackageableElement';
+import { DSL_EXTERNAL_FORMAT_HASH_STRUCTURE } from '../../../../../DSLExternalFormat_ModelUtils';
+
+export class ModelUnit implements Hashable {
+  packageableElementIncludes: PackageableElementReference<PackageableElement>[] =
+    [];
+  packageableElementExcludes: PackageableElementReference<PackageableElement>[] =
+    [];
+
+  constructor() {
+    makeObservable(this, {
+      packageableElementIncludes: observable,
+      packageableElementExcludes: observable,
+      hashCode: computed,
+      addPackageableElementIncludes: action,
+      deletePackageableElementIncludes: action,
+      updatePackageableElementIncludes: action,
+      addPackageableElementExcludes: action,
+      deletePackageableElementExcludes: action,
+      updatePackageableElementExcludes: action,
+    });
+  }
+
+  addPackageableElementIncludes(
+    value: PackageableElementReference<PackageableElement>,
+  ): void {
+    addUniqueEntry(this.packageableElementIncludes, value);
+  }
+
+  deletePackageableElementIncludes(
+    value: PackageableElementReference<PackageableElement>,
+  ): void {
+    deleteEntry(this.packageableElementIncludes, value);
+  }
+
+  updatePackageableElementIncludes(
+    oldValue: PackageableElementReference<PackageableElement>,
+    newValue: PackageableElementReference<PackageableElement>,
+  ): void {
+    changeEntry(this.packageableElementIncludes, oldValue, newValue);
+  }
+
+  addPackageableElementExcludes(
+    value: PackageableElementReference<PackageableElement>,
+  ): void {
+    addUniqueEntry(this.packageableElementExcludes, value);
+  }
+
+  deletePackageableElementExcludes(
+    value: PackageableElementReference<PackageableElement>,
+  ): void {
+    deleteEntry(this.packageableElementExcludes, value);
+  }
+
+  updatePackageableElementExcludes(
+    oldValue: PackageableElementReference<PackageableElement>,
+    newValue: PackageableElementReference<PackageableElement>,
+  ): void {
+    changeEntry(this.packageableElementExcludes, oldValue, newValue);
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      DSL_EXTERNAL_FORMAT_HASH_STRUCTURE.MODEL_UNIT,
+      hashArray(
+        this.packageableElementIncludes.map((element) => element.hashValue),
+      ),
+      hashArray(
+        this.packageableElementExcludes.map((element) => element.hashValue),
+      ),
+    ]);
+  }
+}

package/src/models/metamodels/pure/packageableElements/mapping/MergeOperationSetImplementation.ts

@@ -0,0 +1,81 @@
+/**
+ * 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, makeObservable } from 'mobx';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+import type { PackageableElementReference } from '../PackageableElementReference';
+import type { Mapping } from './Mapping';
+import type { Class } from '../domain/Class';
+import type { InferableMappingElementIdValue } from './InferableMappingElementId';
+import type { InferableMappingElementRoot } from './InferableMappingElementRoot';
+import {
+  type OperationType,
+  OperationSetImplementation,
+} from './OperationSetImplementation';
+import type { Stubable } from '../../../../../helpers/Stubable';
+import type { RawLambda } from '../../rawValueSpecification/RawLambda';
+import type { SetImplementationVisitor } from './SetImplementation';
+import { hashLambda } from '../../../../../MetaModelUtils';
+
+export class MergeOperationSetImplementation
+  extends OperationSetImplementation
+  implements Hashable, Stubable
+{
+  validationFunction: RawLambda;
+
+  constructor(
+    id: InferableMappingElementIdValue,
+    parent: Mapping,
+    pureClass: PackageableElementReference<Class>,
+    root: InferableMappingElementRoot,
+    operation: OperationType,
+    validationFunction: RawLambda,
+  ) {
+    super(id, parent, pureClass, root, operation);
+
+    makeObservable(this, {
+      validationFunction: observable,
+      setValidationFunction: action,
+    });
+
+    this.validationFunction = validationFunction;
+  }
+
+  setValidationFunction(value: RawLambda): void {
+    this.validationFunction = value;
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.OPERATION_SET_IMPLEMENTATION,
+      this.operation,
+      hashArray(
+        this.parameters.map((param) => param.setImplementation.value.id.value),
+      ),
+      hashLambda(
+        this.validationFunction.parameters,
+        this.validationFunction.body,
+      ),
+    ]);
+  }
+
+  override accept_SetImplementationVisitor<T>(
+    visitor: SetImplementationVisitor<T>,
+  ): T {
+    return visitor.visit_MergeOperationSetImplementation(this);
+  }
+}

package/src/models/metamodels/pure/packageableElements/mapping/OperationSetImplementation.ts

@@ -40,7 +40,7 @@ export enum OperationType {
   STORE_UNION = 'STORE_UNION',
   ROUTER_UNION = 'ROUTER_UNION',
   INHERITANCE = 'INHERITANCE',
-  // MERGE = 'MERGE',
+  MERGE = 'MERGE',
 }
 
 export const getClassMappingOperationType = (value: string): OperationType =>

package/src/models/metamodels/pure/packageableElements/mapping/SetImplementation.ts

@@ -42,9 +42,13 @@ import {
 } from './InferableMappingElementRoot';
 import type { AggregationAwareSetImplementation } from './aggregationAware/AggregationAwareSetImplementation';
 import type { InstanceSetImplementation } from './InstanceSetImplementation';
+import type { MergeOperationSetImplementation } from './MergeOperationSetImplementation';
 
 export interface SetImplementationVisitor<T> {
   visit_SetImplementation(setImplementation: InstanceSetImplementation): T;
+  visit_MergeOperationSetImplementation(
+    setImplementation: MergeOperationSetImplementation,
+  ): T;
   visit_OperationSetImplementation(
     setImplementation: OperationSetImplementation,
   ): T;
@@ -148,6 +152,7 @@ export enum BASIC_SET_IMPLEMENTATION_TYPE {
 
 export enum SET_IMPLEMENTATION_TYPE {
   OPERATION = 'operation',
+  MERGE_OPERATION = 'mergeOperation',
   PUREINSTANCE = 'pureInstance',
   FLAT_DATA = 'flatData',
   EMBEDDED_FLAT_DATA = 'embeddedFlatData',

package/src/models/metamodels/pure/packageableElements/store/relational/connection/DatasourceSpecification.ts

@@ -345,25 +345,43 @@ export class RedshiftDatasourceSpecification
   extends DatasourceSpecification
   implements Hashable
 {
+  clusterID: string;
   databaseName: string;
-  endpoint: string;
+  host: string;
   port: number;
+  region: string;
+  endpointURL: string;
 
-  constructor(databaseName: string, endpoint: string, port: number) {
+  constructor(
+    databaseName: string,
+    endpointURL: string,
+    port: number,
+    host: string,
+    clusterID: string,
+    region: string,
+  ) {
     super();
 
     makeObservable(this, {
       databaseName: observable,
-      endpoint: observable,
+      endpointURL: observable,
       port: observable,
+      region: observable,
+      clusterID: observable,
+      host: observable,
       hashCode: computed,
       setDatabaseName: action,
-      setEndpoint: action,
+      setEndpointURL: action,
       setPort: action,
+      setRegion: action,
+      setClusterID: action,
+      setHost: action,
     });
-
+    this.clusterID = clusterID;
+    this.region = region;
+    this.host = host;
     this.databaseName = databaseName;
-    this.endpoint = endpoint;
+    this.endpointURL = endpointURL;
     this.port = port;
   }
 
@@ -371,20 +389,33 @@ export class RedshiftDatasourceSpecification
     this.databaseName = val;
   }
 
-  setEndpoint(val: string): void {
-    this.endpoint = val;
+  setEndpointURL(val: string): void {
+    this.endpointURL = val;
   }
 
   setPort(val: number): void {
     this.port = val;
   }
+  setRegion(val: string): void {
+    this.region = val;
+  }
 
+  setHost(val: string): void {
+    this.host = val;
+  }
+
+  setClusterID(val: string): void {
+    this.clusterID = val;
+  }
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.REDSHIFT_DATASOURCE_SPECIFICATION,
       this.databaseName,
-      this.endpoint,
+      this.endpointURL,
       this.port.toString(),
+      this.clusterID,
+      this.host,
+      this.region,
     ]);
   }
 }

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/RelationalPropertyMapping.ts

@@ -30,6 +30,7 @@ import {
   isStubRelationalOperationElement,
   type RawRelationalOperationElement,
 } from '../model/RawRelationalOperationElement';
+import type { BindingTransformer } from '../../../externalFormat/store/BindingTransformer';
 
 export class RelationalPropertyMapping
   extends PropertyMapping
@@ -37,6 +38,7 @@ export class RelationalPropertyMapping
 {
   transformer?: EnumerationMapping | undefined;
   relationalOperation!: RawRelationalOperationElement; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process relational operation element
+  bindingTransformer?: BindingTransformer | undefined;
 
   constructor(
     owner: PropertyMappingsImplementation,
@@ -49,6 +51,8 @@ export class RelationalPropertyMapping
     makeObservable(this, {
       transformer: observable,
       relationalOperation: observable.ref,
+      bindingTransformer: observable,
+      setBindingTransformer: action,
       setTransformer: action,
       hashCode: computed,
     });
@@ -58,6 +62,10 @@ export class RelationalPropertyMapping
     this.transformer = value;
   }
 
+  setBindingTransformer(value: BindingTransformer | undefined): void {
+    this.bindingTransformer = value;
+  }
+
   accept_PropertyMappingVisitor<T>(visitor: PropertyMappingVisitor<T>): T {
     return visitor.visit_RelationalPropertyMapping(this);
   }
@@ -71,6 +79,7 @@ export class RelationalPropertyMapping
       CORE_HASH_STRUCTURE.REALTIONAL_PROPERTY_MAPPING,
       super.hashCode,
       this.transformer?.id.value ?? '',
+      this.bindingTransformer ?? '',
       hashObjectWithoutSourceInformation(this.relationalOperation),
     ]);
   }

package/src/models/metamodels/pure/packageableElements/store/relational/model/RelationalDataType.ts

@@ -315,3 +315,17 @@ export class Real extends RelationalDataType {
     return hashArray([CORE_HASH_STRUCTURE.RELATIONAL_DATATYPE_REAL]);
   }
 }
+
+export class SemiStructured extends RelationalDataType {
+  constructor() {
+    super();
+
+    makeObservable(this, {
+      hashCode: computed,
+    });
+  }
+
+  get hashCode(): string {
+    return hashArray([CORE_HASH_STRUCTURE.RELATIONAL_DATATYPE_SEMISTRUCTURED]);
+  }
+}