@eagleoutice/flowr 2.1.10 → 2.1.11

package/cli/flowr.js

@@ -21,6 +21,7 @@ const core_1 = require("./repl/core");
 const repl_version_1 = require("./repl/commands/repl-version");
 const print_version_1 = require("./repl/print-version");
 const flowr_main_options_1 = require("./flowr-main-options");
+const fs_1 = __importDefault(require("fs"));
 exports.toolName = 'flowr';
 exports.optionHelp = [
     {
@@ -59,6 +60,13 @@ if (options['config-json']) {
     }
 }
 if (!usedConfig) {
+    if (options['config-file']) {
+        // validate it exists
+        if (!fs_1.default.existsSync(options['config-file'])) {
+            log_1.log.error(`Config file '${options['config-file']}' does not exist`);
+            process.exit(1);
+        }
+    }
     (0, config_1.setConfigFile)(options['config-file'] ?? flowr_main_options_1.defaultConfigFile, undefined, true);
 }
 function retrieveShell() {

package/cli/repl/commands/repl-query.js

@@ -21,8 +21,10 @@ function printHelp(output) {
     output.stdout('The query is an array of query objects to represent multiple queries. Each query object may have the following properties:');
     output.stdout((0, schema_1.describeSchema)((0, query_1.AnyQuerySchema)(), output.formatter));
     output.stdout(`\n\nThe example ${(0, ansi_1.italic)(':query "[{\\"type\\": \\"call-context\\", \\"callName\\": \\"mean\\" }]" mean(1:10)', output.formatter)} would return the call context of the mean function.`);
-    output.stdout('As a convenience, we interpret any (non-help) string not starting with \'[\' as a regex for the simple call-context query.');
+    output.stdout('As a convenience, we interpret any (non-help, non-@) string not starting with \'[\' as a regex for the simple call-context query.');
     output.stdout(`Hence, ${(0, ansi_1.italic)(':query "mean" mean(1:10)', output.formatter)} is equivalent to the above example.`);
+    output.stdout(`Similarly, '@<type>' is interpreted as a query of the given type.`);
+    output.stdout(`With this, ${(0, ansi_1.italic)(':query @config', output.formatter)} prints the result of the config query.`);
 }
 async function processQueryArgs(line, shell, output) {
     const args = (0, args_1.splitAtEscapeSensitive)(line);
@@ -36,7 +38,16 @@ async function processQueryArgs(line, shell, output) {
         return;
     }
     let parsedQuery = [];
-    if (query.startsWith('[')) {
+    if (query.startsWith('@')) {
+        parsedQuery = [{ type: query.slice(1) }];
+        const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
+        if (validationResult.error) {
+            output.stderr(`Invalid query: ${validationResult.error.message}`);
+            printHelp(output);
+            return;
+        }
+    }
+    else if (query.startsWith('[')) {
         parsedQuery = JSON.parse(query);
         const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
         if (validationResult.error) {

package/dataflow/environments/resolve-by-name.d.ts

@@ -11,7 +11,8 @@ import type { DataflowGraph } from '../graph/graph';
  * @param environment  - The current environment used for name resolution
  * @param target       - The target (meta) type of the identifier to resolve
  *
- * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
+ * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
+ *          if the identifier is undefined in the current scope/with the current environment information.
  */
 export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target?: ReferenceType): IdentifierDefinition[] | undefined;
 export declare function resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;

package/dataflow/environments/resolve-by-name.js

@@ -35,7 +35,8 @@ const TargetTypePredicate = {
  * @param environment  - The current environment used for name resolution
  * @param target       - The target (meta) type of the identifier to resolve
  *
- * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
+ * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
+ *          if the identifier is undefined in the current scope/with the current environment information.
  */
 function resolveByName(name, environment, target = identifier_1.ReferenceType.Unknown) {
     let current = environment.current;

package/dataflow/internal/process/functions/call/built-in/built-in-access.js

@@ -13,6 +13,7 @@ const built_in_assignment_1 = require("./built-in-assignment");
 const identifier_1 = require("../../../../../environments/identifier");
 const vertex_1 = require("../../../../../graph/vertex");
 const list_access_1 = require("../../../../../../util/list-access");
+const config_1 = require("../../../../../../config");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
     return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
@@ -147,34 +148,36 @@ function processStringBasedAccess(args, data, name, rootId, config) {
     if (accessedArg === undefined || accessArg === undefined) {
         return fnCall;
     }
-    let accessedIndicesCollection;
-    // If the accessedArg is a symbol, it's either a simple access or the base case of a nested access
-    if (accessedArg.value?.type === type_1.RType.Symbol) {
-        accessedIndicesCollection = (0, list_access_1.resolveSingleIndex)(accessedArg, accessArg, data.environment);
-    }
-    else {
-        // Higher access call
-        const underlyingAccessId = accessedArg.value?.info.id ?? -1;
-        const vertex = fnCall.information.graph.getVertex(underlyingAccessId);
-        const subIndices = vertex?.indicesCollection
-            ?.flatMap(indices => indices.indices)
-            ?.flatMap(index => index?.subIndices ?? []);
-        if (subIndices) {
-            accessedIndicesCollection = (0, list_access_1.filterIndices)(subIndices, accessArg);
+    if ((0, config_1.getConfig)().solver.pointerTracking) {
+        let accessedIndicesCollection;
+        // If the accessedArg is a symbol, it's either a simple access or the base case of a nested access
+        if (accessedArg.value?.type === type_1.RType.Symbol) {
+            accessedIndicesCollection = (0, list_access_1.resolveSingleIndex)(accessedArg, accessArg, data.environment);
         }
-    }
-    // Add indices to vertex afterward
-    if (accessedIndicesCollection) {
-        const vertex = fnCall.information.graph.getVertex(rootId);
-        if (vertex) {
-            vertex.indicesCollection = accessedIndicesCollection;
+        else {
+            // Higher access call
+            const underlyingAccessId = accessedArg.value?.info.id ?? -1;
+            const vertex = fnCall.information.graph.getVertex(underlyingAccessId);
+            const subIndices = vertex?.indicesCollection
+                ?.flatMap(indices => indices.indices)
+                ?.flatMap(index => index?.subIndices ?? []);
+            if (subIndices) {
+                accessedIndicesCollection = (0, list_access_1.filterIndices)(subIndices, accessArg);
+            }
         }
-        // When access has no access as parent, it's the top most
-        const rootNode = data.completeAst.idMap.get(rootId);
-        const parentNode = data.completeAst.idMap.get(rootNode?.info.parent ?? -1);
-        if (parentNode?.type !== type_1.RType.Access) {
-            // Only reference indices in top most access
-            referenceIndices(accessedIndicesCollection, fnCall, name.info.id);
+        // Add indices to vertex afterward
+        if (accessedIndicesCollection) {
+            const vertex = fnCall.information.graph.getVertex(rootId);
+            if (vertex) {
+                vertex.indicesCollection = accessedIndicesCollection;
+            }
+            // When access has no access as parent, it's the top most
+            const rootNode = data.completeAst.idMap.get(rootId);
+            const parentNode = data.completeAst.idMap.get(rootNode?.info.parent ?? -1);
+            if (parentNode?.type !== type_1.RType.Access) {
+                // Only reference indices in top most access
+                referenceIndices(accessedIndicesCollection, fnCall, name.info.id);
+            }
         }
     }
     return fnCall;

package/dataflow/internal/process/functions/call/built-in/built-in-assignment.d.ts

@@ -42,8 +42,7 @@ export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfi
  * @param nodeToDefine       - `x`
  * @param sourceIds          - `v`
  * @param rootIdOfAssignment - `<-`
- * @param quoteSource        - whether to quote the source (i.e., define `x` without a direct reference to `v`)
- * @param superAssignment    - whether this is a super assignment (i.e., `<<-`)
+ * @param config             - configuration for the assignment processing
  */
 export declare function markAsAssignment(information: {
     environment: REnvironmentInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-assignment.js

@@ -18,6 +18,7 @@ const define_1 = require("../../../../../environments/define");
 const edge_1 = require("../../../../../graph/edge");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const list_access_1 = require("../../../../../../util/list-access");
+const config_1 = require("../../../../../../config");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -184,29 +185,30 @@ function checkTargetReferenceType(source, sourceInfo) {
  * @param nodeToDefine       - `x`
  * @param sourceIds          - `v`
  * @param rootIdOfAssignment - `<-`
- * @param quoteSource        - whether to quote the source (i.e., define `x` without a direct reference to `v`)
- * @param superAssignment    - whether this is a super assignment (i.e., `<<-`)
+ * @param config             - configuration for the assignment processing
  */
 function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, config) {
-    let indicesCollection = undefined;
-    if (sourceIds.length === 1) {
-        // support for tracking indices
-        // Indices were defined for the vertex e.g. a <- list(c = 1) or a$b <- list(c = 1)
-        indicesCollection = information.graph.getVertex(sourceIds[0])?.indicesCollection;
-    }
-    // Indices defined by replacement operation e.g. $<-
-    if (config?.indicesCollection !== undefined) {
-        // If there were indices stored in the vertex, then a container was defined
-        // and assigned to the index of another container e.g. a$b <- list(c = 1)
-        if (indicesCollection) {
-            indicesCollection = (0, list_access_1.addSubIndicesToLeafIndices)(config.indicesCollection, indicesCollection);
+    if ((0, config_1.getConfig)().solver.pointerTracking) {
+        let indicesCollection = undefined;
+        if (sourceIds.length === 1) {
+            // support for tracking indices
+            // Indices were defined for the vertex e.g. a <- list(c = 1) or a$b <- list(c = 1)
+            indicesCollection = information.graph.getVertex(sourceIds[0])?.indicesCollection;
         }
-        else {
-            // No indices were defined for the vertex e.g. a$b <- 2
-            indicesCollection = config.indicesCollection;
+        // Indices defined by replacement operation e.g. $<-
+        if (config?.indicesCollection !== undefined) {
+            // If there were indices stored in the vertex, then a container was defined
+            // and assigned to the index of another container e.g. a$b <- list(c = 1)
+            if (indicesCollection) {
+                indicesCollection = (0, list_access_1.addSubIndicesToLeafIndices)(config.indicesCollection, indicesCollection);
+            }
+            else {
+                // No indices were defined for the vertex e.g. a$b <- 2
+                indicesCollection = config.indicesCollection;
+            }
         }
+        nodeToDefine.indicesCollection ??= indicesCollection;
     }
-    nodeToDefine.indicesCollection ??= indicesCollection;
     information.environment = (0, define_1.define)(nodeToDefine, config?.superAssignment, information.environment);
     information.graph.setDefinitionOfVertex(nodeToDefine);
     if (!config?.quoteSource) {
@@ -215,12 +217,14 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
         }
     }
     information.graph.addEdge(nodeToDefine, rootIdOfAssignment, edge_1.EdgeType.DefinedBy);
-    // kinda dirty, but we have to remove existing read edges for the symbol, added by the child
-    const out = information.graph.outgoingEdges(nodeToDefine.nodeId);
-    for (const [id, edge] of (out ?? [])) {
-        edge.types &= ~edge_1.EdgeType.Reads;
-        if (edge.types == 0) {
-            out?.delete(id);
+    if ((0, config_1.getConfig)().solver.pointerTracking) {
+        // kinda dirty, but we have to remove existing read edges for the symbol, added by the child
+        const out = information.graph.outgoingEdges(nodeToDefine.nodeId);
+        for (const [id, edge] of (out ?? [])) {
+            edge.types &= ~edge_1.EdgeType.Reads;
+            if (edge.types == 0) {
+                out?.delete(id);
+            }
         }
     }
 }

package/dataflow/internal/process/functions/call/built-in/built-in-replacement.js

@@ -15,6 +15,7 @@ const edge_1 = require("../../../../../graph/edge");
 const dfg_1 = require("../../../../../../util/mermaid/dfg");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const list_access_1 = require("../../../../../../util/list-access");
+const config_1 = require("../../../../../../config");
 function processReplacementFunction(name, 
 /** The last one has to be the value */
 args, rootId, data, config) {
@@ -25,7 +26,7 @@ args, rootId, data, config) {
     /* we only get here if <-, <<-, ... or whatever is part of the replacement is not overwritten */
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Replacement ${name.content} with ${JSON.stringify(args)}, processing`);
     let indices = undefined;
-    if (name.content === '$<-') {
+    if (name.content === '$<-' && (0, config_1.getConfig)().solver.pointerTracking) {
         const nonEmptyArgs = args.filter(arg => arg !== r_function_call_1.EmptyArgument);
         const accessedArg = nonEmptyArgs.find(arg => arg.info.role === "accessed" /* RoleInParent.Accessed */);
         const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-access" /* RoleInParent.IndexAccess */);

package/documentation/print-interface-wiki.js

@@ -162,6 +162,11 @@ function explainConfigFile() {
 When running _flowR_, you may want to specify some behaviors with a dedicated configuration file. 
 By default, flowR looks for a file named \`${flowr_main_options_1.defaultConfigFile}\` in the current working directory (or any higher directory). 
 You can also specify a different file with ${(0, doc_cli_option_1.getCliLongOptionOf)('flowr', 'config-file')} or pass the configuration inline using ${(0, doc_cli_option_1.getCliLongOptionOf)('flowr', 'config-json')}.
+To inspect the current configuration, you can run flowr with the ${(0, doc_cli_option_1.getCliLongOptionOf)('flowr', 'verbose')} flag, or use the \`config\` [Query](${doc_files_1.FlowrWikiBaseRef}/Query%20API).
+Within the REPL this works by running the following:
+
+${(0, doc_code_1.codeBlock)('shell', ':query @config')}
+
 
 The following summarizes the configuration options:
 
@@ -209,8 +214,8 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
 - \`loadDefaults\` (boolean, initially \`true\`): If set to \`true\`, the default built-in definitions are loaded before applying the custom definitions. Setting this flag to \`false\` explicitly disables the loading of the default definitions.
 - \`definitions\` (array, initially empty): Allows to overwrite or define new built-in elements. Each object within must have a \`type\` which is one of the below. Furthermore, they may define a string array of \`names\` which specifies the identifiers to bind the definitions to. You may use \`assumePrimitive\` to specify whether _flowR_ should assume that this is a primitive non-library definition (so you probably just do not want to specify the key).
 
-  | Type          | Description                                                                                                                                                                                                                                                                                              | Example                                                                                                    |
-  | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
+  | Type            | Description                                                                                                                                                                                                                                                                                              | Example                                                                                                    |
+  | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
   | \`constant\`    | Additionally allows for a \`value\` this should resolve to.                                                                                                                                                                                                                                                | \`{ type: 'constant', names: ['NULL', 'NA'],  value: null }\`                                                |
   | \`function\`    | Is a rather flexible way to define and bind built-in functions. For the time, we do not have extensive documentation to cover all the cases, so please either consult the sources with the \`default-builtin-config.ts\` or open a [new issue](${doc_issue_1.NewIssueUrl}). | \`{ type: 'function', names: ['next'], processor: 'builtin:default', config: { cfg: ExitPointType.Next } }\` |
   | \`replacement\` | A comfortable way to specify replacement functions like \`$<-\` or \`names<-\`. \`suffixes\` describes the... suffixes to attach automatically. | \`{ type: 'replacement', suffixes: ['<-', '<<-'], names: ['[', '[['] }\` |

package/documentation/print-query-wiki.js

@@ -25,6 +25,7 @@ const doc_cli_option_1 = require("./doc-util/doc-cli-option");
 const doc_issue_1 = require("./doc-util/doc-issue");
 const location_map_query_executor_1 = require("../queries/catalog/location-map-query/location-map-query-executor");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
+const config_query_executor_1 = require("../queries/catalog/config-query/config-query-executor");
 (0, doc_query_1.registerQueryDocumentation)('call-context', {
     name: 'Call-Context Query',
     type: 'active',
@@ -208,6 +209,18 @@ ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
 		`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('config', {
+    name: 'Config Query',
+    type: 'active',
+    shortDescription: 'Returns the current configuration of flowR.',
+    functionName: config_query_executor_1.executeConfigQuery.name,
+    functionFile: '../queries/catalog/config-query/config-query-format.ts',
+    // eslint-disable-next-line @typescript-eslint/require-await -- no need for async here
+    buildExplanation: async () => {
+        return `
+This query provides access to the current configuration of the flowR instance. See the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface) wiki page for more information on what the configuration represents.`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('compound', {
     name: 'Compound Query',
     type: 'virtual',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.1.10",
+  "version": "2.1.11",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/queries/catalog/config-query/config-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigQuery, ConfigQueryResult } from './config-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeConfigQuery(_: BasicQueryData, queries: readonly ConfigQuery[]): ConfigQueryResult;

package/queries/catalog/config-query/config-query-executor.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeConfigQuery = executeConfigQuery;
+const log_1 = require("../../../util/log");
+const config_1 = require("../../../config");
+function executeConfigQuery(_, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('Config query expects only up to one query, but got', queries.length);
+    }
+    return {
+        '.meta': {
+            /* there is no sense in measuring a get */
+            timing: 0
+        },
+        config: (0, config_1.getConfig)()
+    };
+}
+//# sourceMappingURL=config-query-executor.js.map

package/queries/catalog/config-query/config-query-format.d.ts

@@ -0,0 +1,16 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import { executeConfigQuery } from './config-query-executor';
+import { type OutputFormatter } from '../../../util/ansi';
+import Joi from 'joi';
+import type { FlowrConfigOptions } from '../../../config';
+export interface ConfigQuery extends BaseQueryFormat {
+    readonly type: 'config';
+}
+export interface ConfigQueryResult extends BaseQueryResult {
+    readonly config: FlowrConfigOptions;
+}
+export declare const ConfigQueryDefinition: {
+    readonly executor: typeof executeConfigQuery;
+    readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+    readonly schema: Joi.ObjectSchema<any>;
+};

package/queries/catalog/config-query/config-query-format.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigQueryDefinition = void 0;
+const config_query_executor_1 = require("./config-query-executor");
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const json_1 = require("../../../util/json");
+exports.ConfigQueryDefinition = {
+    executor: config_query_executor_1.executeConfigQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('config', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ Config:\n${JSON.stringify(out.config, json_1.jsonReplacer, 4)}`);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('config').required().description('The type of the query.'),
+    }).description('The config query retrieves the current configuration of the flowR instance.')
+};
+//# sourceMappingURL=config-query-format.js.map

package/queries/catalog/location-map-query/location-map-query-format.js

@@ -19,6 +19,6 @@ exports.LocationMapQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('location-map').required().description('The type of the query.'),
-    }).description('The id map query retrieves the location of every id in the ast.')
+    }).description('The location map query retrieves the location of every id in the ast.')
 };
 //# sourceMappingURL=location-map-query-format.js.map

package/queries/query.d.ts

@@ -14,7 +14,8 @@ import type { PipelineOutput } from '../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE } from '../core/steps/pipeline/default-pipelines';
 import Joi from 'joi';
 import type { LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
-export type Query = CallContextQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
+import type { ConfigQuery } from './catalog/config-query/config-query-format';
+export type Query = CallContextQuery | ConfigQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -33,6 +34,11 @@ export declare const SupportedQueries: {
         readonly asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, result: string[]) => boolean;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly config: {
+        readonly executor: typeof import("./catalog/config-query/config-query-executor").executeConfigQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
     readonly dataflow: {
         readonly executor: typeof import("./catalog/dataflow-query/dataflow-query-executor").executeDataflowQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{

package/queries/query.js

@@ -22,8 +22,10 @@ const cluster_query_format_1 = require("./catalog/cluster-query/cluster-query-fo
 const dependencies_query_format_1 = require("./catalog/dependencies-query/dependencies-query-format");
 const joi_1 = __importDefault(require("joi"));
 const location_map_query_format_1 = require("./catalog/location-map-query/location-map-query-format");
+const config_query_format_1 = require("./catalog/config-query/config-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
+    'config': config_query_format_1.ConfigQueryDefinition,
     'dataflow': dataflow_query_format_1.DataflowQueryDefinition,
     'id-map': id_map_query_format_1.IdMapQueryDefinition,
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.1.10';
+const version = '2.1.11';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }