@eagleoutice/flowr 2.1.2 → 2.1.4

package/queries/catalog/call-context-query/call-context-query-format.d.ts

@@ -1,17 +1,11 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-export declare enum CallTargets {
-    /** call targets a function that is not defined locally (e.g., the call targets a library function) */
-    OnlyGlobal = "global",
-    /** call targets a function that is defined locally or globally, but must include a global function */
-    MustIncludeGlobal = "must-include-global",
-    /** call targets a function that is defined locally  */
-    OnlyLocal = "local",
-    /** call targets a function that is defined locally or globally, but must include a local function */
-    MustIncludeLocal = "must-include-local",
-    /** call targets a function that is defined locally or globally */
-    Any = "any"
-}
+import { executeCallContextQueries } from './call-context-query-executor';
+import type { OutputFormatter } from '../../../util/ansi';
+import Joi from 'joi';
+import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
+import type { DEFAULT_DATAFLOW_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
+import { CallTargets } from './identify-link-to-last-call-relation';
 export interface DefaultCallContextQueryFormat<CallName extends RegExp | string> extends BaseQueryFormat {
     readonly type: 'call-context';
     /** Regex regarding the function name, please note that strings will be interpreted as regular expressions too! */
@@ -45,13 +39,15 @@ interface LinkToLastCall<CallName extends RegExp | string = RegExp | string> ext
     /** Regex regarding the function name of the last call. Similar to {@link DefaultCallContextQueryFormat#callName}, strings are interpreted as a `RegExp`. */
     readonly callName: CallName;
 }
-type LinkTo<CallName extends RegExp | string> = LinkToLastCall<CallName>;
+export type LinkTo<CallName extends RegExp | string> = LinkToLastCall<CallName>;
 export interface SubCallContextQueryFormat<CallName extends RegExp | string = RegExp | string> extends DefaultCallContextQueryFormat<CallName> {
     readonly linkTo: LinkTo<CallName>;
 }
 export interface CallContextQuerySubKindResult {
     /** The id of the call vertex identified within the supplied dataflow graph */
     readonly id: NodeId;
+    /** The name of the function call */
+    readonly name: string;
     /**
      * Ids of functions which are called by the respective function call,
      * this will only be populated whenever you explicitly state the {@link DefaultCallContextQueryFormat#callTargets}.
@@ -73,4 +69,9 @@ export interface CallContextQueryResult extends BaseQueryResult {
     readonly kinds: CallContextQueryKindResult;
 }
 export type CallContextQuery<CallName extends RegExp | string = RegExp | string> = DefaultCallContextQueryFormat<CallName> | SubCallContextQueryFormat<CallName>;
+export declare const CallContextQueryDefinition: {
+    readonly executor: typeof executeCallContextQueries;
+    readonly asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, result: string[]) => boolean;
+    readonly schema: Joi.ObjectSchema<any>;
+};
 export {};

package/queries/catalog/call-context-query/call-context-query-format.js

@@ -1,17 +1,35 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CallTargets = void 0;
-var CallTargets;
-(function (CallTargets) {
-    /** call targets a function that is not defined locally (e.g., the call targets a library function) */
-    CallTargets["OnlyGlobal"] = "global";
-    /** call targets a function that is defined locally or globally, but must include a global function */
-    CallTargets["MustIncludeGlobal"] = "must-include-global";
-    /** call targets a function that is defined locally  */
-    CallTargets["OnlyLocal"] = "local";
-    /** call targets a function that is defined locally or globally, but must include a local function */
-    CallTargets["MustIncludeLocal"] = "must-include-local";
-    /** call targets a function that is defined locally or globally */
-    CallTargets["Any"] = "any";
-})(CallTargets || (exports.CallTargets = CallTargets = {}));
+exports.CallContextQueryDefinition = void 0;
+const call_context_query_executor_1 = require("./call-context-query-executor");
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const query_print_1 = require("../../query-print");
+const identify_link_to_last_call_relation_1 = require("./identify-link-to-last-call-relation");
+exports.CallContextQueryDefinition = {
+    executor: call_context_query_executor_1.executeCallContextQueries,
+    asciiSummarizer: (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('call-context', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push((0, query_print_1.asciiCallContext)(formatter, out, processed));
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('call-context').required().description('The type of the query.'),
+        callName: joi_1.default.string().required().description('Regex regarding the function name!'),
+        callNameExact: joi_1.default.boolean().optional().description('Should we automatically add the `^` and `$` anchors to the regex to make it an exact match?'),
+        kind: joi_1.default.string().optional().description('The kind of the call, this can be used to group calls together (e.g., linking `plot` to `visualize`). Defaults to `.`'),
+        subkind: joi_1.default.string().optional().description('The subkind of the call, this can be used to uniquely identify the respective call type when grouping the output (e.g., the normalized name, linking `ggplot` to `plot`). Defaults to `.`'),
+        callTargets: joi_1.default.string().valid(...Object.values(identify_link_to_last_call_relation_1.CallTargets)).optional().description('Call targets the function may have. This defaults to `any`. Request this specifically to gain all call targets we can resolve.'),
+        includeAliases: joi_1.default.boolean().optional().description('Consider a case like `f <- function_of_interest`, do you want uses of `f` to be included in the results?'),
+        linkTo: joi_1.default.object({
+            type: joi_1.default.string().valid('link-to-last-call').required().description('The type of the linkTo sub-query.'),
+            callName: joi_1.default.string().required().description('Regex regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression.')
+        }).optional().description('Links the current call to the last call of the given kind. This way, you can link a call like `points` to the latest graphics plot etc.')
+    }).description('Call context query used to find calls in the dataflow graph')
+};
 //# sourceMappingURL=call-context-query-format.js.map

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.d.ts

@@ -0,0 +1,17 @@
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ControlFlowGraph } from '../../../util/cfg/cfg';
+import type { DataflowGraph } from '../../../dataflow/graph/graph';
+export declare enum CallTargets {
+    /** call targets a function that is not defined locally (e.g., the call targets a library function) */
+    OnlyGlobal = "global",
+    /** call targets a function that is defined locally or globally, but must include a global function */
+    MustIncludeGlobal = "must-include-global",
+    /** call targets a function that is defined locally  */
+    OnlyLocal = "local",
+    /** call targets a function that is defined locally or globally, but must include a local function */
+    MustIncludeLocal = "must-include-local",
+    /** call targets a function that is defined locally or globally */
+    Any = "any"
+}
+export declare function satisfiesCallTargets(id: NodeId, graph: DataflowGraph, callTarget: CallTargets): NodeId[] | 'no';
+export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, linkTo: RegExp): NodeId[];

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallTargets = void 0;
+exports.satisfiesCallTargets = satisfiesCallTargets;
+exports.identifyLinkToLastCallRelation = identifyLinkToLastCallRelation;
+const visitor_1 = require("../../../util/cfg/visitor");
+const vertex_1 = require("../../../dataflow/graph/vertex");
+const edge_1 = require("../../../dataflow/graph/edge");
+const resolve_by_name_1 = require("../../../dataflow/environments/resolve-by-name");
+const identifier_1 = require("../../../dataflow/environments/identifier");
+const built_in_1 = require("../../../dataflow/environments/built-in");
+const assert_1 = require("../../../util/assert");
+var CallTargets;
+(function (CallTargets) {
+    /** call targets a function that is not defined locally (e.g., the call targets a library function) */
+    CallTargets["OnlyGlobal"] = "global";
+    /** call targets a function that is defined locally or globally, but must include a global function */
+    CallTargets["MustIncludeGlobal"] = "must-include-global";
+    /** call targets a function that is defined locally  */
+    CallTargets["OnlyLocal"] = "local";
+    /** call targets a function that is defined locally or globally, but must include a local function */
+    CallTargets["MustIncludeLocal"] = "must-include-local";
+    /** call targets a function that is defined locally or globally */
+    CallTargets["Any"] = "any";
+})(CallTargets || (exports.CallTargets = CallTargets = {}));
+function satisfiesCallTargets(id, graph, callTarget) {
+    const callVertex = graph.get(id);
+    if (callVertex === undefined || callVertex[0].tag !== vertex_1.VertexType.FunctionCall) {
+        return 'no';
+    }
+    const [info, outgoing] = callVertex;
+    const callTargets = [...outgoing]
+        .filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Calls))
+        .map(([t]) => t);
+    let builtIn = false;
+    if (info.environment === undefined) {
+        /* if we have a call with an unbound environment,
+         * this only happens if we are sure of built-in relations and want to save references
+         */
+        builtIn = true;
+    }
+    else {
+        /*
+         * for performance and scoping reasons, flowR will not identify the global linkage,
+         * including any potential built-in mapping.
+         */
+        const reResolved = (0, resolve_by_name_1.resolveByName)(info.name, info.environment, identifier_1.ReferenceType.Unknown);
+        if (reResolved?.some(t => t.definedAt === built_in_1.BuiltIn)) {
+            builtIn = true;
+        }
+    }
+    switch (callTarget) {
+        case CallTargets.Any:
+            return callTargets;
+        case CallTargets.OnlyGlobal:
+            if (callTargets.length === 0) {
+                return builtIn ? [built_in_1.BuiltIn] : [];
+            }
+            else {
+                return 'no';
+            }
+        case CallTargets.MustIncludeGlobal:
+            return builtIn || callTargets.length === 0 ? [...callTargets, built_in_1.BuiltIn] : 'no';
+        case CallTargets.OnlyLocal:
+            return !builtIn && callTargets.length > 0 ? callTargets : 'no';
+        case CallTargets.MustIncludeLocal:
+            if (callTargets.length > 0) {
+                return builtIn ? [...callTargets, built_in_1.BuiltIn] : callTargets;
+            }
+            else {
+                return 'no';
+            }
+        default:
+            (0, assert_1.assertUnreachable)(callTarget);
+    }
+}
+function identifyLinkToLastCallRelation(from, cfg, graph, linkTo) {
+    const found = [];
+    (0, visitor_1.visitInReverseOrder)(cfg, from, node => {
+        /* we ignore the start id as it cannot be the last call */
+        if (node === from) {
+            return;
+        }
+        const vertex = graph.get(node);
+        if (vertex === undefined || vertex[0].tag !== vertex_1.VertexType.FunctionCall) {
+            return;
+        }
+        if (linkTo.test(vertex[0].name)) {
+            const tar = satisfiesCallTargets(vertex[0].id, graph, CallTargets.MustIncludeGlobal);
+            if (tar === 'no') {
+                return true;
+            }
+            found.push(node);
+            return true;
+        }
+    });
+    return found;
+}
+//# sourceMappingURL=identify-link-to-last-call-relation.js.map

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

@@ -1,3 +1,3 @@
-import type { BasicQueryData } from '../../query';
 import type { DataflowClusterQuery, DataflowClusterQueryResult } from './cluster-query-format';
+import type { BasicQueryData } from '../../base-query-format';
 export declare function executeDataflowClusterQuery({ graph }: BasicQueryData, queries: readonly DataflowClusterQuery[]): DataflowClusterQueryResult;

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

@@ -1,5 +1,7 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
 import type { DataflowGraphClusters } from '../../../dataflow/cluster';
+import { executeDataflowClusterQuery } from './cluster-query-executor';
 /**
  * Calculates and returns all clusters encountered in the dataflow graph.
  */
@@ -10,3 +12,60 @@ export interface DataflowClusterQueryResult extends BaseQueryResult {
     /** All clusters found in the respective dataflow */
     readonly clusters: DataflowGraphClusters;
 }
+export declare const ClusterQueryDefinition: {
+    readonly executor: typeof executeDataflowClusterQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/ansi").OutputFormatter, processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../core/steps/all/core/00-parse").ParseRequiredInput>) => Promise<import("../../../core/steps/all/core/00-parse").ParseStepOutput>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../core/steps/all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../core/steps/all/core/00-parse").ParseRequiredInput;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../core/steps/all/core/00-parse").ParseStepOutput;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+};

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

@@ -1,3 +1,32 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterQueryDefinition = void 0;
+const ansi_1 = require("../../../util/ansi");
+const joi_1 = __importDefault(require("joi"));
+const cluster_query_executor_1 = require("./cluster-query-executor");
+const dfg_1 = require("../../../util/mermaid/dfg");
+const query_print_1 = require("../../query-print");
+exports.ClusterQueryDefinition = {
+    executor: cluster_query_executor_1.executeDataflowClusterQuery,
+    asciiSummarizer: (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('dataflow-cluster', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        result.push(`   ╰ Found ${out.clusters.length} cluster${out.clusters.length === 1 ? '' : 's'}`);
+        for (const cluster of out.clusters) {
+            const unknownSideEffects = cluster.hasUnknownSideEffects ? '(has unknown side effect)' : '';
+            let suffix = '';
+            if (formatter === ansi_1.markdownFormatter) {
+                suffix = `([marked](${(0, dfg_1.graphToMermaidUrl)(processed.dataflow.graph, false, new Set(cluster.members))}))`;
+            }
+            result.push(`      ╰ ${unknownSideEffects} {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, cluster.members)}} ${suffix}`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('dataflow-cluster').required().description('The type of the query.'),
+    }).description('The cluster query calculates and returns all clusters in the dataflow graph.')
+};
 //# sourceMappingURL=cluster-query-format.js.map

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

@@ -1,3 +1,3 @@
-import type { BasicQueryData } from '../../query';
 import type { DataflowQuery, DataflowQueryResult } from './dataflow-query-format';
+import type { BasicQueryData } from '../../base-query-format';
 export declare function executeDataflowQuery({ graph }: BasicQueryData, queries: readonly DataflowQuery[]): DataflowQueryResult;

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

@@ -1,5 +1,7 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import { executeDataflowQuery } from './dataflow-query-executor';
+import Joi from 'joi';
 /**
  * Simple re-returns the dataflow graph of the analysis.
  */
@@ -10,3 +12,60 @@ export interface DataflowQueryResult extends BaseQueryResult {
     /** Please be aware that this is the graph in its JSON representation, use {@link DataflowGraph#fromJson} if the result is serialized */
     readonly graph: DataflowGraph;
 }
+export declare const DataflowQueryDefinition: {
+    readonly executor: typeof executeDataflowQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../core/steps/all/core/00-parse").ParseRequiredInput>) => Promise<import("../../../core/steps/all/core/00-parse").ParseStepOutput>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../core/steps/all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../core/steps/all/core/00-parse").ParseRequiredInput;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../core/steps/all/core/00-parse").ParseStepOutput;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+};

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

@@ -1,3 +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.DataflowQueryDefinition = void 0;
+const dataflow_query_executor_1 = require("./dataflow-query-executor");
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const dfg_1 = require("../../../util/mermaid/dfg");
+const joi_1 = __importDefault(require("joi"));
+exports.DataflowQueryDefinition = {
+    executor: dataflow_query_executor_1.executeDataflowQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('dataflow', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ [Dataflow Graph](${(0, dfg_1.graphToMermaidUrl)(out.graph)})`);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('dataflow').required().description('The type of the query.'),
+    }).description('The dataflow query simply returns the dataflow graph, there is no need to pass it multiple times!')
+};
 //# sourceMappingURL=dataflow-query-format.js.map

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

@@ -0,0 +1,3 @@
+import type { DependenciesQuery, DependenciesQueryResult } from './dependencies-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeDependenciesQuery(data: BasicQueryData, queries: readonly DependenciesQuery[]): DependenciesQueryResult;

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDependenciesQuery = executeDependenciesQuery;
+const query_1 = require("../../query");
+const dependencies_query_format_1 = require("./dependencies-query-format");
+const graph_1 = require("../../../dataflow/graph/graph");
+const log_1 = require("../../../util/log");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const retriever_1 = require("../../../r-bridge/retriever");
+const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const assert_1 = require("../../../util/assert");
+const objects_1 = require("../../../util/objects");
+const SupportedVertexTypes = [type_1.RType.String, type_1.RType.Logical, type_1.RType.Number];
+const Unknown = 'unknown';
+function executeDependenciesQuery(data, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('Dependencies query expects only up to one query, but got ', queries.length, 'only using the first query');
+    }
+    const now = Date.now();
+    const [query] = queries;
+    const ignoreDefault = query.ignoreDefaultFunctions ?? false;
+    const libraryFunctions = getFunctionsToCheck(query.libraryFunctions, ignoreDefault, dependencies_query_format_1.LibraryFunctions);
+    const sourceFunctions = getFunctionsToCheck(query.sourceFunctions, ignoreDefault, dependencies_query_format_1.SourceFunctions);
+    const readFunctions = getFunctionsToCheck(query.readFunctions, ignoreDefault, dependencies_query_format_1.ReadFunctions);
+    const writeFunctions = getFunctionsToCheck(query.writeFunctions, ignoreDefault, dependencies_query_format_1.WriteFunctions);
+    const numberOfFunctions = libraryFunctions.length + sourceFunctions.length + readFunctions.length + writeFunctions.length;
+    const results = numberOfFunctions === 0 ? { kinds: {}, '.meta': { timing: 0 } } : (0, query_1.executeQueriesOfSameType)(data, ...makeCallContextQuery(libraryFunctions, 'library'), ...makeCallContextQuery(sourceFunctions, 'source'), ...makeCallContextQuery(readFunctions, 'read'), ...makeCallContextQuery(writeFunctions, 'write'));
+    const libraries = getResults(data, results, 'library', libraryFunctions, (id, vertex, argument) => ({
+        nodeId: id,
+        functionName: vertex.name,
+        libraryName: argument ?? Unknown
+    }), [type_1.RType.Symbol]);
+    if (!ignoreDefault) {
+        /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
+        (0, visitor_1.visitAst)(data.ast.ast, n => {
+            if (n.type === type_1.RType.Symbol && n.namespace) {
+                /* we should improve the identification of ':::' */
+                libraries.push({
+                    nodeId: n.info.id,
+                    functionName: (n.info.fullLexeme ?? n.lexeme).includes(':::') ? ':::' : '::',
+                    libraryName: n.namespace
+                });
+            }
+        });
+    }
+    const sourcedFiles = getResults(data, results, 'source', sourceFunctions, (id, vertex, argument, linkedIds) => ({
+        nodeId: id,
+        functionName: vertex.name,
+        file: argument ?? Unknown,
+        linkedIds: (linkedIds?.length ?? 0) > 0 ? linkedIds : undefined
+    }));
+    const readData = getResults(data, results, 'read', readFunctions, (id, vertex, argument, linkedIds) => ({
+        nodeId: id,
+        functionName: vertex.name,
+        source: argument ?? Unknown,
+        linkedIds: (linkedIds?.length ?? 0) > 0 ? linkedIds : undefined
+    }));
+    const writtenData = getResults(data, results, 'write', writeFunctions, (id, vertex, argument, linkedIds) => ({
+        nodeId: id,
+        functionName: vertex.name,
+        // write functions that don't have argIndex are assumed to write to stdout
+        destination: argument ?? ((linkedIds?.length ?? 0) > 0 ? Unknown : 'stdout'),
+        linkedIds: (linkedIds?.length ?? 0) > 0 ? linkedIds : undefined
+    }));
+    return {
+        '.meta': {
+            timing: Date.now() - now
+        },
+        libraries, sourcedFiles, readData, writtenData
+    };
+}
+function makeCallContextQuery(functions, kind) {
+    return functions.map(f => ({
+        type: 'call-context',
+        callName: f.name,
+        includeAliases: true,
+        callNameExact: true,
+        subkind: f.name,
+        linkTo: f.linkTo ? { type: 'link-to-last-call', callName: f.linkTo } : undefined,
+        kind
+    }));
+}
+function getResults(data, results, kind, functions, makeInfo, additionalAllowedTypes) {
+    return Object.entries(results?.kinds[kind]?.subkinds ?? {}).flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
+        const vertex = data.graph.getVertex(id);
+        const info = functions.find(f => f.name === name);
+        let index = info.argIdx;
+        if (info.argName) {
+            const arg = vertex?.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === info.argName);
+            if (arg >= 0) {
+                index = arg;
+            }
+        }
+        const args = index !== undefined ? getArgumentValue(data, vertex, index, additionalAllowedTypes) : undefined;
+        if (!args) {
+            return (0, objects_1.compactRecord)(makeInfo(id, vertex, undefined, linkedIds));
+        }
+        return args.flatMap(a => (0, objects_1.compactRecord)(makeInfo(id, vertex, a, linkedIds)));
+    })).filter(assert_1.isNotUndefined) ?? [];
+}
+function getArgumentValue({ graph }, vertex, argumentIndex, additionalAllowedTypes) {
+    if (vertex) {
+        if (argumentIndex === 'unnamed') {
+            // return all unnamed arguments
+            const references = vertex.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+            return references.map(ref => {
+                if (!ref) {
+                    return undefined;
+                }
+                let valueNode = graph.idMap?.get(ref);
+                if (valueNode?.type === type_1.RType.Argument) {
+                    valueNode = valueNode.value;
+                }
+                if (valueNode) {
+                    const allowedTypes = [...SupportedVertexTypes, ...additionalAllowedTypes ?? []];
+                    return allowedTypes.includes(valueNode.type) ? (0, retriever_1.removeRQuotes)(valueNode.lexeme) : Unknown;
+                }
+            });
+        }
+        if (vertex.args.length > argumentIndex) {
+            const arg = (0, graph_1.getReferenceOfArgument)(vertex.args[argumentIndex]);
+            if (arg) {
+                let valueNode = graph.idMap?.get(arg);
+                if (valueNode?.type === type_1.RType.Argument) {
+                    valueNode = valueNode.value;
+                }
+                if (valueNode) {
+                    const allowedTypes = [...SupportedVertexTypes, ...additionalAllowedTypes ?? []];
+                    return [allowedTypes.includes(valueNode.type) ? (0, retriever_1.removeRQuotes)(valueNode.lexeme) : Unknown];
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function getFunctionsToCheck(customFunctions, ignoreDefaultFunctions, defaultFunctions) {
+    const functions = ignoreDefaultFunctions ? [] : [...defaultFunctions];
+    if (customFunctions) {
+        functions.push(...customFunctions);
+    }
+    return functions;
+}
+//# sourceMappingURL=dependencies-query-executor.js.map