@garrix82/reactgenie-dsl 1.0.4 → 1.0.6

package/dist/cli/dsl-interpreter.js

@@ -0,0 +1,1023 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DslInterpreter = exports.InvalidParameterTypeError = exports.FunctionStaticError = exports.FunctionMissingError = exports.FieldStaticError = exports.FieldMissingError = exports.ClassMissingError = exports.InterpreterError = void 0;
+const parser_gen_js_1 = require("../dsl/parser.gen.js");
+const dsl_descriptor_1 = require("../dsl-descriptor");
+function parseType(value_type) {
+    if (value_type.endsWith("[]")) {
+        return {
+            is_array: true,
+            original_type: value_type.substring(0, value_type.length - 2),
+        };
+    }
+    else {
+        return { is_array: false, original_type: value_type };
+    }
+}
+class InterpreterError extends Error {
+}
+exports.InterpreterError = InterpreterError;
+class ClassMissingError extends InterpreterError {
+    constructor(class_name) {
+        super(`Class ${class_name} is missing`);
+        this.class_name = class_name;
+    }
+}
+exports.ClassMissingError = ClassMissingError;
+class FieldMissingError extends InterpreterError {
+    constructor(class_name, field_name) {
+        super(`Field ${class_name}.${field_name} is missing`);
+        this.class_name = class_name;
+        this.field_name = field_name;
+    }
+}
+exports.FieldMissingError = FieldMissingError;
+class FieldStaticError extends InterpreterError {
+    constructor(class_name, field_name) {
+        super(`Field ${class_name}.${field_name} should be static`);
+        this.class_name = class_name;
+        this.field_name = field_name;
+    }
+}
+exports.FieldStaticError = FieldStaticError;
+class FunctionMissingError extends InterpreterError {
+    constructor(class_name, func_name) {
+        super(`Function ${class_name}.${func_name} is missing`);
+        this.class_name = class_name;
+        this.func_name = func_name;
+    }
+}
+exports.FunctionMissingError = FunctionMissingError;
+class FunctionStaticError extends InterpreterError {
+    constructor(class_name, func_name) {
+        super(`Function ${class_name}.${func_name} should be static`);
+        this.class_name = class_name;
+        this.func_name = func_name;
+    }
+}
+exports.FunctionStaticError = FunctionStaticError;
+class InvalidParameterTypeError extends InterpreterError {
+    constructor(func_name, parameter_name, expected_type, received_type) {
+        super(`Invalid DSL: ${func_name}(${parameter_name}: ...) requires a dotted accessor such as .name, but received ${received_type}.`);
+        this.func_name = func_name;
+        this.parameter_name = parameter_name;
+        this.expected_type = expected_type;
+        this.received_type = received_type;
+    }
+}
+exports.InvalidParameterTypeError = InvalidParameterTypeError;
+class DslInterpreter {
+    matching(value, template) {
+        if (typeof value === "string" && typeof template === "string") {
+            return value.toLowerCase().includes(template.toLowerCase());
+        }
+        if (typeof value === "string" && typeof template === "number") {
+            const parsed = new Date(value);
+            if (!isNaN(parsed.getTime())) {
+                return parsed.getMonth() + 1 === template;
+            }
+            return value.includes(String(template));
+        }
+        if ((typeof value === "number" || typeof value === "boolean") && typeof template === "string") {
+            const asNum = Number(template);
+            if (!isNaN(asNum))
+                return value === asNum;
+            return String(value).toLowerCase() === template.toLowerCase();
+        }
+        if (typeof value === "number" || typeof value === "boolean") {
+            return value === template;
+        }
+        if (value && template && typeof value === "object" && typeof template === "object") {
+            if (typeof value._getConstructorParams === "function" && typeof template._getConstructorParams === "function") {
+                return (JSON.stringify(value._getConstructorParams()) ===
+                    JSON.stringify(template._getConstructorParams()));
+            }
+            return JSON.stringify(value) === JSON.stringify(template);
+        }
+        return false;
+    }
+    contains(value, template) {
+        if (typeof value === "string" && typeof template === "string") {
+            return value.toLowerCase().includes(template.toLowerCase());
+        }
+        if (typeof value === "string" && typeof template === "number") {
+            const parsed = new Date(value);
+            if (!isNaN(parsed.getTime())) {
+                return parsed.getMonth() + 1 === template;
+            }
+            return value.includes(String(template));
+        }
+        else if (Array.isArray(value)) {
+            let contains = false;
+            for (let i = 0; i < value.length; i++) {
+                if (this.matching(value[i], template)) {
+                    contains = true;
+                    break;
+                }
+            }
+            return contains;
+        }
+        else {
+            return value === template;
+        }
+    }
+    equals(a, b) {
+        if (a === b) {
+            return true;
+        }
+        else if (typeof a === "string" && typeof b === "string") {
+            return a.toLowerCase() === b.toLowerCase();
+        }
+        else {
+            return false;
+        }
+    }
+    compareObjectsSafely(left, right) {
+        const leftCompare = left?.constructor?.compare;
+        if (typeof leftCompare === "function") {
+            return leftCompare(left, right);
+        }
+        const rightCompare = right?.constructor?.compare;
+        if (typeof rightCompare === "function") {
+            return rightCompare(left, right);
+        }
+        return null;
+    }
+    isDateOnlyString(value) {
+        return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value);
+    }
+    isIsoDateTimeString(value) {
+        return (typeof value === "string" &&
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(value));
+    }
+    parseDateLikeString(value) {
+        if (typeof value !== "string") {
+            return null;
+        }
+        const trimmed = value.trim();
+        const dateOnlyMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(trimmed);
+        if (dateOnlyMatch) {
+            const [, year, month, day] = dateOnlyMatch;
+            return new Date(Number.parseInt(year, 10), Number.parseInt(month, 10) - 1, Number.parseInt(day, 10), 0, 0, 0, 0).getTime();
+        }
+        const localDateTimeMatch = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.(\d{1,3}))?)?$/.exec(trimmed);
+        if (localDateTimeMatch) {
+            const [, year, month, day, hour, minute, second = "00", , fraction = "0"] = localDateTimeMatch;
+            return new Date(Number.parseInt(year, 10), Number.parseInt(month, 10) - 1, Number.parseInt(day, 10), Number.parseInt(hour, 10), Number.parseInt(minute, 10), Number.parseInt(second, 10), Number.parseInt(fraction.padEnd(3, "0"), 10)).getTime();
+        }
+        const parsed = new Date(trimmed);
+        const timestamp = parsed.getTime();
+        return Number.isNaN(timestamp) ? null : timestamp;
+    }
+    comparePrimitiveValues(left, right) {
+        if ((typeof left === "string" || typeof right === "string") &&
+            typeof left !== "boolean" &&
+            typeof right !== "boolean") {
+            const leftTimestamp = this.parseDateLikeString(left);
+            const rightTimestamp = this.parseDateLikeString(right);
+            if (leftTimestamp !== null && rightTimestamp !== null) {
+                return leftTimestamp - rightTimestamp;
+            }
+        }
+        if ((typeof left === "string" || typeof left === "number") &&
+            (typeof right === "string" || typeof right === "number")) {
+            if (left < right)
+                return -1;
+            if (left > right)
+                return 1;
+            return 0;
+        }
+        if (typeof left === "boolean" && typeof right === "boolean") {
+            if (left === right)
+                return 0;
+            return left ? 1 : -1;
+        }
+        return null;
+    }
+    normalizeBetweenBound(value, bound, isUpperBound) {
+        if (this.isIsoDateTimeString(value) && this.isDateOnlyString(bound)) {
+            return isUpperBound
+                ? `${bound}T23:59:59.999Z`
+                : `${bound}T00:00:00.000Z`;
+        }
+        return bound;
+    }
+    emitTrace(entry) {
+        this.options.onTrace?.({
+            sequence: ++this.traceSequence,
+            ...entry,
+        });
+    }
+    serializeAccessor(accessor) {
+        if (!accessor)
+            return undefined;
+        if (typeof accessor === "string") {
+            return `.${accessor}`;
+        }
+        if (accessor.type === "access") {
+            const parent = this.serializeAccessor(accessor.parent);
+            const access = this.serializeAccessor(accessor.access);
+            if (parent && access) {
+                return `${parent}${access}`;
+            }
+            return access ?? parent;
+        }
+        if (accessor.type === "accessor" && typeof accessor.field === "string") {
+            return `.${accessor.field}`;
+        }
+        return undefined;
+    }
+    serializeCandidate(candidate) {
+        if (!candidate || typeof candidate !== "object") {
+            return candidate;
+        }
+        if (typeof candidate.probeId === "string") {
+            return { key: candidate.probeId };
+        }
+        if (typeof candidate.analysisId === "string") {
+            return { key: candidate.analysisId };
+        }
+        if (typeof candidate.draftId === "string") {
+            return { key: candidate.draftId };
+        }
+        if (typeof candidate.id === "string" || typeof candidate.id === "number") {
+            return { key: candidate.id };
+        }
+        return {
+            className: candidate.constructor?.ClassDescriptor?.className ||
+                candidate.constructor?.name ||
+                "Object",
+        };
+    }
+    serializeValue(value) {
+        if (value == null ||
+            typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((entry) => this.serializeValue(entry));
+        }
+        if (typeof value._getConstructorParams === "function") {
+            return value._getConstructorParams();
+        }
+        return value;
+    }
+    explainMatching(fieldValue, template, matched) {
+        if (typeof fieldValue === "string" && typeof template === "string") {
+            return matched
+                ? "matching(string): case-insensitive substring matched"
+                : "matching(string): substring not found";
+        }
+        if (typeof fieldValue === "string" && typeof template === "number") {
+            return matched
+                ? "matching(date-string|number): date-derived or numeric substring matched"
+                : "matching(date-string|number): no matching month or numeric substring";
+        }
+        if ((typeof fieldValue === "number" || typeof fieldValue === "boolean") &&
+            typeof template === "string") {
+            return matched
+                ? "matching(primitive|string): normalized equality matched"
+                : "matching(primitive|string): normalized equality failed";
+        }
+        if (fieldValue && template && typeof fieldValue === "object" && typeof template === "object") {
+            return matched
+                ? "matching(object): deep comparison matched"
+                : "matching(object): deep comparison failed";
+        }
+        return matched
+            ? "matching(primitive): equality matched"
+            : "matching(primitive): equality failed";
+    }
+    explainContains(fieldValue, template, matched) {
+        if (typeof fieldValue === "string" && typeof template === "string") {
+            return matched
+                ? "contains(string): case-insensitive substring matched"
+                : "contains(string): substring not found";
+        }
+        if (Array.isArray(fieldValue)) {
+            return matched
+                ? "contains(array): at least one array element matched"
+                : "contains(array): no array element matched";
+        }
+        if (typeof fieldValue === "string" && typeof template === "number") {
+            return matched
+                ? "contains(date-string|number): date-derived or numeric substring matched"
+                : "contains(date-string|number): no matching month or numeric substring";
+        }
+        return matched
+            ? "contains(non-string): strict equality matched"
+            : "contains(non-string): strict equality failed";
+    }
+    explainEquals(fieldValue, template, matched) {
+        if (typeof fieldValue === "string" && typeof template === "string") {
+            return matched
+                ? "equals(string): exact equality matched"
+                : "equals(string): case-insensitive exact match failed";
+        }
+        return matched
+            ? "equals(non-string): strict equality matched"
+            : "equals(non-string): strict equality failed";
+    }
+    explainBetween(fieldValue, from, to, lowerMatched, upperMatched, matched) {
+        if (matched) {
+            return "between: value satisfied all provided bounds";
+        }
+        if (from !== undefined && !lowerMatched) {
+            return `between: value < from bound (${JSON.stringify(this.serializeValue(fieldValue))} < ${JSON.stringify(this.serializeValue(from))})`;
+        }
+        if (to !== undefined && !upperMatched) {
+            return `between: value > to bound (${JSON.stringify(this.serializeValue(fieldValue))} > ${JSON.stringify(this.serializeValue(to))})`;
+        }
+        return "between: comparison failed";
+    }
+    constructor(classDescriptors, dry_run = false, options = {}) {
+        this.dry_run = dry_run;
+        this.options = options;
+        this.traceSequence = 0;
+        this.arrayFunctionDescriptors = [
+            new dsl_descriptor_1.FuncDescriptor("matching", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("value", "object"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("contains", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("value", "object"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("between", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("from", "object", false),
+                new dsl_descriptor_1.ParamDescriptor("to", "object", false),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("equals", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("value", "object"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("sort", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("ascending", "boolean"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("index", [new dsl_descriptor_1.ParamDescriptor("index", "int")], "object", false),
+            new dsl_descriptor_1.FuncDescriptor("length", [], "int", false)
+        ];
+        this.arrayFunctionImplementations = {
+            matching: async ({ fieldAccessor, value, array, }) => {
+                return array.filter((element) => {
+                    const matched = this.matching(element.fieldValue, value);
+                    this.emitTrace({
+                        primitive: "matching",
+                        fieldAccessor,
+                        candidate: this.serializeCandidate(element.element),
+                        fieldValue: this.serializeValue(element.fieldValue),
+                        comparison: { value: this.serializeValue(value) },
+                        matched,
+                        reason: this.explainMatching(element.fieldValue, value, matched),
+                    });
+                    return matched;
+                }).map((v) => v.element);
+            },
+            contains: async ({ fieldAccessor, value, array, }) => {
+                return array.filter((element) => {
+                    const matched = this.contains(element.fieldValue, value);
+                    this.emitTrace({
+                        primitive: "contains",
+                        fieldAccessor,
+                        candidate: this.serializeCandidate(element.element),
+                        fieldValue: this.serializeValue(element.fieldValue),
+                        comparison: { value: this.serializeValue(value) },
+                        matched,
+                        reason: this.explainContains(element.fieldValue, value, matched),
+                    });
+                    return matched;
+                }).map((v) => v.element);
+            },
+            between: async ({ fieldAccessor, from, to, array, }) => {
+                let newArray = [];
+                for (const element of array) {
+                    let first = true;
+                    let second = true;
+                    let value = element.fieldValue;
+                    const effectiveFrom = this.normalizeBetweenBound(value, from, false);
+                    const effectiveTo = this.normalizeBetweenBound(value, to, true);
+                    let valueIsPrimitive = typeof value === "string" ||
+                        typeof value === "number" ||
+                        typeof value === "boolean";
+                    if (from !== undefined) {
+                        let fromIsPrimitive = typeof effectiveFrom === "string" ||
+                            typeof effectiveFrom === "number" ||
+                            typeof effectiveFrom === "boolean";
+                        if (fromIsPrimitive && valueIsPrimitive) {
+                            const compareResult = this.comparePrimitiveValues(value, effectiveFrom);
+                            first = compareResult !== null ? compareResult >= 0 : false;
+                        }
+                        else if (fromIsPrimitive && !valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, effectiveFrom);
+                            first = compareResult !== null ? compareResult >= 0 : false;
+                        }
+                        else if (!fromIsPrimitive && valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, effectiveFrom);
+                            first = compareResult !== null ? compareResult >= 0 : false;
+                        }
+                        else {
+                            const compareResult = this.compareObjectsSafely(value, effectiveFrom);
+                            first = compareResult !== null ? compareResult >= 0 : false;
+                        }
+                    }
+                    if (to !== undefined) {
+                        let toIsPrimitive = typeof effectiveTo === "string" ||
+                            typeof effectiveTo === "number" ||
+                            typeof effectiveTo === "boolean";
+                        if (toIsPrimitive && valueIsPrimitive) {
+                            const compareResult = this.comparePrimitiveValues(value, effectiveTo);
+                            second = compareResult !== null ? compareResult <= 0 : false;
+                        }
+                        else if (toIsPrimitive && !valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, effectiveTo);
+                            second = compareResult !== null ? compareResult <= 0 : false;
+                        }
+                        else if (!toIsPrimitive && valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, effectiveTo);
+                            second = compareResult !== null ? compareResult <= 0 : false;
+                        }
+                        else {
+                            const compareResult = this.compareObjectsSafely(value, effectiveTo);
+                            second = compareResult !== null ? compareResult <= 0 : false;
+                        }
+                    }
+                    const matched = first && second;
+                    this.emitTrace({
+                        primitive: "between",
+                        fieldAccessor,
+                        candidate: this.serializeCandidate(element.element),
+                        fieldValue: this.serializeValue(value),
+                        comparison: {
+                            from: this.serializeValue(effectiveFrom),
+                            to: this.serializeValue(effectiveTo),
+                        },
+                        matched,
+                        reason: this.explainBetween(value, effectiveFrom, effectiveTo, first, second, matched),
+                    });
+                    if (matched) {
+                        newArray.push(element.element);
+                    }
+                }
+                return newArray;
+            },
+            equals: async ({ fieldAccessor, value, array, }) => {
+                return array.filter((element) => {
+                    const matched = this.equals(element.fieldValue, value);
+                    this.emitTrace({
+                        primitive: "equals",
+                        fieldAccessor,
+                        candidate: this.serializeCandidate(element.element),
+                        fieldValue: this.serializeValue(element.fieldValue),
+                        comparison: { value: this.serializeValue(value) },
+                        matched,
+                        reason: this.explainEquals(element.fieldValue, value, matched),
+                    });
+                    return matched;
+                }).map((v) => v.element);
+            },
+            sort: async ({ fieldAccessor, ascending, array, }) => {
+                const sorted = array.sort((a, b) => {
+                    if (ascending) {
+                        if (a.fieldValue < b.fieldValue) {
+                            return -1;
+                        }
+                        else if (a.fieldValue > b.fieldValue) {
+                            return 1;
+                        }
+                        else {
+                            return 0;
+                        }
+                    }
+                    else {
+                        if (a.fieldValue < b.fieldValue) {
+                            return 1;
+                        }
+                        else if (a.fieldValue > b.fieldValue) {
+                            return -1;
+                        }
+                        else {
+                            return 0;
+                        }
+                    }
+                }).map((v) => v.element);
+                this.emitTrace({
+                    primitive: "sort",
+                    fieldAccessor,
+                    comparison: { ascending },
+                    reason: "sort: ordered array by field value",
+                });
+                return sorted;
+            },
+            index: async ({ index, array }) => {
+                console.assert(typeof index === "number");
+                if (index < 0) {
+                    index = array.length + index;
+                }
+                this.emitTrace({
+                    primitive: "index",
+                    comparison: { index },
+                    reason: "index: selected array element by zero-based index",
+                });
+                return array[index];
+            },
+            length: async ({ array }) => {
+                this.emitTrace({
+                    primitive: "length",
+                    comparison: { length: array.length },
+                    reason: "length: returned array length",
+                });
+                return array.length;
+            }
+        };
+        this.resolveSteps = [];
+        this.resolveStepsEnabled = false;
+        this.classDescriptors = [...classDescriptors];
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("String", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("Number", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("float", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("int", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("Boolean", [], [], null));
+    }
+    async interpret(input) {
+        const ast = (0, parser_gen_js_1.parse)(input);
+        var lastResult = null;
+        for (const statement of ast) {
+            lastResult = await this.resolve(statement);
+        }
+        return lastResult;
+    }
+    async interpretSteps(input) {
+        const ast = (0, parser_gen_js_1.parse)(input);
+        var lastResult = null;
+        let allSteps = [];
+        for (const statement of ast) {
+            this.resolveSteps = [];
+            this.resolveStepsEnabled = true;
+            lastResult = await this.resolve(statement);
+            this.resolveStepsEnabled = false;
+            allSteps.push({ ast: statement, result: lastResult, steps: this.resolveSteps });
+        }
+        return allSteps;
+    }
+    async describe(ast) {
+        switch (ast.type) {
+            case "array":
+                const elements = [];
+                for (const e of ast.value) {
+                    elements.push(await this.describe(e));
+                }
+                return {
+                    type: "array",
+                    elements: elements,
+                };
+            case "string":
+            case "int":
+            case "boolean":
+                return ast.value;
+            case "object":
+                if (ast.value !== undefined) {
+                    if (ast.objectType == "string" || ast.objectType == "int" || ast.objectType == "float" || ast.objectType == "number") {
+                        return {
+                            type: "object",
+                            objectType: ast.objectType,
+                            value: ast.value,
+                        };
+                    }
+                    else {
+                        if (ast.value.update !== undefined) {
+                            await ast.value.update();
+                        }
+                        return { type: "object", value: await ast.value.description() };
+                    }
+                }
+                else {
+                    console.assert(ast.objectType == "void");
+                    return { type: "object", value: "undefined" };
+                }
+        }
+    }
+    async describeSteps(list) {
+        const steps = [];
+        for (const e of list) {
+            steps.push(await this.describe(e.result));
+        }
+        return steps;
+    }
+    strip(ast) {
+        switch (ast.type) {
+            case "class":
+                return this.classDescriptors.find((c) => c.className === ast.value)
+                    .classConstructor;
+            case "array":
+                return ast.value.map((v) => this.strip(v));
+            case "accessor":
+                return ast;
+            case "string":
+            case "int":
+            case "boolean":
+            case "object":
+                return ast.value;
+        }
+    }
+    async resolve(ast, env = null) {
+        let result = null;
+        switch (ast.type) {
+            case "access":
+                result = await this.resolveAccess(ast, env);
+                break;
+            case "index":
+                result = await this.resolveIndex(ast, env);
+                break;
+            case "function_call":
+                result = await this.resolveFunctionCall(ast, env);
+                break;
+            case "array":
+                result = await this.resolveArray(ast, env);
+                break;
+            case "string":
+            case "int":
+            case "float":
+            case "boolean":
+            case "accessor":
+            case "object":
+                result = ast;
+                break;
+            default:
+                throw new Error("Unsupported AST type: " + ast.type);
+        }
+        if (this.resolveStepsEnabled) {
+            this.resolveSteps.push({ ast: ast, result: result });
+        }
+        return result;
+    }
+    describeResolvedParameterType(param) {
+        if (!param || typeof param !== "object") {
+            return typeof param;
+        }
+        if (param.type === "object" && typeof param.objectType === "string") {
+            return param.objectType;
+        }
+        return param.type || typeof param;
+    }
+    validateResolvedParameters(func_name, funcDescriptor, parameters) {
+        for (const descriptor of funcDescriptor.parameters) {
+            const param = parameters.get(descriptor.name);
+            if (param == null) {
+                continue;
+            }
+            if (descriptor.type === "accessor" && param.type !== "accessor") {
+                throw new InvalidParameterTypeError(func_name, descriptor.name, descriptor.type, this.describeResolvedParameterType(param));
+            }
+        }
+    }
+    async resolveAccess(ast, env) {
+        console.assert(env == null);
+        let parent;
+        if (typeof ast.parent === "string") {
+            parent = { type: "class", value: ast.parent };
+        }
+        else if (ast.parent.type === "object") {
+            parent = ast.parent;
+        }
+        else {
+            parent = await this.resolve(ast.parent, null);
+        }
+        if (typeof ast.access === "string") {
+            const isObject = parent.type === "object";
+            const className = isObject ? parent.objectType : parent.value;
+            const classDescriptor = this.classDescriptors.find((c) => c.className === className);
+            if (classDescriptor === undefined) {
+                if (parent.type == "array") {
+                    const arrayValue = [];
+                    for (const v of parent.value) {
+                        try {
+                            arrayValue.push(await this.resolveAccess({
+                                ...ast,
+                                parent: v
+                            }, env));
+                        }
+                        catch (e) {
+                            console.log(e);
+                        }
+                    }
+                    let objType = null;
+                    if (arrayValue.length > 0) {
+                        objType = arrayValue[0].objectType;
+                    }
+                    return {
+                        type: "array",
+                        value: arrayValue,
+                        objectType: objType
+                    };
+                }
+                else {
+                    throw new ClassMissingError(className);
+                }
+            }
+            const fieldDescriptor = Array.from(classDescriptor.fields).find((f) => f.field === ast.access);
+            if (fieldDescriptor === undefined) {
+                throw new FieldMissingError(className, ast.access);
+            }
+            if (!isObject && !fieldDescriptor.isStatic) {
+                throw new FieldStaticError(className, ast.access);
+            }
+            const fieldType = parseType(fieldDescriptor.fieldType);
+            let fieldValue;
+            if (this.dry_run) {
+                if (fieldType.is_array) {
+                    fieldValue = [null];
+                }
+                else {
+                    fieldValue = null;
+                }
+            }
+            else {
+                if (isObject) {
+                    const parentObject = this.strip(parent);
+                    if (parentObject === undefined || parentObject === null) {
+                        throw new InterpreterError(`Cannot access ${className}.${ast.access}: target object is undefined`);
+                    }
+                    if (!this.dry_run) {
+                        await parentObject.update();
+                    }
+                    fieldValue = parentObject[ast.access];
+                }
+                else {
+                    fieldValue = classDescriptor.classConstructor[ast.access];
+                }
+            }
+            if (fieldType.is_array) {
+                return {
+                    type: "array",
+                    value: fieldValue.map((v) => {
+                        return {
+                            type: "object",
+                            value: v,
+                            objectType: fieldType.original_type,
+                        };
+                    }),
+                };
+            }
+            else {
+                return {
+                    type: "object",
+                    value: fieldValue,
+                    objectType: fieldType.original_type,
+                };
+            }
+        }
+        else {
+            return await this.resolve(ast.access, parent);
+        }
+    }
+    async resolveIndex(ast, env) {
+        console.assert(env == null);
+        let indexParam;
+        if (typeof ast.index === "number") {
+            indexParam = { type: "int", value: ast.index };
+        }
+        else {
+            indexParam = ast.index;
+        }
+        return await this.resolve({
+            type: "access",
+            parent: ast.parent,
+            access: {
+                type: "function_call",
+                func_name: "index",
+                parameters: [{ parameter: "index", value: indexParam }],
+            },
+        }, env);
+    }
+    async resolveArray(ast, env) {
+        console.assert(env == null);
+        const values = [];
+        for (const v of ast.value) {
+            values.push(await this.resolve(v, null));
+        }
+        console.assert(values.every((v) => v.type === "object"));
+        console.assert(values.every((v) => v.objectType === values[0].objectType));
+        return {
+            type: "array",
+            value: values,
+        };
+    }
+    async resolveFunctionCall(ast, env) {
+        const parameter_entries = [];
+        if (ast.parameters !== null) {
+            for (const p of ast.parameters) {
+                parameter_entries.push([p.parameter, await this.resolve(p.value, null)]);
+            }
+        }
+        const parameters = new Map(parameter_entries);
+        let classDescriptor;
+        let funcDescriptor;
+        let isArray = false;
+        let isArrayElementFunction = false;
+        if (env !== null) {
+            switch (env.type) {
+                case "class":
+                    classDescriptor =
+                        this.classDescriptors.find((c) => c.className === env.value);
+                    if (classDescriptor === undefined) {
+                        throw new ClassMissingError(env.value);
+                    }
+                    funcDescriptor = Array.from(classDescriptor.functions).find((f) => f.func_name === ast.func_name);
+                    if (funcDescriptor === undefined) {
+                        throw new FunctionMissingError(env.value, ast.func_name);
+                    }
+                    else if (!funcDescriptor.isStatic) {
+                        throw new FunctionStaticError(env.value, ast.func_name);
+                    }
+                    break;
+                case "object":
+                    classDescriptor = this.classDescriptors.find((c) => c.className === env.objectType);
+                    if (classDescriptor === undefined) {
+                        throw new ClassMissingError(env.objectType);
+                    }
+                    funcDescriptor = Array.from(classDescriptor.functions).find((f) => f.func_name === ast.func_name);
+                    if (funcDescriptor === undefined) {
+                        throw new FunctionMissingError(env.objectType, ast.func_name);
+                    }
+                    break;
+                case "array":
+                    if (env.value.length == 0)
+                        return {
+                            type: "array",
+                            value: [],
+                            objectType: null
+                        };
+                    funcDescriptor = this.arrayFunctionDescriptors.find((f) => f.func_name === ast.func_name);
+                    if (funcDescriptor === undefined || env.value[0]["type"] === "array") {
+                        const arrayValue = [];
+                        for (const v of env.value) {
+                            arrayValue.push(await this.resolveFunctionCall(ast, v));
+                        }
+                        return {
+                            type: "array",
+                            value: arrayValue,
+                            objectType: arrayValue[0].objectType
+                        };
+                    }
+                    if (env.value.length > 0) {
+                        funcDescriptor = JSON.parse(JSON.stringify(funcDescriptor));
+                        funcDescriptor.returnType = funcDescriptor.returnType.replace("object", env.value[0].objectType);
+                    }
+                    isArray = true;
+                    break;
+            }
+        }
+        else {
+            const classDescriptor = this.classDescriptors.find((c) => c.className === ast.func_name);
+            funcDescriptor = Array.from(classDescriptor.functions).find((f) => f.func_name === "constructor");
+        }
+        this.validateResolvedParameters(ast.func_name, funcDescriptor, parameters);
+        let matchedParameters = {};
+        for (const descriptor of funcDescriptor.parameters) {
+            const param = parameters.get(descriptor.name);
+            if (param != null) {
+                matchedParameters[descriptor.name] = this.strip(param);
+            }
+        }
+        if (env === null) {
+            const classDescriptor = this.classDescriptors.find((c) => c.className === ast.func_name);
+            if (this.dry_run) {
+                return {
+                    type: "object",
+                    value: null,
+                    objectType: ast.func_name,
+                };
+            }
+            else {
+                return {
+                    type: "object",
+                    value: new classDescriptor.classConstructor(matchedParameters),
+                    objectType: ast.func_name,
+                };
+            }
+        }
+        const returnType = parseType(funcDescriptor.returnType);
+        if (isArray) {
+            for (const element of env.value) {
+                if (element.type == "object" && !this.dry_run) {
+                    await element.value.update();
+                }
+            }
+            matchedParameters["array"] = this.strip(env);
+            if (matchedParameters["field"] !== undefined) {
+                function constructAccess(accessor, parent) {
+                    if (typeof accessor == "string") {
+                        return {
+                            type: "access",
+                            parent: parent,
+                            access: accessor,
+                        };
+                    }
+                    else {
+                        if (accessor.type == "access") {
+                            return {
+                                type: "access",
+                                parent: constructAccess(accessor.parent, parent),
+                                access: accessor.access,
+                            };
+                        }
+                    }
+                }
+                const field = matchedParameters["field"].field;
+                matchedParameters["fieldAccessor"] = this.serializeAccessor(matchedParameters["field"]);
+                if (this.dry_run) {
+                    await this.resolve(constructAccess(field, {
+                        type: "object",
+                        value: null,
+                        objectType: returnType.original_type,
+                    }), null);
+                }
+                else {
+                    if (ast.func_name != "index" && ast.func_name != "length") {
+                        const originalArray = matchedParameters["array"];
+                        const array = [];
+                        for (const element of originalArray) {
+                            const fieldValue = await this.strip(await this.resolve(constructAccess(field, {
+                                type: "object",
+                                value: element,
+                                objectType: returnType.original_type,
+                            })));
+                            array.push({
+                                element: element,
+                                fieldValue: fieldValue,
+                            });
+                        }
+                        matchedParameters["array"] = array;
+                    }
+                }
+            }
+        }
+        const targetImplementation = isArray
+            ? this.arrayFunctionImplementations
+            : this.strip(env);
+        if (!isArray &&
+            env?.type === "object" &&
+            !this.dry_run &&
+            (targetImplementation === undefined || targetImplementation === null)) {
+            throw new InterpreterError(`Cannot call ${ast.func_name}: target object is undefined`);
+        }
+        if (returnType.is_array) {
+            if (this.dry_run) {
+                return {
+                    type: "array",
+                    value: [{
+                            type: "object",
+                            value: null,
+                            objectType: returnType.original_type,
+                        }],
+                };
+            }
+            else {
+                if (env.type === "object" && !this.dry_run) {
+                    if (typeof targetImplementation.update !== "function") {
+                        throw new InterpreterError(`Cannot call ${ast.func_name}: target object has no update method`);
+                    }
+                    await targetImplementation.update();
+                }
+                return {
+                    type: "array",
+                    value: (await targetImplementation[ast.func_name](matchedParameters)).map((v) => {
+                        return {
+                            type: "object",
+                            value: v,
+                            objectType: returnType.original_type,
+                        };
+                    }),
+                };
+            }
+        }
+        else {
+            if (this.dry_run) {
+                return {
+                    type: "object",
+                    value: null,
+                    objectType: returnType.original_type,
+                };
+            }
+            else {
+                if (env.type === "object" && !this.dry_run) {
+                    if (typeof targetImplementation.update !== "function") {
+                        throw new InterpreterError(`Cannot call ${ast.func_name}: target object has no update method`);
+                    }
+                    await targetImplementation.update();
+                }
+                return {
+                    type: "object",
+                    value: await (targetImplementation[ast.func_name](matchedParameters)),
+                    objectType: returnType.original_type,
+                };
+            }
+        }
+    }
+}
+exports.DslInterpreter = DslInterpreter;
+//# sourceMappingURL=dsl-interpreter.js.map