@finos/legend-query-builder 1.0.6 → 2.0.1

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -24,6 +24,7 @@ import {
   PackageableElementExplicitReference,
   RootGraphFetchTree,
   getAllSuperclasses,
+  type Binding,
 } from '@finos/legend-graph';
 import {
   type QueryBuilderGraphFetchTreeData,
@@ -54,6 +55,145 @@ import {
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
 import { isValueExpressionReferencedInValue } from '../../QueryBuilderValueSpecificationHelper.js';
 
+export enum SERIALIZATION_TYPE {
+  PURE = 'PURE',
+  EXTERNAL_FORMAT = 'EXTERNAL_FORMAT',
+}
+
+const DEFAULT_PURE_CONFIG_TYPE_NAME = '@type';
+
+export class PureSerializationConfig {
+  typeKeyName: string;
+  includeType: boolean;
+  includeEnumType: boolean;
+  removePropertiesWithNullValues: boolean;
+  removePropertiesWithEmptySets: boolean;
+  fullyQualifiedTypePath: boolean;
+  includeObjectReference: boolean;
+
+  constructor() {
+    // default values
+    this.typeKeyName = DEFAULT_PURE_CONFIG_TYPE_NAME;
+    this.includeType = true;
+    this.includeEnumType = true;
+    this.removePropertiesWithNullValues = true;
+    this.removePropertiesWithEmptySets = false;
+    this.fullyQualifiedTypePath = true;
+    this.includeObjectReference = false;
+    makeObservable(this, {
+      typeKeyName: observable,
+      includeType: observable,
+      includeEnumType: observable,
+      removePropertiesWithNullValues: observable,
+      removePropertiesWithEmptySets: observable,
+      fullyQualifiedTypePath: observable,
+      includeObjectReference: observable,
+      setTypeName: action,
+      setIncludeObjectReference: action,
+      setIncludeType: action,
+      setFullyQualifiedTypePath: action,
+      setRemovePropertiesWithEmptySets: action,
+      setInclueEnumType: action,
+      setRemovePropertiesWithNullValues: action,
+    });
+  }
+
+  setTypeName(val: string): void {
+    this.typeKeyName = val;
+  }
+
+  setIncludeType(val: boolean): void {
+    this.includeType = val;
+  }
+
+  setInclueEnumType(val: boolean): void {
+    this.includeEnumType = val;
+  }
+
+  setRemovePropertiesWithNullValues(val: boolean): void {
+    this.removePropertiesWithNullValues = val;
+  }
+
+  setRemovePropertiesWithEmptySets(val: boolean): void {
+    this.removePropertiesWithEmptySets = val;
+  }
+
+  setFullyQualifiedTypePath(val: boolean): void {
+    this.fullyQualifiedTypePath = val;
+  }
+
+  setIncludeObjectReference(val: boolean): void {
+    this.includeObjectReference = val;
+  }
+}
+
+export abstract class GraphFetchSerializationState {
+  readonly queryBuilderGraphFetchTreeState: QueryBuilderGraphFetchTreeState;
+
+  constructor(graphFetchTreeState: QueryBuilderGraphFetchTreeState) {
+    this.queryBuilderGraphFetchTreeState = graphFetchTreeState;
+  }
+
+  abstract getLabel(): string;
+}
+
+export class GraphFetchPureSerializationState extends GraphFetchSerializationState {
+  config: PureSerializationConfig | undefined;
+  configModal = false;
+
+  constructor(graphFetchTreeState: QueryBuilderGraphFetchTreeState) {
+    super(graphFetchTreeState);
+    makeObservable(this, {
+      config: observable,
+      configModal: observable,
+      setConfigModal: action,
+    });
+  }
+
+  setConfig(value: PureSerializationConfig | undefined): void {
+    this.config = value;
+  }
+
+  setConfigModal(val: boolean): void {
+    this.configModal = val;
+  }
+
+  override getLabel(): string {
+    return SERIALIZATION_TYPE.PURE;
+  }
+}
+
+export class GraphFetchExternalFormatSerializationState extends GraphFetchSerializationState {
+  targetBinding: Binding;
+  treeData: QueryBuilderGraphFetchTreeData | undefined;
+
+  constructor(
+    graphFetchTreeState: QueryBuilderGraphFetchTreeState,
+    targetBinding: Binding,
+    treeData: QueryBuilderGraphFetchTreeData | undefined,
+  ) {
+    super(graphFetchTreeState);
+    makeObservable(this, {
+      targetBinding: observable,
+      treeData: observable.ref,
+    });
+    this.targetBinding = targetBinding;
+    this.treeData = treeData;
+  }
+
+  setBinding(value: Binding): void {
+    this.targetBinding = value;
+  }
+
+  setGraphFetchTree(val: QueryBuilderGraphFetchTreeData | undefined): void {
+    this.treeData = val;
+  }
+
+  override getLabel(): string {
+    return SERIALIZATION_TYPE.EXTERNAL_FORMAT;
+  }
+}
+
 export class QueryBuilderGraphFetchTreeState
   extends QueryBuilderFetchStructureImplementationState
   implements Hashable
@@ -66,6 +206,11 @@ export class QueryBuilderGraphFetchTreeState
    */
   isChecked = false;
 
+  /**
+   * Used to describe how the graph fetch tree is serialized to the final result set
+   */
+  serializationState: GraphFetchSerializationState;
+
   constructor(
     queryBuilderState: QueryBuilderState,
     fetchStructureState: QueryBuilderFetchStructureState,
@@ -75,13 +220,18 @@ export class QueryBuilderGraphFetchTreeState
     makeObservable(this, {
       treeData: observable.ref,
       isChecked: observable,
+      serializationState: observable,
       TEMPORARY__showPostFetchStructurePanel: computed,
       setGraphFetchTree: action,
+      setSerializationState: action,
       setChecked: action,
+      initialize: action,
     });
 
     // try to initialize the graph-fetch tree data using the setup class
     this.updateTreeData(this.queryBuilderState.class);
+    // we will default to standard pure serialization with no config
+    this.serializationState = new GraphFetchPureSerializationState(this);
   }
 
   get type(): string {
@@ -143,6 +293,14 @@ export class QueryBuilderGraphFetchTreeState
     return undefined;
   }
 
+  override initialize(): void {
+    this.queryBuilderState.filterState.setShowPanel(true);
+  }
+
+  setSerializationState(val: GraphFetchSerializationState): void {
+    this.serializationState = val;
+  }
+
   setGraphFetchTree(val: QueryBuilderGraphFetchTreeData | undefined): void {
     this.treeData = val;
   }

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeStateBuilder.ts

@@ -15,19 +15,45 @@
  */
 
 import {
+  PrimitiveInstanceValue,
+  type KeyExpression,
+  PRIMITIVE_TYPE,
   type LambdaFunction,
   GraphFetchTreeInstanceValue,
   matchFunctionName,
   RootGraphFetchTree,
   SimpleFunctionExpression,
+  InstanceValue,
+  PackageableElementReference,
+  Binding,
+  SUPPORTED_FUNCTIONS,
+  Class,
+  PURE_SERIALIZE_CONFIG_CLASS,
+  KeyExpressionInstanceValue,
+  CollectionInstanceValue,
+  getClassProperty,
+  PrimitiveType,
 } from '@finos/legend-graph';
-import { assertTrue, guaranteeType } from '@finos/legend-shared';
+import {
+  assertIsBoolean,
+  assertIsString,
+  assertTrue,
+  guaranteeIsString,
+  guaranteeNonNullable,
+  guaranteeType,
+} from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
 import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../QueryBuilderStateBuilder.js';
 import { FETCH_STRUCTURE_IMPLEMENTATION } from '../QueryBuilderFetchStructureImplementationState.js';
-import { QueryBuilderGraphFetchTreeState } from './QueryBuilderGraphFetchTreeState.js';
+import {
+  GraphFetchExternalFormatSerializationState,
+  GraphFetchPureSerializationState,
+  PureSerializationConfig,
+  QueryBuilderGraphFetchTreeState,
+} from './QueryBuilderGraphFetchTreeState.js';
 import { buildGraphFetchTreeData } from './QueryBuilderGraphFetchTreeUtil.js';
+import {} from 'mobx';
 
 export const processGraphFetchExpression = (
   expression: SimpleFunctionExpression,
@@ -77,6 +103,67 @@ export const processGraphFetchExpression = (
   }
 };
 
+type PropertyValue = object | string | number | boolean;
+
+// Dynamically sets key values of config
+// TODO we can further enhance this by making configInstance just a list of key value pairs and using class config definition to render in query builder
+const processKeyExpressionValueOnSerializationConfig = (
+  keyExpression: KeyExpression,
+  configInstance: Record<PropertyKey, PropertyValue>,
+  configClassDef: Class,
+  idx: number,
+): void => {
+  // initial checks
+  const expressionKey = guaranteeType(
+    keyExpression.key,
+    PrimitiveInstanceValue,
+    `Can't process serialize() expression: serialization config key expression ${idx} key expected to be a primitive value`,
+  );
+  assertTrue(
+    expressionKey.genericType.value.rawType.path === PRIMITIVE_TYPE.STRING,
+    `Can't process serialize() expression: serialization config key expression ${idx} key expected to be a primitive string value`,
+  );
+  const keyValue = guaranteeIsString(
+    expressionKey.values[0],
+    `Can't process serialize() expression: serialization config key expression ${idx} expected to be a non-nullable primitive string value`,
+  );
+  // check instance
+  const properties = Object.getOwnPropertyNames(configInstance);
+  guaranteeNonNullable(
+    properties.find((prop) => prop === keyValue),
+    `Property name '${keyValue}' not defined in serialization config, accepted properties are ${properties.join(
+      ',',
+    )}`,
+  );
+  // check class
+  const _classProperty = getClassProperty(configClassDef, keyValue);
+  const _classType = guaranteeType(
+    _classProperty.genericType.value.rawType,
+    PrimitiveType,
+    `Only primitive types suppported for config. Property ${keyValue} for class ${PURE_SERIALIZE_CONFIG_CLASS} is of type ${_classProperty.genericType.value.rawType.path}`,
+  );
+  const expressionValue = guaranteeNonNullable(
+    guaranteeType(
+      keyExpression.expression,
+      PrimitiveInstanceValue,
+      `Can't process serialize() expression: config key expression's value expected to be a primitive instance value`,
+    ).values[0],
+    `Can't process serialize() expression: config key expression's value expected to be a non nullable primitive value`,
+  );
+  // TODO move to separate method and make it more robust
+  switch (_classType.path) {
+    case PRIMITIVE_TYPE.STRING:
+      assertIsString(expressionValue);
+      break;
+    case PRIMITIVE_TYPE.BOOLEAN:
+      assertIsBoolean(expressionValue);
+      break;
+    default:
+      return;
+  }
+  configInstance[keyValue] = expressionValue as PropertyValue;
+};
+
 export const processGraphFetchSerializeExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
@@ -89,8 +176,9 @@ export const processGraphFetchSerializeExpression = (
 
   // check parameters
   assertTrue(
-    expression.parametersValues.length === 2,
-    `Can't process serialize() expression: serialize() expects 1 argument`,
+    expression.parametersValues.length === 2 ||
+      expression.parametersValues.length === 3,
+    `Can't process serialize() expression: serialize() expects 1 or 2 argument`,
   );
 
   // check preceding expression
@@ -132,5 +220,171 @@ export const processGraphFetchSerializeExpression = (
     graphFetchTreeState.setGraphFetchTree(
       buildGraphFetchTreeData(graphFetchTreeRoot),
     );
+
+    const serializeConfigParameter = expression.parametersValues[2];
+    if (serializeConfigParameter) {
+      const pureConfigFunction = guaranteeType(
+        serializeConfigParameter,
+        SimpleFunctionExpression,
+        `Can't process serialize() expression: serialize() function expects a function to configure custom serialization`,
+      );
+      assertTrue(
+        matchFunctionName(pureConfigFunction.functionName, [
+          SUPPORTED_FUNCTIONS.NEW,
+        ]),
+        `Can't process serialize() expression: config expects 'new' function instaniate new config class`,
+      );
+
+      const pureSerializationState = guaranteeType(
+        graphFetchTreeState.serializationState,
+        GraphFetchPureSerializationState,
+        `Can't process serialize() expression: serialization state expected to be of type pure with serialize()`,
+      );
+      // first para: config class
+      const configClass = guaranteeType(
+        guaranteeType(
+          guaranteeType(
+            pureConfigFunction.parametersValues[0],
+            InstanceValue,
+            `Can't process serialize() expression: serialization config expects first param to be an instance value`,
+          ).values[0],
+          PackageableElementReference,
+          `Can't process serialize() expression: serialization config expects first param to be a packageable element`,
+        ).value,
+        Class,
+        `Can't process serialize() expression: serialization config expects first param to be a class`,
+      );
+      assertTrue(
+        configClass.path === PURE_SERIALIZE_CONFIG_CLASS,
+        `Can't process serialize() expression: serialiaztion config class expected to be ${PURE_SERIALIZE_CONFIG_CLASS}, got : ${configClass.path}`,
+      );
+      // 2nd param: empty string
+      // TODO: Investigate why `new` function as the second input as empty string
+
+      // 2rd param: key expression values representing property values of config
+      const collectionInstanceValue = guaranteeType(
+        pureConfigFunction.parametersValues[2],
+        CollectionInstanceValue,
+        `Can't process serialize() expression: serialization config expects third param to be a collection instance of key expressions`,
+      );
+      const serializationConfig = new PureSerializationConfig();
+      collectionInstanceValue.values.forEach((val, idx) => {
+        const keyExpInstance = guaranteeType(
+          val,
+          KeyExpressionInstanceValue,
+          `Can't process serialize() expression: collection instance value expects value ${
+            idx + 1
+          } to be key expression instance `,
+        );
+        const keyExpression = guaranteeNonNullable(
+          keyExpInstance.values[0],
+          `Can't process serialize() expression: serialization config key expression ${idx} expected to non null`,
+        );
+        processKeyExpressionValueOnSerializationConfig(
+          keyExpression,
+          serializationConfig as unknown as Record<PropertyKey, PropertyValue>,
+          configClass,
+          idx,
+        );
+      });
+      pureSerializationState.setConfig(serializationConfig);
+    }
+  }
+};
+
+export const processGraphFetchExternalizeExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  // update fetch-structure
+  queryBuilderState.fetchStructureState.changeImplementation(
+    FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH,
+  );
+
+  // check parameters
+  assertTrue(
+    expression.parametersValues.length === 3,
+    `Can't process externalize() expression: externalize() expects 2 argument`,
+  );
+
+  const precedingExpression = guaranteeType(
+    expression.parametersValues[0],
+    SimpleFunctionExpression,
+    `Can't process externalize() expression: only support externalize() immediately following an expression`,
+  );
+
+  // build preceding expression
+  assertTrue(
+    matchFunctionName(precedingExpression.functionName, [
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
+    ]),
+    `Can't process externalize() expression: only support externalize() in graph-fetch expression`,
+  );
+  QueryBuilderValueSpecificationProcessor.process(
+    precedingExpression,
+    parentLambda,
+    queryBuilderState,
+  );
+
+  // build state
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderGraphFetchTreeState
+  ) {
+    const graphFetchTreeState =
+      queryBuilderState.fetchStructureState.implementation;
+    // TODO: move to graph fetch processing once we completely deattach serialize graph fetch from main graphfetch tree
+    const mainGraphFetchTree = guaranteeType(
+      precedingExpression.parametersValues[1],
+      GraphFetchTreeInstanceValue,
+      `Can't process graphfetch() expression: externalize() graph-fetch is missing`,
+    );
+    const mainGraphFetchTreeRoot = guaranteeType(
+      mainGraphFetchTree.values[0],
+      RootGraphFetchTree,
+      `Can't process graphfetch() expression: graph-fetch tree root is missing`,
+    );
+    graphFetchTreeState.setGraphFetchTree(
+      buildGraphFetchTreeData(mainGraphFetchTreeRoot),
+    );
+
+    // build externalizeState
+    const instanceExpression = guaranteeType(
+      expression.parametersValues[1],
+      InstanceValue,
+      `Can't process externalize() expression: only support externalize() with 1st parameter as instance value`,
+    );
+    const binding = guaranteeType(
+      guaranteeType(
+        instanceExpression.values[0],
+        PackageableElementReference,
+        `Can't process externalize() expression: only support externalize() with 1st parameter as packagableElement value`,
+      ).value,
+      Binding,
+      `Can't process externalize() expression: only support externalize() with 1st parameter as binding value`,
+    );
+
+    const externalizeState = new GraphFetchExternalFormatSerializationState(
+      graphFetchTreeState,
+      binding,
+      undefined,
+    );
+    graphFetchTreeState.setSerializationState(externalizeState);
+
+    const graphFetchTree = guaranteeType(
+      expression.parametersValues[2],
+      GraphFetchTreeInstanceValue,
+      `Can't process externalize() expression: externalize() graph-fetch is missing`,
+    );
+    const graphFetchTreeRoot = guaranteeType(
+      graphFetchTree.values[0],
+      RootGraphFetchTree,
+      `Can't process externalize() expression: externalize() graph-fetch tree root is missing`,
+    );
+    externalizeState.setGraphFetchTree(
+      buildGraphFetchTreeData(graphFetchTreeRoot),
+    );
   }
 };