@finos/legend-query-builder 1.0.5 → 2.0.0

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),
+    );
   }
 };

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

@@ -15,20 +15,37 @@
  */
 
 import {
+  type ValueSpecification,
+  type LambdaFunction,
+  type PureModel,
   extractElementNameFromPath,
   GenericType,
   GenericTypeExplicitReference,
   matchFunctionName,
   PrimitiveInstanceValue,
   SimpleFunctionExpression,
-  type ValueSpecification,
-  type LambdaFunction,
   GraphFetchTreeInstanceValue,
   PrimitiveType,
+  InstanceValue,
+  Multiplicity,
+  PackageableElementExplicitReference,
+  SUPPORTED_FUNCTIONS,
+  PURE_SERIALIZE_CONFIG_CLASS,
+  CollectionInstanceValue,
+  KeyExpressionInstanceValue,
+  KeyExpression,
 } from '@finos/legend-graph';
-import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
+import {
+  UnsupportedOperationError,
+  guaranteeNonNullable,
+  guaranteeType,
+} from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
-import type { QueryBuilderGraphFetchTreeState } from './QueryBuilderGraphFetchTreeState.js';
+import {
+  GraphFetchExternalFormatSerializationState,
+  GraphFetchPureSerializationState,
+  type QueryBuilderGraphFetchTreeState,
+} from './QueryBuilderGraphFetchTreeState.js';
 import { isGraphFetchTreeDataEmpty } from './QueryBuilderGraphFetchTreeUtil.js';
 
 const appendTakeLimit = (
@@ -79,6 +96,67 @@ const appendTakeLimit = (
   return lambda;
 };
 
+export const buildPureSerializationConfig = (
+  config: Record<PropertyKey, boolean>,
+  graph: PureModel,
+): SimpleFunctionExpression => {
+  const configClass = graph.getClass(PURE_SERIALIZE_CONFIG_CLASS);
+  const newFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(SUPPORTED_FUNCTIONS.NEW),
+  );
+  // build instance
+  const instance = new InstanceValue(Multiplicity.ONE, undefined);
+  instance.values[0] = PackageableElementExplicitReference.create(configClass);
+  // build values
+  const primitiveInstance = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
+  );
+  primitiveInstance.values = [''];
+  const pureConfigCollection = new CollectionInstanceValue(
+    Multiplicity.ONE,
+    undefined,
+  );
+  configClass.properties.forEach((classProperty) => {
+    const property = Object.getOwnPropertyNames(config).find(
+      (p) => p === classProperty.name,
+    );
+    if (property) {
+      const keyExpressionInstance = new KeyExpressionInstanceValue();
+      // key expression
+      const keyInstance = new PrimitiveInstanceValue(
+        GenericTypeExplicitReference.create(
+          new GenericType(PrimitiveType.STRING),
+        ),
+      );
+      keyInstance.values = [property];
+      // primitive
+      const keyPrimitiveInstance = new PrimitiveInstanceValue(
+        GenericTypeExplicitReference.create(
+          new GenericType(classProperty.genericType.value.rawType),
+        ),
+      );
+      keyPrimitiveInstance.values = [config[property]];
+      const keyExpression = new KeyExpression(
+        keyInstance,
+        keyPrimitiveInstance,
+        false,
+      );
+      keyExpressionInstance.values = [keyExpression];
+      pureConfigCollection.values.push(keyExpressionInstance);
+    }
+  });
+  pureConfigCollection.multiplicity = new Multiplicity(
+    pureConfigCollection.values.length,
+    pureConfigCollection.values.length,
+  );
+  newFunction.parametersValues = [
+    instance,
+    primitiveInstance,
+    pureConfigCollection,
+  ];
+  return newFunction;
+};
+
 export const appendGraphFetch = (
   graphFetchTreeState: QueryBuilderGraphFetchTreeState,
   lambdaFunction: LambdaFunction,
@@ -97,30 +175,94 @@ export const appendGraphFetch = (
     `Can't build graph-fetch tree expression: preceding expression is not defined`,
   );
 
-  // build graph-fetch tree
-  if (
-    graphFetchTreeState.treeData &&
-    !isGraphFetchTreeDataEmpty(graphFetchTreeState.treeData)
+  const seriaizationState = graphFetchTreeState.serializationState;
+  if (seriaizationState instanceof GraphFetchPureSerializationState) {
+    // build graph-fetch tree
+    if (
+      graphFetchTreeState.treeData &&
+      !isGraphFetchTreeDataEmpty(graphFetchTreeState.treeData)
+    ) {
+      const graphFetchInstance = new GraphFetchTreeInstanceValue();
+      graphFetchInstance.values = [graphFetchTreeState.treeData.tree];
+      const serializeFunction = new SimpleFunctionExpression(
+        extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE),
+      );
+      const graphFetchFunc = new SimpleFunctionExpression(
+        graphFetchTreeState.isChecked
+          ? extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
+            )
+          : extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
+            ),
+      );
+      graphFetchFunc.parametersValues = [
+        precedingExpression,
+        graphFetchInstance,
+      ];
+      serializeFunction.parametersValues = [graphFetchFunc, graphFetchInstance];
+      if (seriaizationState.config) {
+        const configFunction = buildPureSerializationConfig(
+          seriaizationState.config as unknown as Record<PropertyKey, boolean>,
+          graphFetchTreeState.queryBuilderState.graphManagerState.graph,
+        );
+        serializeFunction.parametersValues.push(configFunction);
+      }
+      lambdaFunction.expressionSequence[0] = serializeFunction;
+    }
+  } else if (
+    seriaizationState instanceof GraphFetchExternalFormatSerializationState
   ) {
-    const graphFetchInstance = new GraphFetchTreeInstanceValue();
-    graphFetchInstance.values = [graphFetchTreeState.treeData.tree];
-    const serializeFunction = new SimpleFunctionExpression(
-      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE),
+    const externalizeFunction = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXTERNALIZE),
     );
-    const graphFetchFunc = new SimpleFunctionExpression(
-      graphFetchTreeState.isChecked
-        ? extractElementNameFromPath(
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
-          )
-        : extractElementNameFromPath(
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
-          ),
+    const mainGraphTree = graphFetchTreeState.treeData;
+    const externalizeTree = seriaizationState.treeData;
+    if (
+      mainGraphTree &&
+      externalizeTree &&
+      !isGraphFetchTreeDataEmpty(mainGraphTree) &&
+      !isGraphFetchTreeDataEmpty(externalizeTree)
+    ) {
+      // 0th param
+      const graphFetchInstance = new GraphFetchTreeInstanceValue();
+      graphFetchInstance.values = [mainGraphTree.tree];
+      const graphFetchFunc = new SimpleFunctionExpression(
+        graphFetchTreeState.isChecked
+          ? extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
+            )
+          : extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
+            ),
+      );
+      graphFetchFunc.parametersValues = [
+        precedingExpression,
+        graphFetchInstance,
+      ];
+      // 1st param
+      const bindingInstance = new InstanceValue(Multiplicity.ONE, undefined);
+      bindingInstance.values = [
+        PackageableElementExplicitReference.create(
+          seriaizationState.targetBinding,
+        ),
+      ];
+      // 2nd parameter
+      const xtGraphFetchInstance = new GraphFetchTreeInstanceValue();
+      xtGraphFetchInstance.values = [externalizeTree.tree];
+      // build externalize
+      externalizeFunction.parametersValues = [
+        graphFetchFunc,
+        bindingInstance,
+        xtGraphFetchInstance,
+      ];
+      lambdaFunction.expressionSequence[0] = externalizeFunction;
+    }
+  } else {
+    throw new UnsupportedOperationError(
+      `Unsupported serialization state ${seriaizationState.getLabel()}`,
     );
-    graphFetchFunc.parametersValues = [precedingExpression, graphFetchInstance];
-    serializeFunction.parametersValues = [graphFetchFunc, graphFetchInstance];
-    lambdaFunction.expressionSequence[0] = serializeFunction;
   }
-
   // build result set modifier: i.e. preview limit
   if (options?.isBuildingExecutionQuery) {
     appendTakeLimit(lambdaFunction, queryBuilderState.resultState.previewLimit);

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -135,6 +135,7 @@ export class QueryBuilderTDSState
       addColumn: action,
       moveColumn: action,
       replaceColumn: action,
+      initialize: action,
       setShowPostFilterPanel: action,
       setShowWindowFuncPanel: action,
       convertDerivationProjectionObjects: flow,
@@ -294,6 +295,12 @@ export class QueryBuilderTDSState
     );
   }
 
+  override initialize(): void {
+    this.queryBuilderState.filterState.setShowPanel(true);
+    this.setShowPostFilterPanel(false);
+    this.setShowWindowFuncPanel(false);
+  }
+
   isColumnInUse(tdsCol: QueryBuilderTDSColumnState): boolean {
     return Boolean(
       [