@finos/legend-query-builder 4.14.30 → 4.14.31

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.ts

@@ -28,6 +28,7 @@ import {
   V1_RawLambda,
   VariableExpression,
   PrimitiveInstanceValue,
+  ColSpecArrayInstance,
 } from '@finos/legend-graph';
 import {
   assertNonNullable,
@@ -44,7 +45,10 @@ import {
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
   QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '../../../../graph/QueryBuilderMetaModelConst.js';
-import type { QueryBuilderState } from '../../../QueryBuilderState.js';
+import {
+  QUERY_BUILDER_LAMBDA_WRITER_MODE,
+  type QueryBuilderState,
+} from '../../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderStateBuilder.js';
 import {
   extractNullableNumberFromInstanceValue,
@@ -59,11 +63,74 @@ import {
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import { SortColumnState } from '../QueryResultSetModifierState.js';
 
+export const processTypedTDSProjectExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  // check parameters
+  assertTrue(
+    expression.parametersValues.length === 2,
+    `Can't process project() expression: project() expects 2 arguments`,
+  );
+  // update fetch-structure
+  queryBuilderState.fetchStructureState.changeImplementation(
+    FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
+  );
+
+  // check preceding expression
+  const precedingExpression = guaranteeType(
+    expression.parametersValues[0],
+    SimpleFunctionExpression,
+    `Can't process project() expression: only support project() immediately following an expression`,
+  );
+  assertTrue(
+    matchFunctionName(precedingExpression.functionName, [
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
+    ]),
+    `Can't process project() expression: only support project() immediately following either getAll(), filter(), or forWatermark()`,
+  );
+  QueryBuilderValueSpecificationProcessor.process(
+    precedingExpression,
+    parentLambda,
+    queryBuilderState,
+  );
+  // check columns
+  const classInstance = expression.parametersValues[1];
+  assertType(
+    classInstance,
+    ColSpecArrayInstance,
+    `Can't process project() expression: project() expects argument #1 to be a ColSpecArrayInstance`,
+  );
+  queryBuilderState.setLambdaWriteMode(
+    QUERY_BUILDER_LAMBDA_WRITER_MODE.TYPED_FETCH_STRUCTURE,
+  );
+  QueryBuilderValueSpecificationProcessor.processChild(
+    classInstance,
+    expression,
+    parentLambda,
+    queryBuilderState,
+  );
+};
+
 export const processTDSProjectExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
   parentLambda: LambdaFunction,
 ): void => {
+  if (expression.parametersValues.length === 2) {
+    processTypedTDSProjectExpression(
+      expression,
+      queryBuilderState,
+      parentLambda,
+    );
+
+    return;
+  }
   // update fetch-structure
   queryBuilderState.fetchStructureState.changeImplementation(
     FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
@@ -142,6 +209,7 @@ export const processTDSProjectExpression = (
 
 export const processTDSProjectionColumnPropertyExpression = (
   expression: AbstractPropertyExpression,
+  columnName: string | undefined,
   queryBuilderState: QueryBuilderState,
 ): void => {
   if (
@@ -200,7 +268,9 @@ export const processTDSProjectionColumnPropertyExpression = (
     );
 
     tdsState.addColumn(columnState, { skipSorting: true });
-
+    if (columnName) {
+      columnState.setColumnName(columnName);
+    }
     // NOTE: technically we should set the lambda parameter name when we process
     // the lambda, not when we process the lambda body like this, but that requires
     // some setup, so it's easier to do it here. The validation of this should have
@@ -211,6 +281,7 @@ export const processTDSProjectionColumnPropertyExpression = (
 
 export const processTDSProjectionDerivationExpression = (
   value: INTERNAL__UnknownValueSpecification,
+  columnName: string | undefined,
   parentExpression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
 ): void => {
@@ -236,6 +307,9 @@ export const processTDSProjectionDerivationExpression = (
       new RawLambda(rawLambdaProtocol.parameters, rawLambdaProtocol.body),
     );
     projectionState.addColumn(columnState, { skipSorting: true });
+    if (columnName) {
+      columnState.setColumnName(columnName);
+    }
   }
 };
 

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -45,10 +45,14 @@ import {
 } from '../QueryResultSetModifierState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
-import { buildPropertyExpressionChain } from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  buildPropertyExpressionChain,
+  type LambdaFunctionBuilderOption,
+} from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
 import { appendOLAPGroupByState } from '../window/QueryBuilderWindowValueSpecificationBuilder.js';
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
 import { buildTDSSortTypeExpression } from '../QueryBuilderTDSHelper.js';
+import { buildRelationProjection } from './QueryBuilderRelationProjectValueSpecBuidler.js';
 
 const buildSortExpression = (
   sortColumnState: SortColumnState,
@@ -174,15 +178,7 @@ const appendResultSetModifier = (
 export const appendProjection = (
   tdsState: QueryBuilderTDSState,
   lambdaFunction: LambdaFunction,
-  options?: {
-    /**
-     * Set queryBuilderState to `true` when we construct query for execution within the app.
-     * queryBuilderState will make the lambda function building process overrides several query values, such as the row limit.
-     */
-    isBuildingExecutionQuery?: boolean | undefined;
-    keepSourceInformation?: boolean | undefined;
-    isExportingResult?: boolean | undefined;
-  },
+  options?: LambdaFunctionBuilderOption,
 ): void => {
   const queryBuilderState = tdsState.queryBuilderState;
   const precedingExpression = guaranteeNonNullable(
@@ -327,82 +323,95 @@ export const appendProjection = (
     ];
     lambdaFunction.expressionSequence[0] = groupByFunction;
   } else if (tdsState.projectionColumns.length) {
-    // projection
-    const projectFunction = new SimpleFunctionExpression(
-      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT),
-    );
-    const colLambdas = new CollectionInstanceValue(
-      queryBuilderState.graphManagerState.graph.getMultiplicity(
-        tdsState.projectionColumns.length,
-        tdsState.projectionColumns.length,
-      ),
-    );
-    const colAliases = new CollectionInstanceValue(
-      queryBuilderState.graphManagerState.graph.getMultiplicity(
-        tdsState.projectionColumns.length,
-        tdsState.projectionColumns.length,
-      ),
-    );
-    tdsState.projectionColumns.forEach((projectionColumnState) => {
-      // column alias
-      const colAlias = new PrimitiveInstanceValue(
-        GenericTypeExplicitReference.create(
-          new GenericType(PrimitiveType.STRING),
+    if (!tdsState.queryBuilderState.isFetchStructureTyped) {
+      // projection
+      const projectFunction = new SimpleFunctionExpression(
+        extractElementNameFromPath(
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
         ),
       );
-      colAlias.values.push(projectionColumnState.columnName);
-      colAliases.values.push(colAlias);
-
-      // column projection
-      let columnLambda: ValueSpecification;
-      if (
-        projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
-      ) {
-        columnLambda = buildGenericLambdaFunctionInstanceValue(
-          projectionColumnState.lambdaParameterName,
-          [
-            buildPropertyExpressionChain(
-              projectionColumnState.propertyExpressionState.propertyExpression,
-              projectionColumnState.propertyExpressionState.queryBuilderState,
-              projectionColumnState.lambdaParameterName,
-              options,
-            ),
-          ],
-          queryBuilderState.graphManagerState.graph,
+      const colLambdas = new CollectionInstanceValue(
+        queryBuilderState.graphManagerState.graph.getMultiplicity(
+          tdsState.projectionColumns.length,
+          tdsState.projectionColumns.length,
+        ),
+      );
+      const colAliases = new CollectionInstanceValue(
+        queryBuilderState.graphManagerState.graph.getMultiplicity(
+          tdsState.projectionColumns.length,
+          tdsState.projectionColumns.length,
+        ),
+      );
+      tdsState.projectionColumns.forEach((projectionColumnState) => {
+        // column alias
+        const colAlias = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.STRING),
+          ),
         );
-      } else if (
-        projectionColumnState instanceof
-        QueryBuilderDerivationProjectionColumnState
-      ) {
-        columnLambda = new INTERNAL__UnknownValueSpecification(
-          V1_serializeRawValueSpecification(
-            V1_transformRawLambda(
-              projectionColumnState.lambda,
-              new V1_GraphTransformerContextBuilder(
-                // TODO?: do we need to include the plugins here?
-                [],
-              )
-                .withKeepSourceInformationFlag(
-                  Boolean(options?.keepSourceInformation),
+        colAlias.values.push(projectionColumnState.columnName);
+        colAliases.values.push(colAlias);
+
+        // column projection
+        let columnLambda: ValueSpecification;
+        if (
+          projectionColumnState instanceof
+          QueryBuilderSimpleProjectionColumnState
+        ) {
+          columnLambda = buildGenericLambdaFunctionInstanceValue(
+            projectionColumnState.lambdaParameterName,
+            [
+              buildPropertyExpressionChain(
+                projectionColumnState.propertyExpressionState
+                  .propertyExpression,
+                projectionColumnState.propertyExpressionState.queryBuilderState,
+                projectionColumnState.lambdaParameterName,
+                options,
+              ),
+            ],
+            queryBuilderState.graphManagerState.graph,
+          );
+        } else if (
+          projectionColumnState instanceof
+          QueryBuilderDerivationProjectionColumnState
+        ) {
+          columnLambda = new INTERNAL__UnknownValueSpecification(
+            V1_serializeRawValueSpecification(
+              V1_transformRawLambda(
+                projectionColumnState.lambda,
+                new V1_GraphTransformerContextBuilder(
+                  // TODO?: do we need to include the plugins here?
+                  [],
                 )
-                .build(),
+                  .withKeepSourceInformationFlag(
+                    Boolean(options?.keepSourceInformation),
+                  )
+                  .build(),
+              ),
             ),
-          ),
-        );
-      } else {
-        throw new UnsupportedOperationError(
-          `Can't build project() column expression: unsupported projection column state`,
-          projectionColumnState,
-        );
-      }
-      colLambdas.values.push(columnLambda);
-    });
-    projectFunction.parametersValues = [
-      precedingExpression,
-      colLambdas,
-      colAliases,
-    ];
-    lambdaFunction.expressionSequence[0] = projectFunction;
+          );
+        } else {
+          throw new UnsupportedOperationError(
+            `Can't build project() column expression: unsupported projection column state`,
+            projectionColumnState,
+          );
+        }
+        colLambdas.values.push(columnLambda);
+      });
+      projectFunction.parametersValues = [
+        precedingExpression,
+        colLambdas,
+        colAliases,
+      ];
+      lambdaFunction.expressionSequence[0] = projectFunction;
+    } else {
+      const projectFunction = buildRelationProjection(
+        precedingExpression,
+        tdsState,
+        options,
+      );
+      lambdaFunction.expressionSequence[0] = projectFunction;
+    }
   }
 
   // build olapGroupBy

package/src/stores/fetch-structure/tds/projection/QueryBuilderRelationProjectValueSpecBuidler.ts

@@ -0,0 +1,108 @@
+/**
+ * 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 {
+  ColSpecArray,
+  type ValueSpecification,
+  extractElementNameFromPath,
+  SimpleFunctionExpression,
+  ColSpecArrayInstance,
+  Multiplicity,
+  ColSpec,
+  INTERNAL__UnknownValueSpecification,
+  V1_serializeRawValueSpecification,
+  V1_transformRawLambda,
+  V1_GraphTransformerContextBuilder,
+} from '@finos/legend-graph';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
+import {
+  QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from './QueryBuilderProjectionColumnState.js';
+import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
+import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
+import {
+  buildPropertyExpressionChain,
+  type LambdaFunctionBuilderOption,
+} from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+
+export const buildRelationProjection = (
+  precedingExpression: ValueSpecification,
+  tdsState: QueryBuilderTDSState,
+  options?: LambdaFunctionBuilderOption,
+): SimpleFunctionExpression => {
+  const projectFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT),
+  );
+  const queryBuilderState = tdsState.queryBuilderState;
+
+  const instanceVal = new ColSpecArrayInstance(Multiplicity.ONE, undefined);
+
+  const colSepcArray = new ColSpecArray();
+  instanceVal.values = [colSepcArray];
+
+  tdsState.projectionColumns.forEach((projectionColumnState) => {
+    const colSpec = new ColSpec();
+    colSepcArray.colSpecs.push(colSpec);
+    colSpec.name = projectionColumnState.columnName;
+    // column projection
+    let columnLambda: ValueSpecification;
+    if (
+      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+    ) {
+      columnLambda = buildGenericLambdaFunctionInstanceValue(
+        projectionColumnState.lambdaParameterName,
+        [
+          buildPropertyExpressionChain(
+            projectionColumnState.propertyExpressionState.propertyExpression,
+            projectionColumnState.propertyExpressionState.queryBuilderState,
+            projectionColumnState.lambdaParameterName,
+            options,
+          ),
+        ],
+        queryBuilderState.graphManagerState.graph,
+      );
+    } else if (
+      projectionColumnState instanceof
+      QueryBuilderDerivationProjectionColumnState
+    ) {
+      columnLambda = new INTERNAL__UnknownValueSpecification(
+        V1_serializeRawValueSpecification(
+          V1_transformRawLambda(
+            projectionColumnState.lambda,
+            new V1_GraphTransformerContextBuilder(
+              // TODO?: do we need to include the plugins here?
+              [],
+            )
+              .withKeepSourceInformationFlag(
+                Boolean(options?.keepSourceInformation),
+              )
+              .build(),
+          ),
+        ),
+      );
+    } else {
+      throw new UnsupportedOperationError(
+        `Can't build relation project() column expression: unsupported projection column state`,
+        projectionColumnState,
+      );
+    }
+    colSpec.function1 = columnLambda;
+  });
+  projectFunction.parametersValues = [precedingExpression, instanceVal];
+  return projectFunction;
+};

package/src/stores/query-workflow/QueryBuilderWorkFlowState.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 { QueryBuilderState } from '../QueryBuilderState.js';
+
+export interface FetchStructureLayoutConfig {
+  label: string;
+  showInFetchPanel: boolean;
+}
+
+export abstract class QueryBuilderWorkflowState {
+  abstract get showStatusBar(): boolean;
+
+  abstract getFetchStructureLayoutConfig(
+    state: QueryBuilderState,
+  ): FetchStructureLayoutConfig;
+}
+
+export class QueryBuilderAdvancedWorkflowState extends QueryBuilderWorkflowState {
+  get showStatusBar(): boolean {
+    return true;
+  }
+
+  override getFetchStructureLayoutConfig(
+    state: QueryBuilderState,
+  ): FetchStructureLayoutConfig {
+    return {
+      label: 'fetch structure',
+      showInFetchPanel: true,
+    };
+  }
+
+  static INSTANCE = new QueryBuilderAdvancedWorkflowState();
+}
+
+export class QueryBuilderDataBrowserWorkflow extends QueryBuilderWorkflowState {
+  override get showStatusBar(): boolean {
+    return false;
+  }
+
+  override getFetchStructureLayoutConfig(
+    state: QueryBuilderState,
+  ): FetchStructureLayoutConfig {
+    return {
+      label: state.fetchStructureState.implementation.fetchLabel,
+      showInFetchPanel: false,
+    };
+  }
+
+  static readonly INSTANCE = new QueryBuilderDataBrowserWorkflow();
+}

package/src/stores/workflows/FunctionQueryBuilderState.ts

@@ -21,7 +21,7 @@ import type {
 } from '@finos/legend-graph';
 import { ClassQueryBuilderState } from './ClassQueryBuilderState.js';
 import type { QueryBuilderConfig } from '../../graph-manager/QueryBuilderConfig.js';
-import type { QueryBuilderWorkflowState } from '../workflow/QueryBuilderWorkFlowState.js';
+import type { QueryBuilderWorkflowState } from '../query-workflow/QueryBuilderWorkFlowState.js';
 
 // Note: We may want to move it to extend QueryBuilderState directly
 // but for now we will use the same setup as class as class, mapping, runtime are editable

package/src/stores/workflows/MappingQueryBuilderState.ts

@@ -28,7 +28,7 @@ import { getNullableFirstEntry } from '@finos/legend-shared';
 import { renderMappingQueryBuilderSetupPanelContent } from '../../components/workflows/MappingQueryBuilder.js';
 import { QueryBuilderState } from '../QueryBuilderState.js';
 import type { QueryBuilderConfig } from '../../graph-manager/QueryBuilderConfig.js';
-import type { QueryBuilderWorkflowState } from '../workflow/QueryBuilderWorkFlowState.js';
+import type { QueryBuilderWorkflowState } from '../query-workflow/QueryBuilderWorkFlowState.js';
 
 export class MappingQueryBuilderState extends QueryBuilderState {
   readonly onMappingChange?: ((val: Mapping) => void) | undefined;

package/src/stores/workflows/ServiceQueryBuilderState.ts

@@ -34,7 +34,7 @@ import { action, makeObservable, observable } from 'mobx';
 import { renderServiceQueryBuilderSetupPanelContent } from '../../components/workflows/ServiceQueryBuilder.js';
 import { QueryBuilderState } from '../QueryBuilderState.js';
 import type { QueryBuilderConfig } from '../../graph-manager/QueryBuilderConfig.js';
-import type { QueryBuilderWorkflowState } from '../workflow/QueryBuilderWorkFlowState.js';
+import type { QueryBuilderWorkflowState } from '../query-workflow/QueryBuilderWorkFlowState.js';
 
 export type ServiceExecutionContext = {
   key: string;

package/tsconfig.json

@@ -92,6 +92,7 @@
     "./src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeStateBuilder.ts",
     "./src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeUtil.ts",
     "./src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeValueSpecificationBuilder.ts",
+    "./src/stores/fetch-structure/tds/QueryBuilderAdvancedWorkflowState.ts",
     "./src/stores/fetch-structure/tds/QueryBuilderTDSColumnState.ts",
     "./src/stores/fetch-structure/tds/QueryBuilderTDSHelper.ts",
     "./src/stores/fetch-structure/tds/QueryBuilderTDSState.ts",
@@ -134,6 +135,7 @@
     "./src/stores/fetch-structure/tds/projection/QueryBuilderProjectionColumnState.ts",
     "./src/stores/fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.ts",
     "./src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts",
+    "./src/stores/fetch-structure/tds/projection/QueryBuilderRelationProjectValueSpecBuidler.ts",
     "./src/stores/fetch-structure/tds/window/QueryBuilderWindowGroupByOperatorLoader.ts",
     "./src/stores/fetch-structure/tds/window/QueryBuilderWindowState.ts",
     "./src/stores/fetch-structure/tds/window/QueryBuilderWindowStateBuilder.ts",
@@ -170,6 +172,7 @@
     "./src/stores/milestoning/QueryBuilderMilestoningImplementation.ts",
     "./src/stores/milestoning/QueryBuilderMilestoningState.ts",
     "./src/stores/milestoning/QueryBuilderProcessingTemporalMilestoningImplementation.ts",
+    "./src/stores/query-workflow/QueryBuilderWorkFlowState.ts",
     "./src/stores/shared/LambdaEditorState.ts",
     "./src/stores/shared/LambdaParameterState.ts",
     "./src/stores/shared/ValueSpecificationEditorHelper.ts",
@@ -177,7 +180,6 @@
     "./src/stores/watermark/QueryBuilderWatermarkState.ts",
     "./src/stores/watermark/QueryBuilderWatermarkStateBuilder.ts",
     "./src/stores/watermark/QueryBuilderWatermarkValueSpecificationBuilder.ts",
-    "./src/stores/workflow/QueryBuilderWorkFlowState.ts",
     "./src/stores/workflows/ClassQueryBuilderState.ts",
     "./src/stores/workflows/FunctionQueryBuilderState.ts",
     "./src/stores/workflows/MappingQueryBuilderState.ts",

package/lib/stores/workflow/QueryBuilderWorkFlowState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryBuilderWorkFlowState.d.ts","sourceRoot":"","sources":["../../../src/stores/workflow/QueryBuilderWorkFlowState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,8BAAsB,yBAAyB;IAC7C,QAAQ,KAAK,aAAa,IAAI,OAAO,CAAC;CACvC;AAED,qBAAa,iCAAkC,SAAQ,yBAAyB;IAC9E,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED,MAAM,CAAC,QAAQ,oCAA2C;CAC3D"}

package/lib/stores/workflow/QueryBuilderWorkFlowState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryBuilderWorkFlowState.js","sourceRoot":"","sources":["../../../src/stores/workflow/QueryBuilderWorkFlowState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,OAAgB,yBAAyB;CAE9C;AAED,MAAM,OAAO,iCAAkC,SAAQ,yBAAyB;IAC9E,IAAI,aAAa;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,QAAQ,GAAG,IAAI,iCAAiC,EAAE,CAAC"}