@finos/legend-extension-dsl-data-quality 1.0.0

package/src/graph-manager/protocol/pure/v1/model/graphFetch/V1_DataQualityRootGraphFetchTree.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 Hashable, hashArray } from '@finos/legend-shared';
+import { DATA_QUALITY_HASH_STRUCTURE } from '../../../../../../graph/metamodel/DSL_DataQuality_HashUtils.js';
+import { V1_RootGraphFetchTree } from '@finos/legend-graph';
+
+export class V1_DataQualityRootGraphFetchTree
+  extends V1_RootGraphFetchTree
+  implements Hashable
+{
+  constraints: string[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_ROOT_GRAPH_FETCH_TREE,
+      hashArray(this.subTrees),
+      hashArray(this.subTypeTrees),
+      hashArray(this.constraints),
+      this.class,
+    ]);
+  }
+}

package/src/graph-manager/protocol/pure/v1/transformation/V1_ValueSpecificationBuilderHelper.ts

@@ -0,0 +1,241 @@
+/**
+ * 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 { V1_DataQualityPropertyGraphFetchTree } from '../model/graphFetch/V1_DataQualityPropertyGraphFetchTree.js';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { V1_DataQualityRootGraphFetchTree } from '../model/graphFetch/V1_DataQualityRootGraphFetchTree.js';
+import {
+  DataQualityPropertyGraphFetchTree,
+  DataQualityRootGraphFetchTree,
+} from '../../../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';
+import {
+  type V1_DataQualityExecutionContext,
+  V1_DataSpaceDataQualityExecutionContext,
+  V1_MappingAndRuntimeDataQualityExecutionContext,
+} from '../V1_DataQualityConstraintsConfiguration.js';
+import {
+  type DataQualityExecutionContext,
+  DataSpaceDataQualityExecutionContext,
+  MappingAndRuntimeDataQualityExecutionContext,
+} from '../../../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import {
+  type V1_GraphBuilderContext,
+  type Class,
+  type GraphFetchTree,
+  type Mapping,
+  type PackageableElementImplicitReference,
+  type PackageableRuntime,
+  type PropertyGraphFetchTree,
+  type RootGraphFetchTree,
+  type V1_GraphFetchTree,
+  type V1_ProcessingContext,
+  type V1_PropertyGraphFetchTree,
+  type V1_RootGraphFetchTree,
+  V1_buildPropertyGraphFetchTree,
+  V1_buildRootGraphFetchTree,
+} from '@finos/legend-graph';
+import type { DataSpace } from '@finos/legend-extension-dsl-data-space/graph';
+
+export function V1_buildDataQualityExecutionContext(
+  dataQualityExecutionContext: V1_DataQualityExecutionContext,
+  graphContext: V1_GraphBuilderContext,
+): DataQualityExecutionContext {
+  if (
+    dataQualityExecutionContext instanceof
+    V1_DataSpaceDataQualityExecutionContext
+  ) {
+    const dataSpaceExecutionContext =
+      new DataSpaceDataQualityExecutionContext();
+    dataSpaceExecutionContext.context = dataQualityExecutionContext.context;
+    dataSpaceExecutionContext.dataSpace = graphContext.resolveElement(
+      dataQualityExecutionContext.dataSpace.path,
+      false,
+    ) as PackageableElementImplicitReference<DataSpace>;
+    return dataSpaceExecutionContext;
+  } else if (
+    dataQualityExecutionContext instanceof
+    V1_MappingAndRuntimeDataQualityExecutionContext
+  ) {
+    const mappingAndRuntimeExecutionContext =
+      new MappingAndRuntimeDataQualityExecutionContext();
+    mappingAndRuntimeExecutionContext.mapping = graphContext.resolveElement(
+      dataQualityExecutionContext.mapping.path,
+      false,
+    ) as PackageableElementImplicitReference<Mapping>;
+    mappingAndRuntimeExecutionContext.runtime = graphContext.resolveElement(
+      dataQualityExecutionContext.runtime.path,
+      false,
+    ) as PackageableElementImplicitReference<PackageableRuntime>;
+    return mappingAndRuntimeExecutionContext;
+  }
+
+  throw new UnsupportedOperationError(
+    `Can't build data quality execution context`,
+    dataQualityExecutionContext,
+  );
+}
+
+export function V1_buildGraphFetchTree(
+  graphFetchTree: V1_GraphFetchTree,
+  context: V1_GraphBuilderContext,
+  parentClass: Class | undefined,
+  openVariables: string[],
+  processingContext: V1_ProcessingContext,
+  canResolveLocalProperty?: boolean | undefined,
+): GraphFetchTree {
+  if (graphFetchTree instanceof V1_DataQualityPropertyGraphFetchTree) {
+    return V1_buildPropertyGraphFetchTree(
+      graphFetchTree,
+      context,
+      guaranteeNonNullable(parentClass),
+      openVariables,
+      processingContext,
+      canResolveLocalProperty,
+    );
+  }
+  if (graphFetchTree instanceof V1_DataQualityRootGraphFetchTree) {
+    return V1_buildRootGraphFetchTree(
+      graphFetchTree,
+      context,
+      openVariables,
+      processingContext,
+      canResolveLocalProperty,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't build graph fetch tree`,
+    graphFetchTree,
+  );
+}
+
+export function V1_buildDataQualityGraphFetchTree(
+  graphFetchTree: V1_GraphFetchTree,
+  context: V1_GraphBuilderContext,
+  parentClass: Class | undefined,
+  openVariables: string[],
+  processingContext: V1_ProcessingContext,
+  canResolveLocalProperty?: boolean | undefined,
+): GraphFetchTree {
+  const _graphFetchTree = V1_buildGraphFetchTree(
+    graphFetchTree,
+    context,
+    parentClass,
+    openVariables,
+    processingContext,
+    canResolveLocalProperty,
+  );
+  return transformGraphFetchTreeToDataQualityGraphFetchTree(
+    _graphFetchTree,
+    graphFetchTree,
+  );
+}
+
+function transformGraphFetchTreeToDataQualityGraphFetchTree(
+  graphFetchTree: GraphFetchTree,
+  V1_graphFetchTree: V1_GraphFetchTree,
+): GraphFetchTree {
+  if (V1_graphFetchTree instanceof V1_DataQualityRootGraphFetchTree) {
+    return transformRootGraphFetchTreeToDataQualityRootGraphFetchTree(
+      graphFetchTree as RootGraphFetchTree,
+      V1_graphFetchTree,
+    );
+  } else if (
+    V1_graphFetchTree instanceof V1_DataQualityPropertyGraphFetchTree
+  ) {
+    return transformPropertyGraphFetchTreeToDataQualityPropertyGraphFetchTree(
+      graphFetchTree as PropertyGraphFetchTree,
+      V1_graphFetchTree,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform graph fetch tree to data quality graph fetch tree`,
+    V1_graphFetchTree,
+  );
+}
+
+function transformRootGraphFetchTreeToDataQualityRootGraphFetchTree(
+  rootGraphFetchTree: RootGraphFetchTree,
+  V1_rootGraphFetchTree: V1_DataQualityRootGraphFetchTree,
+): DataQualityRootGraphFetchTree {
+  const dataQualityRootGraphFetchTree = new DataQualityRootGraphFetchTree(
+    rootGraphFetchTree.class,
+  );
+  dataQualityRootGraphFetchTree.constraints = V1_rootGraphFetchTree.constraints;
+  dataQualityRootGraphFetchTree.subTrees = rootGraphFetchTree.subTrees.map(
+    (_propertyTree, index) =>
+      transformGraphFetchTreeToDataQualityGraphFetchTree(
+        _propertyTree,
+        V1_rootGraphFetchTree.subTrees[index]!,
+      ),
+  );
+  return dataQualityRootGraphFetchTree;
+}
+
+function transformPropertyGraphFetchTreeToDataQualityPropertyGraphFetchTree(
+  propertyGraphFetchTree: PropertyGraphFetchTree,
+  V1_propertyGraphFetchTree: V1_DataQualityPropertyGraphFetchTree,
+): DataQualityPropertyGraphFetchTree {
+  const dataQualityPropertyGraphFetchTree =
+    new DataQualityPropertyGraphFetchTree(
+      propertyGraphFetchTree.property,
+      propertyGraphFetchTree.subType,
+    );
+  dataQualityPropertyGraphFetchTree.alias = propertyGraphFetchTree.alias;
+  dataQualityPropertyGraphFetchTree.parameters =
+    propertyGraphFetchTree.parameters;
+  dataQualityPropertyGraphFetchTree.subTrees =
+    propertyGraphFetchTree.subTrees.map((_propertyTree, index) =>
+      transformGraphFetchTreeToDataQualityGraphFetchTree(
+        _propertyTree,
+        V1_propertyGraphFetchTree.subTrees[index]!,
+      ),
+    );
+  dataQualityPropertyGraphFetchTree.constraints =
+    V1_propertyGraphFetchTree.constraints;
+  return dataQualityPropertyGraphFetchTree;
+}
+export function V1_transformRootGraphFetchTreeToDataQualityRootGraphFetchTree(
+  rootGraphFetchTree: V1_RootGraphFetchTree,
+): V1_DataQualityRootGraphFetchTree {
+  const dataQualityRootGraphFetchTree = new V1_DataQualityRootGraphFetchTree();
+  dataQualityRootGraphFetchTree.class = rootGraphFetchTree.class;
+  dataQualityRootGraphFetchTree.subTrees = rootGraphFetchTree.subTrees.map(
+    (_propertyTree) =>
+      V1_transformPropertyGraphFetchTreeToDataQualityPropertyGraphFetchTree(
+        _propertyTree as V1_PropertyGraphFetchTree,
+      ),
+  );
+  return dataQualityRootGraphFetchTree;
+}
+
+function V1_transformPropertyGraphFetchTreeToDataQualityPropertyGraphFetchTree(
+  graphFetchTree: V1_PropertyGraphFetchTree,
+): V1_DataQualityPropertyGraphFetchTree {
+  const dataQualityPropertyGraphFetchTree =
+    new V1_DataQualityPropertyGraphFetchTree();
+  dataQualityPropertyGraphFetchTree.property = graphFetchTree.property;
+  dataQualityPropertyGraphFetchTree.parameters = graphFetchTree.parameters;
+  dataQualityPropertyGraphFetchTree.subTrees = graphFetchTree.subTrees.map(
+    (_propertyTree) =>
+      V1_transformPropertyGraphFetchTreeToDataQualityPropertyGraphFetchTree(
+        _propertyTree as V1_PropertyGraphFetchTree,
+      ),
+  );
+  return dataQualityPropertyGraphFetchTree;
+}

package/src/graph-manager/protocol/pure/v1/transformation/V1_ValueSpecificationSerializer.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 PureProtocolProcessorPlugin,
+  type V1_GraphFetchTree,
+  V1_deserializeValueSpecification,
+  V1_serializeValueSpecification,
+} from '@finos/legend-graph';
+import { V1_DataQualityRootGraphFetchTree } from '../model/graphFetch/V1_DataQualityRootGraphFetchTree.js';
+import { V1_DataQualityPropertyGraphFetchTree } from '../model/graphFetch/V1_DataQualityPropertyGraphFetchTree.js';
+import {
+  type ModelSchema,
+  custom,
+  deserialize,
+  serialize,
+  createModelSchema,
+  list,
+  optional,
+  primitive,
+} from 'serializr';
+import {
+  type PlainObject,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+} from '@finos/legend-shared';
+
+const DATA_QUALTIY_ROOT_GRAPH_FETCH_TREE_TYPE = 'dataQualityRootGraphFetchTree';
+const DATA_QUALITY_PROPERTY_GRAPH_FETCH_TREE_TYPE =
+  'dataQualityPropertyGraphFetchTree';
+
+const rootGraphFetchTreeModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DataQualityRootGraphFetchTree> =>
+  createModelSchema(V1_DataQualityRootGraphFetchTree, {
+    _type: usingConstantValueSchema(DATA_QUALTIY_ROOT_GRAPH_FETCH_TREE_TYPE),
+    class: primitive(),
+    constraints: list(primitive()),
+    subTrees: list(
+      custom(
+        (val) => V1_serializeGraphFetchTree(val, plugins),
+        (val) => V1_deserializeGraphFetchTree(val, plugins),
+      ),
+    ),
+  });
+
+const propertyGraphFetchTreeModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DataQualityPropertyGraphFetchTree> =>
+  createModelSchema(V1_DataQualityPropertyGraphFetchTree, {
+    _type: usingConstantValueSchema(
+      DATA_QUALITY_PROPERTY_GRAPH_FETCH_TREE_TYPE,
+    ),
+    alias: optional(primitive()),
+    parameters: list(
+      custom(
+        (val) => V1_serializeValueSpecification(val, plugins),
+        (val) => V1_deserializeValueSpecification(val, plugins),
+      ),
+    ),
+    property: primitive(),
+    constraints: list(primitive()),
+    subTrees: list(
+      custom(
+        (val) => V1_serializeGraphFetchTree(val, plugins),
+        (val) => V1_deserializeGraphFetchTree(val, plugins),
+      ),
+    ),
+  });
+
+export function V1_serializeGraphFetchTree(
+  protocol: V1_GraphFetchTree,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_GraphFetchTree> {
+  if (protocol instanceof V1_DataQualityPropertyGraphFetchTree) {
+    return serialize(propertyGraphFetchTreeModelSchema(plugins), protocol);
+  } else if (protocol instanceof V1_DataQualityRootGraphFetchTree) {
+    return serialize(rootGraphFetchTreeModelSchema(plugins), protocol);
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize data quality graph fetch tree`,
+    protocol,
+  );
+}
+
+export function V1_deserializeGraphFetchTree(
+  json: PlainObject<V1_GraphFetchTree>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_GraphFetchTree {
+  switch (json._type) {
+    case DATA_QUALITY_PROPERTY_GRAPH_FETCH_TREE_TYPE:
+      return deserialize(propertyGraphFetchTreeModelSchema(plugins), json);
+    case DATA_QUALTIY_ROOT_GRAPH_FETCH_TREE_TYPE:
+      return deserialize(rootGraphFetchTreeModelSchema(plugins), json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize data quality graph fetch tree node of type '${json._type}'`,
+      );
+  }
+}

package/src/graph-manager/protocol/pure/v1/transformation/V1_ValueSpecificationTransformer.ts

@@ -0,0 +1,139 @@
+/**
+ * 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 GraphFetchTree,
+  type V1_GraphFetchTree,
+  PackageableElementPointerType,
+  V1_PackageableElementPointer,
+  V1_PropertyGraphFetchTree,
+  V1_RootGraphFetchTree,
+  V1_transformGraphFetchTree,
+} from '@finos/legend-graph';
+import { V1_DataQualityRootGraphFetchTree } from '../model/graphFetch/V1_DataQualityRootGraphFetchTree.js';
+import { assertType, UnsupportedOperationError } from '@finos/legend-shared';
+import { V1_DataQualityPropertyGraphFetchTree } from '../model/graphFetch/V1_DataQualityPropertyGraphFetchTree.js';
+import {
+  DataQualityPropertyGraphFetchTree,
+  DataQualityRootGraphFetchTree,
+} from '../../../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';
+import {
+  type DataQualityExecutionContext,
+  DataSpaceDataQualityExecutionContext,
+  MappingAndRuntimeDataQualityExecutionContext,
+} from '../../../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import {
+  type V1_DataQualityExecutionContext,
+  V1_DataSpaceDataQualityExecutionContext,
+  V1_MappingAndRuntimeDataQualityExecutionContext,
+} from '../V1_DataQualityConstraintsConfiguration.js';
+import { DATA_SPACE_ELEMENT_POINTER } from '@finos/legend-extension-dsl-data-space/graph';
+
+export function V1_transformDataQualityGraphFetchTree(
+  value: GraphFetchTree,
+  inScope: string[],
+  open: Map<string, unknown[]>,
+  isParameter: boolean,
+  useAppliedFunction: boolean,
+): V1_GraphFetchTree {
+  const v1_GraphFetchTree = V1_transformGraphFetchTree(
+    value,
+    inScope,
+    open,
+    isParameter,
+    useAppliedFunction,
+  );
+  return V1_transformGraphFetchTreeToDataQualityGraphFetchTree(
+    v1_GraphFetchTree,
+    value,
+  );
+}
+
+export function V1_transformGraphFetchTreeToDataQualityGraphFetchTree(
+  v1_graphFetchTree: V1_GraphFetchTree,
+  graphFetchTree: GraphFetchTree,
+): V1_GraphFetchTree {
+  if (v1_graphFetchTree instanceof V1_RootGraphFetchTree) {
+    assertType(graphFetchTree, DataQualityRootGraphFetchTree);
+    const v1_DataQualityRootGraphFetchTree =
+      new V1_DataQualityRootGraphFetchTree();
+    v1_DataQualityRootGraphFetchTree.class = v1_graphFetchTree.class;
+    v1_DataQualityRootGraphFetchTree.constraints = graphFetchTree.constraints;
+    v1_DataQualityRootGraphFetchTree.subTrees = v1_graphFetchTree.subTrees.map(
+      (subTree, index) =>
+        V1_transformGraphFetchTreeToDataQualityGraphFetchTree(
+          subTree,
+          graphFetchTree.subTrees[index]!,
+        ),
+    );
+    return v1_DataQualityRootGraphFetchTree;
+  }
+  if (v1_graphFetchTree instanceof V1_PropertyGraphFetchTree) {
+    assertType(graphFetchTree, DataQualityPropertyGraphFetchTree);
+    const v1_DataQualityPropertyGraphFetchTree =
+      new V1_DataQualityPropertyGraphFetchTree();
+    v1_DataQualityPropertyGraphFetchTree.alias = v1_graphFetchTree.alias;
+    v1_DataQualityPropertyGraphFetchTree.parameters =
+      v1_graphFetchTree.parameters;
+    v1_DataQualityPropertyGraphFetchTree.property = v1_graphFetchTree.property;
+    v1_DataQualityPropertyGraphFetchTree.subType = v1_graphFetchTree.subType;
+    v1_DataQualityPropertyGraphFetchTree.constraints =
+      graphFetchTree.constraints;
+    v1_DataQualityPropertyGraphFetchTree.subTrees =
+      v1_graphFetchTree.subTrees.map((subTree, index) =>
+        V1_transformGraphFetchTreeToDataQualityGraphFetchTree(
+          subTree,
+          graphFetchTree.subTrees[index]!,
+        ),
+      );
+    return v1_DataQualityPropertyGraphFetchTree;
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform graph fetch tree to data quality graph fetch tree`,
+  );
+}
+
+export function V1_transformDataQualityExecutionContext(
+  value: DataQualityExecutionContext,
+): V1_DataQualityExecutionContext {
+  if (value instanceof DataSpaceDataQualityExecutionContext) {
+    const dataSpaceExecutionContext =
+      new V1_DataSpaceDataQualityExecutionContext();
+    dataSpaceExecutionContext.context = value.context!;
+    dataSpaceExecutionContext.dataSpace = new V1_PackageableElementPointer(
+      DATA_SPACE_ELEMENT_POINTER,
+      value.dataSpace.valueForSerialization ?? '',
+    );
+    return dataSpaceExecutionContext;
+  } else if (value instanceof MappingAndRuntimeDataQualityExecutionContext) {
+    const mappingAndRuntimeExecutionContext =
+      new V1_MappingAndRuntimeDataQualityExecutionContext();
+    mappingAndRuntimeExecutionContext.mapping =
+      new V1_PackageableElementPointer(
+        PackageableElementPointerType.MAPPING,
+        value.mapping.valueForSerialization ?? '',
+      );
+    mappingAndRuntimeExecutionContext.runtime =
+      new V1_PackageableElementPointer(
+        PackageableElementPointerType.RUNTIME,
+        value.runtime.valueForSerialization ?? '',
+      );
+    return mappingAndRuntimeExecutionContext;
+  }
+  throw new UnsupportedOperationError(
+    `Can't build data quality execution context '${value.toString()}'`,
+  );
+}