@eagleoutice/flowr/queries/query.js

Static Dataflow Analyzer and Program Slicer for the R Programming Language

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CompoundQuerySchema = exports.SupportedQueries = void 0;
exports.executeQueriesOfSameType = executeQueriesOfSameType;
exports.executeQueries = executeQueries;
exports.SupportedQueriesSchema = SupportedQueriesSchema;
exports.VirtualQuerySchema = VirtualQuerySchema;
exports.AnyQuerySchema = AnyQuerySchema;
exports.QueriesSchema = QueriesSchema;
const call_context_query_format_1 = require("./catalog/call-context-query/call-context-query-format");
const assert_1 = require("../util/assert");
const virtual_queries_1 = require("./virtual-query/virtual-queries");
const dataflow_query_format_1 = require("./catalog/dataflow-query/dataflow-query-format");
const id_map_query_format_1 = require("./catalog/id-map-query/id-map-query-format");
const normalized_ast_query_format_1 = require("./catalog/normalized-ast-query/normalized-ast-query-format");
const lineage_query_format_1 = require("./catalog/lineage-query/lineage-query-format");
const static_slice_query_format_1 = require("./catalog/static-slice-query/static-slice-query-format");
const cluster_query_format_1 = require("./catalog/cluster-query/cluster-query-format");
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");
const search_query_format_1 = require("./catalog/search-query/search-query-format");
const happens_before_query_format_1 = require("./catalog/happens-before-query/happens-before-query-format");
const resolve_value_query_format_1 = require("./catalog/resolve-value-query/resolve-value-query-format");
const dataflow_lens_query_format_1 = require("./catalog/dataflow-lens-query/dataflow-lens-query-format");
const project_query_format_1 = require("./catalog/project-query/project-query-format");
const origin_query_format_1 = require("./catalog/origin-query/origin-query-format");
const linter_query_format_1 = require("./catalog/linter-query/linter-query-format");
const control_flow_query_format_1 = require("./catalog/control-flow-query/control-flow-query-format");
exports.SupportedQueries = {
    'call-context': call_context_query_format_1.CallContextQueryDefinition,
    'config': config_query_format_1.ConfigQueryDefinition,
    'control-flow': control_flow_query_format_1.ControlFlowQueryDefinition,
    'dataflow': dataflow_query_format_1.DataflowQueryDefinition,
    'dataflow-lens': dataflow_lens_query_format_1.DataflowLensQueryDefinition,
    'id-map': id_map_query_format_1.IdMapQueryDefinition,
    'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,
    'dataflow-cluster': cluster_query_format_1.ClusterQueryDefinition,
    'static-slice': static_slice_query_format_1.StaticSliceQueryDefinition,
    'lineage': lineage_query_format_1.LineageQueryDefinition,
    'dependencies': dependencies_query_format_1.DependenciesQueryDefinition,
    'location-map': location_map_query_format_1.LocationMapQueryDefinition,
    'search': search_query_format_1.SearchQueryDefinition,
    'happens-before': happens_before_query_format_1.HappensBeforeQueryDefinition,
    'resolve-value': resolve_value_query_format_1.ResolveValueQueryDefinition,
    'project': project_query_format_1.ProjectQueryDefinition,
    'origin': origin_query_format_1.OriginQueryDefinition,
    'linter': linter_query_format_1.LinterQueryDefinition
};
function executeQueriesOfSameType(data, ...queries) {
    (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');
    /* every query must have the same type */
    (0, assert_1.guard)(queries.every(q => q.type === queries[0].type), 'All queries must have the same type');
    const query = exports.SupportedQueries[queries[0].type];
    (0, assert_1.guard)(query !== undefined, `Unsupported query type: ${queries[0].type}`);
    return query.executor(data, queries);
}
function isVirtualQuery(query) {
    return virtual_queries_1.SupportedVirtualQueries[query.type] !== undefined;
}
function groupQueriesByType(queries) {
    const grouped = {};
    function addQuery(query) {
        if (grouped[query.type] === undefined) {
            grouped[query.type] = [];
        }
        grouped[query.type].push(query);
    }
    for (const query of queries) {
        if (isVirtualQuery(query)) {
            const executor = virtual_queries_1.SupportedVirtualQueries[query.type];
            const subQueries = executor(query);
            for (const subQuery of subQueries) {
                addQuery(subQuery);
            }
        }
        else {
            addQuery(query);
        }
    }
    return grouped;
}
function executeQueries(data, queries) {
    const now = Date.now();
    const grouped = groupQueriesByType(queries);
    const results = {};
    for (const type of Object.keys(grouped)) {
        results[type] = executeQueriesOfSameType(data, ...grouped[type]);
    }
    results['.meta'] = {
        timing: Date.now() - now
    };
    return results;
}
function SupportedQueriesSchema() {
    return joi_1.default.alternatives(Object.values(exports.SupportedQueries).map(q => q.schema)).description('Supported queries');
}
exports.CompoundQuerySchema = joi_1.default.object({
    type: joi_1.default.string().valid('compound').required().description('The type of the query.'),
    query: joi_1.default.string().required().description('The query to run on the file analysis information.'),
    commonArguments: joi_1.default.object().required().description('Common arguments for all queries.'),
    arguments: joi_1.default.array().items(joi_1.default.object()).required().description('Arguments for each query.')
}).description('Compound query used to combine queries of the same type');
function VirtualQuerySchema() {
    return joi_1.default.alternatives(exports.CompoundQuerySchema).description('Virtual queries (used for structure)');
}
function AnyQuerySchema() {
    return joi_1.default.alternatives(SupportedQueriesSchema(), VirtualQuerySchema()).description('Any query');
}
function QueriesSchema() {
    return joi_1.default.array().items(AnyQuerySchema()).description('Queries to run on the file analysis information (in the form of an array)');
}
//# sourceMappingURL=query.js.map