@eagleoutice/flowr 2.1.3 → 2.1.5

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: false,
+        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

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

@@ -0,0 +1,102 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import Joi from 'joi';
+import { executeDependenciesQuery } from './dependencies-query-executor';
+export declare const LibraryFunctions: FunctionInfo[];
+export declare const SourceFunctions: FunctionInfo[];
+export declare const ReadFunctions: FunctionInfo[];
+export declare const WriteFunctions: FunctionInfo[];
+export interface FunctionInfo {
+    name: string;
+    argIdx?: number | 'unnamed';
+    argName?: string;
+    linkTo?: string;
+}
+export interface DependenciesQuery extends BaseQueryFormat {
+    readonly type: 'dependencies';
+    readonly ignoreDefaultFunctions?: boolean;
+    readonly libraryFunctions?: FunctionInfo[];
+    readonly sourceFunctions?: FunctionInfo[];
+    readonly readFunctions?: FunctionInfo[];
+    readonly writeFunctions?: FunctionInfo[];
+}
+export interface DependenciesQueryResult extends BaseQueryResult {
+    libraries: LibraryInfo[];
+    sourcedFiles: SourceInfo[];
+    readData: ReadInfo[];
+    writtenData: WriteInfo[];
+}
+export interface DependencyInfo extends Record<string, unknown> {
+    nodeId: NodeId;
+    functionName: string;
+    linkedIds?: readonly NodeId[];
+}
+export type LibraryInfo = (DependencyInfo & {
+    libraryName: 'unknown' | string;
+});
+export type SourceInfo = (DependencyInfo & {
+    file: string;
+});
+export type ReadInfo = (DependencyInfo & {
+    source: string;
+});
+export type WriteInfo = (DependencyInfo & {
+    destination: 'stdout' | string;
+});
+export declare const DependenciesQueryDefinition: {
+    readonly executor: typeof executeDependenciesQuery;
+    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/dependencies-query/dependencies-query-format.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependenciesQueryDefinition = exports.WriteFunctions = exports.ReadFunctions = exports.SourceFunctions = exports.LibraryFunctions = void 0;
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const dependencies_query_executor_1 = require("./dependencies-query-executor");
+// these lists are originally based on https://github.com/duncantl/CodeDepends/blob/7fd96dfee16b252e5f642c77a7ababf48e9326f8/R/codeTypes.R
+exports.LibraryFunctions = [
+    { name: 'library', argIdx: 0, argName: 'package' },
+    { name: 'require', argIdx: 0, argName: 'package' },
+    { name: 'loadNamespace', argIdx: 0, argName: 'package' },
+    { name: 'attachNamespace', argIdx: 0, argName: 'ns' },
+    { name: 'attach', argIdx: 0, argName: 'what' },
+    { name: 'groundhog.library', argIdx: 0, argName: 'pkg' },
+    { name: 'p_load', argIdx: 'unnamed' }, // pacman
+    { name: 'p_load_gh', argIdx: 'unnamed' }, // pacman
+    { name: 'from_import', argIdx: 0, argName: 'package' }, // easypackages
+    { name: 'libraries', argIdx: 'unnamed' }, // easypackages
+    { name: 'shelf', argIdx: 'unnamed' } // librarian
+];
+exports.SourceFunctions = [
+    { name: 'source', argIdx: 0, argName: 'file' },
+    { name: 'sys.source', argIdx: 0, argName: 'file' }
+];
+exports.ReadFunctions = [
+    { name: 'read.table', argIdx: 0, argName: 'file' },
+    { name: 'read.csv', argIdx: 0, argName: 'file' },
+    { name: 'read.csv2', argIdx: 0, argName: 'file' },
+    { name: 'read.delim', argIdx: 0, argName: 'file' },
+    { name: 'read.dcf', argIdx: 0, argName: 'file' },
+    { name: 'scan', argIdx: 0, argName: 'file' },
+    { name: 'read.fwf', argIdx: 0, argName: 'file' },
+    { name: 'file', argIdx: 1, argName: 'open' },
+    { name: 'url', argIdx: 1, argName: 'open' },
+    { name: 'load', argIdx: 0, argName: 'file' },
+    { name: 'gzfile', argIdx: 1, argName: 'open' },
+    { name: 'bzfile', argIdx: 1, argName: 'open' },
+    { name: 'download.file', argIdx: 0, argName: 'url' },
+    { name: 'pipe', argIdx: 1, argName: 'open' },
+    { name: 'fifo', argIdx: 1, argName: 'open' },
+    { name: 'unz', argIdx: 1, argName: 'open' },
+    { name: 'matrix', argIdx: 0, argName: 'data' },
+    { name: 'readRDS', argIdx: 0, argName: 'file' },
+    { name: 'readLines', argIdx: 0, argName: 'con' },
+    { name: 'readRenviron', argIdx: 0, argName: 'path' },
+    // readr
+    { name: 'read_csv', argIdx: 0, argName: 'file' },
+    { name: 'read_csv2', argIdx: 0, argName: 'file' },
+    { name: 'read_lines', argIdx: 0, argName: 'file' },
+    { name: 'read_delim', argIdx: 0, argName: 'file' },
+    { name: 'read_dsv', argIdx: 0, argName: 'file' },
+    { name: 'read_fwf', argIdx: 0, argName: 'file' },
+    { name: 'read_tsv', argIdx: 0, argName: 'file' },
+    { name: 'read_table', argIdx: 0, argName: 'file' },
+    { name: 'read_log', argIdx: 0, argName: 'file' },
+    { name: 'read_lines', argIdx: 0, argName: 'file' },
+    { name: 'read_lines_chunked', argIdx: 0, argName: 'file' },
+    // xlsx
+    { name: 'read.xlsx', argIdx: 0, argName: 'file' },
+    { name: 'read.xlsx2', argIdx: 0, argName: 'file' },
+    // data.table
+    { name: 'fread', argIdx: 0, argName: 'file' },
+    // haven
+    { name: 'read_sas', argIdx: 0, argName: 'file' },
+    { name: 'read_sav', argIdx: 0, argName: 'file' },
+    { name: 'read_por', argIdx: 0, argName: 'file' },
+    { name: 'read_dta', argIdx: 0, argName: 'file' },
+    { name: 'read_xpt', argIdx: 0, argName: 'file' },
+    // feather
+    { name: 'read_feather', argIdx: 0, argName: 'file' },
+    // foreign
+    { name: 'read.arff', argIdx: 0, argName: 'file' },
+    { name: 'read.dbf', argIdx: 0, argName: 'file' },
+    { name: 'read.dta', argIdx: 0, argName: 'file' },
+    { name: 'read.epiinfo', argIdx: 0, argName: 'file' },
+    { name: 'read.mtp', argIdx: 0, argName: 'file' },
+    { name: 'read.octave', argIdx: 0, argName: 'file' },
+    { name: 'read.spss', argIdx: 0, argName: 'file' },
+    { name: 'read.ssd', argIdx: 0, argName: 'file' },
+    { name: 'read.systat', argIdx: 0, argName: 'file' },
+    { name: 'read.xport', argIdx: 0, argName: 'file' },
+];
+exports.WriteFunctions = [
+    { name: 'save', argIdx: 0, argName: '...' },
+    { name: 'save.image', argIdx: 0, argName: 'file' },
+    { name: 'write', argIdx: 1, argName: 'file' },
+    { name: 'dput', argIdx: 1, argName: 'file' },
+    { name: 'dump', argIdx: 1, argName: 'file' },
+    { name: 'write.table', argIdx: 1, argName: 'file' },
+    { name: 'write.csv', argIdx: 1, argName: 'file' },
+    { name: 'saveRDS', argIdx: 1, argName: 'file' },
+    // write functions that don't have argIndex are assumed to write to stdout
+    { name: 'print', linkTo: 'sink' },
+    { name: 'cat', linkTo: 'sink', argIdx: 1, argName: 'file' },
+    { name: 'message', linkTo: 'sink' },
+    { name: 'warning', linkTo: 'sink' },
+    // readr
+    { name: 'write_csv', argIdx: 1, argName: 'file' },
+    { name: 'write_csv2', argIdx: 1, argName: 'file' },
+    { name: 'write_delim', argIdx: 1, argName: 'file' },
+    { name: 'write_dsv', argIdx: 1, argName: 'file' },
+    { name: 'write_fwf', argIdx: 1, argName: 'file' },
+    { name: 'write_tsv', argIdx: 1, argName: 'file' },
+    { name: 'write_table', argIdx: 1, argName: 'file' },
+    { name: 'write_log', argIdx: 1, argName: 'file' },
+    // heaven
+    { name: 'write_sas', argIdx: 1, argName: 'file' },
+    { name: 'write_sav', argIdx: 1, argName: 'file' },
+    { name: 'write_por', argIdx: 1, argName: 'file' },
+    { name: 'write_dta', argIdx: 1, argName: 'file' },
+    { name: 'write_xpt', argIdx: 1, argName: 'file' },
+    // feather
+    { name: 'write_feather', argIdx: 1, argName: 'file' },
+    // foreign
+    { name: 'write.arff', argIdx: 1, argName: 'file' },
+    { name: 'write.dbf', argIdx: 1, argName: 'file' },
+    { name: 'write.dta', argIdx: 1, argName: 'file' },
+    { name: 'write.foreign', argIdx: 1, argName: 'file' },
+    // xlsx
+    { name: 'write.xlsx', argIdx: 1, argName: 'file' },
+    { name: 'write.xlsx2', argIdx: 1, argName: 'file' },
+    // graphics
+    { name: 'pdf', argIdx: 0, argName: 'file' },
+    { name: 'jpeg', argIdx: 0, argName: 'file' },
+    { name: 'png', argIdx: 0, argName: 'file' },
+    { name: 'windows', argIdx: 0, argName: 'file' },
+    { name: 'postscript', argIdx: 0, argName: 'file' },
+    { name: 'xfix', argIdx: 0, argName: 'file' },
+    { name: 'bitmap', argIdx: 0, argName: 'file' },
+    { name: 'pictex', argIdx: 0, argName: 'file' },
+    { name: 'cairo_pdf', argIdx: 0, argName: 'file' },
+    { name: 'svg', argIdx: 0, argName: 'file' },
+    { name: 'bmp', argIdx: 0, argName: 'file' },
+    { name: 'tiff', argIdx: 0, argName: 'file' },
+    { name: 'X11', argIdx: 0, argName: 'file' },
+    { name: 'quartz', argIdx: 0, argName: 'file' },
+];
+function printResultSection(title, infos, result, sectionSpecifics) {
+    if (infos.length <= 0) {
+        return;
+    }
+    result.push(`   ╰ ${title}`);
+    const grouped = infos.reduce(function (groups, i) {
+        const array = groups.get(i.functionName);
+        if (array) {
+            array.push(i);
+        }
+        else {
+            groups.set(i.functionName, [i]);
+        }
+        return groups;
+    }, new Map());
+    for (const [functionName, infos] of grouped) {
+        result.push(`       ╰ \`${functionName}\``);
+        result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}, ${sectionSpecifics(i)}`).join('\n'));
+    }
+}
+const functionInfoSchema = joi_1.default.array().items(joi_1.default.object({
+    name: joi_1.default.string().required().description('The name of the library function.'),
+    argIdx: joi_1.default.number().optional().description('The index of the argument that contains the library name.'),
+    argName: joi_1.default.string().optional().description('The name of the argument that contains the library name.'),
+})).optional();
+exports.DependenciesQueryDefinition = {
+    executor: dependencies_query_executor_1.executeDependenciesQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('dependencies', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        printResultSection('Libraries', out.libraries, result, l => `\`${l.libraryName}\``);
+        printResultSection('Sourced Files', out.sourcedFiles, result, s => `\`${s.file}\``);
+        printResultSection('Read Data', out.readData, result, r => `\`${r.source}\``);
+        printResultSection('Written Data', out.writtenData, result, w => `\`${w.destination}\``);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('dependencies').required().description('The type of the query.'),
+        ignoreDefaultFunctions: joi_1.default.boolean().optional().description('Should the set of functions that are detected by default be ignored/skipped?'),
+        libraryFunctions: functionInfoSchema.description('The set of library functions to search for.'),
+        sourceFunctions: functionInfoSchema.description('The set of source functions to search for.'),
+        readFunctions: functionInfoSchema.description('The set of data reading functions to search for.'),
+        writeFunctions: functionInfoSchema.description('The set of data writing functions to search for.'),
+    }).description('The dependencies query retrieves and returns the set of all dependencies in the dataflow graph, which includes libraries, sourced files, read data, and written data.')
+};
+//# sourceMappingURL=dependencies-query-format.js.map

package/queries/catalog/id-map-query/id-map-query-executor.d.ts

@@ -1,3 +1,3 @@
-import type { BasicQueryData } from '../../query';
 import type { IdMapQuery, IdMapQueryResult } from './id-map-query-format';
+import type { BasicQueryData } from '../../base-query-format';
 export declare function executeIdMapQuery({ ast }: BasicQueryData, queries: readonly IdMapQuery[]): IdMapQueryResult;

package/queries/catalog/id-map-query/id-map-query-format.d.ts

@@ -1,8 +1,67 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { AstIdMap } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { executeIdMapQuery } from './id-map-query-executor';
+import Joi from 'joi';
 export interface IdMapQuery extends BaseQueryFormat {
     readonly type: 'id-map';
 }
 export interface IdMapQueryResult extends BaseQueryResult {
     readonly idMap: AstIdMap;
 }
+export declare const IdMapQueryDefinition: {
+    readonly executor: typeof executeIdMapQuery;
+    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/id-map-query/id-map-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.IdMapQueryDefinition = void 0;
+const id_map_query_executor_1 = require("./id-map-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");
+exports.IdMapQueryDefinition = {
+    executor: id_map_query_executor_1.executeIdMapQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('id-map', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ Id List: {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, [...out.idMap.keys()])}}`);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('id-map').required().description('The type of the query.'),
+    }).description('The id map query retrieves the id map from the normalized AST.')
+};
 //# sourceMappingURL=id-map-query-format.js.map

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

@@ -1,3 +1,3 @@
-import type { BasicQueryData } from '../../query';
 import type { LineageQuery, LineageQueryResult } from './lineage-query-format';
+import type { BasicQueryData } from '../../base-query-format';
 export declare function executeLineageQuery({ graph, ast }: BasicQueryData, queries: readonly LineageQuery[]): LineageQueryResult;

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

@@ -1,6 +1,8 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import Joi from 'joi';
+import { executeLineageQuery } from './lineage-query-executor';
 /**
  * Calculates the lineage of the given criterion.
  */
@@ -12,3 +14,60 @@ export interface LineageQueryResult extends BaseQueryResult {
     /** Maps each criterion to the found lineage, duplicates are ignored. */
     readonly lineages: Record<SingleSlicingCriterion, Set<NodeId>>;
 }
+export declare const LineageQueryDefinition: {
+    readonly executor: typeof executeLineageQuery;
+    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/lineage-query/lineage-query-format.js

@@ -1,3 +1,27 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineageQueryDefinition = void 0;
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const lineage_query_executor_1 = require("./lineage-query-executor");
+const query_print_1 = require("../../query-print");
+exports.LineageQueryDefinition = {
+    executor: lineage_query_executor_1.executeLineageQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('lineage', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        for (const [criteria, lineage] of Object.entries(out.lineages)) {
+            result.push(`   ╰ ${criteria}: {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, [...lineage])}}`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('lineage').required().description('The type of the query.'),
+        criterion: joi_1.default.string().required().description('The slicing criterion of the node to get the lineage of.')
+    }).description('Lineage query used to find the lineage of a node in the dataflow graph')
+};
 //# sourceMappingURL=lineage-query-format.js.map